La explicación en los comentarios es muy detallada, por lo que no hablaré muchas tonterías aquí, solo ingrese el código:
<script type = "text/javaScript"> // ECMA-262 Define un objeto como: "Una colección de atributos no ordenados, cuyos atributos pueden contener valores, objetos o funciones básicos" // La forma más fácil de comprender el objeto es crear una instancia del objeto y agregar atributos y métodos a su persona = nuevo objeto (); persona.name = "xulei"; persona.age = "23"; persona.job = "Ingeniero front-end"; persona.sayname = function () {alert (this.name); } // También puede escribir var persona = {nombre: "xulei", edad: 23, trabajo: "ingeniería front-end", sayname: function () {alert (this.name)}} // 1. Tipo de atributo: Atributo de datos y acceder a su atributo // 1. Atributo de datos, hay 4 características que describen su comportamiento // [configurable]: indica si el atributo se puede eliminar para redefinir el atributo, si el atributo puede modificarse o si el atributo puede modificarse en el atributo del accesor, el valor predeterminado es verdadero // [enumerable]: indica si el atributo puede ser devuelto por la entrada, el valor predeterminado es verdadero // [writable]: indica el valor de los atributos que el atributo puede ser modificado. True // [valor]: contiene el valor de datos de este atributo. The default value is undefined var person = { name: "xulei" } //A person object is created here, and the value value is "xulei" //To modify the default properties of the property, ECMAScript5's Object.defineProperty (the object where the property is located, the name of the property, the descriptor object) //The descriptor object must be configurable, enumerable, writable, value var peron = {} Object.defineProperty (perón, "nombre", {Writable: False, // La propiedad no se puede modificar valor: "Xu lei-xulei"}); alerta (peron.name); // xu lei-xulei peron.name = "xu lei"; alerta (peron.name); // xu lei-xulei // Las operaciones anteriores se ignorarán en modo no rictamente. Si se lanza una excepción en modo estricto // una vez que el atributo se define como poco configial, no se puede volver a convertir en configurable. // En la mayoría de los casos, no es necesario utilizar estas características avanzadas proporcionadas por el método Object.DefineProperty (). Pero es muy útil para comprender JavaScript. // Se recomienda a los lectores que no usen este método en IE8. // 2. Acceder a sus propiedades tiene 4 características // [configurable]: indica si el atributo se puede eliminar para redefinir el atributo, si las características del atributo pueden modificarse o si el atributo puede modificarse en el atributo de accesor, el valor predeterminado es verdadero // [enumerable]: indica si el atributo puede ser devuelto a través de la entrada, el valor predeterminado es verdadero /// [get]: el valor predeterminado de la función de la función ineguetada se puede devolver el valor predeterminado cuando está en la lectura. // [SET]: el valor predeterminado de la función llamado Al escribir el atributo Undefined var book = {_Year: 2004, edición: 1} objeto.defineproperty (libro, "año", {get: function () {return this._year;}, set: function (valor) {if (valor> 2004) {this._year; this.edition +edición +valor; }); book.Year = 2005; alerta (book.edition); // 2 // crea un objeto // 1. Trate el constructor como una persona de función (nombre, edad, trabajo) {this.name = name; this.age = edad; this.job = trabajo; this.sayName = function () {alert (this.name); }} // use var persona = nueva persona ("xulei", 23, "software"); persona.sayname (); // use persona ("xulei2", 23, "Job2"); // Agregar a Window.sayName (); // llame a var en el alcance de otro objeto o = nuevo objeto (); Persona.call (o, "xulei3", 23, "job3"); O.SayName (); </script>Tengamos otro párrafo:
<script type = "text/javaScript"> // 1. Comprender el objeto prototipo // 2. Prototipo y en operador // 3. Sintaxis de prototipo más simple // 4. Dinamidad del prototipo // 5. Prototipo de objeto nativo // 6. Problemas con el objeto prototipo // 1. Siempre que se cree una función, se creará un atributo prototipo para la función basada en un conjunto específico de reglas. Este atributo apunta al objeto prototipo de la función // de forma predeterminada, todos los objetos prototipo obtendrán automáticamente un atributo Constructor (Constructor), que contiene un puntero a la función donde el atributo prototipo se encuentra // como la persona personal () {} //person.prototype.constructor Points to Person // después de crear un costumbre, es un objeto de protección, solo el objeto de protección, solo el objeto constructor. En cuanto a otros métodos, se heredan desde el objeto .// Cuando la llamada para crear una nueva instancia, la instancia contiene un puntero (propiedad interna) para señalar el objeto prototipo del constructor.//in Firefox, Safari y Chrome, una propiedad_proto_access var p1 = nueva persona (); alert (persona.prototype.isprototypeOf (p1)) alert (object.getPrototypeOf (p1) == Person.prototype) // Aunque se puede acceder al valor guardado en el prototipo a través de la instancia de Object, el valor en el prototipo no se puede reescar a través de la instancia de objeto. Si agregamos una propiedad // a la instancia y el nombre de la propiedad es el mismo que la instancia en el prototipo, entonces creamos la propiedad en la instancia y la propiedad bloqueará la propiedad en el prototipo. Eg: function Person () {} Person.prototype.name = "Amber"; Persona.prototype.age = 23; Persona.prototype.job = "ingeniero de software"; Persona.prototype.sayname = function () {alert (this.name)} var persona1 = new Person (); var persona2 = nueva persona (); persona1.name = "Amber.xu"; alerta (persona1.name); // Amber.xu ---Frum instancia alerta (persona2.name); // Amber --from Prototype Eliminar persona1.name; alerta (persona1.name); // Amber --Fr the Prototype // Utilice el método de iSownProperty () para detectar si existe una propiedad en la instancia o en el prototipo. Este método (heredado del objeto) // return verdadero function persona () {} persona.prototype.name = "Amber"; Persona.prototype.age = 23; Persona.prototype.job = "ingeniero de software"; Persona.prototype.sayname = function () {alert (this.name)} var persona1 = new Person (); var persona2 = nueva persona (); alerta (persona1.hasownproperty ("nombre")); // falso desde la instancia alerta (persona2.hasownproperty ("nombre"))); // falso de la instancia persona1.name = "Amber.xu"; alerta (persona1.name); alerta (persona1.hasownproperty ("nombre")); // Verdadero de la instancia eliminar la persona1.name; alerta (persona1.name); alerta (persona1.hasownproperty ("nombre")); // falso del prototipo // 2. Prototipo y en el operador // en hay dos formas de usarlo, uno se usa por separado y en For-In. Cuando se usa solo, el operador in devuelve verdadero cuando el objeto puede acceder a una propiedad dada // sin importar si la propiedad proviene del prototipo o la función de instancia persona () {} persona.prototype.name = "Amber"; Persona.prototype.age = 23; Persona.prototype.job = "ingeniero de software"; Persona.prototype.sayname = function () {alert (this.name)} var persona1 = new Person (); var persona2 = nueva persona (); alert ("nombre" en persona1); // true desde el prototipo alerta ("nombre" en persona2); // true desde la alerta de prototipo ("altura" en persona1); // false // de esta manera puede encapsular una función (si la propiedad dada es el prototipo para el objeto dado) function haprototypePreperty (objeto, nombre) {return! Object.hasownproperty (nombre) (nombre) (nombre) (nombre) (nombre); } alert("--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Returns all enumerable Propiedades a las que se puede acceder a través de objetos, incluidas las propiedades de prototipo y de instancia. toString: function () {return "mi objeto"; Acepte un objeto como argumento, // Una matriz de cadenas que contiene todas las propiedades enumerables funciones Person () {} persona.prototype.name = "Amber"; Persona.prototype.age = 23; Persona.prototype.job = "ingeniero de software"; Persona.prototype.sayname = function () {alert (this.name)} var persona1 = new Person (); var persona2 = nueva persona (); var teclas = objeto.keys (persona.prototype); alerta (claves) persona1.name = "Amber.xu"; persona1.age = 23; var teclas = objeto.keys (persona1); alerta (claves) alerta("--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ----------------------------------------------------------------------------------------------- Nombre: "Amber", Age: 23, Job: "Software", Sayname: Function () {Alert (this.name)}} // Después de escribir esto, el atributo de constructor ya no apunta a la función de la persona, sino al constructor de objeto EG: alerta (amigo instanciaf objeto) // true alerta (amigo.constructor == persona); // false alerta (amigo.constructor == objeto); // true // Si el constructor es realmente importante para usted, puede configurarlo en el valor apropiado como la función de la función a continuación () {} persona.protype = {constructor: Person, nombre: "Amber", Edad: 23, Job: Job: Software ", Sayname", SayneM () alerta (this.name)}} var amigo = nueva persona (); alerta ("establecido manualmente Constructor ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- // En este caso, puede usar Object.DefineProperty (Person.prototype, "Constructor", {enumerable: false, valor: persona}); La instancia y el prototipo, la conexión entre la instancia y el prototipo es solo un puntero, no una copia // cuando llamamos al método sayhi (), primero buscaremos un método llamado Sayhi en la instancia y buscaremos el prototipo si no se encuentra. // Sin embargo, si reescribe todo el objeto prototipo, la situación será diferente. // Sabemos que al llamar al constructor, se agregará un puntero prototipo al prototipo original a la instancia, y modificar el prototipo a otro objeto es equivalente a cortar la conexión entre el constructor y el prototipo original. // Recuerde: el puntero en la instancia solo apunta al prototipo, no al constructor. por ejemplo: función a () {} var a1 = new a (); A.Prototype = {Constructor: A, Nombre: "Amber", Age: 23, Job: "Software", SayName: Function () {Alert (this.name)}} alert("ERROR------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ Even all native Los tipos de referencia se crean utilizando este patrón. String.prototype.startswith = function (text) {return this.indexof (text) == 0; }; var msg = "hola"; alerta (msg.startswith ("h")); // No recomendamos hacer esto. alerta ("Problema de prototipo con Prototype Object"); // 6. Prototype Ejemplo de función Ques () {} ques.prototype = {constructor: ques, nombre: "Amber", edad: 23, trabajo: "it", amigos: ["zhang san", "li si"], // tipo de referencia dice: function () {alerta (this.name)}}; var q1 = new Ques (); var q2 = new Ques (); Q1.Friends.push ("Wang Wu"); alerta (q1.friends); // alerta (q2.friends); // alerta (q1.friends === Q2.Friends); // Creo que todos han visto el problema. Cuando creé dos instancias Q1 y Q2, y cuando agregué "Wang Wu" a "Amigos" de Q1, los "Amigos" de Q2 también tenían tres "Wang San, Li Si y Wang Wu // Eso es porque la matriz existe en Ques.prototype, no en Q1. Por lo tanto, los resultados anteriores aparecen.Este artículo terminará aquí. Continuaremos discutiendo la programación orientada a objetos de JavaScript en el futuro. Espero que a todos les pueda gustar.