Hoy, mientras miraba el código prototipo, descubrí el operador de eliminación.
desarmado: función (tecla) {
valor var = this._object[clave];
eliminar this._object[clave];
valor de retorno;
}
Revisé el manual,
El operador de eliminación elimina una propiedad de un objeto o un elemento de una matriz.
eliminar expresión
El parámetro de expresión es una expresión JScript válida, normalmente un nombre de propiedad o un elemento de matriz.
Descripción Si el resultado de la expresión es un objeto y el atributo especificado en la expresión existe y el objeto no permite eliminarlo, se devuelve falso.
En todos los demás casos, devuelve verdadero.
Se siente bien ver "eliminar un elemento de la matriz", pero después de intentarlo en ff, parece que solo puede eliminar el valor de ese elemento, no el elemento en sí. Sin embargo, es posible eliminar una propiedad de un objeto.
Busqué en Google nuevamente y encontré un artículo que detalla mucho, así que lo volveré a publicar aquí para no olvidarlo:
Título: Variables Javascript y operador de eliminación Declaración de derechos de autor: Puede reimprimir a voluntad, pero debe indicar el autor original charlee y el enlace original http://tech.idv2.com/2008/01/09/javascript-variables-and- eliminar al reimprimir -operador/ y esta declaración.
contenido:
Acabo de leer un buen artículo (enlace original), que proporciona un análisis exhaustivo del operador de eliminación en Javascript. Aquí hay una breve introducción al contenido.
Aunque es un operador de eliminación pequeño, su comportamiento es extremadamente complejo.
variables javascript
Objeto eliminado por el operador de eliminación Cuando se ejecuta la eliminación en una variable, atributos que se pueden eliminar y atributos que no se pueden eliminar, variables que se pueden eliminar y variables que no se pueden eliminar
Valor de retorno de eliminar
---------------------------------------------- --- ----------------------------------
Variables de Javascript De hecho, en Javascript, variables = propiedades del objeto, esto se debe a que Javascript creará un objeto Global antes de ejecutar el script. Todas las variables globales son propiedades de este objeto Global. Al ejecutar la función, también se creará un objeto de Activación. Todas las variables locales son propiedades de este objeto de Activación. Por ejemplo:
var global = 42;this.global; // 42, puede acceder al objeto global a través de this.global2 = 12;global2; // 12function foo() { var local = 36; se puede acceder directamente, // Por lo tanto, no se puede acceder a la variable local a través de foo.local} El objeto eliminado por el operador de eliminación
También hay un operador de eliminación en C++, que elimina el objeto al que apunta el puntero. Por ejemplo:
// C++class Object {public: Object *x;}Object o;ox = new Object();delete ox; // El nuevo objeto Object en la línea anterior se publicará, pero la eliminación de Javascript es diferente de C ++ El objeto señalado por ox no se elimina, pero el atributo ox en sí se elimina.
// Javascriptvar o = {};ox = new Object();eliminar ox; // El objeto Objeto nuevo en la línea anterior todavía existe ox; // indefinido, la propiedad denominada x de o se elimina en el Javascript real. Después de eliminar ox, el objeto Objeto se recolectará como basura porque ha perdido su referencia. Por lo tanto, eliminar ox es "equivalente" a eliminar el objeto señalado por ox. Sin embargo, esta acción no es un estándar ECMAScript. incluso si una implementación es completa. No eliminar el objeto Object no viola el estándar ECMAScript.
"Eliminar atributos en lugar de eliminar objetos" se puede confirmar con el siguiente código.
var o = {};var a = { x: 10 };oa = a;delete oa; // El atributo oa se elimina oa; // undefinidoa.x; 10, porque el objeto { x: 10 } sigue siendo una referencia, por lo que no se reciclará. Además, eliminar ox también se puede escribir como eliminar o["x"], los cuales tienen el mismo efecto.
Al eliminar una variable, la variable también es una propiedad del objeto Global o de Activación, por lo que la operación de eliminación de la variable tiene el mismo resultado.
var global = 42; eliminar global; // Eliminar Global.globalfunction foo() { var local = 36; eliminar Activation.local} Propiedades que se pueden eliminar y propiedades que no se pueden eliminar No todas las propiedades se pueden eliminar borrar. Por ejemplo, las propiedades declaradas en el prototipo no se pueden eliminar:
función C() { this.x = 42; C.prototype.x = 12;var o = new C();ox // 42, definida en el constructor o .xdelete ox;ox; // 12, ox definido en el prototipo no se eliminará incluso si se ejecuta eliminar ox nuevamente. Las propiedades predefinidas del objeto no se pueden eliminar. Se puede considerar que este tipo de atributo tiene las características de DontDelete.
var re = /abc/i;delete re.ignoreCase;re.ignoreCase; // verdadero, ignoreCase no puede eliminar las variables que se pueden eliminar y las variables que no se pueden eliminar. Las variables declaradas mediante var y las funciones declaradas mediante función tienen el atributo DontDelete y. no se puede eliminar.
var x = 36;eliminar x;x; // 36, x no se elimina y = 12;eliminar y;y; // función indefinida foo() { return }eliminar foo;foo(); Una excepción es que en el código ejecutado mediante eval, aunque las variables declaradas mediante var pertenecen al mismo objeto global que las variables declaradas mediante var normales, no tienen el atributo DontDelete y se pueden eliminar.
eval("var x = 36;");x; // 42delete x;x; // undefined Pero hay una excepción. Las variables definidas por var en la función en el código de evaluación tienen DontDelete y no se pueden eliminar eval(" ( function() { var x = 42; eliminar x; return x })();"); // Devuelve el valor de retorno de 42delete
Eliminar es un operador normal y devuelve verdadero o falso. La regla es: cuando la propiedad del objeto eliminado existe y tiene DontDelete, devuelve falso; de lo contrario, devuelve verdadero. Una característica aquí es que se devuelve verdadero incluso cuando el atributo del objeto no existe, por lo que el valor de retorno no es completamente equivalente a si la eliminación se realizó correctamente o no.
función C() { this.x = 42; }C.prototype.y = 12;var o = new C();eliminar ox; // trueo.x; // indefinido"x" en o; / ox existe y no hay DontDelete, return truedelete oy; // trueo.y; // 12// o en sí no tiene atributo oy, así que devuelve true// Desde aquí también puedes ver la existencia de la cadena prototipo, el los atributos propios del objeto y los atributos del prototipo son diferentes eliminar o; // false// Global.o tiene el atributo DontDelete por lo que devuelve falsedelete undefinedProperty; // true// Global no tiene ninguna propiedad llamada undefinedProperty por lo que devuelve truedelete 42 // true/ /42 no es una propiedad por lo que devuelve verdadero. Algunas implementaciones generarán una excepción (violando el estándar ECMAScript) var x = 24; eliminar x++; // truex // 25// Lo que se elimina es el valor de retorno (24) de x++, no un atributo, por lo que se devuelve verdadero.