JavaScript baseia -se nas características de vários idiomas; Por exemplo, sintaxe java, funções se baseiam no esquema, a herança do protótipo se baseia em si e a expressão regular extrai do Perl. (DC JavaScript: Essência da linguagem).
Primeiro, cada JS é uma linguagem orientada a objetos baseada na herança do protótipo. A matriz dentro é um objeto, a função é um objeto e, é claro, o "objeto" ainda é um objeto. Além disso, cada objeto possui um slot interno [[protótipo]], que é a chave para conectar a cadeia de protótipo. É certo que podemos definir uma propriedade de protótipo para um objeto, mas e daí? Esta é apenas uma manifestação; Há uma intenção assassina escondida por trás disso.
Ok, então eu posso usar o ISProTypeOf () para verificar se um objeto é um protótipo de outro objeto; No entanto, isso também é baseado na cadeia [[protótipo]].
Por exemplo:
// Crie uma função função foo () {} // modifique a propriedade do protótipo da função foo.prototype = {name: "foo.prototype"}; // Crie uma instância var a = new Foo (); // Reescreva o protótipo padrão de A, que deveria ter sido foo.prototype. A.Prototype = {Nome: "A.Prototype"};A seguinte pergunta é se foo.prototype é o protótipo de A? !
Isso precisa ser visto separadamente: por um lado, a.prototype é de fato {nome: "A.Prototype"}; No entanto, foo.prototype.isprototypeof (a) O resultado é verdadeiro.
Vamos dar uma olhada no relacionamento específico: (usando ---> significa uma cadeia insignificante [[protótipo]], ---- significa um relacionamento de propriedade do protótipo)
Function ---> function.prototype ---> object.prototype
Function.prototype <--- foo ---- Foo.prototype ------> object.prototype.
Além disso, [[protPtype]] de número, booleano, string, etc. ainda é um objeto função.Prototype. O objeto function.prototype é "função" e não contém [[construto]] por dentro, por isso não pode ser usado como construtor; De fato, function.prototype é semelhante: function () {}. Além do slot interno [[protótipo]], o tipo "função" também possui um atributo de protótipo. Cada função sempre possui um objeto de protótipo: this.prototype = {construtor: this} (um objeto normal). O [[protótipo]] desse objeto normal está conectado ao objeto.prototipo.
O [[protótipo]] do objeto de instância é criado pelo construtor um objeto.Prototype?
O [[protótipo]] desta instância é inicializado pela propriedade do protótipo do construtor. Observe que não é o [[protótipo]] da função. Portanto, se for um objeto construído pela função do objeto, é de fato.
Objeto é uma função, seu protótipo é o objeto famoso.Prototype (um bit bitsense), mas seu [[protótipo]] aponta para function.prototype. Por favor, veja abaixo:
Objeto -----> function.prototype ------> object.prototype.
Como alterar essa cadeia [[protótipo]]?
Pode ser na forma de var a = object.create (obj) ou object.SetPrototypeof (obja, objb). Eu não acho que há necessidade de dar exemplos, porque o relacionamento é muito simples; Vamos dar apenas alguns exemplos ruins. Não há sentido.
A última pergunta é: a delegação comportamental é baseada na cadeia [[protótipo]]?
Sim, esse é o caso.