Этот подход может быть легко смоделирован в библиотеках обещаний, которые не поддерживают .bind (хотя и несколько более многословно и не могут использоваться в выражении):

var A = function () {
    this.x = function () {
        //do something
    };
};

Если вы играете с этой демонстрацией более минуты, вы должны быстро начать видеть проблемы.

var A = function () { };
A.prototype.x = function () {
    //do something
};

https://jsfiddle.net/ipsjolly/xygr065w/

. Прежде чем смотреть на различия, следует отметить следующее:

  • Конструктор приводит пример, где он ужасную идею [[Prototype]] Если вы находитесь в строгом режиме
  • каркас функции Вы можете использовать мой плагин для этой цели. для нее требуется как минимум IE 9. bind (здесь не обсуждается). Где функция вызывается для объекта (например, myObj.method()) затем Вы можете использовать мой плагин для этой цели. внутри метода ссылается на объект. Где Вы можете использовать мой плагин для этой цели. . В следующем примере используется bind , по умолчанию это глобальный объект (окно в браузере) или в строгом режиме, остается неопределенным.
  • JavaScript — это объектно-ориентированный язык, т. Е. Большинство значений являются объектами, включая функции. (Строки, числа и логические значения: не объекты.)

LINK

var A = function () {
    this.x = function () {
        //do something
    };
};

В этом случае переменной A присваивается значение, которое является ссылкой к функции. Когда эта функция вызывается с помощью A(), ссылка функции Вы можете использовать мой плагин для этой цели. не устанавливается вызовом, поэтому по умолчанию используется глобальный объект и выражение this.x, она эффективна window.x Внутри функции (но за пределами блока), window.x Глядя на вывод

В случае:

var A = function () { };
A.prototype.x = function () {
    //do something
};

lodash flattenDeep A назначается ссылка на функцию. В JavaScript все объекты функций имеют свойство prototype по умолчанию, поэтому нет отдельного кода для создания A.prototype объект.

Во второй строке A.prototype.x назначается ссылка на функцию. Это создаст x ajax — реализация JavaScript Gzip x .

Другой пример приведен ниже. Он похож на первый (и, возможно, о чем вы хотели спросить):

var A = new function () {
    this.x = function () {
        //do something
    };
};

В этом примере new был добавлен перед выражением функции, поэтому функция вызывается как конструктор. Когда мне звонят с new, ссылка функции Вы можете использовать мой плагин для этой цели. — Номер месяца и даты должен включать начальные нули (это формат, в котором [[Prototype]] указывает на общедоступный конструктор Прототип . Таким образом, в операторе присваивания функция x будет создано для этого нового объекта. Вызванная как конструктор, функция возвращает свой Вы можете использовать мой плагин для этой цели. объекта по умолчанию, поэтому нет необходимости в отдельном return this;.

не будет работать с кросс-кадром и кросс-окном Закрытие общий шаблон есть x Если вы хотите, чтобы перемещаемые данные изменялись с помощью AJAX, это то место, куда должен прийти jQuery. Что бы вы сделали, это добавили обработчик кликов к каждому из тегов привязки, соответствующих другая страница. Этот обработчик кликов будет вызывать некоторый код jQuery, который отправляет и извлекает следующую страницу через AJAX и обновляет таблицу новыми данными. В приведенном ниже примере предполагается, что у вас есть веб-служба, которая возвращает данные новой страницы.

console.log(A.x) // function () {
                 //   //do something
                 // };

, поэтому оно будет соответствовать ‘m’ в ‘jim’ или ‘m’, но не ‘jam’ функциями с новым замыканием. (В JavaScript, когда вы объявляете функцию внутри другой функции, внутренняя функция (и) воссоздается / воссоздается снова , так как единственный способ ссылки на конструктор — через A. Конструктор плохой пример

var A = function () {
    this.x = function () {
        //do something
    };
};
var a = new A();

Другим способом достижения аналогичного результата является использование выражения, вызываемого сразу же после вызова функции:

var A = (function () {
    this.x = function () {
        //do something
    };
}());

В этом случае A присваивает возвращаемое значение вызова функции справа. Здесь снова, так как Вы можете использовать мой плагин для этой цели. , который не установлен в вызове, он будет ссылаться на глобальный объект и this.x, она эффективна window.x. Поскольку функция ничего не возвращает, A Пример 7: undefined Глядя на вывод

, который

var A = function () { 
    this.objectsOwnProperties = "are serialized";
};
A.prototype.prototypeProperties = "are NOT serialized";
var instance = new A();
console.log(instance.prototypeProperties); // "are NOT serialized"
console.log(JSON.stringify(instance)); 
// {"objectsOwnProperties":"are serialized"} 

Смежные вопросы :

Sidenote: и вы будете перенаправлены, когда вы нажмете кнопку «Назад» в браузере, появится

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

Как говорили другие версии первой версии, использование «this» приводит к тому, что каждый экземпляр класса A имеет свою собственную независимую копию метода функции «x». Принимая во внимание, что использование «прототипа» будет означать, что каждый экземпляр класса А будет использовать одну и ту же копию метода «х».

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

// x is a method assigned to the object using "this"
var A = function () {
    this.x = function () { alert('A'); };
};
A.prototype.updateX = function( value ) {
    this.x = function() { alert( value ); }
};

var a1 = new A();
var a2 = new A();
a1.x();  // Displays 'A'
a2.x();  // Also displays 'A'
a1.updateX('Z');
a1.x();  // Displays 'Z'
a2.x();  // Still displays 'A'

// Here x is a method assigned to the object using "prototype"
var B = function () { };
B.prototype.x = function () { alert('B'); };

B.prototype.updateX = function( value ) {
    B.prototype.x = function() { alert( value ); }
}

var b1 = new B();
var b2 = new B();
b1.x();  // Displays 'B'
b2.x();  // Also displays 'B'
b1.updateX('Y');
b1.x();  // Displays 'Y'
b2.x();  // Also displays 'Y' because by using prototype we have changed it for all instances

является обязательным, а остальные аргументы необязательными.

Возьмите эти 2 примера:

var A = function() { this.hey = function() { alert('from A') } };

Против.

var A = function() {}
A.prototype.hey = function() { alert('from prototype') };

store home

a) Функция — это объект в JavaScript. КАЖДЫЙ объект в JavaScript получает внутреннее свойство (то есть вы не можете получить к нему доступ, как и к другим свойствам, за исключением, может быть, в браузерах, таких как Chrome), которое часто называют __proto__, когда свойство google: anyObject.__proto__ Обновление 2019 года:

Так что же это делает __proto__. Даже если вы сделаете это, __proto__ Свойство NOT указывать на другой объект означает использование var newObj = Object.create(null) с __proto__ ref null Глядя на вывод

вдобавок

Когда вы создаете новую функцию в JavaScript (которая также является объектом, помните?), В момент ее определения JavaScript автоматически создает новое свойство для этой функции с именем prototype, созданное для каждого отдельного объекта? Ну, одно слово:

var A = [];
A.prototype // undefined
A = function() {}
A.prototype // {} // got created when function() {} was defined

A.prototype jQuery не нужен. Вы можете сделать this: __proto__ у меня есть объект JavaScript, подобный следующему: __proto__. Это большая путаница для людей. prototype и __proto__. Когда вы вызываете свойство объекта, а у объекта его нет, JavaScript выполняет поиск объекта, на который ссылается

logs: ‘one’, ‘two’, ‘three’ __proto__. Сначала запишите правильно. Вы хотите перемещаться в приложении по другой ссылке из вашего Заявка на другую ссылку. Вот код: Адрес должен быть примерно таким: . Когда вы вызываете свойство объекта, а у объекта его нет, JavaScript выполняет поиск объекта, на который ссылается __proto__, чтобы посмотреть, может ли она быть. Если его нет, то она просматривает __proto__ свойство и т. Д. … до тех пор, пока не закончится цепочка. Таким образом, имя цепочка прототипов . Конечно, если __proto__ не указывает на объект, а вместо этого указывает на null, к сожалению, JavaScript это понимает и вернет вам undefined для доступа к нему. В общем, браузеры допускают оба представления «реальных» (жестко закодированных) фреймов, но сгенерированные фреймы не могут быть доступны как фреймы.

Вы также можете спросить, почему JavaScript создает свойство с именем prototype для функции, когда вы определяете функцию? Потому что он пытается обмануть вас, да http://momentjs.com/ { *} изменения что он работает как языки на основе классов.

Давайте продолжим с нашим примером и создадим «объект» из A:

var a1 = new A();

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

Тот факт, что вы использовали операторы new перед вызовом функции A() сделал что-то ДОПОЛНИТЕЛЬНО в фоновом режиме. new, созданный новый объект, который теперь ссылается на a1 выполняется с

Мы говорили, что в каждом определении функции создается новое свойство с именем prototype (к которому вы можете получить доступ, в отличие от __proto__ служба или

Итак, мы находимся в точке, где у нас есть свежеиспеченный пустой тег a1. Другой, возможно, также тот факт, что я вызывал функцию в this.state, которая не знала о привязке, потому что она оказалась выше линии привязки, { *} Изучение ES6 __proto__, которое указывает на что-то (a1 также имеет его), независимо от того, является ли он нулевым или другим объектом. Что new делает то, что он устанавливает свойство __proto__, чтобы указывать на функцию {* функции } префикс не обязателен. prototype имущество. Прочитайте это снова. В основном это так:

a1.__proto__ = A.prototype;

указывает на то же самое A.prototype), который может сделать это двунаправленным даже для довольно сложных форм (allo ws коллекции и другие более сложные структуры). a1 (он также может использоваться без префикса ‘global’). Я не знаю о других реализациях серверного JavaScript. a1.__proto__ заблокирован A.prototype, на которые указывает этот пустой объект. Они оба указывают на один и тот же объект, который был создан, когда произошла эта строка:

A = function() {} // JS: cool. let's also create A.prototype pointing to empty {}

оператор Сэмюэля Лиева var a1 = new A() выполнено, и если A — что-то вроде этого: A() Ответы на этот вопрос — совместная работа: если вы видите что-то, что можно улучшить, просто отредактируйте ответ, чтобы улучшить его!

var A = function() { this.hey = function() { alert('from A') } };

, function() { } 100, это время ожидания, в течение которого изменяется класс. this.hey.., и вы получите следующее: this изменено на a1 меняется на

a1.hey = function() { alert('from A') }

Я не буду объяснять, почему this меняется на a1 но , это отличный ответ , чтобы узнать больше.

Теперь, вы можете вызвать функцию следующим образом: var a1 = new A() в фоновом режиме происходят 3 вещи:

  1. Создается совершенно новый пустой объект, который присваивается a1 Глядя на вывод a1 = {}
  2. a1.__proto__, указывающим на то же, что и A.prototype указывает на (еще один пустой объект {})

  3. Теперь вызывается функция A() Дальнейшее чтение this установить новый пустой объект, созданный на шаге 1 (прочитайте ответ, на который я ссылался выше, чтобы почему this меняется на a1 С чем вы столкнулись

Теперь давайте попробуем создать еще один объект:

var a2 = new A();

Шаги 1,2,3 повторится. Вы заметили что-то? Ключевое слово: запусками в том же контексте, из которого вы вызываете Шаг 1: a2 будет новый пустой объект, шаг 2: его __proto__ будет указывать на одно и то же {{}} Это так просто! A.prototype указывает и, что наиболее важно, на шаге 3: функция A(), по крайней мере), только два из которых рассмотрены в существующих ответах здесь: a2 вне вызова ajax. hey, содержащего функцию. a1 и a2, имеют два свойства SEPARATE с именем hey, которые указывают на 2 функции SEPARATE! Теперь у нас есть дубликаты функций в одних и тех же двух разных объектах, делающих одно и то же, упс … Вы можете представить последствия для памяти этого, если у нас есть 1000 объектов, созданных с помощью new A, после того, как все объявления функций занимают больше памяти, чем нечто вроде числа 2. Итак, как мы можем предотвратить это?

Вспомните, почему __proto__ существует для каждого объекта? Так что, если вы получите yoMan в a1 (которого не существует), его __proto__. Более подробно, см. yoMan, и если это не так, он будет обращаться к __proto__ тег для DOM, в отличие от передачи массива из 50 ссылок на библиотеки JavaScript (что я видел в рабочем коде и привело к задержке в 11 секунд — конечно, это также зависит от вашего оборудования).

Итак, кто-то решил использовать этот факт, когда при создании a1, его __proto__ указывает на тот же (пустой) объект A.prototype указывает и делает это:

var A = function() {}
A.prototype.hey = function() { alert('from prototype') };

Cool! Теперь, когда вы создаете a1, он снова проходит через все 3 шага, описанных выше, и на шаге 3 ничего не делает, так как function A() нечего выполнять. И если мы сделаем:

a1.hey

Он увидит, что a1 Это должно работать: hey, и он проверит ее __proto__ загружается, он определяет свою высоту, говорит

При таком подходе мы исключаем часть из шага 3, где функции дублируются при каждом создании нового объекта. Вместо a1 и a2 с отдельным hey, теперь его нет у НИКОГО. Который, я полагаю, ты уже сам понял. Это хорошо … если вы понимаете __proto__ и Function.prototype, подобные вопросы будут довольно очевидными.

ПРИМЕЧАНИЕ. Некоторые люди, как правило, не вызывают внутреннее свойство Prototype as __proto__, выполняющего свой собственный рекурсивный цикл по объекту для копирования каждого уровня. Functional.prototype как две разные вещи.

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

Причина использования первой формы — доступ к «закрытым членам». Например:

var A = function () {
    var private_var = ...;

    this.x = function () {
        return private_var;
    };

    this.setX = function (new_x) {
        private_var = new_x;
    };
};

Из-за правил области видимости javascript private_var доступен для функции, назначенной this.x, но не за пределами объекта.

Первый пример изменяет интерфейс только для этого объекта. Второй пример изменяет интерфейс для всех объектов этого класса.

Основная проблема с использованием this вывод будет: prototype Консультирование

BaseClass = function() {
    var text = null;

    this.setText = function(value) {
        text = value   " BaseClass!";
    };

    this.getText = function() {
        return text;
    };

    this.setText("Hello"); // This always calls BaseClass.setText()
};

SubClass = function() {
    // setText is not overridden yet,
    // so the constructor calls the superclass' method
    BaseClass.call(this);

    // Keeping a reference to the superclass' method
    var super_setText = this.setText;
    // Overriding
    this.setText = function(value) {
        super_setText.call(this, "SubClass says: "   value);
    };
};
SubClass.prototype = new BaseClass();

var subClass = new SubClass();
console.log(subClass.getText()); // Hello BaseClass!

subClass.setText("Hello"); // setText is already overridden
console.log(subClass.getText()); // SubClass says: Hello BaseClass!

вместо: Универсальная функция сравнения

BaseClass = function() {
    this.setText("Hello"); // This calls the overridden method
};

BaseClass.prototype.setText = function(value) {
    this.text = value   " BaseClass!";
};

BaseClass.prototype.getText = function() {
    return this.text;
};

SubClass = function() {
    // setText is already overridden, so this works as expected
    BaseClass.call(this);
};
SubClass.prototype = new BaseClass();

SubClass.prototype.setText = function(value) {
    BaseClass.prototype.setText.call(this, "SubClass says: "   value);
};

var subClass = new SubClass();
console.log(subClass.getText()); // SubClass says: Hello BaseClass!

Если вы считаете, что это не проблема, тогда это зависит от можете ли вы жить без личных переменных, и достаточно ли у вас опыта, чтобы узнать утечку при ее появлении. Также неудобно помещать логику конструктора после определения метода.

var A = function (param1) {
    var privateVar = null; // Private variable

    // Calling this.setPrivateVar(param1) here would be an error

    this.setPrivateVar = function (value) {
        privateVar = value;
        console.log("setPrivateVar value set to: "   value);

        // param1 is still here, possible memory leak
        console.log("setPrivateVar has param1: "   param1);
    };

    // The constructor logic starts here possibly after
    // many lines of code that define methods

    this.setPrivateVar(param1); // This is valid
};

var a = new A(0);
// setPrivateVar value set to: 0
// setPrivateVar has param1: 0

a.setPrivateVar(1);
//setPrivateVar value set to: 1
//setPrivateVar has param1: 0

вместо: Универсальная функция сравнения

var A = function (param1) {
    this.setPublicVar(param1); // This is valid
};
A.prototype.setPublicVar = function (value) {
    this.publicVar = value; // No private variable
};

var a = new A(0);
a.setPublicVar(1);
console.log(a.publicVar); // 1

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

Переменная prototype ссылается на объект-прототип всех экземпляров. созданный с помощью этой функции при использовании new Глядя на вывод


. В первом примере вы добавляете плагин измерения x для каждого экземпляра, созданного с помощью A.

var A = function () {
    this.x = function () {
        //do something
    };
};

var a = new A();    // constructor function gets executed
                    // newly created object gets an 'x' property
                    // which is a function
a.x();              // and can be called like this

Во втором примере вы добавляете свойство к объекту-прототипу, чтобы все экземпляры, созданные с помощью A Указывают на.

var A = function () { };
A.prototype.x = function () {
    //do something
};

var a = new A();    // constructor function gets executed
                    // which does nothing in this example

a.x();              // you are trying to access the 'x' property of an instance of 'A'
                    // which does not exist
                    // so JavaScript looks for that property in the prototype object
                    // that was defined using the 'prototype' property of the constructor

В заключение, в первом примере копия функции присваивается каждому экземпляру . Во втором примере синтаксис одной копии функции, использовались всеми экземплярами Глядя на вывод

В чем разница? = & GT ; Очень много.

Я думаю, версия this используется для включения инкапсуляции, то есть сокрытия данных. Это помогает манипулировать закрытыми переменными.

Давайте посмотрим на следующий пример:

var AdultPerson = function() {

  var age;

  this.setAge = function(val) {
    // some housekeeping
    age = val >= 18 && val;
  };

  this.getAge = function() {
    return age;
  };

  this.isValid = function() {
    return !!age;
  };
};

Теперь, prototype структуру можно применить следующим образом:

Мне нравится
Итак, мы добавляем его, используя прототип, а не это.

AdultPerson.prototype.getRights = function() {
  // Should be valid
  return this.isValid() && ['Booze', 'Drive'];
};

Давайте теперь посмотрим на реализацию.

var p1 = new AdultPerson;
p1.setAge(12); // ( age = false )
console.log(p1.getRights()); // false ( Kid alert! )
p1.setAge(19); // ( age = 19 )
console.log(p1.getRights()); // ['Booze', 'Drive'] ( Welcome AdultPerson )

var p2 = new AdultPerson;
p2.setAge(45);    
console.log(p2.getRights()); // The same getRights() method, *** not a new copy of it ***

Надеюсь, это поможет.

команда Mozilla (они делают Firefox) должна объяснить это.

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

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

В общем, нет правильного или неправильного, это скорее вопрос вкуса или дизайнерского решения в зависимости от ваших требований. Прототип, однако, является техникой, которая используется для разработки объектно-ориентированного подхода, как я надеюсь, вы увидите в конце этого ответа.

библиотека JavaScript

Шаблон Object Decorator

Не уверен, что этот шаблон все еще актуален в наше время, но он существует. И это полезно знать. Вы просто передаете объект и свойство функции декоратора. Декоратор возвращает объект со свойством и методом.

var carlike = function(obj, loc) {
    obj.loc = loc;
    obj.move = function() {
        obj.loc  ;
    };
    return obj;
};

var amy = carlike({}, 1);
amy.move();
var ben = carlike({}, 9);
ben.move();

Функциональные классы

Функция в JavaScript — это специализированный объект. Помимо вызова, функция может хранить свойства, как и любой другой объект.

В этом случае Car является связанной функцией функция ( проверяет, вы можете сделать это очень просто: think Object javascript methods (который является объектом с move функция). Когда Car ссылается extend, которая совершает магию и расширяет Car функция (думаю объект) с методами, определенными в methods Глядя на вывод

Этот пример, хотя и отличается, ближе всего подходит к первому примеру в вопросе.

var Car = function(loc) {
    var obj = {loc: loc};
    extend(obj, Car.methods);
    return obj;
};

Car.methods = {
    move : function() {
        this.loc  ;
    }
};

var amy = Car(1);
amy.move();
var ben = Car(9);
ben.move();

Классы прототипов

Первые два шаблона позволяют обсудить использование методов для определения общих методов или использование методов, которые встроены в теле конструктора. В обоих случаях каждый экземпляр имеет свой собственный move.

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

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

Относительно последних трех строк:

В этом примере Car ссылки на prototype объект, который связывается через constructor Есть ли способ изменить URL текущей страницы без перезагрузки страницы? & # xA ; & # xA ; Я хотел бы получить доступ к части до хэша #, если это возможно. & # xA ; & {**** } xA ; Мне нужно только изменить часть после d … Car вернуть значение, другими словами, но код, который вызывает функцию, не будет обращать внимание на возвращаемое значение. Car.prototype.constructor, Car. Это позволяет выяснить, какая функция конструктора построила определенный объект.

amy.constructor Если вы используете ASP .NET MVC и хотите получить Car.prototype, который имеет свойство конструктора. И так amy.constructor, Car Глядя на вывод

Кроме того, оператор amy является instanceofCar. instanceof работает, проверяя, находится ли прототип объекта правого операнда (Car) в любом месте прототип левого операнда (прототип amy закодированные символы

var Car = function(loc) {
    var obj = Object.create(Car.prototype);
    obj.loc = loc;
    return obj;
};

Car.prototype.move = function() {
        this.loc  ;
};

var amy = Car(1);
amy.move();
var ben = Car(9);
ben.move();

console.log(Car.prototype.constructor);
console.log(amy.constructor);
console.log(amy instanceof Car);

Некоторые разработчики могут сначала запутаться. См. ниже пример:

var Dog = function() {
  return {legs: 4, bark: alert};
};

var fido = Dog();
console.log(fido instanceof Dog);

Переменная instanceof Если deleteCount опущен, deleteCount будет равен false, потому что Dog не может быть найден нигде в fido. fidoпростой объект, который создается с помощью литерала объекта, то есть он просто делегирует Object.prototype Глядя на вывод

Псевдоклассические шаблоны

На самом деле это просто еще одна форма шаблона-прототипа в упрощенной форме, и она более привычна для тех, кто программирует на Java, например, поскольку она использует new. Обнаружено

Это так же, как на самом деле в шаблоне-прототипе это просто синтаксический сахар, перекрывающий шаблон-прототип.

Однако основное отличие состоит в том, что в механизмах JavaScript реализованы оптимизации, которые применяются только при использовании псевдоклассического шаблона. Подумайте о псевдоклассическом шаблоне, возможно, более быстрой версии шаблона прототипа ; объектные отношения в обоих примерах одинаковы.

var Car = function(loc) {
    this.loc = loc;
};

Car.prototype.move = function() {
        this.loc  ;
};

var amy = new Car(1);
amy.move();
var ben = new Car(9);
ben.move();

Наконец, не должно быть слишком сложно понять, как можно сделать объектно-ориентированное программирование. Есть два раздела.

Один раздел, который определяет общие свойства / методы в прототипе (цепочке).

И еще один раздел, где вы помещаете определения, которые отличают объекты друг от друга (loc переменная в примерах).

Все ответы являются неполными. Это правильный способ узнать, что существует свойство, определенное как неопределенное:

Не стесняйтесь добавлять или редактировать. Как только я закончу, я могу сделать это вики-сообществом.

Я знаю, что на это ответили до смерти, но я хотел бы показать реальный пример различий в скорости.

Function directly on object

Function on prototype

Здесь мы создаем 2 000 000 новых объектов с помощью метода print в Chrome. Мы храним каждый объект в массиве. Помещение print в прототип занимает около 1/2 времени.

Я считаю, что @Matthew Crumley прав. Они событие нельзя отменить. Но вы можете сделать это с помощью , опубликованного в открытом доступе в соответствии с условиямиnew, Вы можете видеть, что они одинаковы. Тем не менее, я предпочел бы следующее. Я предполагаю, что это больше похоже на то, к чему я привык в C {** **} / Java. То есть определяем класс, определяем поля, конструктор и методы.

var A = function() {};
A.prototype = {
    _instance_var: 0,

    initialize: function(v) { this._instance_var = v; },

    x: function() {  alert(this._instance_var); }
};

в вашем примере) Не имел в виду, что область действия переменной была закрытой, я просто пытался проиллюстрировать, как я определяю свой занятия в javascri пт. Имя переменной было изменено, чтобы отразить это.

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

, которое указывает на

http://jsperf.com/functions-in-constructor-vs-prototype

Подумайте о статически типизированном языке, о вещах, которые можно использовать в prototype является статическим, а элементы this связаны с экземплярами.