<script> function p () {var len = arguments.length; pour (var i = 0; i <len; i ++) {document.write (arguments [i] + "<br/>"); }} fonction myClass (x, y) {this.x = x; this.y = y; this.show = function () {return this.x + this.y; }} var m1 = new myClass (1,2); var m2 = new myClass (3,4); p (m1.show (), m2.show ()); </cript>Problèmes existants
1. Étant donné que toutes les instances de copie des entités définies par la même méthode, l'efficacité (efficacité de la mémoire et exécution inefficace) peut être résolue par l'héritage du prototype.
2. Impossible d'accès au contrôle des valeurs d'attribut (privé, public) peut être résolu par les fermetures
L'objet d'opération accessible par les attributs n'est pas une variable mais une référence à l'objet
Traitement de la lecture uniquement des parties entières des valeurs numériques
Math [ceci <0? «Celling»: «plancher»] (ceci);
Tableau associatif
Dans JS, vous devez transmettre des objets pour implémenter des tableaux associatifs
Les opérations de base sont effectuées par les clés, la définition d'éléments et la suppression des éléments.
<Script> var map = {x: 3, y: 4}; p (map.x); supprimer map.x; //truep(map.x); // non défini le résultat de l'accès à des éléments inexistants n'est pas défini. Étant donné que la valeur peut être définie sur un non-défini, il est impossible de juger si la valeur existe en comparant la valeur avec un non-défini. Vous pouvez l'énumérer par pour a = 'undefined'; p (a); // undefinedp (typeof map.x == a); // true </cript>En tant que tableau associatif, vous devriez prêter attention
<cript> fonction myClass (x, y) {this.x = x; this.y = y;} myclass.prototype.z = 5; var obj = new myClass (1,2); for (var key in obj) {p (key + ":" + obj [key]); // Les attributs hérités par le prototype seront énumérés} // x: 1 y: 2 z: 5delete obj.x; // truep (obj.x); //undefinedp(obj.z); // 5 // Les attributs hérités via le prototype ne peuvent pas être supprimés supprimer obj.z; //truep(obj.z) ;//5//when utilisant des objets comme tableau associatif, les littéraux sont généralement créés. Même si la vue utilise un littéral d'objet vide pour créer un tableau associatif sans éléments, l'attribut du prototype p ('toString' dans obj); // truevar obj1 = {}; p ('toString' dans obj1); // true // enumenp (obj1.length); // UndefinedFor (var k dans obj1) {p (obj1 [k]);} // aucun éléments n'est énuméré. Ceci est dû à l'attribut énumérable.//truevar obj1 = {}; p ('toString' dans obj1); // true // énumération d'énumération de p (obj1.length); // UndefinedFor (var k dans obj1) {p (obj1 [k]);} // aucun éléments n'est énuméré. Ceci est dû à l'attribut énumérable.//truevar obj1 = {}; p ('toString' dans obj1); // true // attribut auto-like var hérité en participant au prototype map = {}; p (map.hasownproperty ('toString')); //falSEMAP['toString'gal=1 ;p(map.hasownproperty('tostring ')); // TredeDelete map ['toString']; p (map.hasownproperty ('toString')); // faux </cript>Attributs
Les attributs de l'objet ont également certains attributs
Le tableau suivant résume les attributs définis dans la cinquième édition d'ECMascript, et la valeur d'attribut est définie comme des attributs de valeur.
Tableau 1
Nom d'attribut | signification |
scrutin | La valeur de l'attribut peut être réécrite |
dénuable | Peut être énuméré par en |
configurable | Vous pouvez modifier les attributs et supprimer les attributs |
obtenir | Fonction Getter qui spécifie les valeurs de propriété |
ensemble | Fonction de setter qui peut spécifier les valeurs d'attribut |
Objets immuables
Autrement dit, un objet dont l'état ne peut pas être modifié après la génération, et un objet String est un objet immuable typique.
L'utilisation flexible d'objets immuables peut améliorer la robustesse du programme, par exemple lors du passage aux paramètres de méthode, il existe une méthode pour réécrire le contenu de l'objet, etc.
Les objets immuables peuvent être mis en œuvre en js
1. Masquer l'attribut (statut caché) et ne pas fournir d'opérations de changement (mise en œuvre de la fermeture)
2. Utilisation flexible des fonctions fournies par Ecmascript dans la cinquième édition
3. Utilisation flexible des attributs, des setters et des getters écrivains
Les fonctions utilisées pour prendre en charge les objets immuables dans ECMAScript version 5 sont affichés dans le tableau suivant
Nom de méthode | Nouveaux attributs | Attribut Supprimer | Changement de valeur d'attribut | Méthode de confirmation |
prévenus | x | o | o | Objet.isextenible |
joint | x | x | o | Objet. |
geler | x | x | x | Objet. |
Object.Pretentextensions Exemple
<Script> var obj = {x: 2, y: 3}; object.pretentextensions (obj); // ne peut pas ajouter l'attribut obj.z = 4; p (object.keys (obj)); // x, y // ne peut pas supprimer l'attribut obj.y; p (object.keys (obj)); // x // Impossible d'ajouter la valeur d'attribut obj.x = 20; p (obj.x); //20//object.seal Exemple définit le configurable de l'attribut à false var obj = {x: 2, y: 3}; object.seal (obj); // ne peut pas ajouter ou supprimer obj.z = 3; p (object.keys (obj)); // x, ydelete obj.x; //falsep(object.keys(obj)) ;//x,y//can modifie la valeur d'attribut obj.x = 20; p (obj.x); // 20 // obj.z = 3; p (object.keys (obj)); // x, y // peut modifier la valeur d'attribut obj.x = 20; p (obj.x); // 20 </ script>Besoin de faire attention
1. Pour les trois méthodes ci-dessus, il ne peut pas être restauré une fois qu'ils sont modifiés.
2. Si vous voulez rendre la méthode héritée dans un héritage prototype inchangé, vous devez l'afficher.