new

Оператор new позволяет разработчикам создавать экземпляр пользовательского типа объекта или одного из встроенных типов объектов, имеющих конструктор.

Попробуйте

function Car(make, model, year) {
  this.make = make;
  this.model = model;
  this.year = year;
}

const car1 = new Car("Eagle", "Talon TSi", 1993);

console.log(car1.make);
// Expected output: "Eagle"

Синтаксис

new constructor
new constructor()
new constructor(arg1)
new constructor(arg1, arg2)
new constructor(arg1, arg2, /* …, */ argN)

Параметры

constructor

Класс или функция, определяющая тип экземпляра объекта. Выражение может быть чем угодно с достаточным приоритетом, включая идентификатор, доступ к свойству или другое выражение new, но опциональная цепочка не разрешена.

arg1, arg2, …, argN

Список значений, с которыми будет вызван constructor. new Foo эквивалентен new Foo(), то есть, если список аргументов не указан, Foo вызывается без аргументов.

Описание

Когда функция вызывается с ключевым словом new, функция используется как конструктор. new выполнит следующие действия:

1. Создает пустой, обычный объект JavaScript. Для удобства назовем его newInstance.

2. Привязывает [[Prototype]] объекта newInstance к свойству prototype конструкторской функции, если prototype является Object. В противном случае newInstance останется обычным объектом с Object.prototype в качестве его [[Prototype]].

   Примечание: Свойства/объекты, добавленные к свойству prototype конструкторской функции, поэтому доступны всем экземплярам, созданным из конструкторской функции.

3. Выполняет конструкторскую функцию с заданными аргументами, привязывая newInstance в качестве контекста this (т.е. все ссылки на this в конструкторской функции теперь ссылаются на newInstance).
4. Если конструкторская функция возвращает не примитивное значение, это возвращаемое значение становится результатом всего выражения new. В противном случае, если конструкторская функция ничего не возвращает или возвращает примитив, вместо этого возвращается newInstance. (Обычно конструкторы не возвращают значение, но они могут выбрать это, чтобы переопределить обычный процесс создания объекта.)

Классы могут быть инстанциированы только с оператором new — попытка вызвать класс без new приведет к ошибке TypeError.

Создание объекта с пользовательской конструкторской функцией требует двух шагов:

1. Определите тип объекта, написав функцию, которая определяет его имя и свойства. Например, конструкторская функция для создания объекта Foo может выглядеть так:

   function Foo(bar1, bar2) {
     this.bar1 = bar1;
     this.bar2 = bar2;
   }
   

2. Создайте экземпляр объекта с помощью new.

   const myFoo = new Foo("Bar 1", 2021);
   

Вы всегда можете добавить свойство к ранее определенному экземпляру объекта. Например, оператор car1.color = "black" добавляет свойство color к car1 и присваивает ему значение "black".

Однако это не влияет на другие объекты. Чтобы добавить новое свойство ко всем объектам одного типа, вы должны добавить свойство к свойству prototype конструктора. Это определяет свойство, общее для всех объектов, созданных этой функцией, а не только для одного экземпляра типа объекта. Следующий код добавляет свойство color со значением "original color" ко всем объектам типа Car, а затем перезаписывает это значение строкой "black" только в объекте экземпляра car1. Дополнительную информацию см. в разделе prototype.

function Car() {}
const car1 = new Car();
const car2 = new Car();

console.log(car1.color); // undefined

Car.prototype.color = "original color";
console.log(car1.color); // 'original color'

car1.color = "black";
console.log(car1.color); // 'black'

console.log(Object.getPrototypeOf(car1).color); // 'original color'
console.log(Object.getPrototypeOf(car2).color); // 'original color'
console.log(car1.color); // 'black'
console.log(car2.color); // 'original color'

Функция может узнать, была ли она вызвана с new, проверив new.target. new.target является undefined только при вызове функции без new. Например, вы можете создать функцию, которая ведет себя по-разному при вызове и при конструировании:

function Car(color) {
  if (!new.target) {
    // Called as function.
    return `${color} car`;
  }
  // Called with new.
  this.color = color;
}

const a = Car("red"); // a is "red car"
const b = new Car("red"); // b is `Car { color: "red" }`

До ES6, который ввел классы, большинство встроенных объектов JavaScript были как вызываемыми, так и конструируемыми, хотя многие из них проявляли различное поведение. Кратко:

• Array(), Error() и Function() ведут себя одинаково при вызове как функция или как конструктор.
• Boolean(), Number() и String() при вызове преобразуют свой аргумент в соответствующий примитивный тип и возвращают обертывающие объекты при конструировании.
• Date() при вызове возвращает строку, представляющую текущую дату, эквивалентную new Date().toString().

После ES6 язык стал строже в отношении того, что является конструктором, а что — функцией. Например:

• Symbol() и BigInt() можно вызывать только без new. Попытка их конструирования приведет к ошибке TypeError.
• Proxy и Map можно конструировать только с помощью new. Попытка их вызова приведет к ошибке TypeError.

Примеры

Тип объекта и экземпляр объекта

Предположим, вы хотите создать тип объекта для автомобилей. Вы хотите, чтобы этот тип объекта назывался Car, и чтобы он имел свойства make, model и year. Для этого вы бы написали следующую функцию:

function Car(make, model, year) {
  this.make = make;
  this.model = model;
  this.year = year;
}

Теперь вы можете создать объект под названием myCar следующим образом:

const myCar = new Car("Eagle", "Talon TSi", 1993);

Этот оператор создает myCar и присваивает ему указанные значения для его свойств. Затем значение myCar.make — это строка "Eagle", myCar.year — целое число 1993 и так далее.

Вы можете создать любое количество объектов car путем вызовов new. Например:

const kensCar = new Car("Nissan", "300ZX", 1992);

Свойство объекта, которое само по себе является другим объектом

Предположим, вы определяете объект под названием Person следующим образом:

function Person(name, age, sex) {
  this.name = name;
  this.age = age;
  this.sex = sex;
}

А затем создаете два новых объекта Person следующим образом:

const rand = new Person("Rand McNally", 33, "M");
const ken = new Person("Ken Jones", 39, "M");

Затем вы можете переписать определение Car, чтобы включить свойство owner, которое принимает объект Person, следующим образом:

function Car(make, model, year, owner) {
  this.make = make;
  this.model = model;
  this.year = year;
  this.owner = owner;
}

Чтобы создать новые объекты, вы затем используете следующее:

const car1 = new Car("Eagle", "Talon TSi", 1993, rand);
const car2 = new Car("Nissan", "300ZX", 1992, ken);

Вместо передачи литеральной строки или целочисленного значения при создании новых объектов, вышеприведенные операторы передают объекты rand и ken в качестве параметров для владельцев. Чтобы узнать имя владельца car2, вы можете получить доступ к следующему свойству:

car2.owner.name;

Использование new с классами

class Person {
  constructor(name) {
    this.name = name;
  }
  greet() {
    console.log(`Hello, my name is ${this.name}`);
  }
}

const p = new Person("Caroline");
p.greet(); // Hello, my name is Caroline

Спецификации

Совместимость с браузерами

См. также

• Function
• Reflect.construct()
• Object