Para comprender los objetos de JavaScript, podemos comenzar desde la creación de objetos, las operaciones de propiedades y los métodos de objetos. Para resumir, incluye los siguientes módulos:
1. Crea un objeto
1.1 Medición directa de objetos
La cantidad directa de un objeto es la forma más fácil de crear un objeto, y consta de varios pares de nombre/valor:
Var Point = {x: 0, y: 0};No hay límite para los nombres de atributos. Pueden ser palabras clave JS o cualquier cadena. Si estas dos situaciones, los atributos deben estar encerrados en citas dobles:
var vacía = {}; VA Point = {x: 0, y: 0}; var libro = {"título principal": "javascript", "sub-tito": "la guía definitiva", "para": "toda audiencia", autor: {firstName: "Davide", LastName: "Flanagan"}};Es muy simple crear objetos directamente, pero generalmente no se usa de esta manera. El código es bajo reutilizable. Si desea usar el objeto en otro lugar y los valores de los atributos son diferentes, ¿haz esto? ¿Tienes que recrear otro código?
1.2 Crear un objeto a través de nuevo
Antes de crear un objeto a través de nuevo, primero debe crear una función, y los nuevos tratan esta función como un constructor. Por ejemplo, cree un objeto de persona a través de nuevo:
función persona () {// constructor} var persona = nueva persona ();Los tipos primitivos en el núcleo del idioma JavaScript contienen constructores incorporados:
var a = new Array (); var d = new Date (); var r = new Regexp ("JS");1.3 Object.Create ()
Antes de entender el método Crear objeto, queremos ver qué es un prototipo. Cada objeto JavaScript (excepto nulo) está asociado con otro objeto. El objeto "otro" es lo que llamamos un prototipo. Cada objeto hereda los atributos del prototipo.
Todos los objetos creados a través de la cantidad directa de objetos tienen el mismo prototipo de objeto objeto.prototype. El prototipo de objeto creado por la palabra clave New and Constructor es el valor de la propiedad prototipo del constructor. El prototipo del objeto creado a través de New Array () es Array.Prototype, y el prototipo del objeto creado a través de una nueva fecha () es date.prototype. El prototipo se ha introducido aquí.
El método Object.Create contiene dos parámetros. El primer parámetro es el prototipo del objeto y el segundo parámetro es opcional para describir las propiedades del objeto. Es fácil de usar, simplemente pase por el objeto prototipo requerido:
var o1 = object.create ({x: 1, y: 2}); // El prototipo es objeto.prototypeSi desea crear un objeto sin un prototipo, puede pasar nulo como parámetro. Los objetos creados de esta manera no heredan ninguna propiedad, y no hay un método como ToString:
var o2 = object.create (nulo); // sin prototipo
Si desea crear un objeto vacío normal, pasarlo directamente a Object.Prototype:
var o3 = object.create (object.prototype);
Si es un objeto personalizado, es lo mismo que crear un objeto vacío. Pase el nombre del objeto directamente.prototype:
función persona () {} var o4 = object.create (persona.prototype);2. Gestión de atributos
2.1 Consulta y configuración de propiedades
Las propiedades de un objeto se pueden obtener a través del operador DOT (.) O soporte cuadrado ([]). Si usa puntos para obtener el atributo, el nombre del atributo debe ser un indicador simple. No puede ser una palabra reservada, como o. para o o.class.
AR Autor = Book.author; // Correcto var name = autor.surname; // Correcto VAR Title = Book ["Título principal"]; // Correcto var classname = book.class; //Error
La sintaxis del objeto ["propiedad"] se parece más a una matriz, excepto que los elementos de esta matriz están indexados por cadenas en lugar de números. Este tipo de matriz es lo que llamamos una matriz asociativa, también conocida como hash, mapa o diccionario. Los objetos JavaScript son matrices asociativas.
Dado que el objeto es una matriz asociativa, JavaScript también nos proporciona un método para/in a las propiedades transversales. El siguiente ejemplo usa para/in para calcular el valor total de la cartera:
función getValue (cartera) {var en total = 0.0; para (stock en Portolio) {var shares = portolio [stock]; VAR Price = GetQuote (stock); Total += acciones * precio; } return total;}Herencia: los objetos JavaScript tienen sus propias propiedades, y algunas propiedades se heredan de objetos prototipo. Primero veamos una función de herencia que implementa la herencia:
función heredar (p) {if (p == null) typeError (); // p es un objeto, no puede ser nulo if (object.create) {return object.create (p); // use el método objeto.create directamente} var t = typeof p; if (t! == "objeto" && t! == "función") thyeRorRor (); función f () {}; F.Prototype = P; // Establecer su atributo prototipo a p return nuevo f ();}Supongamos que desea consultar el atributo x del objeto o. Si X no existe en o, continuará consultando el atributo x en el objeto prototipo de o. Si no hay X en el objeto prototipo, pero el objeto prototipo también tiene un prototipo, continúe ejecutando la consulta en el prototipo del objeto prototipo hasta que se encuentra x o se encuentra un objeto nulo.
var o = {}; // atributo objeto oinherit ox = 1 de object.prototype; // Definir los atributos x para o var p = heredar (o); // pinherit o y object.prototypeP.y = 2; // PDEFINE ATTRIBE YVAR Q = HERHERIT (P); // Qinherit P, O y Object.Prototypeq.z = 3; // Definir el atributo Zvar S = Q.ToString (); // tostring hereda de object.prototypeq.x + qy // => 3: x e y hereño de O y P respectivamente2.2 Eliminar atributos
El operador Eliminar puede eliminar las propiedades del objeto:
eliminar book.author; eliminar el libro ["Título principal"];
Delete solo puede eliminar sus propios atributos y no puede eliminar los atributos heredados. Para eliminar una propiedad heredada, debe eliminarse del objeto prototipo que define la propiedad, y esto afecta a todos los objetos heredados del prototipo. La eliminación volverá verdadera.
ar o = {x: 1}; eliminar buey; // Eliminar x y devolver trueDelete buey; // x ya no existe, no se hace nada, devuelve verdadero. eliminar o.tostring; // no hacer nada, devolver verdadero. Eliminar no puede eliminar los atributos con el tipo configurable False. Las propiedades de algunos objetos incorporados no son configurables, como las propiedades del objeto global creado a través de declaraciones variables y declaraciones de funciones: Eliminar objeto.prototype // no se puede eliminar, las propiedades no son configurables var x = 1; eliminar esto.x; // Esta propiedad no se puede eliminar la función f () {} Eliminar this.f; // La función global no se puede eliminar2.3 Detectar propiedades
Para determinar si existe una propiedad en un objeto, puede ser detectado por los métodos In -Operator, AlownProperty () y PropertyIsenumerable ().
En el operador: el operador es el nombre de la propiedad a la izquierda y el objeto a la derecha. Devuelve verdadero si el atributo o atributo heredado del objeto contiene atributos:
var o = {x: 1}; "x" en o; // Verdadero: X es el atributo "y" en o; // falso: y no es el atributo "toString" en o; // Verdadero: o hereda el atributo tostringMétodo de iSownProperty (): detecta si el nombre de pila es la propiedad del objeto. Para el atributo heredado, devolverá falso:
var o = {x: 1}; O.HasownProperty ("x"); // Verdadero: O tiene una propiedad gratuita xo.hasownproperty ("y"); // falso: no hay propiedad yo.hasoenproperty ("toString"); // Falso: ToString es una propiedad de herenciaMétodo PropertyIsEnumerable (): es una versión mejorada de HasnownProperty. Devolverá verdadero solo si se detecta la propia propiedad y esta propiedad se considera verdadera:
var o = heredero ({y: 2}); ox = 1; o.propertyisenumerable ("x"); // Verdadero: O tiene una propiedad enumerable xo.propertyisenumerable ("y"); // falso: y es el objeto heredado.prototype.propertyisenumerable ("toString"); // Falso: no puede ser enumerable2.4 Propiedades de enumeración
Por lo general, para/in se usa para recorrer las propiedades del objeto, y las propiedades atravesadas incluyen sus propias propiedades y propiedades heredadas. Los métodos incorporados de herencia de objetos no son enumerables, pero las propiedades agregadas a los objetos en el código son enumerables. Por ejemplo:
var o = {x: 1, y: 2, z: 3}; // tres propiedades enumerables o.PropertyisEnumeable ("toString"); // falso, no se puede enumerar para (p en o) // transferir la propiedad console.log (p); // Salida x, y y z, sin salida de tostringA veces solo queremos iterar sobre nuestras propias propiedades, y las propiedades no son funciones:
para (p in o) {if (! O.HasownProperty (p)) continuar; if (typeof o [p] === "función") continuar;}Podemos copiar atributos enumerables a través de la función transversal de enumeración:
/** Copie los atributos enumerables en p en o y return o* si o y p contienen atributos del mismo nombre, sobrescriben los atributos en o* Esta función no maneja getters y setters y copia atributos*/function extend (o, p) {para (prop en p) {// transfiere todos los atributos en p o [prop] = p [prop]; // Agregar atributos a O} return o;}ES5 define dos funciones que enumeran los nombres de los atributos. El primero es Object.Keys (), que devuelve una matriz compuesta de nombres de atributos enumerables en el objeto. La segunda función de enumeración es Object.getOwnPropertynames (), que es similar a Object.Keys (), que devuelve todas las propiedades del objeto, no solo propiedades enumerables.
3. Encapsulación de atributos
3.1 Atributos Getter y Setter
Los atributos del objeto están compuestos de nombres, valores y un conjunto de atributos. En ES5, los valores de los atributos pueden ser reemplazados por uno o dos métodos, que son getters y setters. Los atributos definidos por Getters y Setters se llaman "Atributos de accesorios". A diferencia de los "atributos de datos", los atributos de datos tienen solo un valor simple.
A diferencia de los atributos de datos, el atributo de accesor no es escritable. Si la propiedad tiene métodos Getter y Setter, entonces es una propiedad de lectura/escritura. Si solo tiene métodos de Getter, entonces es una propiedad de solo lectura, si solo tiene métodos setter, entonces es una propiedad de solo escritura. Lectura Los atributos de escritura solo siempre devuelven indefinidos.
La sintaxis de la definición del atributo de accesorios también es relativamente simple. La definición de funciones no usa la palabra clave de función, pero usa Get o SET:
var o = {// atributo de datos ordinarios data_prop: 1, // Los atributos del accesor son todas las funciones definidas por pares obtienen accessor_prop () {/* Aquí está el cuerpo de funciones*/}, set accessor_prop (valor) {}};Piense en el siguiente objeto que representa las coordenadas de los puntos cartesianos 2D. Tiene dos propiedades normales x e y representan coordenadas x y coordenadas y respectivamente. También tiene dos propiedades de accesorios equivalentes para representar las coordenadas polares de los puntos:
var p = {// x e y son atributos de datos de lectura-escritura ordinarios x: 1.0, y: 1.0, // r es un atributo de accesor de lectura-escritura, que tiene getter y setter get r () {return math.sqrt (this.x * this.x + this.y * this.y); }, establecer r (newValue) {var OldValue = Math.Sqrt (this.x * this.x + this.y * this); VAR Ratio = newValue / OldValue; this.x *= relación; this.y *= Ratio; }, // theta es un atributo de accesor de solo lectura, solo el método getter obtiene theta () {return Math.atan2 (this.y, this.x); }};Al igual que los atributos de datos, los atributos de accesorios son heredables, por lo que el objeto P en el código anterior puede considerarse como un prototipo de otro "punto". Puede definir sus propiedades x e y para un objeto sexual, pero las propiedades R y Theta heredan de:
var q = heredero (p); qx = 1, qy = 1; console.log (qr); cosole.log (q.theta);
3.2 Características del atributo
Podemos considerar los métodos Getter y Setter del atributo de accesor como características de atributo. Según esta lógica, también podemos ver las características de las propiedades de las propiedades. Por lo tanto, se puede considerar que una propiedad contiene un nombre y 4 atributos.
Las cuatro características de una propiedad numérica son su valor, escrito, enumerable y configurable.
Los atributos de accesorios no tienen características de valor y escritabilidad, por lo que incluyen: leer (obtener), escribir (set), enumeración y configurabilidad.
ES5 define un objeto llamado "Descriptor de atributos", que representa esos 4 atributos. Los atributos del objeto descriptor del atributo de datos incluyen valor, escritura, enumerable y configurable. El objeto descriptor del atributo del accesor se reemplaza por el atributo GET y el atributo establecido. Entre ellos, los valores booleanos son valores booleanos, y el atributo GET y el atributo establecido son valores de función.
Puede obtener el descriptor de propiedades para una propiedad específica de un objeto llamando a Object.getOwnPropertyDescriptor ()::
// return {value: 1, Writable: true, enumerable: true, configurable: true} object.getownproepryDescriptor ({x: 1}, "x"); // consulta la propiedad octet del objeto aleatorio definido anterior "Octet"); // para atributos heredados y atributos inexistentes, devuelve undefinedObject.getownpropertyDesciptor ({}, "x"); object.getownpropertydesciptor ({}, "toString");Como puede ver desde el nombre de la función, Object.getOwnPropertyDesciptor () solo puede obtener el descriptor de sus propias propiedades. Para obtener las características de los atributos hereditarios, debe atravesar la cadena prototipo (Object.getPrototipof ()).
Si desea establecer las propiedades de las propiedades, o hacer que las propiedades recién creadas tengan ciertas propiedades, debe llamar a Object.DefineProperty (), que contiene tres parámetros: objeto, nombre de propiedad y objeto descriptor de propiedades:
// existen propiedades, pero el buey no puede enumerarse; // => 1Object.Keys (o) // => [] // Ahora modifique la propiedad x para que sea objeto de solo lectura. DefineProperty (o, "x", {Writable: true}); // La vista cambia el valor de esta propiedad ox = 2; // La operación falla, pero no se informan errores, y una excepción de error de tipo se arroja en modo estricto // Las propiedades todavía están configurables, por lo que puede modificarse de esta manera: object.defineproperty (o, "x", {valor: 2}); ox // => 2 // modificar x desde la propiedad de datos a la propiedad de accesor. 0;}}); ox // => 0Si desea modificar o crear múltiples propiedades al mismo tiempo, debe usar Object.DefineProperties (). El primer parámetro es el objeto que se modificará, y el segundo parámetro es una tabla de mapeo. Por ejemplo:
var p = object.defineProperties ({}, {x: {value: 1, witable: true, enumerable: true, configurable: true}, y: {value: 2, witable: true, enumerable: true, configurable: true}, r: {get: function () {return math.sqrt (this.x * this.x + this.y * this.y *y); configurable: true}});API anticuadas para Getters and Setters: antes de ES5, la mayoría de las implementaciones de JavaScript ya podrían admitir la redacción de Get y establecer la escritura en la sintaxis de la cantidad directa de objetos. Estas implementaciones proporcionan API anticuadas no estándar para consultar y configurar Getters y Setters. Estas API están compuestas por cuatro métodos, y todos los objetos tienen estos métodos.
__lookupgetter __ () y __lookupsetter __ () se utilizan para devolver un método de Getter y Setter con nombre.
__definegetter __ () y __definesetter __ () se utilizan para definir getters y setters. El primer parámetro es el nombre del atributo, y el segundo parámetro son los métodos Getter and Setter.
var o = {}; o .__ definegetter __ ("x", function () {return 0;}); o .__ defineSetter __ ("y", function (valor) {console.log ("set valor:" + valor);});4. Tres propiedades de un objeto
Cada objeto tiene un prototipo, clase y atributo extensible relacionado con él. A continuación, hablemos de lo que hacen estos atributos.
4.1 Propiedades prototipo
Los atributos prototipo de un objeto se utilizan para heredar los atributos. A menudo llamamos a los atributos del prototipo de O "directamente" el prototipo de O ". Anteriormente, "Crear objetos" introdujo tres formas de crear objetos. Los objetos creados por los objetos se usan como su prototipo usando Object.Prototype. Objetos creados por New Use el atributo prototipo del constructor como su prototipo. Objetos creados con Object.Create () Use el primer parámetro como su prototipo.
En ES5, el prototipo de objeto se puede consultar a través de Object.getPrototypeOf (). En ES3, no existe una función equivalente, sino que la expresión O.Constructor.prototype se usa para verificar el prototipo del objeto.
Para detectar si un objeto es un prototipo de otro objeto (o está en la cadena prototipo), use el método ISPrototypeOf (). Por ejemplo, puede detectar si P es un prototipo de O por P.ISprototypeOf (O):
var p = {x: 1}; // Defina un objeto prototipo var o = object.create (p); // Use este prototipo para crear un objeto P.ISprototypeOf (O); // => verdadero, o hereda de POBJECT.Prototype.IsprototypeOf (o) // => True, P hereda de Object.PrototypeJavaScript implementado por Mozilla expone un atributo específicamente llamado __proto__ para consultar/establecer el prototipo de objeto. Sin embargo, IE y Opera no admiten el atributo __proto__, por lo que no se recomienda usar el atributo __proto__ directamente.
4.2 Atributos de clase
El atributo de clase de un objeto es una cadena para representar la información de tipo de objeto. Tanto ES3 como ES5 proporcionan métodos para establecer esta propiedad, y solo hay una forma indirecta de consultarla. El método ToString () predeterminado devuelve una cadena en este formato: [clase de objeto].
Puede llamar al método toString () y luego extraer los caracteres entre la octava y la penúltima posición de la cadena devuelta. Pero existe el problema de que muchos objetos heredaron los métodos de toString () se han reescrito. Para poder llamar a la versión correcta de toString (), el método funct.call () debe llamarse indirectamente. La función ClassOf en el siguiente ejemplo puede devolver la clase de cualquier objeto:
function classOf (o) {if (o === null) return "null"; if (o === indefinido) return "indefinido"; return object.prototype.tostring.call (o) .slice (8, -1);}4.3 escalabilidad
La extensibilidad del objeto se usa para indicar si se pueden agregar nuevas propiedades al objeto. Todos los objetos integrados y personalizados son explícitamente extensibles. En ES5, los objetos se pueden convertir a no escalables.
Además de configurar el objeto para que no sea extensible, el método Object.Seal () también puede establecer que todas las propiedades del objeto no sean conformes. Es decir, no se pueden agregar nuevos atributos al objeto, y los atributos existentes no se pueden eliminar y configurar.
El método Object.issealed () se usa para detectar si el objeto está encerrado.
El método Object.Freeze () bloqueará los objetos más estrictamente. Además de tener la función del método Object.Seal (), también puede establecer todos sus propios atributos de datos a solo lectura (si el atributo de accesor de objeto tiene un método Setter, el atributo del accesor no se ve afectado, y aún puede llamarlos asignando valores a los atributos).
Object.Isfrozen () se usa para detectar si el objeto está congelado.
5. Serializar objetos
La serialización del objeto se refiere a convertir el estado de un objeto en una cadena, o puede restaurar la cadena a un objeto. ES5 proporciona funciones incorporadas json.stringify () y json.parse () para serializar y restaurar los objetos JavaScript. Todos estos métodos usan JSON como formato de intercambio de datos. Por ejemplo:
o = {x: 1, y: {z: [falso, nulo, ""]}}; // Definir un objeto de prueba S = json.stringify (o); // {"x": 1, "y": {"z": [false, nulo, ""]}} p = json.parse (s); // p es una copia profunda de OLa sintaxis de JSON es un subconjunto de la sintaxis de JavaScript, y no puede representar todos los valores en JavaScript. Los objetos, matrices, cuerdas, números infinitos, verdaderos, falsos y nulos son compatibles, y pueden ser serializados y restaurados. Los resultados de la serialización de Nan, Infinity e Infinity son todos nulos. Las funciones, regexp, objetos de error y valores indefinidos no se pueden serializar y restaurar.
Aquí agregaré el método del objeto:
Método toString (): devolverá una cadena que representa el valor del objeto que llama a este método. Muchos objetos han reescrito el método toString (), como Array.ToString (), date.ToString () y function.ToString ().
Método TOJSON (): Object.prototype en realidad no define el método tojson (), pero debido a la necesidad de realizar la serialización, el método json.stringify () llamará al método tojson (). Si este método existe en el objeto serializado, se llama.
Método ValueOf (): El método ValueOf () es muy similar al método ToString (), pero JavaScript a menudo lo llama cuando convierte un objeto en cierto valor original en lugar de una cadena, especialmente cuando se convierte en un número. Algunas clases incorporadas personalizan el método valueOf (), como date.ValueOf ().
El artículo anterior comprende de manera integral el avance de los objetos JavaScript es todo el contenido que comparto con usted. Espero que pueda darle una referencia y espero que pueda apoyar más a Wulin.com.