Introducción a ECMAScript5
En primer lugar, debemos averiguar que Ecmascript es un Dios-Ma. Sabemos que JavaScript o Livescript fue creado originalmente por Netscape, y luego Microsoft también siguió para crear JScript. Scriptease también tiene su propio Cenvi. De esta manera, hay tres versiones del guión del navegador que hacen los suyos. Todos entienden este caótico, por lo que el problema de la estandarización se pone en la agenda. En 1997, la propuesta basada en JavaScript1.1 se presentó a la Asociación Europea de Fabricantes de Computadores (European Computer M -Factorers A Sector). Finalmente, todos desarrollaron ECMA-262, un nuevo estándar de lenguaje de secuencias de comandos llamado ECMAScript. Al año siguiente, ISO/IEC (Organización Internacional de Estandarización y Comisión Electrotecnical Internacional) también adoptó ECMAScript como el estándar. Después de eso, el mundo será pacífico. Los principales fabricantes de navegadores utilizan ECMAScript como base para su respectiva implementación de JavaScript. Por supuesto, es solo la base y no se ha seguido por completo. De lo contrario, no tendríamos tantos problemas de compatibilidad del navegador.
¿Qué es ECMAScript5? Como su nombre indica, es la quinta versión de esta cosa extraña, al igual que el iPhone 5. Ecmascript3, que a menudo usamos ahora, se considera un lenguaje de programación real en lugar de un juguete, y se ha vuelto muy popular.
texto:
Siempre he tenido una comprensión incorrecta de Get/Set antes, y creo que Get SET es un método de atributo de objeto. También tenía muchas preguntas después de leer los blogs de otras personas. Hoy, el sistema hizo muchas pruebas y finalmente lo descubrió. (Si pasa las pruebas de demostración de lectura y escritura usted mismo, si hay alguna incorrecta, puede criticarme y corregirme)
El accesor Get/Set no es la propiedad de un objeto, sino la propiedad de una propiedad. Todos deben distinguir claramente. Las características solo se usan internamente, por lo que no se puede acceder directamente a JavaScript. Para indicar que las características son valores internos se incluyen entre paréntesis entre los dos equipos, como [[valor]].
1. Permítanme introducir brevemente estas características de los atributos (aquí hay un simple respaldo)
(1) Atributo de datos: la posición que contiene un valor de datos. Esta posición puede leer y escribir valores.
Los atributos de datos tienen cuatro características que describen su comportamiento:
[[Configurable]]: ¿es configurable?
[[Enumerable]]: ¿Es enumerable?
[[Writable]]: ¿Es legible?
[[Valor]]: valor de atributo
(2) Atributo de atributo de accesor: no contiene valores de datos, contiene una función Getter y Setter (estas dos funciones no son necesarias)
Las propiedades de los accesorios también tienen cuatro características que describen su comportamiento:
[[Configurable]]: ¿es configurable?
[[Enumerable]]: ¿Es enumerable?
[[Get]]: la función llamada cuando se lee atributos, el valor predeterminado está indefinido
[[SET]]: la función llamada Al escribir atributos, el valor predeterminado está indefinido
2. Aquí nos centramos en introducir [[get]]/[[set]] es lo que llamamos accesor Get/Set
Primero hablemos sobre las características de comportamiento del accesor GET/SET mencionado en el libro: el accesor Get/Set se puede leer y escribir sin definición. También puedes definir solo uno. Si solo se define Get, los atributos descritos solo pueden ser legibles y no escritos. Si solo se define el conjunto, los atributos descritos solo pueden escribirse y no legibles.
(1) Nuestro método Get Set original es el siguiente:
function foo (val) {var valor = val; this.getValue = function () {value de retorno;}; this.setValue = function (val) {value = val;};} var obj = new foo ("hello"); alert (obj.getValue ()); // "hola" obj.setvalue ("hi"); alerta (obj.getvalue ();El código anterior es solo un método Get SET implementado utilizando el alcance de cierre. Tenga en cuenta que el método es el método de atributo del objeto de instancia, no la propiedad de atributo. Si no se define, el valor del valor no será accesible
función foo (val) {var value = val;/* this.getValue = function () {value de retorno;}; this.setValue = function (val) {value = val;};*/} var obj = new foo ("hello"); alert (obj.value); // undefinadoLos siguientes ejemplos también son métodos de atributos de objetos, no de propiedades de atributos.
var obj = {name: "John", get: function () {return this.age;} // Solo get está definido, el conjunto no está definido, pero aún puede leer, escribir y nombrar atributos, incluso si es edad // el método definido aquí no afectará los atributos Get, establecidos de los atributos. Solo un atributo de objeto normal}; alerta (obj.name); // John legible obj.name = "jack"; // alerta de escritura (obj.name); // jack(2) Obtener/establecer el accesor como una propiedad del atributo de accesor.
Una vez más, no es el atributo de un objeto, deciden si el atributo se puede leer y escribir. Si no se establece, está bien, al igual que leer y escribir normalmente (las propiedades se pueden leer o leer
Escribir, leer y escribir acceso a la propiedad en sí)
Hay dos formas de cambiar el atributo GET /SET:
a. Use Object.defineProperty ()
var objeto = {_ Nombre: "Daisy"}; objeto.defineProperty (objeto, "nombre", {// El nombre del método aquí significa que se define una propiedad de nombre (por lo que se puede acceder a través de Object.name), solo el accesor Getter está definido, no se define [[valor]] valor: function () this._name;}}); alert (object.name); // "margara" object.name = "jack"; // Solo se define el accesor de Getter, por lo que la escritura está inválida alerta (objeto.name); // "Daisy" Object.name = "Jack"; // Solo el accesor de Getter está definido, por lo que la escritura está invalida alerta (Object.name);Tenga en cuenta que el nombre de la propiedad en Object.DefineProperty (Object, Pro, {}) debe corresponder a las propiedades accedidas por Object.pro.
b. Use la palabra clave Get Set:
VAR Object = {_ Nombre: "Daisy", Get Name () {// El nombre del método aquí significa que se define un atributo de nombre (por lo que se puede acceder a través de Object.name), solo se define el accesor Getter, no se define el valor [[valor]]. Devuelve this._name;} // get, establecer el método es solo una propiedad del atributo, no un método de objeto, que determina si el atributo se puede leer y escribir}; alerta (objeto.name); // Daisy El método para eliminar el subrayador aquí es Daisy; Además, es undefinedObject.name = "Jack"; // Solo se define el accesor de Getter, por lo que solo se puede leer pero no escribir alerta (object.name); // DaisyLos dos métodos anteriores son equivalentes. Tenga en cuenta que los dos métodos anteriores tendrán dos atributos en el objeto Objeto: _name (con valor inicial) Nombre (sin valor inicial), que se puede ver a través de la consola del navegador.
Entonces, ¿cuándo está realmente definido este atributo de nombre? Sabemos que Object.DefineProperty (Object, Pro, {}) puede definir una nueva propiedad Pro para el objeto. Desde que get pro () {}/set pro () {} y object.defineproperty (objeto, pro, {}) son equivalentes, también se definirá una nueva propiedad Pro. Es por eso que hay dos propiedades en el objeto.
(3) El Código de implementación de Get and Set Accessor en JavaScript en este artículo: Relacionado con la implementación de los accesorios GET y SET de los estándares estándar: Pensamientos razonables
Yo mismo escribí un ejemplo
función foo (val) {this.value = val; // El atributo de valor está definido y no _value} foo.prototype = {set value (val) {// El atributo se define en el prototipo return this._value;}}; // El accesor que los devuelve y los establece son _name, y no hay definición aquí. ¿Por qué se puede leer o escribir? ? ? ? var obj = new foo ("hola"); alerta (obj.value); // "hola" obj.value = "yehoo"; alerta (obj.value); // "Yehoo"Para resolver la pregunta anterior, se han realizado muchas pruebas, echemos un vistazo una por una:
Primero mira este ejemplo. Solo la función Get se define en el prototipo. Al leer el atributo de valor en obj.value, búscalo en el caso sin él y luego busque en el prototipo. Se llama al método GET, que solo se puede leer pero no escrito.
función foo (val) {this._value = val; // El atributo aquí está subrayado, inicializa el atributo _value del objeto de instancia, el atributo _value es legible y es escrito} foo.prototype = {// set value (val) {// Tenga en cuenta que el nombre del método es el mismo que el nombre del atributo y el atributo de valor está definido en el prototipo de prototipo // this._value = val; //}, get value () {// El nombre del método es el mismo que el nombre del atributo, define el atributo de valor y su atributo Get en el prototipo return this._value;}}; var obj = new foo ("hola"); alerta (obj.value); // Hello accede al valor en el prototipo El atributo obj.value = "yehoo"; // solo define el atributo Get del atributo de nombre, por lo que solo se puede leer pero no escrito. La escritura es alerta no válida (obj.value); // holaSi esto. Todavía puede controlar la lectura y la escritura del atributo de valor. En otras palabras, cuando Obj.Value accede a los atributos, se llamará al método GET, primero buscar en el objeto en sí, si no, luego busca en prototipo. Si nada no lo es, se considerará indefinido. El valor predeterminado es legible y es escrito.
función foo (val) {this.value = val; // Solo la característica get del valor se define en el prototipo, por lo que la escritura aquí no es válida} foo.prototype = {// set value (val) {// Tenga en cuenta que el nombre del método y el nombre del atributo son la misma, la característica establecida del atributo de valor está definida en el prototipo // this._value = val; //}, // value: "hah", // incluso si el valor de valor se escribe manualmente, ya que el método get devuelve esto._value, el valor no se puede leer correctamente: "hah" // siempre que la definición de la función get pro () {} y establez valor () {// El nombre del método es el mismo que el nombre del atributo. El atributo de valor y su atributo GET se definen en el prototipo. Devolver esto._value;}}; var obj = new foo ("hola"); // "hola" no se escribió con éxito alerta (obj.value); // undefined obj.value = "yehoo"; // solo definió el atributo get, por lo que solo puede ser escrito pero no escrito, y la escritura está alerta (obj.value); // alerta (obj.value);//UDFININEPara demostrar que el ejemplo anterior es legible y no es escrito: escriba manualmente _value: "ja", puede leer el valor pero no puede escribirlo.
función foo (val) {this.value = val; // Solo la característica get del valor se define en el prototipo, por lo que la escritura aquí no es válida} foo.prototype = {// set value (val) {// Tenga en cuenta que el nombre del método y el nombre del atributo son la misma, la característica establecida del atributo de valor está definida en el prototipo // this._value = val; //}, _ valor: "hah", // incluso si el valor del valor se escribe manualmente, ya que el método get devuelve esto._value, el valor no se puede leer correctamente: "hah" // siempre que la definición de la función get pro () {} y establez valor () {// El nombre del método es el mismo que el nombre del atributo. El atributo de valor y su atributo GET se definen en el prototipo. Devolver esto._value;}}; var obj = new foo ("hola"); // "hola" no se escribió con éxito alerta (obj.value); // "hah" obj.value = "yehoo"; // solo se define el atributo Get, por lo que solo se puede leer pero no escrito, y la escritura está alerta (obj.value); // "hah"Si el valor: "ja" se escribe manualmente, ¿puedo esforzarme por leer el valor del valor? Dado que esto no está definido.
función foo (val) {this.value = val; // Solo la característica Get del valor se define en el prototipo, por lo que la escritura aquí no es inválida} foo.prototype = {// set value (val) {// tiene en cuenta que el nombre del método y el nombre de la atributo son la misma característica de establecer del atributo de valor se define en el prototipo // this._value Incluso si el valor del valor se escribe manualmente, ya que el método GET devuelve esto. valor () {// El nombre del método y el nombre del atributo son los mismos. El atributo de valor y su función Get se definen en el prototipo. Devolver esto._value;}}; var obj = new foo ("hello"); // "hola" no se escribió con éxito alerta (obj.value); // una lectura invalida invalidada porque mientras obj.value, obtenga devoluciones de this._value, y no hay valor, por lo que invalorizan los invalores = "yehoo"; // Solo se define la característica, por lo que solo se puede leer, pero no se escribe, y la escritura Invalor alerta (obj.value); // indefinidoMirando este ejemplo, Get Set se define, pero devuelve esto. Puede encontrar que el valor se puede leer y escribir. Eliminar el método Get Set en el prototipo y aún puede ser legible o escrito
función 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); // hola obj.value = "yehoo"; alert (obj.Value); // yehoo función foo (val) {this.value = val;} // Es lo mismo de lo habitual, es decir, regresa a la estadística predeterminada donde las características de los accesorios de acceso nuevo/set son de forma nueva. Foo ("hola"); alerta (obj.value); // hola obj.value = "yehoo"; alerta (obj.value); // yehooResumir
Solo el atributo Get Pro () {} es legible y no es escrito;
Solo declare que el atributo Set pro () {} es redactado e inseguible.
Si ninguna de las declaraciones se declara, los atributos son legibles y escritos;
Si se hacen todas las declaraciones, lea y escriba de acuerdo con el método definido por Get Set;
Si todos se declaran, pero el método de lectura y escritura definido no se puede leer y escribir correctamente, Get/Set fallará. Convertirse en la legible predeterminada y escritable
El atributo de valor definido en el prototipo define el atributo GET. Todavía puede controlar la lectura y la escritura del atributo de valor. En otras palabras, cuando Obj.Value accede a los atributos, se llamará al método GET, primero buscar en el objeto en sí y luego buscar en el prototipo. Si no hay nada, se considerará indefinido. El valor predeterminado es legible y es escrito.
Reponer:
Si usa get pro () {}/set pro () {} u object.defineproperty (objeto, pro, {get: function () {return this._name;}});Pro no puede ser lo mismo que devolver esto. De lo contrario, se informará el siguiente error: (No sé por qué, parece ser un desbordamiento de pila causado por mi propia llamada)
Después de la corrección del maestro, entiendo por qué el error se informa aquí: si este.value se devuelve en el método Get Value () {}, el método GET de valor se volverá a llamar, cayendo así en un bucle muerto, lo que hace que la pila de métodos se desborde.