Introduction à ecmascript5
Tout d'abord, nous devons comprendre qu'Ecmascript est un dieu-ma. Nous savons que JavaScript ou Livescript a été créé à l'origine par Netscape, et plus tard Microsoft a également suivi pour créer JScript. ScriptEase a également son propre Cenvi. De cette façon, il existe trois versions du script de navigateur qui font les leurs. Tout le monde comprend ce chaotique, donc la question de la normalisation est mise à l'ordre du jour. En 1997, la proposition basée sur JavaScript1.1 a été soumise à l'European Computer Manufacturers Association (European Computer Mufacturers A secteur). Enfin, tout le monde a développé ECMA-262, une nouvelle norme de langage de script appelé ECMAScript. L'année suivante, ISO / IEC (Organisation internationale pour la normalisation et la Commission électrotechnique internationale) a également adopté ECMAScript comme norme. Après cela, le monde sera paisible. Les principaux fabricants de navigateurs utilisent ECMascript comme base pour leur implémentation respective de JavaScript. Bien sûr, c'est juste le fond de base et n'a pas été complètement suivi. Sinon, nous n'aurions pas autant de problèmes de compatibilité des navigateurs.
Qu'est-ce que Ecmascript5? Comme son nom l'indique, c'est la cinquième version de cette étrange chose, tout comme l'iPhone 5. Ecmascript3, que nous utilisons souvent maintenant, est considéré comme un véritable langage de programmation plutôt qu'un jouet, et est devenu très populaire.
texte:
J'ai toujours eu une mauvaise compréhension de Get / Set avant, et je pense que Get Set est une méthode d'attribut d'objet. J'ai également eu de nombreuses questions après avoir lu les blogs d'autres personnes. Aujourd'hui, le système a fait beaucoup de tests et l'a finalement compris. (Si vous passez vous-même les tests de démonstration de lecture et d'écriture, s'il y a un incorrect, vous êtes invités à me critiquer et à me corriger)
L'accessoire GET / SET n'est pas la propriété d'un objet, mais la propriété d'une propriété. Tout le monde doit distinguer clairement. Les fonctionnalités ne sont utilisées qu'en interne, ils ne sont donc pas accessibles directement dans JavaScript. Pour indiquer que les caractéristiques sont des valeurs internes qui sont enfermées entre parenthèses entre les deux équipes, telles que [[valeur]].
1. Permettez-moi d'introduire brièvement ces caractéristiques des attributs (voici une simple approbation)
(1) Attribut de données - La position contenant une valeur de données. Cette position peut lire et écrire des valeurs.
Les attributs de données ont quatre caractéristiques qui décrivent leur comportement:
[[Configurable]]: est-il configurable?
[[Énumérable]]: Est-ce énumérable?
[[Writable]]: Est-ce lisible
[[Valeur]]: valeur d'attribut
(2) Attribut d'attribut accessor - ne contient pas de valeurs de données, contient une fonction Getter et Setter (ces deux fonctions ne sont pas requises)
Les propriétés accessoires ont également quatre caractéristiques qui décrivent leur comportement:
[[Configurable]]: est-il configurable?
[[Énumérable]]: Est-ce énumérable?
[[Get]]: la fonction appelée lors des attributs de lecture, la valeur par défaut n'est pas définie
[[Set]]: La fonction appelée lors des attributs d'écriture, la valeur par défaut n'est pas définie
2. Ici, nous nous concentrons sur l'introduction [[GET]] / [[set]] est ce que nous appelons accessoire Get / Set
Parlons d'abord des caractéristiques comportementales de l'accessoire GET / SET mentionné dans le livre: L'accessoire GET / SET peut être lu et écrit sans définition. Vous ne pouvez également en définir qu'un. S'il est défini uniquement, les attributs décrits ne peuvent être lisibles et non écrivains. Si seul le jeu est défini, les attributs décrits ne peuvent être écrits et non lisibles.
(1) Notre méthode d'origine GET SET est la suivante:
fonction foo (val) {var value = val; this.getValue = function () {return value;}; this.setValue = function (val) {value = val;};} var obj = new foo ("hello"); alert (obj.getValue ()); // "hello" obj.setvalue ("hi"); alert (obj.getvalue ());Le code ci-dessus est juste une méthode GET SET implémentée à l'aide de la portée de fermeture. Notez que la méthode est la méthode d'attribut de l'objet d'instance, pas la propriété d'attribut. Si cela n'est pas défini, la valeur de la valeur ne sera pas accessible
fonction foo (val) {var valeur = val; / * this.getValue = function () {return value;}; this.setValue = function (val) {value = val;}; * /} var obj = new foo ("hello"); alert (obj.value); // indéfiniLes exemples suivants sont également des méthodes d'attribut d'objets, et non des propriétés d'attribut.
var obj = {name: "John", get: function () {return this.age;} // seul get est défini, le défini n'est pas défini, mais il peut toujours lire, écrire et nom des attributs, même s'il s'agit d'âge // La méthode définie ici n'affectera pas les attributs Get, définis des attributs. Juste un attribut d'objet normal}; alert (obj.name); // John lisible obj.name = "jack"; // alert écrit (obj.name); // jack(2) Obtenez / définissez l'accessoire en tant que propriété de l'attribut Accessor.
Encore une fois, ce n'est pas l'attribut d'un objet, ils décident si l'attribut peut être lu et écrit. Si ce n'est pas défini, c'est OK, tout comme la lecture et l'écriture normalement (les propriétés peuvent être lues ou lues
Écrivez, lire et écrire un accès à la propriété elle-même)
Il existe deux façons de modifier l'attribut get / set:
un. Utilisez object.defineProperty ()
var object={_name:"Daisy" };Object.defineProperty(object,"name",{//The method name here means that a name property is defined (so it can be accessed through object.name), only the getter accessor is defined, no [[value]] value get:function (){//Only the get attribute is defined, so it can only be read but not written return this._name;}}); alert (object.name); // "daisy" object.name = "jack"; // seul l'accessoire de Getter est défini, donc l'écriture est invalide alert (object.name); // "daisy" object.name = "jack"; // seul accesseur est défini, donc l'écriture est invalide alert (objet);Notez que le nom de propriété dans object.defineProperty (objet, pro, {}) doit correspondre aux propriétés accessibles par objet.pro.
né Utilisez le mot clé Get Set:
var object = {_ name: "Daisy", get name () {// Le nom de la méthode ici signifie qu'un attribut de nom est défini (donc il peut être accessible via object.name), seul l'accessoire Getter est défini, aucune valeur [[valeur]] n'est définie. Return this._name;} // get, la méthode set n'est qu'une propriété de l'attribut, et non une méthode d'objet, qui détermine si l'attribut peut être lu et écrit}; alert (object.name); // Daisy La méthode pour supprimer le soulignement ici est Daisy; De plus, il est undefinedObject.name = "Jack"; // seul l'accessoire Getter est défini, il ne peut donc être lu mais pas écrire alert (object.name); // daisyLes deux méthodes ci-dessus sont équivalentes. Notez que les deux méthodes ci-dessus auront deux attributs dans l'objet objet: _name (avec valeur initiale) Nom (sans valeur initiale), qui peut être vu via la console du navigateur.
Alors, quand cet attribut de nom est-il vraiment défini? Nous savons que Object.DefineProperty (Object, Pro, {}) peut définir une nouvelle propriété Pro pour l'objet. Puisque get pro () {} / set pro () {} et object.defineproperty (objet, pro, {}) sont équivalents, une nouvelle propriété pro sera également définie. C'est pourquoi il y a deux propriétés dans l'objet.
(3) Le code d'implémentation de Get and Set Accessor en JavaScript dans cet article: lié à l'implémentation des accessoires GET et SET des normes standard: Réflexions raisonnables
J'ai écrit un exemple moi-même
Fonction foo (val) {this.value = val; // L'attribut de valeur est défini et non _value} foo.prototype = {set value (val) {// notez que le nom de la méthode et le nom d'attribut sont les mêmes, l'attribut de valeur est défini dans le prototype de ce.__VALUE = VAL;}, Get Value () {// Le nom de la méthode et l'attribut est l'attribut, la valeur et la valeur Get et Get Vale Les attributs sont définis dans le prototype return this._value;}}; // L'accesseur renvoie et les définit est à la fois _name, et il n'y a pas de définition ici. Pourquoi peut-il être lu ou écrit? ? ? ? var obj = new foo ("bonjour"); alert (obj.value); // "bonjour" obj.value = "yehoo"; alerte (obj.value); // "yehoo"Afin de résoudre la question ci-dessus, de nombreux tests ont été effectués, jetons un œil à un par un:
Regardez d'abord cet exemple. Seule la fonction GET est définie dans le prototype. Lorsque vous lisez l'attribut de valeur dans obj.value, recherchez-le dans l'instance sans lui, puis trouvez-le dans le prototype. La méthode GET est appelée, qui ne peut être lue mais non écrite.
Fonction foo (val) {this._value = val; // L'attribut ici est souligné, initialise l'attribut _value de l'objet d'instance, l'attribut _value est lisible et écrivable} foo.prototype = {// Set Value (Val) {// note que le nom de la méthode est le même que le nom d'attribut, et l'attribut de la valeur est défini dans le prototype // this._value = val; //}, get value () {// Le nom de la méthode est le même que le nom d'attribut, définit l'attribut de valeur et son attribut get dans le prototype return._value;}}; var obj = new foo ("hello"); alert (obj.value); // bonjour accède à la valeur du prototype L'attribut obj.value = "yehoo"; // définit uniquement l'attribut get de l'attribut de nom, donc il ne peut être lu mais non écrit. L'écriture est une alerte non valide (obj.value); // bonjourSi ce._value est supprimé du soulignement dans le constructeur, l'attribut de valeur défini dans le prototype définit l'attribut get. Vous pouvez toujours contrôler la lecture et l'écriture de l'attribut de valeur. En d'autres termes, lorsque Obj.Value accède aux attributs, la méthode GET sera appelée, la recherche d'abord dans l'objet lui-même, sinon, puis la recherche dans le prototype. Si rien ne l'est, il sera considéré comme non défini. La valeur par défaut est à la fois lisible et écrit.
fonction foo (val) {this.value = val; // seule la fonction GET de la valeur est définie dans le prototype, donc l'écriture ici est invalide} foo.prototype = {// Set Value (Val) {// note que le nom de la méthode et le nom d'attribut sont les mêmes, la fonction de définition de l'attribut de valeur est définie dans le prototype // this._value = val; //}, // valeur: "hah", // Même si la valeur de la valeur est écrite manuellement, car la méthode GET renvoie ce._value, la valeur ne peut pas être lue: "hah" // Tant que les attributs Get Pro () {} et la définition de la fonction sont les attributs corrects, les attributs corrects ne peuvent pas être présentés, ils peuvent lire et écrire, mais si la définition de la fonction est erronée, la valeur de la propriété correcte ne peut pas être créée, ce qui peut être lu, mais si la définition de la fonction est erronée, la valeur de la propriété correcte ne peut pas être consultée. Value () {// Le nom de la méthode est le même que le nom d'attribut. L'attribut de valeur et son attribut get sont définis dans le prototype. Return this._value;}}; var obj = new foo ("bonjour"); // "bonjour" n'a pas été écrit avec succès (obj.value); // non défini obj.value = "yehoo"; // a uniquePour prouver que l'exemple ci-dessus est lisible et non écrit: Écrivez manuellement _value: "hah", vous pouvez lire la valeur mais ne pouvez pas l'écrire.
fonction foo (val) {this.value = val; // seule la fonction GET de la valeur est définie dans le prototype, donc l'écriture ici est invalide} foo.prototype = {// Set Value (Val) {// note que le nom de la méthode et le nom d'attribut sont les mêmes, la fonction de définition de l'attribut de valeur est définie dans le prototype // this._value = val; //}, _ Valeur: "hah", // Même si la valeur de la valeur est écrite manuellement, car la méthode GET renvoie ce. Value () {// Le nom de la méthode est le même que le nom d'attribut. L'attribut de valeur et son attribut get sont définis dans le prototype. Return this._value;}}; var obj = new foo ("bonjour"); // "bonjour" n'a pas été écrit avec succès (obj.value); // "hah" obj.value = "yehoo"; // seul l'attribut get est défini, il ne peut donc être lu mais pas écrit, et l'écriture est une alerte invalide (obj.value); // "hah"Si la valeur: "hah" est écrite manuellement, puis-je m'efforcer de lire la valeur de la valeur? Étant donné que ce._value renvoyé par la méthode GET n'est pas défini, Obj.Value lit la valeur de valeur et les appels Get Value () {} Méthode à échouer, mais la valeur ne peut toujours pas être écrite.
Fonction foo (val) {this.value = val; // seule la fonction GET de la valeur est définie dans le prototype, donc l'écriture ici est invalide} foo.prototype = {// Set Value (Val) {// Notez que le nom de la méthode et le nom d'attribut sont les mêmes, la fonction définie de l'attribut de valeur est définie dans le prototype // ce.__value = Val; // Même si la valeur de la valeur est écrite manuellement, puisque la méthode GET renvoie ce._value, la valeur ne peut pas être lue correctement: "hah" // tant que le get pro () {} et le set pro () {} les attributs sont déclarés, ils peuvent lire et écrire, mais si la définition de la fonction est erronée, la valeur de propriété correcte ne peut pas être accessible si nécessaire. Value () {// Le nom de la méthode et le nom d'attribut sont les mêmes. L'attribut de valeur et sa fonction GET sont définis dans le prototype. Return this._value;}}; var obj = new foo ("bonjour"); // "bonjour" n'a pas été écrit avec succès alert (obj.value); // non défini lire invalide car tant que Obj.Value, obtenez les rendements. alerte (obj.value); // non définiEn regardant cet exemple, Get Set est défini, mais renvoie ce._value qui n'est pas défini. Vous pouvez constater que la valeur peut être lue et inscrite. Supprimez la méthode Get Set dans le prototype et il peut toujours être lisible ou écrit
fonction foo (val) {this.value = val;} foo.prototype = {set value (val) {this._value = val;}, get value () {return this._value;}}; var obj = new foo ("hello"); alert (obj.value); // bonjour obj.value = "yehoo"; alert (obj.value); // yehoo function foo (val) {this.value = val;} // c'est la même Foo ("bonjour"); alert (obj.value); // bonjour obj.value = "yehoo"; alert (obj.value); // yehooRésumer
Seul l'attribut get pro () {} est lisible et non écrit;
Déclarez uniquement l'attribut set pro () {} pour être écrivable et illisible.
Si aucune des déclarations n'est déclarée, les attributs sont lisibles et écrivains;
Si toutes les déclarations sont faites, lisez et écrivez selon la méthode définie par Get Set;
Si tous sont déclarés, mais la méthode de lecture et d'écriture définie ne peut pas être lue et écrite correctement, GET / SET échouera. Devenez la par défaut lisible et inscriptible
L'attribut de valeur défini dans le prototype définit l'attribut get. Vous pouvez toujours contrôler la lecture et l'écriture de l'attribut de valeur. En d'autres termes, lorsque Obj.Value accède aux attributs, la méthode GET sera appelée, la recherche d'abord dans l'objet lui-même, puis la recherche dans le prototype. S'il n'y a rien, il sera considéré comme non défini. La valeur par défaut est à la fois lisible et écrit.
Remplir:
Si vous utilisez Get pro () {} / set pro () {} ou object.defineProperty (objet, pro, {get: function () {return this._name;}});Pro ne peut pas être le même que le retour., Sinon, l'erreur suivante sera signalée: (Je ne sais pas pourquoi, cela semble être un débordement de pile causé par mon propre appel)
Après la correction du maître, je comprends pourquoi l'erreur est rapportée ici: si cette valeur est renvoyée dans la méthode Get Value () {}, la méthode de valeur GET sera appelée à nouveau, tombant ainsi dans une boucle morte, provoquant le débordement de la pile de méthode.