Discussão: JavaScript Ecamscript5 Novo recurso Get/Set Accessor

Introdução ao ECMAScript5

Primeiro de tudo, devemos descobrir que o Ecmascript é um Deus-Ma. Sabemos que o JavaScript ou o LiveScript foi criado originalmente pelo Netscape, e mais tarde a Microsoft também seguiu para criar o JScript. O scriptase também tem seu próprio Cenvi. Dessa forma, existem três versões do script do navegador que fazem o seu próprio. Todo mundo entende esse caótico, então a questão da padronização é colocada na agenda. Em 1997, a proposta baseada em JavaScript1.1 foi submetida à Associação Europeia de Fabricantes de Computadores (computadores europeus Manufactureiros A setor). Finalmente, todos desenvolveram o ECMA-262, um novo padrão de linguagem de script chamado ECMAScript. No ano seguinte, a ISO/IEC (Organização Internacional de Padronização e Comissão Eletrotécnica Internacional) também adotou o ECMAScript como padrão. Depois disso, o mundo será pacífico. Os principais fabricantes de navegadores usam o ECMAScript como base para a respectiva implementação do JavaScript. Obviamente, é apenas a base e não foi completamente seguida. Caso contrário, não teríamos tantos problemas de compatibilidade do navegador.

O que é o ECMAScript5? Como o nome sugere, é a quinta versão dessa coisa estranha, assim como o iPhone 5. O ECMAScript3, que costumamos usar agora, é considerado uma linguagem de programação real, em vez de um brinquedo, e se tornou muito popular.

texto:

Eu sempre tive uma compreensão errada do Get/Set antes e acho que o Get Set é um método de atributo de objeto. Eu também tive muitas perguntas depois de ler os blogs de outras pessoas. Hoje, o sistema fez muitos testes e finalmente descobriu. (Se você passar nos testes de demonstração de leitura e escrita, se houver algum incorreto, você poderá me criticar e me corrigir)

O acessador GET/Set não é a propriedade de um objeto, mas a propriedade de uma propriedade. Todos devem distinguir claramente. Os recursos são usados apenas internamente, para que não possam ser acessados diretamente no JavaScript. Para indicar que as características são valores internos estão entre colchetes entre as duas equipes, como [[valor]].

1. Deixe -me apresentar brevemente essas características dos atributos (aqui está um endosso simples)

(1) Atributo de dados - a posição que contém um valor de dados. Esta posição pode ler e escrever valores.

Os atributos de dados têm quatro características que descrevem seu comportamento:

[[Configurável]]: É configurável?

[[Enumerable]]: É enumerável?

[[WRITED]]: é legível

[[Valor]]: Valor do atributo

(2) Atributo do acessador Atributo - Não contém valores de dados, contém uma função Getter e Setter (essas duas funções não são necessárias)

As propriedades do acessador também têm quatro características que descrevem seu comportamento:

[[Configurável]]: É configurável?

[[Enumerable]]: É enumerável?

[[Get]]: a função chamada ao ler atributos, o padrão é indefinido

[[Set]]: a função chamada ao escrever atributos, o padrão é indefinido

2. Aqui nos concentramos em introduzir [[get]/[[set]] é o que chamamos de acessador Get/Set Accessor

Vamos falar sobre as características comportamentais do acessador Get/Set mencionado no livro: o acessador Get/Set pode ser lido e escrito sem definição. Você também pode definir apenas um. Se apenas o obtiver for definido, os atributos descritos só podem ser legíveis e não graváveis. Se definido apenas estiver definido, os atributos descritos só poderão ser gravados e não são legíveis.

(1) Nosso método original do GET Set é o seguinte:

 function 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 ".

O código acima é apenas um método GET Set implementado usando o escopo de fechamento. Observe que o método é o método de atributo do objeto de instância, não a propriedade Atributo. Se não for definido, o valor do valor não será acessível

 function foo (val) {var value = val;/* this.getValue = function () {return value;}; this.setValue = function (val) {value = val;};*/} var obj = new Foo ("hello"); alerta (obj.value); // indefinido

Os exemplos a seguir também são métodos de atributo de objetos, não propriedades de atributo.

 var obj = {name: "John", get: function () {return this.age;} // só é definido, o conjunto não é definido, mas ainda pode ler, escrever e nomear atributos, mesmo que seja idade // o método definido aqui não afetará os atributos Get, defina os atributos. Apenas um atributo de objeto normal}; alert (obj.name); // john readerable obj.name = "jack"; // alerta de gravação (obj.name); // jack

(2) Get/Set Accessor como uma propriedade do atributo acessador.

Novamente, não é o atributo de um objeto, eles decidem se o atributo pode ser lido e escrito. Se não estiver definido, está tudo bem, assim como ler e escrever normalmente (as propriedades podem ser lidas ou lidas

Escreva, leia e escreva acesso à própria propriedade)

Existem duas maneiras de alterar o atributo get /set:

um. Use Object.DefineProperty ()

 var object = {_ Nome: "Daisy"}; object.DefineProperty (objeto, "nome", {// O nome do método aqui significa que uma propriedade de nome é definida (para que possa ser acessado através do object.name), apenas que o acessador getter é definido, não é definido, [valor]. this._name;}}); alert (object.name); // "Daisy" object.name = "jack"; // somente o acessador getter é definido, então a gravação é inválida alerta (object.name); // "margarida" writle.name "jack"; // apenas o acessor.name é definido, então all é o que é o que é o que é o que é o que é o que é o que é o que é o que é o que é o que é o que é o que é o que é o que é o que você está fazendo com o objetivo de avaliar o desempenho de um que é um dos melhores pessoas.

Observe que o nome da propriedade em object.DefineProperty (object, pro, {}) deve corresponder às propriedades acessadas pelo object.pro.

b. Use a palavra -chave GET Set:

 var object = {_ nome: "Daisy", get name () {// o nome do método aqui significa que um atributo de nome é definido (para que ele possa ser acessado através do object.name), apenas o acessador do getter é definido, nenhum valor [[valor]] é definido. Retorne this._name;} // get, o método set é apenas uma propriedade do atributo, não um método de objeto, que determina se o atributo pode ser lido e escrito}; alerta (object.name); // Daisy O método para remover o sublinhado aqui é Daisy; Além disso, é UndefinedObject.name = "Jack"; // Somente o acessador getter é definido, para que só possa ser lido, mas não escreva alerta (object.name); // Daisy

Os dois métodos acima são equivalentes. Observe que os dois métodos acima terão dois atributos no objeto do objeto: _name (com valor inicial) Nome (sem valor inicial), que pode ser visto através do console do navegador.

Então, quando esse atributo de nome é realmente definido? Sabemos que object.DefineProperty (objeto, pro, {}) pode definir um novo Propriedade Pro para o objeto. Como get pro () {}/set pro () {} e object.DefineProperty (objeto, pro, {}) são equivalentes, um novo Property Pro também será definido. É por isso que existem duas propriedades no objeto.

(3) O Código de Implementação do Acessador Get e Set em JavaScript neste artigo: Relacionado à implementação de acessadores GET e Set of Standard Standards: Pensamentos razoáveis

Eu mesmo escrevi um exemplo

 function Foo(val){this.value=val;//The value attribute is defined and no _value}Foo.prototype={set value(val){//Note that the method name and attribute name are the same, the value attribute is defined in the prototype this._value=val;}, get value(){//The method name and attribute name are the same, and the value attribute and its get attribute are definido no protótipo retornar this._value;}}; // O acessador retorna e os define são ambos _name, e não há definição aqui. Por que pode ser lido ou escrito? ? ? ?     var obj = new Foo ("Hello"); alerta (obj.value); // "hello" obj.value = "yehoo"; alerta (obj.value); // "yehoo"

Para resolver a pergunta acima, muitos testes foram feitos, vamos dar uma olhada nela um a um:

Primeiro olhe para este exemplo. Somente o recurso GET é definido no protótipo. Ao ler o atributo de valor em obj.value, procure -o na instância sem ele e encontre -o no protótipo. O método GET é chamado, que só pode ser lido, mas não é escrito.

 function foo (val) {this._value = val; // O atributo aqui está sublinhado, inicializa o atributo _value do objeto de instância, o atributo _value é legível e gravável} foo.prototype = {// Set Value (val) {// observa que o nome do método é o mesmo como o nome do atribuído e o nome e o nome do atributo e o nome do atribuições e o nome do atribuído e o nome do atribuído e o nome do atributo é o mesmo que o nome do atribuído e o nome do atributo é o mesmo que o nome do atribuído e o nome do atributo é o mesmo que o nome do atribuído e o nome do atribuído e o nome do atribuído e o nome do nome do atribuído e do método é o mesmo que é o mesmo que o nome do atribuído e o nome do nort///) }, get value () {// O nome do método é o mesmo que o nome do atributo, define o atributo de valor e seu atributo obtiver no protótipo retornar this._value;}}; var obj = novo foo ("hello); alert (obj.value); // hello acessa o valor no protótipo o atributo obj.value =" yehoo "; // define apenas o atributo Get do atributo de nome, para que ele só possa ser lido, mas não escrito. A gravação é um alerta inválido (obj.value); // Olá

Se este._Value for removido do sublinhado no construtor, o atributo de valor definido no protótipo define o atributo GET. Você ainda pode controlar a leitura e a gravação do atributo de valor. Em outras palavras, quando obj.value acessa atributos, o método GET será chamado, primeiro pesquisando no próprio objeto, se não, depois pesquisando no protótipo. Se nada não for, será considerado indefinido. O padrão é legível e gravável.

 function foo (val) {this.value = val; // somente o recurso GET do valor é definido no protótipo; portanto, a gravação aqui é inválida} foo.prototype = {// Definir valor (val) {// observar que o nome do método e o nome do atributo é o mesmo, o recurso de conjunto do valor do valor é definido; Mesmo que o valor do valor seja escrito manualmente, pois o método get retorna isso._Value, o valor não pode ser lido corretamente: "hah" // desde que os atributos get pro () {} e set pro () {} sejam declarados, eles podem ler e escrever, mas se a definição de função estiver errada, o valor correto da propriedade não poderá ser acessado conforme exigido. value () {// o nome do método é o mesmo que o nome do atributo. O atributo de valor e seu atributo GET são definidos no protótipo. Return this._value;}}; var obj = novo foo ("hello); //" hello "não foi escrito com sucesso (obj.value); // obj.value indefinido =" yehoo "; // definiu apenas o atributo get, para que ele só pode ser lido, mas não escrito, e a gravação é um alerta inválido (obj.value);

Para provar que o exemplo acima é legível e não gravável: escreva manualmente _value: "hah", você pode ler o valor, mas não pode escrevê -lo.

 function foo (val) {this.value = val; // somente o recurso GET do valor é definido no protótipo; portanto, a gravação aqui é inválida} foo.prototype = {// Definir valor (val) {// observar que o nome do método e o nome do atributo é o mesmo, o recurso de conjunto do valor do valor é definido »», »,», »,», »//, o nome do método. Mesmo que o valor do valor seja escrito manualmente, pois o método get retorna isso._Value, o valor não pode ser lido corretamente: "hah" // desde que os atributos get pro () {} e set pro () {} sejam declarados, eles podem ler e escrever, mas se a definição de função estiver errada, o valor correto da propriedade não poderá ser acessado conforme exigido. value () {// o nome do método é o mesmo que o nome do atributo. O atributo de valor e seu atributo GET são definidos no protótipo. Return this._value;}}; var obj = novo foo ("hello); //" hello "não foi escrito com sucesso (obj.value); //" hah "obj.value =" yehoo "; // apenas o atributo GET é definido, portanto só pode ser lido, mas não escrito, e a gravação é alerta inválido (obj.value);

Se o valor: "hah" estiver escrito manualmente, posso me esforçar para ler o valor do valor? Como isso._Value retornado pelo método get não está definido, o obj.Value lê o valor do valor e as chamadas Get Value () {} falham, mas o valor ainda não pode ser gravado.

 function foo (val) {this.value = val; // somente o recurso GET do valor é definido no protótipo; portanto, a gravação aqui é inválida} foo.prototype = {// Definir valor (val) {// observar que o nome do método e o nome do atributo é o mesmo, o recurso de conjunto do valor do valor é definido no protipo // this. this. this. O valor do valor é escrito manualmente, pois o método get retorna isso._Value, o valor não pode ser lido corretamente: "hah" // desde que os atributos get pro () {} e set pro () {} sejam declarados, eles podem ler e escrever, mas, se a definição de função estiver errada, o valor correto da propriedade não pode ser acessado conforme exigido. value () {// O nome do método e o nome do atributo são os mesmos. O atributo de valor e seu recurso GET são definidos no protótipo. Return this._value;}}; var obj = new Foo ("Hello); //" Hello "não foi escrito com sucesso (obj.value); // Leia indefinido inválido porque, enquanto obj.Value, obtenha retorno isso._Value e não há valor, então não se refinou, assim como não pode ser definido, assim, não pode ser definido. alerta (obj.value); // indefinido

Olhando para este exemplo, o Set definido é definido, mas retorna isso._Value que não está definido. Você pode descobrir que o valor pode ser lido e escrito. Remova o método Get Set no protótipo e ele ainda pode ser legível ou escrito

 function foo (val) {this.value = val;} foo.prototype = {set value (val) {this._value = val;}, get value () {return this._value;}}; var obj = novo foo ("hello); alerta (obj.value); // hello obj.value =" yehoo "; alerta (obj.value); // yehoo function foo (val) {this.value = val;} // é o mesmo que sempre, é o retorno Foo ("hello"); alert (obj.value); // hello obj.value = "yehoo"; alert (obj.value); // yehoo

Resumir

Somente o atributo get pro () {} é legível e não gravável;

Declare apenas o atributo set pro () {} como gravável e ilegível.

Se nenhuma das declarações for declarada, os atributos serão legíveis e graváveis;

Se todas as declarações forem feitas, leia e escreva de acordo com o método definido pelo Get Set;

Se todos forem declarados, mas o método de leitura e gravação definido não pode ser lido e escrito corretamente, o Get/Set falhará. Torne -se o padrão legível e escrito

O atributo de valor definido no protótipo define o atributo get. Você ainda pode controlar a leitura e a gravação do atributo de valor. Em outras palavras, quando obj.value acessa atributos, o método GET será chamado, primeiro pesquisando no próprio objeto e depois pesquisando no protótipo. Se não houver nada, será considerado indefinido. O padrão é legível e gravável.

Reabastecer:

 Seja usando get pro () {}/set pro () {} ou object.DefineProperty (objeto, pro, {get: function () {return this._name;}});

Pro não pode ser o mesmo que retornar isso., Caso contrário, o seguinte erro será relatado: (não sei por que, parece ser um transbordamento de pilha causado pela minha própria chamada)

Após a correção do mestre, entendo por que o erro é relatado aqui: se este.