Copiar código del código de la siguiente manera:
<mce: script type = "text/javaScript"> <!-
/*
Cada instancia de objeto tiene un prototipo (prototipo) que los miembros del atributo se usan para apuntar a su instancia de objeto (llamado temporalmente el objeto principal)
Señalamos la relación entre el prototipo del padre como [prototipo prototipo de prototipo Chian]
El prototipo también tiene un padre, porque a menudo es una instancia de objeto, a menos que lo cambiemos personalmente
En JavaScript, "Todo es un objeto, la función es el primer tipo".
La función y los objetos son instancias de funciones.
El prototipo del padre de la función apunta al prototipo de función, la función.
El prototipo principal del objeto también señala el prototipo de la función.
En el motor Spidermonkey, se puede acceder al prototipo principal a través de __proto__
*/
Function.prototype.hi = function () {alert ('HI Function');}
Object.prototype.hi = function () {alert ('HI Object');}
var a = function () {
this.txt = "A";
}
A.Prototype = {
decir: function () {alert ('a');}
}
Alerta (una función de instancia);
Alerta (a .__ loto___ === Función.prototype);
Alerta (función instancia de objeto) // La función es una instancia de objeto;
Alerta (función .__ loto__ === Concción FU.prototype);
Alerta (function.prototype .__ loto__ === Object.prototype);
Alerta (objeto .__ Proto__ === Function.Prototype);
Alerta (objeto.prototype .__ loto __);
Alerta (a.prototype instancia de objeto);
Alerta (A.Prototype .__ loto__ === Object.prototype);
var a = function () {};
A.prototype = new a ();
A.prototype.say = function () {
alerta ('a');
}
Alerta (una función de instancia);
Alerta (a .__ propo___ === function.prototype);
Alerta (A.Prototype instancia de a);
Alerta (A.Prototype .__ loto__ === A.Prototype);
var ia = nuevo A (); // IA es una instancia de A, ia .__ Proto__ ===
var ib = new a (); // Ib es una instancia de A, Ib .__ Proto__ ===
Ia.hi ();
/*
IA en sí no tiene método HI (no en la estructura, y no lo he definido),
Así que busque IA .__ Proto__, es decir, A.Prototype, y no lo encontré.
Así que busque A.Prototype .__ loto__, es decir, A.Prototype, y todavía no lo encontré.
Continúe encontrando a.prototype .___ loto__, eso es objeto. Prototipo, wow, encontré hola, así que lo llamé y dejé de buscar
Salida: HI Object
*/
Ib.hi ();
/*
IB en sí no tiene método HI (no en la estructura, y no lo he definido),
Así que encuentre IB .__ loto__, es decir, A.Prototype, pero aún no lo encontró.
Continúe encontrando a.prototype .___ loto__, eso es objeto. Prototipo, wow, encontré hola, así que lo llamé y dejé de buscar
Salida: HI Object
*/
a.hi ();
/*
A en sí no tiene un método HI (no hay en la estructura, y no lo he definido),
Así que encuentre un .__ propo___ ambas funciones. Prototype, wow, encontré hola, así que lo llamé y dejé
Salida: HI Función
*/
ia.say ();
/*
Ia en sí no tiene un dicho (no en la estructura, y no lo he definido),
Así que encontrar ia .__ Proto__, eso es A. Prototype, wow, descubrí que lo llamé y dejé de buscar
Entonces, aquí está A.Prototype.say
Salida: A
*/
Ib.say ();
/*
IB en sí no tiene algo que decir (no en la estructura, y no lo he definido),
Así que encuentra IB .__ loto__, ese es A. Prototype, wow, encontré decir, así que lo llamé y dejé de buscar
Entonces, aquí está A.Prototype.say
Salida: A
*/
ia.bad ();
/*
IA en sí no tiene un mal método (no hay en la estructura, y no lo he definido),
Así que busque IA .__ Proto__, es decir, A.Prototype, y no lo encontré.
Así que busque A.Prototype .__ loto__, es decir, A.Prototype, y todavía no lo encontré.
Continúe encontrando A.Prototype .__ loto__, eso es objeto.prototype.
Error de retorno, ia.bad no es una función
*/
// -> </mce: script>
</script>
¡Gracias a la opinión de corrección de Simon! Todas las instancias no encuentran su propio prototipo al buscar el método de atributo (¡el prototipo de la instancia no está en la cadena de prototipos, solo puede usarse como un atributo)!