Является ли .prototype статическим методом?

Является ли .prototype статическим методом?

Нет, .prototype — это не метод вообще, а свойство объекта функции. Давайте разберёмся в этом важном различии.

Что такое .prototype

.prototype — это обычное свойство, которое есть у каждой функции в JavaScript:

function Person(name) {
  this.name = name;
}

// .prototype — это объект, который содержит общие методы
console.log(typeof Person.prototype); // "object"
console.log(Person.prototype); // { constructor: Person }

// Это свойство, а не метод
console.log(typeof Person.prototype.toString); // "function"

Чем .prototype отличается от статического метода

function Person(name) {
  this.name = name;
}

// .prototype — свойство
Person.prototype.greet = function() {
  return `Привет, я ${this.name}`;
};

// Статический метод
Person.create = function(name) {
  return new Person(name);
};

// Использование
const person = new Person("Иван");

// Вызов метода из прототипа (на экземпляре)
person.greet(); // "Привет, я Иван"

// Вызов статического метода (на самой функции)
Person.create("Мария"); // Person { name: "Мария" }

// .prototype доступен как на функции, так и на экземпляре
console.log(Person.prototype); // объект с методами
console.log(person.constructor.prototype); // тот же объект

Ключевые различия

function Car(brand) {
  this.brand = brand;
}

// 1. .prototype — это свойство ФУНКЦИИ
Car.prototype.drive = function() {
  return `${this.brand} едет`;
};

// 2. Статический метод — это свойство ФУНКЦИИ
Car.build = function(brand) {
  return new Car(brand);
};

// Вызовы:
const myCar = new Car("Toyota");

// Метод из .prototype вызывается на экземпляре
myCar.drive(); // "Toyota едет"

// Статический метод вызывается на функции
Car.build("BMW"); // Car { brand: "BMW" }

// .prototype НЕ вызывается как функция
// Car.prototype(); // TypeError: Car.prototype is not a function

Как работает наследование через .prototype

// .prototype используется для создания цепи прототипов
function Animal(name) {
  this.name = name;
}

Animal.prototype.eat = function() {
  return `${this.name} ест`;
};

function Dog(name, breed) {
  Animal.call(this, name);
  this.breed = breed;
}

// Устанавливаем прототипную цепь
Dog.prototype = Object.create(Animal.prototype);
Dog.prototype.constructor = Dog;
Dog.prototype.bark = function() {
  return `${this.name} лает`;
};

const dog = new Dog("Барбос", "Овчарка");

// Методы ищутся в цепи прототипов
dog.eat(); // "Барбос ест" (из Animal.prototype)
dog.bark(); // "Барбос лает" (из Dog.prototype)

Статические методы vs методы в .prototype

class User {
  constructor(name) {
    this.name = name;
  }
  
  // Метод экземпляра (в прототипе)
  greet() {
    return `Привет, ${this.name}`;
  }
  
  // Статический метод
  static create(name) {
    return new User(name);
  }
  
  // Статический метод
  static fromJSON(json) {
    const data = JSON.parse(json);
    return new User(data.name);
  }
}

// Использование методов экземпляра
const user = new User("Петр");
user.greet(); // "Привет, Петр"

// Статические методы вызываются на классе
User.create("Нина"); // User { name: "Нина" }
User.fromJSON('{"name": "Анна"}'); // User { name: "Анна" }

.prototype в старом синтаксисе vs современный ES6

// Старый способ (функции + .prototype)
function Person(name) {
  this.name = name;
}
Person.prototype.sayHi = function() {
  console.log(`Hi, I'm ${this.name}`);
};

// Современный способ (классы)
class Person {
  constructor(name) {
    this.name = name;
  }
  
  sayHi() {
    console.log(`Hi, I'm ${this.name}`);
  }
}

// За кулисами они работают одинаково!
// Класс просто синтаксический сахар над .prototype

Практический пример

function Product(name, price) {
  this.name = name;
  this.price = price;
}

// Методы для ВСЕХ экземпляров (в .prototype)
Product.prototype.getInfo = function() {
  return `${this.name}: $${this.price}`;
};

Product.prototype.applyDiscount = function(percent) {
  this.price = this.price * (1 - percent / 100);
  return this.price;
};

// Статический метод для работы с ТИПОМ
Product.create = function(data) {
  return new Product(data.name, data.price);
};

Product.compare = function(p1, p2) {
  return p1.price - p2.price;
};

// Использование
const laptop = new Product("Ноутбук", 1000);
laptop.getInfo(); // "Ноутбук: $1000"
laptop.applyDiscount(10); // 900

// Статические методы
Product.create({ name: "Телефон", price: 500 });
Product.compare(laptop, { price: 600 });

Когда использовать .prototype vs статические методы

class Database {
  constructor(url) {
    this.url = url;
  }
  
  // Метод экземпляра — работает с конкретной БД
  query(sql) {
    return `Запрос к ${this.url}: ${sql}`;
  }
  
  // Статический метод — не зависит от экземпляра
  static connect(url) {
    return new Database(url);
  }
  
  // Статический метод — утилита
  static escape(value) {
    return value.replace(/'/g, "\\'");
  }
}

// Экземплярные методы
const db = Database.connect("mysql://localhost");
db.query("SELECT * FROM users");

// Статические методы
Database.escape("O'Reilly");

Итоги

1. .prototype — это свойство функции, не метод
2. .prototype содержит методы, которые будут доступны всем экземплярам
3. Статические методы — это методы самой функции/класса
4. Методы в .prototype используют this для доступа к данным экземпляра
5. Статические методы не имеют доступа к this экземпляра
6. В ES6 классах это выглядит яснее, но механизм одинаковый

Важный момент: .prototype — это фундамент наследования в JavaScript, а не просто статический метод.