L'explication dans les commentaires est très détaillée, donc je ne parlerai pas beaucoup de bêtises ici, entrez simplement le code:
<Script Type = "Text / JavaScript"> // ECMA-262 Définit un objet comme: "Une collection d'attributs non ordonnés, dont les attributs peuvent contenir des valeurs, des objets ou des fonctions de base" // La façon la plus simple de comprendre l'objet est de créer une instance de l'objet et d'ajouter des attributs et des méthodes à It Var Person = nouvel objet (); personne.name = "xulei"; personne.age = "23"; personne.job = "ingénieur frontal"; personne.sayName = function () {alert (this.name); } // Vous pouvez également écrire var personne = {nom: "xulei", âge: 23, travail: "ingénierie frontale", SayName: function () {alert (this.name)}} // 1. Type d'attribut: attribut de données et accéder à son attribut // 1. Attribut de données, il existe 4 caractéristiques qui décrivent son comportement // [configurable]: indique si l'attribut peut être supprimé pour redéfinir l'attribut, si l'attribut peut être modifié, ou si l'attribut peut être modifié à l'attribut accessoire, la valeur par défaut est vraie // [Énumérable]: indique si l'attribut peut être renvoyé par le biais de la valeur par défaut est vrai // [Écrit]: indique que la valeur est réelle, la valeur par défaut est réelle // true // [Value]: contient la valeur de données de cet attribut. La valeur par défaut est non définie var personne = {name: "xulei"} // Un objet personne est créé ici, et la valeur de valeur est "xulei" // pour modifier les propriétés par défaut de la propriété, le nom de la propriété, l'objet descripteur) // l'objet de descripteur doit être configurable, le nom, la valeur de Vars Object.defineProperty (Peron, "Name", {Writeable: false, // La propriété ne peut pas être modifiée: "Xu lei-xulei"}); alert (peron.name); // xu lei-xulei Peron.name = "xu lei"; alert (peron.name); // xu lei-xulei // Les opérations ci-dessus seront ignorées en mode non strict. Si une exception est lancée en mode strict // Une fois que l'attribut est défini comme non configurable, il ne peut pas être transformé en configurable. // Dans la plupart des cas, il n'est pas nécessaire d'utiliser ces fonctionnalités avancées fournies par la méthode object.defineproperty (). Mais il est très utile pour comprendre JavaScript. // Les lecteurs sont invités à ne pas utiliser cette méthode sur IE8. // 2. L'accès à ses propriétés a 4 caractéristiques // [configurable]: indique si l'attribut peut être supprimé pour redéfinir l'attribut, si les caractéristiques de l'attribut peuvent être modifiées, ou si l'attribut peut être modifié à l'attribut accessoire, la valeur par défaut est vraie // [Énumérable]: indique si l'attribut peut être retourné par la valeur par défaut est vrai // [GET]: la valeur par défaut lorsque la lecture est défectueuse est vrai // [GET // [set]: la valeur par défaut de la fonction appelée lors de l'écriture de l'attribut non défini var book = {_year: 2004, édition: 1} objet.defineproperty (livre, "année", {get: function () {return this._year;}, set: function (value) {if (value> 2004) {this._year =; livre.year = 2005; alert (book.edition); // 2 // créer un objet // 1. Traitez le constructeur comme une personne de fonction (nom, âge, travail) {this.name = name; this.age = âge; this.job = job; this.sayName = function () {alert (this.name); }} // Utiliser var personne = new personne ("xulei", 23, "logiciel"); personne.sayName (); // Utiliser la personne ("xulei2", 23, "job2"); // ajouter à window.sayName (); // appelle var dans la portée d'un autre objet o = nouveau objet (); Person.Call (O, "Xulei3", 23, "Job3"); O.SayName (); </cript>Ayons un autre paragraphe:
<Script Type = "Text / JavaScript"> // 1. Comprendre l'objet Prototype // 2. Prototype et dans l'opérateur // 3. Syntaxe prototype plus simple // 4. Dynamicité du prototype // 5. Prototype d'objet natif // 6. Problèmes avec l'objet prototype // 1. Chaque fois qu'une fonction est créée, un attribut prototype sera créé pour la fonction basée sur un ensemble spécifique de règles. Cet attribut pointe à l'objet prototype de la fonction // Par défaut, tous les objets prototypes obtiendront automatiquement un attribut constructeur (constructeur), qui contient un pointeur vers la fonction où l'attribut prototype est situé // tel que la fonction personne () {} //person.prototype.Constructor pointer le constructeur de constructrices par défaut. En ce qui concerne les autres méthodes, ils sont hérités de l'objet.//when l'appel pour créer une nouvelle instance, l'instance contient un pointeur (propriété interne) pour pointer l'objet prototype du constructeur.//in firefox, safari et chrome, un property_proto_access var p1 = new personne (); alert (personne.prototype.isprototypeof (p1)) alert (object.getprototypeof (p1) == Person.prototype) // Bien que la valeur enregistrée dans le prototype puisse être accessible via l'instance d'objet, la valeur du prototype ne peut pas être réécrite via l'instance d'objet. Si nous ajoutons une propriété // à l'instance et que le nom de la propriété est le même que l'instance du prototype, nous créons la propriété dans l'instance, et la propriété bloquera la propriété dans le prototype. par exemple: fonction personne () {} personne.prototype.name = "Amber"; Personne.prototype.age = 23; Personne.prototype.job = "ingénieur logiciel"; Personne.prototype.sayName = function () {alert (this.name)} var person1 = new personne (); var person2 = new personne (); person1.name = "Amber.xu"; alert (Person1.name); // amber.xu --from instance alert (Person2.name); // Amber --from Prototype Delete Person1.name; alert (Person1.name); // ambre --in-from le prototype // utilise la méthode HasownProperty () pour détecter si une propriété existe dans l'instance ou dans le prototype. Cette méthode (héritée de l'objet) // renvoie true function personne () {} personne.prototype.name = "Amber"; Personne.prototype.age = 23; Personne.prototype.job = "ingénieur logiciel"; Personne.prototype.sayName = function () {alert (this.name)} var person1 = new personne (); var person2 = new personne (); alert (personne1.hasownproperty ("name")); // false de l'alerte d'instance (Person2.hasownproperty ("name")); // false de l'instance personne 1.name = "ambre.xu"; alerte (personne1.name); alert (Person1.HasownProperty ("nom")); // true de l'instance delete Person1.name; alerte (personne1.name); alert (personne1.hasownproperty ("nom")); // false du prototype // 2. Prototype et dans l'opérateur // Il y a deux façons de l'utiliser, une est utilisée séparément et in-in. Lorsqu'elle est utilisée seule, l'opérateur in Retourne True lorsque l'objet peut accéder à une propriété donnée //, peu importe si la propriété provient du prototype ou de la fonction d'instance personne () {} personne.prototype.name = "Amber"; Personne.prototype.age = 23; Personne.prototype.job = "ingénieur logiciel"; Personne.prototype.sayName = function () {alert (this.name)} var person1 = new personne (); var person2 = new personne (); alert ("nom" en person1); // true from the prototype alert ("nom" en person2); // true from the prototype alert ("height" in Person1); // false // de cette façon vous pouvez encapsuler une fonction (si la propriété donnée est le prototype de l'objet donné) function hasprototypePrperty (objet, nom) {return! } alert("--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Returns all Les propriétés énumérées qui peuvent être accessibles via des objets, y compris les propriétés du prototype et de l'instance. O = {toString: function () {return "mon objet";}}; Accepter un objet comme un argument, // un tableau de chaîne contenant toutes les propriétés énumérables function personne () {} personne.prototype.name = "ambre"; Personne.prototype.age = 23; Personne.prototype.job = "ingénieur logiciel"; Personne.prototype.sayName = function () {alert (this.name)} var person1 = new personne (); var person2 = new personne (); var keys = object.keys (personne.prototype); alert (clés) Person1.name = "Amber.xu"; Person1.age = 23; var keys = object.keys (person1); alerte (clés) alerte("--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Nom: "Amber", Âge: 23, "Software", SayName: Function () {alert (this.name)}} // Après avoir écrit ceci, l'attribut du constructeur ne pointe pas de la fonction de la personne, mais le type de l'objet ne peut pas être déterminé par le constructeur. alert (ami instanceof objet) // true alert (ami.constructor == personne); // false alert (ami.constructor == objet); // true // si le constructeur est vraiment important pour vous, vous pouvez le définir sur la valeur appropriée comme la fonction de la fonction () {} personne.prototype = {Constructeur: Personne, nom: "ambre", âge: 23, travail: "Software", fonction: fonction () alert (this.name)}} var ami = new personne (); alerte ("réglé manuellement Constructeur ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- // Dans ce cas, vous pouvez utiliser object.defineProperty (personne.prototype, "constructeur", {énumérable: false, valeur: personne}); Instance et prototype, la connexion entre l'instance et le prototype n'est qu'un pointeur, pas une copie // lorsque nous appelons la méthode sayhi (), nous rechercherons d'abord une méthode nommée Sayhi dans l'instance et rechercher le prototype s'il n'est pas trouvé. // Cependant, si vous réécrivez l'ensemble de l'objet Prototype, la situation sera différente. // Nous savons que lors de l'appel du constructeur, un pointeur prototype vers le prototype d'origine sera ajouté à l'instance, et la modification du prototype à un autre objet équivaut à couper la connexion entre le constructeur et le prototype d'origine. // Rappelez-vous: le pointeur de l'instance ne pointe que le prototype, pas le constructeur. Eg: fonction a () {} var a1 = new a (); A.prototype = {constructeur: a, nom: "ambre", âge: 23, travail: "logiciel", SayName: function () {alert (this.name)}} alert("ERROR------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ Even all Les types de référence natifs sont créés en utilisant ce modèle. String.prototype.startswith = function (text) {return this.indexof (text) == 0; }; var msg = "Bonjour"; alert (msg.startswith ("h")); // Nous ne recommandons pas de faire cela. alert ("Problème de prototype avec l'objet Prototype"); // 6. Exemple de prototype Ques () {} Ques.prototype = {Constructor: Ques, Name: "Amber", Age: 23, Job: "It", Friends: ["Zhang San", "Li Si"], // Type de référence SADNAME: fonction () {alert (this.name)}}; var q1 = new Ques (); var Q2 = new Ques (); Q1.Friends.push ("Wang Wu"); alert (q1.friends); // alert (q2.friends); // alert (q1.friends === q2.friends); // Je crois que tout le monde a vu le problème. Lorsque j'ai créé deux instances Q1 et Q2, et quand j'ai ajouté "Wang Wu" aux "amis" des "Friends" de Q2, a également eu trois "Wang San, Li Si et Wang Wu //, c'est parce que le tableau existe sur les questions.Cet article se terminera ici. Nous continuerons à discuter de la programmation orientée objet de JavaScript à l'avenir. J'espère que tout le monde pourra l'aimer.