Copie o código do código da seguinte forma:
<MCE: script type = "text/javascript"> <!-
/*
Cada instância do objeto possui um protótipo (protótipo) que os membros do atributo são usados para apontar para sua instância do objeto (temporariamente chamado de objeto pai)
Apontamos o relacionamento entre o protótipo do pai como [protótipo de protótipo protótipo Chian]
O protótipo também tem um pai - -nela, porque geralmente é uma instância de objeto, a menos que mudemos pessoalmente
Em JavaScript, "tudo é um objeto, a função é o primeiro tipo".
Função e objetos são instâncias de funções.
O protótipo do pai da função aponta para o protótipo da função, função. O protótipo do pai do protótipo é objeto
O protótipo pai do objeto também aponta para o protótipo da função.
No motor Spidermonkey, o protótipo pai pode ser acessado através de __proto__
*/
Function.prototype.hi = function () {alert ('hi function');}
Object.prototype.hi = function () {alert ('hi objeto');}
var a = function () {
this.txt = "a";
}
A.Prototype = {
Diga: function () {alert ('a');}
}
Alerta (uma função de instância);
Alerta (a .__ loto___ === function.prototype);
Alerta (instância da função do objeto);
Alerta (function .__ loto__ === FU CONCTION.PROTOTYPE);
Alerta (function.prototype .__ loto__ === Object.prototype);
Alerta (objeto .__ proto__ === function.prototype);
Alerta (object.prototype .__ LOTO __);
Alerta (A.Prototype Instância do objeto);
Alerta (a.prototype .__ loto__ === object.prototype);
var a = function () {};
A.prototype = novo a ();
A.prototype.say = function () {
alerta ('a');
}
Alerta (uma função de instância);
Alerta (a .__ Propo___ === function.prototype);
Alerta (a.prototype Instância de a);
Alerta (A.Prototype .__ loto__ === A.Prototipo);
var Ia = novo a ();
var ib = novo a ();
IA.HI ();
/*
O próprio IA não tem o método HI (não na estrutura, e eu não o defini),
Portanto, procure Ia .__ Proto__, isto é, A.Prototype, e não o encontrou.
Portanto, procure a.prototype .__ loto__, ou seja, a.prototype, e eu ainda não o encontrei.
Continue a encontrar a.prototype .___ loto__, isso é objeto.prototipo, uau, eu encontrei oi, então liguei e pare de procurar por
Saída: Hi objeto
*/
Ib.hi ();
/*
O próprio ib não tem o método HI (não na estrutura, e eu não o defini),
Então, encontre ib .__ loto__, ou seja, a.prototipo, mas ainda não o encontrou.
Continue a encontrar a.prototype .___ loto__, isso é objeto.prototipo, uau, eu encontrei oi, então liguei e pare de procurar por
Saída: Hi objeto
*/
a.hi ();
/*
Um em si não tem um método HI (não há na estrutura, e eu não o defini),
Então encontre um .__ propo___ ambos function.prototype, uau, eu encontrei oi, então liguei e pare de procurar por
Saída: Hi function
*/
IA.Say ();
/*
A própria IA não tem um ditado (não na estrutura, e eu não a defini),
Então encontre ia .__ proto__, ou seja, a.prototype, uau, eu encontrei dizer, então liguei e pare de procurar por
Então, aqui está a.prototype.say
Saída: a
*/
Ib.say ();
/*
O próprio IB não tem uma opinião (não na estrutura, e eu não a defini),
Então encontre ib .__ loto__, isso é a.prototype, uau, eu encontrei dizer, então liguei e pare de procurar por
Então, aqui está a.prototype.say
Saída: a
*/
IA.BAD ();
/*
O próprio IA não tem um método ruim (não há na estrutura, e eu não o defini),
Portanto, procure Ia .__ Proto__, isto é, A.Prototype, e não o encontrou.
Portanto, procure a.prototype .__ loto__, ou seja, a.prototype, e eu ainda não o encontrei.
Continue a encontrar a.prototype .__ loto__, isso é objeto.prototipo.
Erro de retorno, Ia.bad não é uma função
*/
// -> </mce: script>
</script>
Graças à opinião de correção de Simon! Todas as instâncias não encontram seu próprio protótipo ao pesquisar o método de atributo (o protótipo da instância não está na cadeia de protótipo, ela só pode ser usada como atributo)!