A explicação nos comentários é muito detalhada, por isso não vou falar muito bobagem aqui, basta inserir o código:
<script type = "text/javascript"> // ecma-262 define um objeto como: "Uma coleção de atributos não ordenados, cujos atributos podem conter valores, objetos ou funções básicos" // A maneira mais fácil de entender o objeto é criar uma instância do objeto e adicionar atributos e métodos a ele var. pessoa.name = "xulei"; pessoa.age = "23"; pessoa.job = "engenheiro front-end"; pessoa.SayName = function () {alert (this.name); } // você também pode escrever var pessoa = {nome: "xulei", idade: 23, trabalho: "engenharia front-end", SayName: function () {alert (this.name)}} // 1. Tipo de atributo: atributo de dados e acesse seu atributo // 1. Atributo de dados, existem 4 características que descrevem seu comportamento // [configurável]: indica se o atributo pode ser excluído para redefinir o atributo, se o atributo pode ser modificado ou se o atributo pode ser modificado para o atributo de que o atributo é regustado, o valor padrão é que o valor é verdadeiro, o que é o que é o que é o que é o que é o que é o que é o que é o que é o que é o que é o que é o que pode ser regustado. O valor padrão é verdadeiro // [valor]: contém o valor dos dados deste 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 (Peron, "Nome", {Writable: false, // A propriedade não pode ser modificada: "Xu Lei-Xulei"}); alerta (peron.name); // xu lei-xulei peron.name = "xu lei"; alerta (peron.name); // xu lei-xulei // As operações acima serão ignoradas no modo não rito. Se uma exceção for lançada no modo rigoroso // Uma vez que o atributo for definido como não confundível, ele não poderá ser transformado em configuração. // Na maioria dos casos, não há necessidade de utilizar esses recursos avançados fornecidos pelo método Object.DefineProperty (). Mas é muito útil para entender o JavaScript. // Os leitores são aconselhados a não usar esse método no IE8. // 2. Accessing its properties has 4 characteristics //[Configurable]: indicates whether the attribute can be deleted to redefine the attribute, whether the attribute's characteristics can be modified, or whether the attribute can be modified to the accessor attribute, the default value is true //[Enumerable]: indicates whether the attribute can be returned through for-in, the default value is true //[Get]: The default value of the function called when reading is indefinido // [set]: o valor padrão da função chamado ao escrever o atributo, indefinido, var livro = {_year: 2004, edição: 1} object.DefineProperty (livro, "ano", {get: function () {return this._year;}, set: function (value) {se (se (se }); Book.Year = 2005; alerta (book.edition); // 2 // Crie um objeto // 1. Trate o construtor como uma pessoa da função (nome, idade, trabalho) {this.name = name; this.age = idade; this.Job = Job; this.sayName = function () {alert (this.name); }} // use var pessoa = new pessoa ("xulei", 23, "software"); pessoa.SayName (); // Use a pessoa ("xulei2", 23, "job2"); // adicione a window.sayname (); // Call var no escopo de outro objeto o = new Object (); Person.Call (O, "Xulei3", 23, "Job3"); O.SayName (); </script>Vamos ter outro parágrafo:
<script type = "text/javascript"> // 1. Entenda o protótipo objeto // 2. Protótipo e no operador // 3. Protótipo mais simples sintaxe // 4. Dinamicidade do protótipo // 5. Prototipo de objeto nativo // 6. Problemas com o protótipo objeto // 1. Sempre que uma função for criada, um atributo de protótipo será criado para a função com base em um conjunto específico de regras. Este atributo aponta para o protótipo objeto da função // Por padrão, todos os objetos do protótipo obterão automaticamente um atributo construtor (construtor), que contém um ponteiro para a função em que o atributo protótipo está localizado // como a pessoa // depois de criar um protótipo. Quanto a outros métodos, eles são herdados do objeto. alerta (PERSON.Prototype.isprototypeof (p1)) alert (object.getPrototypeof (p1) == Person.prototype) // Embora o valor salvo no protótipo possa ser acessado através da instância do objeto, o valor no protótipo não pode ser reescrito na instância do objeto. Se adicionarmos uma propriedade // à instância e o nome da propriedade for o mesmo que a instância no protótipo, criamos a propriedade na instância e a propriedade bloqueará a propriedade no protótipo. por exemplo: function Person () {} Person.prototype.name = "Amber"; Pessoa.prototype.age = 23; Pessoa.prototype.job = "engenheiro de software"; Pessoa.prototype.sayName = function () {alert (this.name)} var pessoa1 = new Person (); var pessoa2 = new Person (); PERSON1.NAME = "Amber.xu"; ALERT (PERSON1.NAME); // Amber.xu -From Instância ALERT (PERSON2.NAME); // AMBER -From Protótipo Delete Person1.Name; alert (Person1.name); // âmbar - -do protótipo // use o método HasOwnProperty () para detectar se existe uma propriedade na instância ou no protótipo. Este método (herdado do objeto) // retorna a verdadeira função PERS () {} PERSON.PROTOTYPE.NAME = "Amber"; Pessoa.prototype.age = 23; Pessoa.prototype.job = "engenheiro de software"; Pessoa.prototype.sayName = function () {alert (this.name)} var pessoa1 = new Person (); var pessoa2 = new Person (); alert (Person1.HasownProperty ("Nome")); // Falso do alerta da instância (PERSON2.HASOWNPROPERTY ("Nome")); // FALSE da instância PERSON1.NAME = "Amber.xu"; alerta (Person1.name); alert (Person1.HasownProperty ("Nome")); // true da instância delete PERSON1.NAME; alerta (Person1.name); ALERT (PERSON1.HASOWNPROPERTY ("Nome")); // Falso do protótipo // 2. Prototype e no operador // em duas maneiras de usá-lo, uma é usada separadamente e in for-in. Quando usado sozinho, o operador no IN retorna true quando o objeto pode acessar uma determinada propriedade //, independentemente de a propriedade vem do protótipo ou da função da instância () {} Person.prototype.name = "Amber"; Pessoa.prototype.age = 23; Pessoa.prototype.job = "engenheiro de software"; Pessoa.prototype.sayName = function () {alert (this.name)} var pessoa1 = new Person (); var pessoa2 = new Person (); alerta ("nome" em pessoa1); // true do protótipo alerta ("nome" pessoalmente2); // true do alerta do protótipo ("altura" em pessoa1); // false // dessa maneira você pode encapsular uma função (nome do objeto e objeto). } alert("--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Returns all Propriedades enumeráveis que podem ser acessadas através de objetos, incluindo protótipos e propriedades de instância. o = {tostring: function () {retorna "meu objeto"; Aceite um objeto como um argumento, // uma matriz de string contendo todas as propriedades enumeráveis Pessoa da função () {} Person.prototype.name = "Amber"; Pessoa.prototype.age = 23; Pessoa.prototype.job = "engenheiro de software"; Pessoa.prototype.sayName = function () {alert (this.name)} var pessoa1 = new Person (); var pessoa2 = new Person (); var keys = object.Keys (Person.prototype); alerta (keys) PERSON1.NAME = "Amber.xu"; Person1.age = 23; var keys = object.Keys (Person1); Alerta (chaves) alerta ("---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Nome: "Amber", Age: 23, "software", SayName: function () {alerta (this.name)}} // Depois de escrever isso, o atributo construtor não aponta mais para a função da pessoa, mas para o objeto que não pode ser o que pode ser o que pode ser necessário Pessoa) // alerta verdadeiro (instância de amigo de objeto) // alerta true (amigo.constructor == pessoa); // alerta false (amigo.constructor == objeto); // true // se o construtor for realmente importante para você, você pode defini -lo para o valor apropriado, como abaixo da função () {}},, o nome da pessoa: " SayName: function () {alert (this.name)}} var amigo = new Person (); alerta ("definido manualmente constructor----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- // Neste caso, você pode usar o Object.DefineProperty (Person.prototype, "Construtor", {Enumerable: False, Valor: Pessoa}); Entre a instância e o protótipo, a conexão entre a instância e o protótipo é apenas um ponteiro, não uma cópia // quando chamamos o método Sayhi (), procuraremos primeiro um método chamado Sayhi na instância e procuraremos o protótipo, se não for encontrado. // No entanto, se você reescrever todo o objeto de protótipo, a situação será diferente. // Sabemos que, ao chamar o construtor, um ponteiro de protótipo para o protótipo original será adicionado à instância e a modificação do protótipo para outro objeto é equivalente a cortar a conexão entre o construtor e o protótipo original. // Lembre -se: o ponteiro na instância aponta apenas para o protótipo, não para o construtor. por exemplo: função a () {} var a1 = novo a (); A.Prototype = {Construtor: A, Nome: "Amber", Idade: 23, Job: "Software", SayName: function () {alert (this.name)}} alert("ERROR------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ Even all Os tipos de referência nativos são criados usando esse padrão. String.prototype.startswith = function (text) {return this.indexOf (text) == 0; }; var msg = "hello"; alerta (msg.startswith ("h")); // Não recomendamos fazer isso. alerta ("Problema do protótipo com o objeto de protótipo"); // 6. Exemplo de protótipo Função Ques () {} Ques.prototype = {Construtor: Ques, Nome: "Amber", Idade: 23, Jó: "It", Amigos: ["Zhang San", "Li si"], // Tipo de referência diz: FUNCTION () {ALERT (this.name)}}; var q1 = new Ques (); var q2 = new Ques (); Q1.friends.push ("Wang Wu"); alerta (Q1.friends); // alerta (q2.friends); // alert (Q1.friends === q2.friends); // Acredito que todo mundo tenha visto o problema. Quando criei duas instâncias Q1 e Q2, e quando adicionei "Wang Wu" a "Amigos" de Q1, os "amigos" de Q2 também tiveram três "Wang San, Li Si e Wang Wu // Isso ocorre porque a matriz existe em que há apenas um problema.Este artigo terminará aqui. Continuaremos a discutir a programação de JavaScript orientada a objetos no futuro. Espero que todos possam gostar.