Создание объекта и новое ключевое слово в javascript [dубликат]

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

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:

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

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

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

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

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

III :

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.

Случай II :

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 ничего не сделает.

В третьем случае следует отметить, что объект, созданный из-за ключевого слова 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, поскольку он дает мне немного большую гибкость внутри и снаружи функции. [ ! d1]

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

obj = new Element();