Pourquoi cela ne fonctionne pas?Pourquoi la réaffectation de Object.prototype ne fonctionne pas?
// this one works as I expected, when objSayHello()
Object.prototype.objSayHello = function(){alert('Hello,from OBJECT prototype')};
// NOT working !
Object.prototype ={objSayHello: function(){alert('Hello,from OBJECT prototype')}};
objSayHello();
Parce que vous avez remplacé le prototype Object, de sorte que vous ajoutez une méthode objSayHello à tout objet descendant de Object (tous les objets).
Ne remplacez pas Object.prototype.
Qu'est-ce que vous voulez sans doute est:
someObj.prototype.objSayHello = function(){alert('Hello,from OBJECT prototype')};
Puis l'appeler avec:
someObj.objSayHello();
Ce que vous semblez être un sens à faire est:
Object.prototype.objSayHello = function(){alert('Hello,from OBJECT prototype')};
Mais c'est probablement une mauvaise idée car cela va entrer en conflit avec teurs (for...in) s'ils ne sont pas manipulés correctement.
Object.prototype.objSayHello = function(to){alert('Hello, ' + to)};
La déclaration ci-dessus signifie que vous avez joint la fonction objSayHello à toutes les instances qui seront créées comme chaque instance est enfant de Object si la liaison d'événement attaché à tous. Par exemple,
var newObject = {};
var anotherNewObject = new Object();
function person(name) {
this.name = name;
}
var newPerson = new Person("Ramiz");
newObject.objSayHello("newObject");
anotherNewObject.objSayHello("anotherNewObject");
newPerson.objSayHello(this.name);
Bien que, l'autre déclaration est incorrecte et sera ignoré complètement que vous êtes sur le point de jeter le prototype d'un objet qui est parent de tous. Si le prototype de Object peut être remplacé, toutes les fonctionnalités d'instances natives auront disparu. Pour éviter une telle erreur, je pense que c'est ignorer être override.
Object.prototype est pour une raison quelconque const, qui signifie en lecture seule.
Object.prototype n'est pas réellement le vrai prototype, c'est seulement une référence. Un objet interne [[prototype]] est utilisé comme prototype, et il est accessible dans certains navigateurs en tant que propriété proto d'un objet. Étant donné le fonctionnement des variables JavaScript, assigner le Object.prototype à un autre objet change sa référence mais sans modifier l'objet interne [[prototype]], donc vous obtenez une propriété normale appelée prototype qui ne dit rien sur la façon dont les propriétés des objets sont résolues. Donc, pourquoi cela fonctionne-t-il quand vous faites Object.prototype.myFunction()? Le Object.prototype est toujours un référence au [[prototype]] interne donc il n'a aucun problème avec l'augmenter avec cette fonction, il fonctionne comme avec tous les autres objets.
L'absence de paupière est incorrecte, vous avez simplement can't reassign the prototypes of intrinsic types comme objet, nombre, etc. Vous pouvez seulement ajouter de nouvelles propriétés.
> Number.prototype
-> Number
> Number.prototype = {} // Reassignment fails
-> Object
> Number.prototype
-> Number
> Number.prototype.objSayHello = 'hi' // Appending succeeds
-> 'hi'
> n = new Number(); n.objSayHello
-> 'hi'
Si vous utilisez vos propres objets, vous pouvez mettre à jour ou réattribuer le prototype (note: réaffectant le prototype n'affectera de nouveaux objets, et non ceux qui existent déjà).
Ne modifiez pas les prototypes intrisèques! Ceci est une 'mauvaise chose' car elle peut causer des effets secondaires difficiles à trouver. Si vous avez besoin d'un type de base avec de nouvelles propriétés, puis créer un nouvel objet avec le prototype pointant vers l'objet de base:
NewObject = function() {};
NewObject.prototype = Object.prototype;
NewObject.prototype.value = 123;
Maintenant vous avez un constructeur qui crée de nouveaux objets qui héritent des propriétés de son propre prototype (par exemple 'value') ainsi que le prototype Object ('toString', 'hasOwnProperty' ...).