JavaScript est le deuxième langage de programmation avec lequel je suis entré en contact après le langage C. Pendant mes vacances d'été de première année, j'ai trouvé une programmation JavaScript écrite chinoise dans la bibliothèque. À cette époque, j'étais presque un novice en programmation. De plus, le livre n'a pas du tout mentionné le mécanisme de programmation de JavaScript, et il y avait des mots trompeurs. J'ai toujours eu un malentendu profond de JavaScript, croyant que JavaScript n'est qu'un langage orienté objet qui s'exécute sur le navigateur. J'écrirai cet article déroutant et mal compris en JavaScript. Bien sûr, en raison du niveau limité de l'auteur et aucune expérience de développement, il existe inévitablement des omissions, et j'espère que la critique et la correction seront effectuées.
Objets JavaScript
Quel est l'objet
Le nouveau mot-clé peut être vu partout dans le code JavaScript, qui est facile à mal comprendre que JavaScript est une langue basée sur l'héritage des classes, tout comme Java. Mais ce n'est pas le cas. Il n'y a pas de classes en JavaScript. Alors, quel est l'objet de JavaScript qui n'est pas une classe? Dans un sens, les objets JavaScript sont des dictionnaires (tables de hachage) dans Python, et ce sont en fait des paires de valeurs clés similaires à ceci:
me = {"fisrtname": "cherche", "lastname": "vérité", "getName": function () {return this.firstname + this.lastName; // Cela équivaut à un pointeur de cet objet}}C'est une compréhension plutôt malentente. Quand je l'ai vu pour la première fois, je me sentais un peu incompréhensible, mais je me sentais toujours raisonnable de l'utiliser soigneusement. Nous pouvons utiliser l'opérateur [] pour obtenir des éléments comme Python, ou utiliser le. opérateur pour obtenir des éléments:
me.firstname // => Seekme ["LastName"] // => trutmme.getName () // => Seektruth
nouvel opérateur
Puisqu'il n'y a pas de classe en JavaScript, que fait le nouvel opérateur? C'est l'un des aspects les plus trompeurs de la conception JavaScript. JavaScript est un langage de programmation fonctionnelle. Les fonctions en JavaScript sont des citoyens de première classe, et les fonctions en JavaScript sont également des objets. Les objets de fonction seront ajoutés aux attributs d'appel lors de leur création. Ce qui est plus des pièges, c'est qu'il existe deux façons d'appeler les fonctions JavaScript. L'un est d'appeler avec le nouveau mot-clé, et l'autre est d'appeler sans le nouveau mot-clé. Le premier renverra un objet et le second renverra le contenu de l'instruction de retour. Considérez la fonction suivante:
fonction obj (name) {this.name = name; Nom de retour;}Si nous utilisons le nouvel opérateur pour appeler:
obj = new Obj ("Seektruth") // Obj sera un objet: {"name": "Seektruth"}
Si nous appelons directement:
obj = obj ("Seektruth") // Obj sera une chaîne: "Seektruth"
C'est en effet un design très délicat. Lorsque nous appelons, nous devons distinguer si nous devons utiliser de nouveaux. D'une manière générale, les fonctions qui doivent utiliser le nouveau mot-clé commenceront par la capitalisation.
Une autre chose délicate est que si la valeur de retour renvoyée est un objet:
fonction obj (name) {this.name = name; retour {};}De cette façon, que nous appelions ou non le nouvel opérateur, nous renvoyer la valeur dans l'instruction RETOUR:
Nouveau obj ("Seektruth") // => {} obj ("Seektruth") // => {}Qu'est-ce qu'il est conçu ...
Héritage d'objet
prototype
Comme mentionné précédemment, il n'y a pas de classe en JavaScript, alors comment JavaScript implémente l'héritage? La réponse passe par la chaîne prototype. Dans JavaScript, chaque objet a un prototype. Lors de la création d'un objet, s'il n'est pas spécifié, le prototype hérité par l'objet est objet.prototype. L'objet de fonction héritera la fonction.prototype (function.prototype objet hérité.prototype):
Object.prototype // => {} function.prototype // => [fonction]Nous pouvons voir le prototype de l'objet à travers la familiarité __proto__ de l'objet:
a = {} a .__ proto__ // => {}JavaScript implémente l'héritage en spécifiant le prototype de l'objet. Il existe trois façons principales de spécifier le prototype de l'objet. L'une consiste à indiquer le prototype dans le constructeur, le second est de modifier directement l'attribut __proto__ de l'objet, et le troisième consiste à utiliser la fonction Object.Create. Jetons un coup d'œil à son tour à tour.
Spécifiez le prototype du constructeur
Nous pouvons spécifier le prototype de l'objet dans le constructeur:
me = {"FirstName": "Seek", "LastName": "Truth", "getName": function () {return this.firstName + this.lastName; // Ceci équivaut à un pointeur de cet objet}} fonction obj (name) {this.firstName = name; ce .__ proto__ = moi; // spécifie le prototype en tant qu'objet ME}Après avoir spécifié le prototype, nous pouvons accéder aux propriétés du prototype après avoir créé un nouvel objet:
obj = new obj ("foo"); // => {FirstName: 'foo'} obj.firstname // => fooobj.lastName // => trutobj.getname () // => "Footruth"Lorsque vous accédez à un objet, vous essayez d'abord de trouver la propriété dans l'objet modifié. Sinon, revenez au prototype pour rechercher jusqu'à objet.prototype. Si nous réécrivons les propriétés (méthodes) du prototype dans un nouvel objet, alors lorsque nous l'utilisons, les propriétés (méthodes) nouvellement écrites écraseront la définition du prototype, ce qui est un peu comme la surcharge de fonction dans un langage basé sur la classe.
Notez que si la propriété LastName de l'objet Prototype ME a changé, car l'objet OBJ recherche des propriétés dans le prototype, la propriété LastName de l'objet OBJ changera également:
me.lastname = "me" obj.lastname // => "me" obj.getname () // => "foome"
Modifier directement le prototype de l'objet
Nous pouvons également spécifier directement (modifier) le prototype de l'objet:
obj2 = {} obj2 .__ proto__ = meoBj2.firstName // => SeekObj2.lastName // => "me" obj2.getName () // => "Seekme"Utilisez la fonction objet.Create
Bien que les deux premières méthodes puissent résoudre le problème, ces deux façons d'écrire ne sont pas élégantes, car JavaScript n'est pas une langue basée sur la classe, et le premier moyen d'écrire est facile à mal comprendre. Crockford, l'auteur de The Essence of JavaScript Language, estime que New ne devrait pas apparaître dans la langue JavaScript, et il est recommandé d'utiliser la fonction Object.Create pour créer des objets basés sur le prototype. L'utilisation de la fonction Object.Create est très simple:
obj3 = object.create (me) // Créez un nouvel objet avec moi comme prototype obj3.firstname // => SeekObj3.lastName // => "me" obj3.getName () // => "Seekme"
obj3 = object.create (me) équivaut à obj2 = {}; obj2.proto = moi, mais le premier est écrit plus élégamment et plus facile à comprendre.
Résumer
En tant que langage de programmation basé sur un prototype et fonctionnel, JavaScript a de nombreuses élégances et puissance dans la conception, mais en même temps, il a de nombreuses scories et des pièges. Pour le plus, JavaScript est également la langue qui est la plus mal compris. Après avoir appris le mécanisme de succession de l'objet de JavaScript, je pense que mon niveau s'est beaucoup amélioré.
La brève discussion ci-dessus sur les objets JavaScript et l'héritage est tout le contenu que je partage avec vous. J'espère que cela pourra vous donner une référence et j'espère que vous pourrez soutenir Wulin.com plus.