En fait, il existe plusieurs façons de créer des objets en JavaScript. Lorsque vous voulez simplement créer un objet, il n'y a aucun avantage à créer des objets " basés sur un constructeur " à l'aide de l' opérateur " nouveau ". Cela revient à créer un objet à l'aide de la syntaxe " littéral objet ". Mais les objets " basés sur un constructeur " créés avec un " nouvel " opérateur sont incroyablement utiles lorsque vous pensez à "l' héritage prototypique ". Vous ne pouvez pas conserver la chaîne d'héritage avec des objets créés avec une syntaxe littérale. Mais vous pouvez créer une fonction constructeur , attacher des propriétés et des méthodes à son prototype.", il retournera un objet qui aura accès à toutes les méthodes et propriétés attachées au prototype de cette fonction constructeur.
Voici un exemple de création d'un objet à l'aide de la fonction constructeur (voir l'explication du code en bas):
function Person(firstname, lastname) {
this.firstname = firstname;
this.lastname = lastname;
}
Person.prototype.fullname = function() {
console.log(this.firstname + ' ' + this.lastname);
}
var zubaer = new Person('Zubaer', 'Ahammed');
var john = new Person('John', 'Doe');
zubaer.fullname();
john.fullname();
Maintenant, vous pouvez créer autant d'objets que vous le souhaitez en instanciant la fonction de construction Personne et tous en hériteront fullname ().
Remarque: " ce " mot clé fera référence à un objet vide dans une fonction constructeur et chaque fois que vous créez un nouvel objet à partir de Personne à l'aide de l' opérateur " nouveau ", il renverra automatiquement un objet contenant toutes les propriétés et méthodes associées au mot clé " ce " . Et ces objets hériteront à coup sûr des méthodes et des propriétés attachées au prototype de la fonction constructeur Person (qui est le principal avantage de cette approche).
Soit dit en passant, si vous souhaitez obtenir la même fonctionnalité avec la syntaxe " littéral objet ", vous devrez créer fullname () sur tous les objets comme ci-dessous:
var zubaer = {
firstname: 'Zubaer',
lastname: 'Ahammed',
fullname: function() {
console.log(this.firstname + ' ' + this.lastname);
}
};
var john= {
firstname: 'John',
lastname: 'Doe',
fullname: function() {
console.log(this.firstname + ' ' + this.lastname);
}
};
zubaer.fullname();
john.fullname();
Enfin, si vous demandez maintenant pourquoi devrais-je utiliser l' approche fonction constructeur au lieu de l' approche littérale objet :
*** L'héritage prototypique permet une chaîne d'héritage simple qui peut être extrêmement utile et puissante.
*** Il économise de la mémoire en héritant des méthodes et propriétés communes définies dans le prototype des fonctions constructeur. Sinon, vous devrez les copier encore et encore dans tous les objets.
J'espère que cela a du sens.
a = new Object
,a = new Object()
,a = {}
, littéral est beaucoup plus simple et quelques tests j'ai couru un certain temps dire il y a il est plus rapide, les compilateurs plus récents peuvent avoir fait ma déclaration fausse. La même chose s'applique aux tableaux littéraux