Cadena de historias en modo prototipo: el proceso de un nuevo objeto

Título general anterior : https: //segmentfault.com/a/11 ...
Pregunta: ¿Tiene un objeto?
Respuesta : No.
Estúpido! ¡No sería bueno si el nuevo!

Pregunta: ¿Por qué debería entender el proceso de un nuevo objeto?
Respuesta: Si no comprende este proceso, no sabe por qué es solo uno nuevo. Este ejemplo puede usar varios métodos del prototipo.

El proceso de un nuevo objeto: necesita pasar por 4 pasos, combinados con el modelo prototipo en el capítulo anterior como ejemplo.
var cat = new Animal ('gato naranja');

1. Cree un nuevo objeto vacío.
var cat = {}

2. Establezca el prototipo implícito del nuevo objeto para que apunte al prototipo explícito de su constructor
cat._proto_ = Animal.protype

3. Ejecute el código del constructor, esto apunta a este nuevo objeto.
Animal.call (gato)

4. Devuelva el objeto (devuelva esto)
var cat = new Animal ();
(Guarde el objeto devuelto en la variable cat, por lo que este gato es una instancia de este objeto, por lo que el gato también es un objeto)

Muy bien, tienes un objeto. Estás fuera de servicio
Si aún es difícil de entender, déjenme decirlo en términos simples: el
código original se ve así.

    //构造函数
    function Animal(name){
        this.name = name;
        //为什么在原型里的方法放到构造函数里呢，因为2.设置新的对象的隐式原型指向其构造函数的显式原型
        this.eat = function(val){
            console.log(this.name + ' like eat '+ val);
        }
    }

Este se convierte en el caso después de usar el nuevo operador.

    //构造函数
    function Animal(name){
        //1.创建一个空的对象（为了方便理解我们让这个对象就叫this）
        var this = {};
        
        //3.执行构造函数代码，往this里添加属性和方法。
        this.name = name;
        this.eat = function(val){
            console.log(this.name + ' like eat '+ val);
        }
        
        //4.返回该对象（返回this）
        return this;
    }

Entonces, cuando var cat = new Animal ('gato naranja');
es equivalente a var cat = this; // Se puede usar el atributo de método cat en esto.

Verificación: verifiquemos si hemos hecho las cosas anteriores.
Paso 2 de verificación:
envíe el registro a la consola:

Como puede ver en la imagen de arriba, cat._proto_ y Animal.protype son completamente iguales. Descripción 2 presas.

Verifique los pasos 3 y 4:

//构造函数
    function Animal(name){
        this.name = name;
        console.log('this:',this)
    }
    
    // 原型
    Animal.prototype = {
        eat:function(val){
            console.log(this.name + ' like eat '+ val);
        }
    }
    
    Animal();//window

Como se puede ver en lo anterior, cuando no hay creación de instancias (cuando no hay nuevas), esto se refiere a la ventana.
Luego, vea si esto apuntará a este nuevo objeto después de nuevo.

//构造函数
    function Animal(name){
        this.name = name;
        console.log('this:',this)
    }
    
    // 原型
    Animal.prototype = {
        eat:function(val){
            console.log(this.name + ' like eat '+ val);
        }
    }

    // 实例化
    var cat = new Animal('橘猫');

    console.log('cat就是：',cat)

El registro de salida de la consola es el siguiente:

Ambos son idénticos, por lo que podemos verificar que los pasos 3 y 4 sean verdaderos. El constructor se ejecuta y esto apunta a este nuevo objeto.

Pregunta: ¿Qué son los prototipos implícitos y los prototipos explícitos? ¿Por qué cat puede llamar a algo en el prototipo explícito?
La próxima vez: prototipo de cadena https: //segmentfault.com/a/11 ...