Cadena de prototipos de prototipos de objetos JavaScript

---

对象的创建方法

1. var obj = {} plainObject objeto literal / objeto directo
2. Constructor
   1. El constructor integrado del sistema new Object()
   2. Función personalizada new FunctionName()

Las funciones personalizadas se nombran con una gran caja camel (todas las primeras letras están en mayúscula)

构造函数内部原理

1. Añada implícitamente this = () al principio del cuerpo de la función
2. Ejecute this.xxx = xxx;
3. Devolver implícitamente esto

También puede pasar parámetros

    function Car(number){
    
    
        // this = {};
        this.date = 2020;
        this.number = number;

        //return this;
    }

    new car1 = new Car(1);

包装类

• nuevo número()
• nueva cadena ()
• nuevo booleano ()

El tipo original no tiene atributos ni métodos
, y en realidad se convierte automáticamente en una clase contenedora cuando se llama

    //包装类
    var a = 1;

    a.abc = 2;
    // 不忍心报错  自动执行 
    // new Number(1).len = 2;  delete  执行完又删除了

    
    console.log(a.len); // undefined
    // 发现访问属性又自动创建 new Number(4).len  是空的 

La cadena tiene la propiedad .length y el
proceso es el mismo que el anterior

    var str = 'abcd';

    str.length = 2;
    // nwe String('abcd').length = 2;  delete
    
    console.log(str);  // 4
    // new String('abcd').length  本身这个属性是存在的

ps. Ejercicios de "Objeto, embalaje (Parte 2)" de Du Yi en la segunda mitad

原型

.prototype: el prototipo es un antepasado

    Person.prototype.name= 'hello';
    function Person{
    
    

    }
    var a = new Person();
    console.log(a.name);   // 输出 hello 继承自原型

El prototipo también es un objeto que se puede escribir así

    Person.prototype = {
    
    
        name : 'hello'
    }
    ...
    方别写很多

Pero hay una pequeña diferencia que se menciona más adelante.

定义

El prototipo es un atributo de la función objeto, que define el antepasado común
del objeto producido por el constructor. El objeto producido por el constructor puede heredar las propiedades y métodos del
prototipo. El prototipo también es un objeto.

功能

Reduzca la duplicación de código y
coloque partes comunes en el prototipo

修改原型

Agregar, eliminar, modificar y verificar
solo puede operar directamente operaciones de prototipo

No puede ser operado por elementos secundarios

    function Father(){
    
    
        this.num = 1;
    }
    var father = new Father();

    Son.prototype = father;
    function Son(){
    
    
        
    }
    var son = new Son();

    son.num = 2;  
    //son.num ++;   同

    console.log(father.num);  // 1

Equivale a agregar un nuevo atributo num al hijo. El atributo en el
padre no ha sido modificado ni modificado (error),
pero esto se puede hacer

    function Father(){
    
    
        this.num = 1;
        this.say = {
    
    
            name : 'niko'
        }
    }
    var father = new Father();

    Son.prototype = father;
    function Son(){
    
    
        
    }
    var son = new Son();

    son.say.name = 'dio';   // 二次调用 .name


    console.log(son.say.name);  // dio

La modificación exitosa solo puede modificar los atributos en el método, lo que equivale a una segunda llamada

constructor

El prototipo del sistema tiene un atributo de constructor y
devuelve un constructor,
pero se puede cambiar manualmente.

_proto_

_proto_Señale el prototipo,
conecte el prototipo y el subobjeto,
busque el atributo en _proto_ después de encontrar el atributo

_proto_El prototipo almacenado por defecto
pero se puede modificar

La diferencia entre la escritura de dos

Marca la diferencia en la segunda modificación

    Person.prototype.name = 'hello';

    function Person(){
    
    
        // 系统自动执行 var this = {_proto_ : Person.prototype}
    }

    var person = new Person();

//两种修改方式
// 1.   Person.prototype.name = 'wow';
// 2.   Person.prototype = {
    
    
//       name : 'wow'
//    }

1. La modificación exitosa equivale a cambiar directamente los datos en el espacio

2. Person.prototype.name sigue siendo
   la ola de saludo. Esta ola es para crear un nuevo espacio. Tenga en cuenta que el comentario en el constructor se refiere a la dirección de _proto_ para una
   fácil comprensión:

    var obj = {
    
    name : 'a'};
    var obj1 = obj ;
    obj = {
    
    name : 'b'};   //  obj1 指向的还是a

    Person.prototype = {
    
    name : 'a'};
    _proto_ = Person.prototype;
    Person.prototype = {
    
    name : 'b'};

Espacio cambiado

1 Cambiar la propiedad de la habitación
2 Cambiar la habitación directamente

¡Tenga en cuenta el orden ahora! !

    Person.prototype.name = 'hello';

    function Person(){
    
    
        // 系统自动执行 var this = {_proto_ : Person.prototype}
    }

    Person.prototype = {
    
    
       name : 'wow'
    }

    var person = new Person();

Ahora modifique con éxito nuevo en la parte posterior

Cadena de prototipos

No necesito decir más sobre la composición de la cadena de prototipos.

Agregar, eliminar, modificar

Igual que el prototipo anterior

este pequeño conocimiento

    Son.prototype = {
    
    
        name : 'niko',
        sayName : function (){
    
    
            console.log(this.name);
        }  
    }

    function Son () {
    
    
        this.name = 'dio';
    }

    var son = new Son();   // dio

esto apunta a la persona que llamó al método aquí es la llamada hijo

Object.create (prototipo)

Construcción más conveniente

    var obj = {
    
    name : 'sunny' , age : 123};
    var obj1 = Object.create(obj);  // obj1 原型就是obj  可以使用name和age

    等同于
    
    Obj.prototype.name = 'sunny';
    function Obj() {
    
    

    }
    var obj1 = new Obj();
    //var obj1 = Object.creat(Obj.prototype);  和上面相等  构造函数是空的就一样

El más terminal de la mayoría de los objetos es Object.prototype

El prototipo de terminal de cadena Object.prototype
tiene métodos como toString (la clase contenedora también tiene su propio toString)

Tenga en cuenta que en la mayoría de los casos, hay casos especiales. El
prototipo puede ser nulo cuando se construye con Object.creat ()

    var obj = Object.creat(null);

No hay ninguna propiedad en el método Object.prototype
establecido en nulo después de agregar personas _proto_que no pueden usar
(duda a la hora de dormir) _proto_y .prototype

toString reescribir

123.toStringEl punto de error se reconoce como un número de coma flotante y se asigna a la variable
. El toString de 123 se llama con la ayuda de una cantidad intermedia . Es el método propio de Number en lugar de Object.

    var num = 123;
    num.toString();   --> // new Number(num).toString();
    
    Number.prototype.toString = function(){
    
    }   --> 有自己的toString
    Number.prototype._proto_=Object.prototype

Esta situación se llama 方法重写: El método del mismo nombre implementa diferentes funciones z
está cubierto en el extremo frontal de la cadena del prototipo

ToSting (); se llama al método cuando document.write (xx); se llama

Precisión fuera de tema

El rango que js puede calcular normalmente es de 16 dígitos antes del punto decimal y 16 dígitos después del punto decimal.

llamar / aplicar

Función Cambio de este punto El
propósito es cambiar este en la función de ejecución al objeto pasado, la
diferencia es que la lista de parámetros es diferente.

    var name = "1";
    var obj = {
    
    
        name:2,
        prop: {
    
    
            name:3,
            getName: function() {
    
    
                return this.name;
            }
        }
    }
    console.log(obj.prop.getName()); //3
    console.log(obj.prop.getName.call(obj)); //2
    console.log(obj.prop.getName.call(this)); //1  在全局的this 是window

Si desea obtener 3 directamente obj.prop.getName (), el objeto actual de este método es prop

Si queremos obtener 2, podemos obj.prop.getName.call (obj) es pasar el objeto obj al método, esta vez este objeto es obj, this.name es equivalente a obj.name

1 es lo mismo que obj.prop.getName.call (this) donde esta es la página actual y la ventana es la misma

Por supuesto, también puede usar apply. La diferencia entre aplicar y llamar es llamar, es decir, el método de llamada acepta una lista de varios parámetros, mientras que el método de aplicación acepta una matriz que contiene varios parámetros. apply (thisargs, []) usa una matriz para pasar parámetros al método, llamar (this, param1, param2); un pequeño ejemplo a continuación

    function callTest(name, price) {
    
    
        console.info(name + "-" + price);
    }
    callTest.call(this, 'superbing', 100);
 
    callTest.apply(this, ['superbing', 200]);

Ejemplo practico

借用别人的函数实现自己的功能

    function Person(name,age,sex){
    
    
        this.name = name;
        this.age = age;
        this.sex = sex;   // Person的this
    }

    function Student(name,age,sex,tel,grade){
    
    
        // var this ={}   等待赋值
        Person.call(this,name,age,sex);
        this.tel = tel;
        this.grade = grade;
    }

    var student = new Student('sunny',123,'male',139,2017);

Pase el objeto Student a Person para que este en Person realmente se refiera a la variable en Student, lo que
equivale a tomar las tres oraciones de Person a Student, se
abrevia cuando la estructura de los demás está completamente en línea con usted.

prototipo y proto

Esto es bueno