Что такое «новое» ключевое слово в JavaScript?

Предположим, что у вас есть эта функция:

var Foo = function(){
  this.A = 1;
  this.B = 2;
};

Если вы называете это автономной функцией следующим образом:

Foo();

Выполнение этой функции добавит два свойства к объекту window (A и B). Он добавляет его в window, потому что window - это объект, который вызывает функцию при ее выполнении так, а this в функции - это объект, который вызывает эту функцию. В Javascript по крайней мере.

Теперь назовите его так: new:

var bar = new Foo();

Что происходит, когда вы добавляете new в вызов функции, является то, что создается новый объект (просто var bar = new Object()) и что this внутри этой функции указывает на новый Object, который вы только что создали, вместо к объекту, который вызывает функцию. Итак, bar теперь является объектом со свойствами A и B. Любая функция может быть конструктором, она не всегда имеет смысл.

В дополнение к ответу Даниэля Говарда, вот что делает new (или, по крайней мере, похоже):

function New(func) {
    var res = {};
    if (func.prototype !== null) {
        res.__proto__ = func.prototype;
    }
    var ret = func.apply(res, Array.prototype.slice.call(arguments, 1));
    if ((typeof ret === "object" || typeof ret === "function") && ret !== null) {
        return ret;
    }
    return res;
}

В то время как

var obj = New(A, 1, 2);

эквивалентно

var obj = new A(1, 2);

Для новичков это лучше понять

попробуйте выполнить следующий код в консоли браузера.

function Foo() { 
    return this; 
}

var a = Foo();       //returns window object
var b = new Foo();   //returns empty object of foo

a instanceof Window;  // true
a instanceof Foo;     // false

b instanceof Window;  // false
b instanceof Foo;     // true

Теперь вы можете прочитать ответ wiki сообщества :)

поэтому он, вероятно, не для создания экземпляры объекта

Он использовал именно для этого. Вы определяете конструктор функции следующим образом:

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

var john = new Person('John');

Однако дополнительная выгода, которую имеет ECMAScript, заключается в том, что вы можете расширить с помощью свойства .prototype, поэтому мы можем сделать что-то вроде...

Person.prototype.getName = function() { return this.name; }

Все объекты, созданные из этого конструктора, теперь будут иметь getName из-за цепи прототипа, к которой у них есть доступ.

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

Javascript - это язык динамического программирования, который поддерживает парадигму объектно-ориентированного программирования и использует ее для создания новых экземпляров объекта.

Классы не нужны для объектов - Javascript является прототипом на основе.

иногда код проще, чем слова:

var func1 = function (x) { this.x = x; }                    // used with 'new' only
var func2 = function (x) { var z={}; z.x = x; return z; }   // used both ways
func1.prototype.y = 11;
func2.prototype.y = 12;

A1 = new func1(1);      // has A1.x  AND  A1.y
A2 =     func1(1);      // undefined ('this' refers to 'window')
B1 = new func2(2);      // has B1.x  ONLY
B2 =     func2(2);      // has B2.x  ONLY

для меня, пока я не прототип, я использую стиль func2, поскольку он дает мне немного большую гибкость внутри и снаружи функции.

Есть уже некоторые очень большие ответы, но я публикую новый, чтобы подчеркнуть мое наблюдение на примере III ниже о том, что происходит, когда у вас есть явный оператор return в функции, которой вы являетесь new вверх. Взгляните ниже:

Случай I:

var Foo = function(){
  this.A = 1; 
  this.B = 2;
};
console.log(Foo()); //prints undefined
console.log(window.A); //prints 1

Выше - простой случай вызова анонимной функции, на которую указывает Foo. Когда вы вызываете эту функцию, она возвращает undefined. Поскольку нет явного оператора return, поэтому интерпретатор JavaScript принудительно вставляет инструкцию return undefined; в конце функции. Здесь window - объект вызова (контекстный this), который получает новые свойства A и B.

Случай II:

var Foo = function(){
  this.A = 1;
  this.B = 2;
};
var bar = new Foo();
console.log(bar()); //illegal isn't pointing to a function but an object
console.log(bar.A); //prints 1

Здесь интерпретатор JavaScript, который видит ключевое слово new, создает новый объект, который действует как объект-вызов (контекстная this) анонимной функции, на которую указывает Foo. В этом случае A и B становятся свойствами только что созданного объекта (вместо объекта окна). Поскольку у вас нет явного оператора return, поэтому интерпретатор JavaScript принудительно вставляет оператор return, чтобы вернуть новый объект, созданный из-за использования ключевого слова new.

Случай III:

var Foo = function(){
  this.A = 1;
  this.B = 2;
  return {C:20,D:30}; 
};
var bar = new Foo();
console.log(bar.C);//prints 20
console.log(bar.A); //prints undefined. bar is not pointing to the object which got created due to new keyword.

В этом случае интерпретатор JavaScript, который видит ключевое слово new, создает новый объект, который действует как объект-вызов (контекстный this) анонимной функции, на который указывает Foo. Опять же, A и B становятся свойствами нового созданного объекта. Но на этот раз у вас есть явный оператор return, поэтому интерпретатор JavaScript ничего не сделает.

В случае III следует отметить, что объект, созданный из-за ключевого слова new, потерялся из вашего радара. bar фактически указывает на совершенно другой объект, который не является тем, который был создан интерпретатором JavaScript из-за ключевого слова new.

Ключевое слово new предназначено для создания новых экземпляров объектов. И да, javascript - это язык динамического программирования, который поддерживает парадигму объектно-ориентированного программирования. Соглашение об именовании объектов всегда использует заглавную букву для объектов, которые должны быть созданы новым ключевым словом.

obj = new Element();

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

Если вы не используете ключевое слово new, контекст, под которым запускается функция Vehicle(), представляет собой тот же контекст, из которого вы вызываете функцию Vehicle. Ключевое слово this будет ссылаться на один и тот же контекст. Когда вы используете new Vehicle(), создается новый контекст, поэтому ключевое слово this внутри функции ссылается на новый контекст. То, что вы получаете взамен, - это вновь созданный контекст.

Ну JavaScript на si может сильно отличаться от платформы к платформе, поскольку она всегда является реализацией исходной спецификации EcmaScript.

В любом случае независимо от реализации все реализации JavaScript, соответствующие спецификации спецификации EcmaScript, предоставят вам объектно-ориентированный язык. Согласно стандарту ES:

ECMAScript - это объектно-ориентированный язык программирования для выполнение вычислений и манипулирование вычислительными объектами в среде хоста.

Итак, теперь, когда мы согласились, что JavaScript является реализацией EcmaScript и поэтому является объектно-ориентированным языком. Определение операции new на любом объектно-ориентированном языке говорит о том, что такое ключевое слово используется для создания экземпляра объекта из класса определенного типа (включая анонимные типы, в случаях, подобных С#).

В EcmaScript мы не используем классы, как вы можете прочитать из спецификаций:

ECMAScript не использует классы, например, в С++, Smalltalk или Java. Вместо этого объекты могут быть созданы различными способами, включая буквальное обозначение или через конструкторы, которые создают объекты, а затем выполняют код, который инициализирует все или часть из них, назначая начальные значения к их свойствам. Каждый конструктор является функцией, которая имеет свойство -     прототип ‖, который используется для реализации наследования на основе прототипов и общих свойств. Объекты создаются с помощью использование конструкторов в новых выражениях; например, новых Дата (2009,11) создает новый объект Date. Вызов конструктора без использования новых имеет последствия, которые зависят от конструктора. Например, Date() создает строковое представление текущая дата и время, а не объект.

Резюме:

new ключевое слово используется в javascript для создания объекта из функции-конструктора. new ключевое слово должно быть помещено перед вызовом функции конструктора и будет выполнять следующие действия:

1. Создает новый объект
2. Устанавливает прототип этого объекта в свойство прототипа функции конструктора
3. Привязывает this ключевое слово к вновь созданному объекту и выполняет функцию конструктора
4. Возвращает вновь созданный объект

Пример:

function Dog (age) {
  this.age = age;
}

const doggie = new Dog(12);

console.log(doggie);
console.log(doggie.__proto__ === Dog.prototype) // true

Что именно происходит:

1. const doggie говорит: Нам нужна память для объявления переменной.
2. Оператор assigment = говорит: мы собираемся инициализировать эту переменную с выражением после =
3. Выражение - new Dog(12). Механизм JS видит новое ключевое слово, создает новый объект и задает прототип для Dog.prototype
4. Функция конструктора выполняется с this значением, установленным для нового объекта. На этом этапе возраст назначается новому созданному объекту doggie.
5. Созданный объект возвращается и присваивается переменной doggie.

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

var Foo = function() {};
Foo.prototype.bar = 'bar';

var foo = new Foo();
foo instanceof Foo; // true

Экземпляры наследуют от prototype функции-конструктора. Итак, приведенный выше пример...

foo.bar; // 'bar'