Почему вы можете пропустить использование ключевого слова `new` в JavaScript [duplicate]

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

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

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

var john = new Person('John');

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

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

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

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

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

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:)

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

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);

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

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

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

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

foo.bar; // 'bar'

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

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

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

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

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

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

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

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

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

Есть уже некоторые очень большие ответы, но я публикую новый, чтобы подчеркнуть мое наблюдение на примере III ниже о том, что происходит, когда у вас есть явный оператор возврата в функции, которую вы 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; в конце функции. Здесь окно - это объект вызова (контекстный 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, f11] создает новый объект, который действует как объект вызова (контекстная this) анонимной функции, на которую указывает Foo. В этом случае A и B становятся свойствами только что созданного объекта (вместо объекта window). Поскольку у вас нет явного оператора 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 будет not делать что-нибудь свое.

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

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

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, поскольку он дает мне немного большую гибкость внутри и снаружи функции.

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

obj = new Element();