Para entender os objetos JavaScript, podemos iniciar a criação de objetos, operações de propriedades e métodos de objetos. Para resumir, inclui os seguintes módulos:
1. Crie um objeto
1.1 Medição de objeto direto
A quantidade direta de um objeto é a maneira mais fácil de criar um objeto e consiste em vários pares de nome/valor:
var point = {x: 0, y: 0};Não há limite para atribuir nomes. Eles podem ser palavras -chave JS ou qualquer seqüência. Se essas duas situações, os atributos precisarão ser fechados em cotações duplas:
var em vazio = {}; va Point = {x: 0, y: 0}; var book = {"Título principal": "JavaScript", "Sub-Title": "The Definitive Guide", "para": "All Audience", Autor: {FirstName: "Davide", Sounname: "Flanagan"};;É muito simples criar objetos diretamente, mas geralmente não é usado dessa maneira. O código é baixo reutilizável. Se você deseja usar o objeto em outro lugar e os valores do atributo são diferentes, faça isso? Você tem que recriar outro código?
1.2 Crie um objeto através de novo
Antes de criar um objeto através do novo, você deve primeiro criar uma função e o novo trata essa função como um construtor. Por exemplo, crie um objeto de pessoa através de novo:
function pessoa () {// construtor} var pessoa = new Person ();Os tipos primitivos no núcleo da linguagem JavaScript contêm construtores internos:
var a = new Array (); var d = new Date (); var r = novo regexp ("js");1.3 Object.create ()
Antes de entendermos o método Create of Object, queremos ver o que é um protótipo. Cada objeto JavaScript (exceto nulo) está associado a outro objeto. O objeto "Outro" é o que chamamos de protótipo. Cada objeto herda os atributos do protótipo.
Todos os objetos criados através da quantidade direta do objeto têm o mesmo objeto de protótipo.Prototype. O protótipo de objeto criado pela palavra -chave novo e construtor é o valor da propriedade Prototype do construtor. O protótipo do objeto criado através do new Array () é Array.prototype, e o protótipo do objeto criado através do new Date () é date.prototype. O protótipo foi introduzido aqui.
O método Object.Create contém dois parâmetros. O primeiro parâmetro é o protótipo do objeto e o segundo parâmetro é opcional para descrever as propriedades do objeto. É fácil de usar, basta passar no objeto de protótipo necessário:
var o1 = object.create ({x: 1, y: 2}); // O protótipo é objeto.prototipoSe você deseja criar um objeto sem um protótipo, pode passar nulo como um parâmetro. Os objetos criados dessa maneira não herdam nenhuma propriedade, e não há método como ToString:
var o2 = object.create (nulo); // sem protótipo
Se você deseja criar um objeto vazio normal, passe -o diretamente para o object.prototype:
var o3 = object.create (object.prototype);
Se for um objeto personalizado, é o mesmo que criar um objeto vazio. Passe o nome do objeto diretamente.prototype:
function pessoa () {} var o4 = object.create (Person.prototype);2. Gerenciamento de atributos
2.1 Consulta de propriedades e configurações
As propriedades de um objeto podem ser obtidas através do operador de ponto (.) Ou suporte quadrado ([]). Se você usar pontos para obter o atributo, o nome do atributo deve ser um indicador simples. Não pode ser uma palavra reservada, como O. para ou O.class.
Autor AR = Book.author; // correto var name = Author.surname; // correto var title = livro ["título principal"]; // correto var className = book.class; //Erro
A sintaxe do objeto ["Propriedade"] parece mais uma matriz, exceto que os elementos dessa matriz são indexados por strings do que por números. Esse tipo de matriz é o que chamamos de matriz associativa, também conhecida como hash, mapa ou dicionário. Os objetos JavaScript são matrizes associativas.
Como o objeto é uma matriz associativa, o JavaScript também nos fornece um método para/in para atravessar as propriedades. O exemplo a seguir usa para/in para calcular o valor total do portfólio:
função getValue (portfólio) {var total = 0,0; para (estoque em portolio) {var sites = Portolio [Stock]; var price = getQuote (estoque); Total += Ações * Preço; } retornar total;}Herança: os objetos JavaScript têm suas próprias propriedades, e algumas propriedades são herdadas a partir de objetos de protótipo. Vamos primeiro olhar para uma função herdar que implementa a herança:
função herd (p) {if (p == null) the typeError (); // p é um objeto, ele não pode ser nulo se (object.create) {return object.create (p); // use o método object.create diretamente} var t = typeof p; if (t! == "objeto" && t! == "function") lança typeError (); função f () {}; F.Prototype = P; // Defina seu atributo de protótipo para P Return New F ();}Suponha que você queira consultar o atributo x do objeto o. Se x não existir em O, você continuará consultando o atributo x no objeto de protótipo de o. Se não houver x no objeto de protótipo, mas o objeto de protótipo também possui um protótipo, continue a executar a consulta no protótipo do protótipo do objeto até que X seja encontrado ou um objeto nulo seja encontrado.
var o = {}; // OIRERIT Object Attribute ox = 1 do object.prototype; // define os atributos x para o var p = herdado (o); // pinherito o e object.prototypep.y = 2; // atributo pDefine yvar q = herdar (p); // qherit p, o e object.prototypeq.z = 3; // define o atributo zvar s = q.toString (); // ToString herda de object.prototypeq.x + QY // => 3: X e Y herdam de O e P, respectivamente,2.2 Excluir atributos
O operador de exclusão pode excluir as propriedades do objeto:
excluir book.author; excluir livro ["título principal"];
A exclusão só pode excluir seus próprios atributos e não pode excluir atributos herdados. Para excluir uma propriedade herdada, ela deve ser excluída do objeto de protótipo que define a propriedade, e isso afeta todos os objetos herdados do protótipo. A exclusão retornará true.
ar o = {x: 1}; excluir ox; // exclua x e retorna o boi do Truelete; // x não existe mais, nada é feito, retorne verdadeiro. excluir o.toString; // não faz nada, retorne verdadeiro. Excluir não pode excluir atributos com tipo configurável false. As propriedades de alguns objetos embutidos não são configuráveis, como as propriedades do objeto global criado através de declarações variáveis e declarações de funções: exclua objeto.Prototype // Não pode ser excluído, as propriedades não são configuráveis var x = 1; delete this.x; // Esta propriedade não pode ser excluída da função f () {} excluir this.f; // A função global não pode ser excluída2.3 Detectar propriedades
Para determinar se existe uma propriedade em um objeto, ela pode ser detectada pelos métodos Operador, HasOwnProperty () e PropertyInumerable ().
No operador: o operador é o nome da propriedade à esquerda e o objeto à direita. Retorne true se o próprio atributo ou atributo herdado do objeto contiver atributos:
var o = {x: 1}; "x" em o; // true: x é o atributo "y" em O; // false: y não é o atributo "ToString" em O; // true: o herda o atributo de toqueMétodo HASOWNPROPERTY (): detecta se o nome fornecido é a própria propriedade do objeto. Para atributo herdado, ele retornará false:
var o = {x: 1}; o.HasownProperty ("x"); // true: o tem uma propriedade gratuita xo.hasownProperty ("y"); // false: nenhuma propriedade yo.hasoenproperty ("tostring"); // FALSE: ToString é uma propriedade de herançaMétodo Propertyisenumerable (): é uma versão aprimorada do HasOwnsProperty. Ele retornará verdadeiro apenas se a própria propriedade for detectada e essa propriedade for mantida como verdadeira:
var o = herdar ({y: 2}); ox = 1; o.propertyisenumerable ("x"); // true: o tem uma propriedade enumerável xo.propertyisenumerable ("y"); // false: y é o objeto herdado.prototype.propertyisenumerable ("tostring"); // false: não pode ser enumerável2.4 Propriedades de enumeração
Geralmente, para/in é usado para percorrer as propriedades do objeto, e as propriedades percorridas incluem suas próprias propriedades e propriedades herdadas. Os métodos internos de herança de objetos não são enumeráveis, mas as propriedades adicionadas aos objetos no código são enumeráveis. Por exemplo:
var o = {x: 1, y: 2, z: 3}; // Três propriedades enumeráveis o.PropertyIsenumable ("ToString"); // false, não pode ser enumerado para (p in o) // transferir a propriedade console.log (p); // saída x, y e z, sem saída de toquesÀs vezes, apenas queremos iterar sobre nossas próprias propriedades, e as propriedades não são funções:
para (P in O) {if (! O.HasownProperty (P)) continue; if (typeof o [p] === "function") continue;}Podemos copiar atributos enumeráveis através da função de travessia de enumeração:
/** Copie os atributos enumeráveis em p em O e retorne o* Se o e p contêm atributos com o mesmo nome, substituem os atributos em O* Esta função não lida com getters e setters e copia atributos*/função estend (o, p) {para (prop em p) {// transfere todos os atributos em P o [prop] = P [prop]; // Adicione atributos a O} retornar o;}O ES5 define duas funções que enumeram nomes de atributos. O primeiro é object.Keys (), que retorna uma matriz composta por nomes de atributos enumeráveis no objeto. A segunda função de enumeração é object.TetownPropertyNames (), que é semelhante a object.keys (), que retorna todas as propriedades do próprio objeto, não apenas propriedades enumeráveis.
3. Encapsulamento de atributos
3.1 atributos getter e setter
Os atributos do objeto são compostos de nomes, valores e um conjunto de atributos. No ES5, os valores de atributo podem ser substituídos por um ou dois métodos, que são getters e setters. Os atributos definidos por getters e setters são chamados de "atributos de acessórios". Ao contrário dos "atributos de dados", os atributos de dados têm apenas um valor simples.
Diferentemente dos atributos de dados, o atributo de acessório não é escrito. Se a propriedade possui métodos Getter e Setter, será uma propriedade de leitura/gravação. Se possui apenas métodos getter, é uma propriedade somente leitura, se possui apenas métodos setter, será uma propriedade somente de gravação. A leitura de atributos somente de gravação sempre retorna indefinidos.
A sintaxe de definição de atributo de acessador também é relativamente simples. A definição da função não usa a palavra -chave da função, mas usa Get ou Set:
var o = {// atributo de dados ordinários data_prop: 1, // atributos de acessórios são todas as funções definidas em pares get acessador_prop () {/* aqui está o corpo da função*/}, set acessor_prop (value) {}};Pense no seguinte objeto que representa as coordenadas dos pontos cartesianos 2D. Possui duas propriedades normais X e Y representam coordenadas X e Y coordenadas, respectivamente. Ele também possui duas propriedades de acessador equivalente para representar as coordenadas polares dos pontos:
var p = {// x e y são atributos de dados de leitura de leitura comuns x: 1.0, y: 1.0, // r é um atributo de acessador de leitura-write, que tem getter e setter get r () {return math.sqrt (this.x * this.x + this.y * this.y); }, set r (newValue) {var OldValue = Math.sqrt (this.x * this.x + this.y * this); Proporção var = newValue / OldValue; this.x *= proporção; this.y *= razão; }, // Theta é um atributo de acessador somente leitura, apenas o método getter obtém theta () {return math.atan2 (this.y, this.x); }};Como os atributos de dados, os atributos do acessador são herdáveis, portanto o objeto P no código acima pode ser considerado como um protótipo de outro "ponto". Ele pode definir suas propriedades X e Y para um objeto sexual, mas as propriedades r e teta herdam de:
var q = herdar (p); qx = 1, qy = 1; console.log (qr); cosole.log (q.theta);
3.2 Recursos de atributo
Podemos considerar os métodos getter e setter do atributo de acessórios como características de atributo. De acordo com essa lógica, também podemos observar as características das propriedades das propriedades. Portanto, pode -se considerar que uma propriedade contém um nome e 4 atributos.
As quatro características de uma propriedade numérica são seu valor, escritas, enumeráveis e configuráveis.
Os atributos de acessórios não têm características de valor e escritura, portanto incluem: leia (get), gravar (set), enumeração e configurabilidade.
O ES5 define um objeto chamado "Descritor de atributo", que representa esses 4 atributos. Os atributos do objeto descritor do atributo de dados incluem valor, gravável, enumerável e configurável. O objeto descritor do atributo acessador é substituído pelo atributo get e pelo atributo set. Entre eles, graváveis, enumeráveis e configuráveis são os valores booleanos, e o atributo Get Attribui e Set são valores de função.
Você pode obter o descritor da propriedade para uma propriedade específica de um objeto chamando Object.GetownPropertyDescriptor ():
// return {value: 1, gravável: true, enumerável: true, configurável: true} object.GetownProeprtyDescriptor ({x: 1}, "x"); // consulta a propriedade do octeto do objeto aleatório definido acima // return {get:/ *func */, se definido, trueleerable: verdadeiro: verdadeiro: confinado acima // return {get:/ *func */, sete: inumerable, verdadeiro: verdadeiro: trueburily: "Octete"); // Para atributos herdados e atributos inexistentes, return undefinedObject.GetownPropertyDesciptor ({}, "x"); object.getownPropertyDesciptor ({}, "tostring");Como você pode ver no nome da função, object.GetownPropertyDesciptor () só pode obter o descritor de suas próprias propriedades. Para obter as características dos atributos herdados, você precisa atravessar a cadeia do protótipo (object.getProTypeof ()).
Se você deseja definir as propriedades das propriedades ou fazer com que as propriedades recém -criadas possuam certas propriedades, você precisa chamar Object.DefineProperty (), que contém três parâmetros: objeto, nome da propriedade e objeto de descritor da propriedade:
// existem propriedades, mas o OX não pode ser enumerado; // => 1Object.Keys (O) // => [] // Agora modifique a propriedade x para torná-la a leitura-somente.DefineProperty (O, "X", {Writion: true}); // A visão altera o valor desta propriedade Ox = 2; // a operação falha, mas nenhum erro é relatado e uma exceção de erro de tipo é lançada em modo rigoroso // as propriedades ainda são configuráveis, para que possa ser modificado dessa maneira: object.DefineProperty (o, "x", {value: 2}); ox // => 2 // agora modificar x da propriedade de dados para a propriedade de acessor 0;}}); ox // => 0Se você deseja modificar ou criar várias propriedades ao mesmo tempo, precisará usar o Object.DefineProperties (). O primeiro parâmetro é o objeto a ser modificado e o segundo parâmetro é uma tabela de mapeamento. Por exemplo:
var p = object.DefineProperties ({}, {x: {Value: 1, gravidade: true, enumerável: true, configurável: true}, y: {value: 2, winditable: true, enumerável: true, configurable: true}, r: {get: function () {return math.sqr (this. this. this.T.T.T.Teer. Verdadeiro, configurável: true}});APIs antiquadas para getters e setters: Antes do ES5, a maioria das implementações de JavaScript já poderia suportar obter e definir a escrita na sintaxe de quantidade direta do objeto. Essas implementações fornecem APIs antiquadas não padrão para consultar e definir getters e setters. Essas APIs são compostas por quatro métodos e todos os objetos têm esses métodos.
__LeoveUpgetter __ () e __LookUpSetter __ () são usados para retornar um método de getter de atributo nomeado e setter.
__Definegetter __ () e __DefineSetter __ () são usados para definir getters e setters. O primeiro parâmetro é o nome do atributo, e o segundo parâmetro é o método Getter e Setter.
var o = {}; o .__ definegetter __ ("x", function () {return 0;}); o .__ defineSetter __ ("y", function (value) {console.log ("set valor:" + value);});4. Três propriedades de um objeto
Cada objeto possui um protótipo, classe e atributo extensível relacionado a ele. Em seguida, vamos falar sobre o que esses atributos fazem.
4.1 Propriedades do protótipo
Os atributos do protótipo de um objeto são usados para herdar atributos. Muitas vezes chamamos de "atributos de protótipo de O" diretamente "o protótipo de O". Anteriormente, "Create Objects" introduziu três maneiras de criar objetos. Os objetos criados pelos objetos são usados como seu protótipo usando object.prototype. Objetos criados pelo novo Use o atributo de protótipo do construtor como protótipo. Objetos criados com object.Create () Use o primeiro parâmetro como seu protótipo.
No ES5, o protótipo de objeto pode ser consultado através do object.getProTypeOf (). No ES3, não há função equivalente, mas, em vez disso, a expressão O.Constructor.Prototype é usada para verificar o protótipo do objeto.
Para detectar se um objeto é um protótipo de outro objeto (ou está na cadeia de protótipo), use o método ISProTypeOf (). Por exemplo, você pode detectar se P é um protótipo de O por p.isprototypeof (O):
var p = {x: 1}; // Defina um protótipo objeto var o = object.create (p); // Use este protótipo para criar um objeto p.isprototypeof (o); // => true, o herda de pobject.prototype.isprototypeof (o) // => true, p herda do object.prototypeO JavaScript implementado por Mozilla expõe um atributo especificamente chamado __proto__ para consultar/definir diretamente o protótipo de objeto. No entanto, o IE e a Opera não suportam o atributo __proto__, portanto, não é recomendável usar o atributo __proto__ diretamente.
4.2 Atributos da classe
O atributo de classe de um objeto é uma string para representar as informações do tipo do objeto. O ES3 e o ES5 fornecem métodos para definir essa propriedade, e há apenas uma maneira indireta de consultá -la. O método ToString () padrão retorna uma string neste formato: [Classe Object].
Você pode chamar o método tostring () e extrair os caracteres entre o oitavo e a penúltima posição da string retornada. Mas há um problema de que muitos objetos herdaram os métodos ToString () foram reescritos. Para poder chamar a versão ToString () correta, o método function.call () deve ser indiretamente chamado. A função de classef no exemplo a seguir pode retornar a classe de qualquer objeto:
function classof (o) {if (o === null) retorna "null"; if (o === indefinido) retornar "indefinido"; Return object.prototype.toString.Call (O) .Slice (8, -1);}4.3 Escalabilidade
A extensibilidade do objeto é usada para indicar se novas propriedades podem ser adicionadas ao objeto. Todos os objetos embutidos e personalizados são explicitamente extensíveis. No ES5, os objetos podem ser convertidos para não escaláveis.
Além de definir o objeto como não extensível, o método object.Seal () também pode definir todas as propriedades do objeto como não confundíveis. Ou seja, novos atributos não podem ser adicionados ao objeto, e os atributos existentes não podem ser excluídos e configurados.
O método object.iSiSealed () é usado para detectar se o objeto está fechado.
O método object.freeze () bloqueará os objetos mais estritamente. Além de ter a função do método Object.Seal (), ele também pode definir todos os seus próprios atributos de dados para somente leitura (se o atributo de acessador do objeto tiver um método Setter, o atributo do acessador não for afetado e você ainda pode chamá-los atribuindo valores aos atributos).
Object.isfrozen () é usado para detectar se o objeto está congelado.
5. serializam objetos
A serialização do objeto refere -se à conversão do estado de um objeto em uma string ou você pode restaurar a sequência em um objeto. O ES5 fornece funções internas json.stringify () e json.parse () para serializar e restaurar objetos JavaScript. Todos esses métodos usam o JSON como formato de troca de dados. Por exemplo:
o = {x: 1, y: {z: [false, null, ""]}}; // define um objeto de teste s = json.stringify (o); // {"x": 1, "y": {"z": [false, null ""]}} p = json.parse (s); // p é uma cópia profunda de OA sintaxe do JSON é um subconjunto da sintaxe JavaScript e não pode representar todos os valores no JavaScript. Objetos, matrizes, cordas, números infinitos, verdadeiros, falsos e nulos são suportados e podem ser serializados e restaurados. Os resultados da serialização da NAN, Infinito e Infinidade são todos nulos. Funções, regexp, objetos de erro e valores indefinidos não podem ser serializados e restaurados.
Aqui vou adicionar o método do objeto:
ToString () Método: ele retornará uma string representando o valor do objeto que chama esse método. Muitos objetos reescreveram o método ToString (), como Array.ToString (), Date.ToString () e Function.ToString ().
Método Tojson (): Object.Prototype não define o método TOJSON (), mas, devido à necessidade de executar a serialização, o método JSON.Stringify () chamará o método TOJSON (). Se esse método existir no objeto serializado, ele será chamado.
Método ValueOf (): O método ValueOf () é muito semelhante ao método ToString (), mas o JavaScript geralmente o chama quando converte um objeto em um determinado valor original em vez de uma string, especialmente quando é convertida em um número. Algumas classes embutidas personalizam o método ValueOf (), como DATE.VALUEOF ().
O artigo acima entende de maneira abrangente o avanço dos objetos JavaScript é todo o conteúdo que compartilho com você. Espero que possa lhe dar uma referência e espero que você possa apoiar mais o wulin.com.