Почему нам нужно установить DerivedObject.prototype.constructor в DerivedObject? [Дубликат]

Это огромная ошибка, если вы написали

Student.prototype.constructor = Student;

, но тогда, если бы существовал Учитель, чей прототип был также Person, и вы написали

Teacher.prototype.constructor = Teacher;

, тогда Студент конструктор теперь учитель!

Редактировать: вы можете избежать этого, убедившись, что вы установили прототипы ученика и учителя, используя новые экземпляры класса Person, созданные с использованием Object.create, как в примере Mozilla.

Student.prototype = Object.create(Person.prototype);
Teacher.prototype = Object.create(Person.prototype);

Для простой функции конструктора:

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


console.log(Person.prototype.constructor) // function Person(){...}

Person.prototype = { //constructor in this case is Object
    sayName: function(){
        return this.name;
    }
}

var person = new Person();
console.log(person instanceof Person); //true
console.log(person.sayName()); //test
console.log(Person.prototype.constructor) // function Object(){...}

По умолчанию (из спецификации https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects / Object / constructor ), все прототипы автоматически получают свойство, называемое конструктором, которое указывает на функцию, на которой это свойство. В зависимости от конструктора к прототипу могут быть добавлены другие свойства и методы, которые не являются очень распространенной практикой, но все же разрешены для расширений.

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

Должны ли мы всегда правильно устанавливать это стоимость? Это помогает при отладке и делает внутреннюю структуру совместимой со спецификацией. Мы должны определенно, когда наш API будет использоваться третьими сторонами, но не совсем, когда код будет окончательно выполнен во время выполнения.

Это необходимо, если вам нужна альтернатива toString без monkeypatching:

//Local
foo = [];
foo.toUpperCase = String(foo).toUpperCase;
foo.push("a");
foo.toUpperCase();

//Global
foo = [];
window.toUpperCase = function (obj) {return String(obj).toUpperCase();}
foo.push("a");
toUpperCase(foo);

//Prototype
foo = [];
Array.prototype.toUpperCase = String.prototype.toUpperCase;
foo.push("a");
foo.toUpperCase();

//toString alternative via Prototype constructor
foo = [];
Array.prototype.constructor = String.prototype.toUpperCase;
foo.push("a,b");
foo.constructor();

//toString override
var foo = [];
foo.push("a");
var bar = String(foo);
foo.toString = function() { return bar.toUpperCase(); }
foo.toString();

//Object prototype as a function
Math.prototype = function(char){return Math.prototype[char]};
Math.prototype.constructor = function() 
  {
  var i = 0, unicode = {}, zero_padding = "0000", max = 9999;
  
  while (i < max) 
    {
    Math.prototype[String.fromCharCode(parseInt(i, 16))] = ("u" + zero_padding + i).substr(-4);

    i = i + 1;
    }    
  }

Math.prototype.constructor();
console.log(Math.prototype("a") );
console.log(Math.prototype["a"] );
console.log(Math.prototype("a") === Math.prototype["a"]);

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

Student.prototype.constructor = Student; 

, это то, что теперь у вас есть ссылка на текущий «конструктор».

В ответе Уэйн, который был отмечен как правильный, вы можете сделать то же самое, что следующий код делает

Person.prototype.copy = function() {  
    // return new Person(this.name); // just as bad
    return new this.constructor(this.name);
};  

с кодом ниже (просто замените this.constructor на Person)

Person.prototype.copy = function() {  
    // return new Person(this.name); // just as bad
    return new Person(this.name);
}; 

Слава Богу, что с ES6 classic Натураторы-пуристы могут использовать собственные операторы языка, такие как класс, extends и super, и нам не нужно видеть, как исправления prototype.constructor и родительские рефери.

Я бы не согласился. Нет необходимости устанавливать прототип. Возьмите тот же самый код, но удалите строку prototype.constructor. Что-нибудь изменилось? Нет. Теперь сделайте следующие изменения:

Person = function () {
    this.favoriteColor = 'black';
}

Student = function () {
    Person.call(this);
    this.favoriteColor = 'blue';
}

и в конце тестового кода ...

alert(student1.favoriteColor);

Цвет будет синим.

Изменение в prototype.constructor, по моему опыту, мало что делает, если вы не делаете очень конкретные, очень сложные вещи, которые, вероятно, не являются хорошей практикой:)

Редактировать: После того, как несколько раз выкарабкались по сети и делали некоторые эксперименты, похоже, что люди устанавливают конструктор так, что он «выглядит» как вещь, которая строится с помощью «нового». Думаю, я бы сказал, что проблема в том, что javascript - это прототип языка - нет такой вещи, как наследование. Но большинство программистов исходят из программирования, который накладывает наследование как «путь». Поэтому мы придумываем всевозможные вещи, чтобы попытаться сделать этот прототип языка «классическим» языком, например, расширением «классов». Действительно, в примере, который они дали, новый студент - это человек - он не «распространяется» от другого ученика. Студент - это все о человеке, и независимо от того, кем является ученик, также. Расширьте учащегося, и все, что вы расширили, - это студент в глубине души, но настроен в соответствии с вашими потребностями.

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

Выполняет ли это какую-либо важную цель?

Да и нет.

В ES5 и ранее JavaScript сам не использовал constructor для что-нибудь. Он определил, что объект по умолчанию для свойства функции prototype будет иметь его и что он будет ссылаться на функцию, а - на .

Это изменилось в ES2015 (ES6), который начал использовать его по отношению к иерархиям наследования. Например, Promise#then использует свойство constructor обещанного вами обещания (через SpeciesConstructor ) при создании нового обещания для возврата. Он также участвует в подтипировании массивов (через ArraySpeciesCreate ).

Вне самого языка иногда люди использовали его при попытке создания общих функций «клонировать» или просто вообще, когда они хотел ссылаться на то, что, по их мнению, будет функцией конструктора объекта. Мой опыт в том, что использование его редко, но иногда люди его используют.

Можно ли его опустить?

Это по умолчанию, вы нужно вернуть его, когда вы замените объект на свойство функции prototype:

Student.prototype = Object.create(Person.prototype);

Если вы этого не сделаете:

Student.prototype.constructor = Student;

... тогда Student.prototype.constructor наследует от Person.prototype, который (предположительно) имеет constructor = Person. Так что это вводит в заблуждение. И, конечно, если вы подклассифицируете что-то, что использует его (например, Promise или Array), а не используя class ¹ (который обрабатывает это для вас), вам нужно убедиться, что вы правильно настроили его. Итак, в основном: это хорошая идея.

Все в порядке, если ничто в коде (или используемом вами библиотечном коде) не использует его. Я всегда гарантировал, что он правильно подключен.

Конечно, с ключевым словом ES2015 (иначе ES6) class, большую часть времени мы бы его использовали, нам не нужно потому что он обрабатывается для нас, когда мы делаем

class Student extends Person {
}

---

¹ "... если вы подклассифицируете что-то, что его использует (например, Promise или Array), и не используя class ... " & nbsp; & mdash; Это возможно сделать это, но это настоящая боль (и немного глупо). Вы должны использовать Reflect.construct .

Не нужно использовать «классы классов» или «Новый» в наши дни. Используйте литералы объектов.

Прототип объекта уже является «классом». Когда вы определяете литерал объекта, он уже является экземпляром прототипа Object. Они также могут выступать в качестве прототипа другого объекта и т. Д.

const Person = {
  name: '[Person.name]',
  greeting: function() {
    console.log( `My name is ${ this.name || '[Name not assigned]' }` );
  }
};
// Person.greeting = function() {...} // or define outside the obj if you must

// Object.create version
const john = Object.create( Person );
john.name = 'John';
console.log( john.name ); // John
john.greeting(); // My name is John 
// Define new greeting method
john.greeting = function() {
    console.log( `Hi, my name is ${ this.name }` )
};
john.greeting(); // Hi, my name is John

// Object.assign version
const jane = Object.assign( Person, { name: 'Jane' } );
console.log( jane.name ); // Jane
// Original greeting
jane.greeting(); // My name is Jane 

// Original Person obj is unaffected
console.log( Person.name ); // [Person.name]
console.log( Person.greeting() ); // My name is [Person.name]

Это стоит прочитать :

Объектно-ориентированное на основе класса Языки, такие как Java и C ++, основаны на концепции двух разных сущностей: классов и экземпляров.

...

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

Получил хороший пример кода, почему действительно необходимо установить конструктор прототипов ..

function CarFactory(name){ 
   this.name=name;  
} 
CarFactory.prototype.CreateNewCar = function(){ 
    return new this.constructor("New Car "+ this.name); 
} 
CarFactory.prototype.toString=function(){ 
    return 'Car Factory ' + this.name;
} 

AudiFactory.prototype = new CarFactory();      // Here's where the inheritance occurs 
AudiFactory.prototype.constructor=AudiFactory;       // Otherwise instances of Audi would have a constructor of Car 

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

AudiFactory.prototype.toString=function(){ 
    return 'Audi Factory ' + this.name;
} 

var myAudiFactory = new AudiFactory('');
  alert('Hay your new ' + myAudiFactory + ' is ready.. Start Producing new audi cars !!! ');            

var newCar =  myAudiFactory.CreateNewCar(); // calls a method inherited from CarFactory 
alert(newCar); 

/*
Without resetting prototype constructor back to instance, new cars will not come from New Audi factory, Instead it will come from car factory ( base class )..   Dont we want our new car from Audi factory ???? 
*/