Registro de aprendizaje_0909

Prototipo, cadena de prototipos

https://juejin.im/post/6844903749345886216

1. Los tipos de referencia son todos objetos
Todos los tipos de referencia en JavaScript son objetos y los objetos son colecciones de propiedades.
Tipo de matriz, tipo de función, tipo de objeto, tipo de datos, tipo de expresión regular, etc. son todos tipos de referencia.
En otras palabras, las matrices son objetos, las funciones son objetos, los objetos regulares son objetos y los objetos son objetos.

let arr = []
let fn = function () {
    
    }
let obj = {
    
    }
arr instanceof Object //  true
fn instanceof Object  //  true
obj instanceof Object  //  true

Dos, prototipo y cadena de prototipos

let obj = {
    
    }
obj.sayHello = function () {
    
     alart("hello") }
obj.hasOwnProperty('sayHello')
obj  //  {sayHello:f}

Cada objeto está asociado con otro objeto desde el principio de la creación y hereda sus propiedades de otro objeto, este otro objeto es el prototipo.
Al acceder a las propiedades de un objeto, primero busque el objeto en sí. Si no puede encontrarlo, puede ir al prototipo del objeto. Si aún no lo puede encontrar, vaya al prototipo del objeto. (El prototipo también es un objeto, y tiene su propio prototipo. ), continúa así, sabiendo que se ha encontrado, o no se encuentra el objeto prototipo superior, finaliza la búsqueda y devuelve indefinido.
Esta cadena de objetos y sus prototipos se llama cadena de prototipos.
Esto explica por qué las matrices pueden usar push, slice y otros métodos, y las funciones pueden usar call, bind y otros métodos, porque los métodos correspondientes se encuentran en su cadena de prototipos.
para resumir:

• El significado de la existencia de prototipos es formar una cadena de prototipos: los tipos de referencia son todos los objetos, cada objeto tiene un prototipo, y el prototipo también es un objeto, y también tiene su propio prototipo, formando una cadena de prototipos capa por capa.
• El significado de la cadena del prototipo es herencia: para acceder a las propiedades del objeto, si no puede encontrarlo en el propio objeto, puede encontrarlo capa por capa en la cadena del prototipo. Un objeto puede acceder a las propiedades de otros objetos.
• El significado de herencia es compartir atributos: reutilización de código, extensibilidad, diferentes objetos pueden heredar los mismos atributos, o puede definir atributos que solo le pertenecen a usted

Tres, crea un objeto

Hay dos formas de crear, una es el nuevo operador seguido de una llamada de función y la otra es la notación literal. (La notación literal es simplemente azúcar sintáctica, la esencia es nueva, la función sigue siendo la misma y el uso es más conciso).

// new操作符后跟函数调用
let obj = new Object()
let arr = new Array()

// 字面量表示法
let obj = {
    
     a: 1 }
//  等同于
let obj = new Object()
obj.a = 1

let arr = [1,2]
// 等同于
let arr = new Array()
arr[0] = 1
arr[1] = 2

Object, Array, etc. se denominan constructores, que no son diferentes de las funciones ordinarias, pero a menudo se utilizan para crear objetos después de new. Llamar a una función vacía después de new también devolverá un objeto, y cualquier función se puede usar como constructor.
Una comprensión más razonable del constructor es la llamada de construcción de la función.
Number, String, Boolean, Array, Object, Function, Date, RegExp, Error son todas funciones y son constructores nativos, que aparecerán automáticamente en el entorno de ejecución en tiempo de ejecución.
El constructor es para crear un tipo específico de objeto. Estos objetos creados por el mismo constructor tienen el mismo prototipo y comparten ciertos métodos. Por ejemplo, todas las matrices pueden llamar al método push porque tienen el mismo prototipo.

function Person(name) {
    
    
  // 函数内this指向构造的对象
  // 构造一个name属性
  this.name = name
  // 构造一个sayName方法
  this.sayName = function() {
    
    
    console.log(this.name)
  }
}

// 使用自定义构造函数Person创建对象
let person = new Person('logan')
person.sayName() // 输出：logan

Resumen: Los constructores se utilizan para crear objetos, los objetos creados por el mismo constructor tienen el mismo prototipo.

Cuatro, _proto_ y prototipo

Cada objeto tiene un prototipo. Los
tipos de referencia de prototipo que apuntan al objeto a través de la propiedad _ proto _ del objeto son todos objetos, por lo que los tipos de referencia tienen propiedades _ proto _, los objetos tienen propiedades _ proto _, las funciones tienen propiedades _ proto _ y las matrices también tienen propiedades _ proto _. proto _ atributos, siempre que sean tipos de referencia, hay _ proto _ atributos, que apuntan a sus respectivos objetos prototipo.
_ proto _ está estandarizado en es6 y no se recomienda. Se recomienda utilizar Object.getPrototypeOf. Object.getPrototypeOf (obj) también puede obtener el prototipo de obj.

Object.getPrototypeOf(person) === person._proto_  //  true

El constructor debe crear un tipo específico de objeto. Si desea que los objetos creados por el constructor de la persona compartan un método, la
demostración del error:

// 调用构造函数Person创建一个新对象personA
let personA = new Person('张三')
// 在personA的原型上添加一个方法，以供之后Person创建的对象所共享
personA._proto_.eat = function() {
    
    
	console.log('吃东西')
}
let personB = new Person("李四")
personB.eat()  //  吃东西

Cada vez que modifica el objeto prototipo de un tipo de objeto, debe crear una nueva instancia de objeto, luego acceder a su objeto prototipo y agregar o modificar propiedades. Dado que el objeto prototipo de la instancia del objeto creado por la función constructora es el mismo, es bueno que haya una conexión entre la función constructora y el objeto prototipo de la instancia del objeto construida por ella. Esta conexión es prototipo y cada función tiene un atributo prototipo, apuntando a un nuevo El objeto prototipo del operador y la instancia de objeto creada por la función.

Person.prototype === personA._proto_  //  true

Demostración adecuada:

Person.prototype.drink = function() {
    
    
	console.log("喝东西")
}
let personA = new Person("张三")
personB.drink()  //  喝东西

para resumir:

• Los objetos tienen propiedades _ proto _, las funciones tienen propiedades _ proto _ y las matrices también tienen propiedades _ proto _ Siempre que sea un tipo de referencia, hay una propiedad _proto _ que apunta a su prototipo.
• Solo la función tiene el atributo prototype, que apunta al objeto prototipo de la instancia del objeto creado por el nuevo operador que llama a la función

Cinco, el nivel superior de la cadena de prototipos

//  1. person的原型对象
person._proto_ === Person.prototype
// 2. Person.prototype的原型对象
Person.prototype._proto_ === Object.prototype
//  3.Object.prototype
Object.prototype === null

* Cadena de prototipos: * La cadena conectada por la propiedad _proto_ del objeto hasta que Object.prototype._proto_ (null) es la cadena de prototipos.
Lea las propiedades del objeto de acuerdo con la simulación js anterior:

function getProperty(obj,propName) {
    
    
	//  在对象本身查找
	if(obj.hasOwnProperty(propName)) {
    
    
		return obj[propName]
	}else if(obj._proto_ !== null) {
    
    
		// 如果对象有原型，则在原型上递归查找
		return getProperty(obj._proto_,propName)
	}else {
    
    
		//  直到找到Object.prototype，Object.prototype.__proto__为null，返回undefined
		return undefined
	}
}

Seis, constructor

El constructor tiene un atributo de prototipo, que apunta al objeto prototipo de la instancia creada con este constructor.
Hay un atributo de constructor en este objeto prototipo, que apunta al constructor.

Person.prototype.constructor === Person  //  true

Siete, la cadena prototipo de objetos de función Los objetos
son creados por constructores, las funciones también son objetos y el constructor de objetos de función es Función.

let fn = function() {
    
    }
fn._proto_ === Function.prototype  //true
//  Function.prototype也是一个普通对象
Function.prototype._proto_ === Object.prototype  //  true
//  特例
Function._proto_ === Function.prototype

Resumen: Todas las funciones son creadas por el constructor nativo de la función, por lo que el atributo _proto_ de la función apunta al atributo prototipo de la función.

let f1 = new Foo('chen')
let o1 = new Object()
function Foo(name){
    
    
	this.name = name
}

Un conocido:

1. Los tipos de referencia son objetos y cada objeto tiene un objeto prototipo
2. Los objetos son creados por su constructor. La propiedad _ proto del objeto apunta a su objeto prototipo, y el atributo prototipo del constructor apunta al objeto prototipo de la instancia de objeto que crea, por lo que el atributo _ proto_ del objeto es igual al prototipo del constructor que lo creó. Atributos
3. El constructor de todos los objetos ordinarios creados por notación literal es Object
4. Todos los objetos prototipo son objetos ordinarios y el constructor es Object
5. El constructor de todas las funciones es Function
6. Object.prototype no tiene objeto prototipo

// f1是通过 new Foo() 创建的函数，其构造函数是 Foo()，所以
f1._proto === Foo.prototype
// Foo.prototype为普通对象，构造函数为Object，所以
Foo.prototype._proto_ === Object.prototype
//  Object.prototype没有原型对象
Object.prototype._proto_ === null

// o1的构造函数为Object
o1._proto_ === Object.prototype

// 原生构造函数也是函数对象，其构造函数为Function
Object._proto_ === Function.prototype
Function._proto_ === Function.prototype

operador de instancia

El operador typeof se puede usar para determinar el tipo de una variable, pero no es aplicable a los tipos de referencia, excepto para el objeto de función, que devuelve función, todos los demás devuelven objeto. Si desea saber el tipo específico de un objeto, debe usar instanceof.

El operador instanceof se usa para probar si la propiedad del prototipo del constructor aparece en cualquier lugar de la cadena del prototipo del objeto.

El lado izquierdo del operador instanceof es un objeto y el lado derecho es un constructor. Busque la cadena del prototipo del objeto a la izquierda. Si sabe que se encuentra la propiedad del prototipo del constructor derecho, devuelva verdadero o busque el nivel superior nulo, (Object.prototype._proto _), Devuelve falso.
Implementación de simulación:

function instanceOf(obj,Constructor) {
    
      //  obj代表左边对象，Constructor代表右边的构造函数
	let right = Constructor.prototype  //  去构造函数显示原型
	let left = obj._proto_  //  取对象隐式原型
	//  到达原型链顶层还未找到则返回false
	if(right === null) {
    
    
		return false	
	}
	//  对象实例的隐式原型等于构造函数的显式原型则返回true
	if(left === right) {
    
    
		return true
	}
	查找原型链shangyuc
	return(obj._proto_,Constructor)
}

fn instanceof Object //true
// 1. fn.__proto__ === Function.prototype
// 2. fn.__proto__.__proto__ === Function.prototype.__proto__ === Object.prototype
arr instanceof Object //true
// 1. arr.__proto__ === Array.prototype
// 2. arr.__proto__.__proto__ === Array.prototype.__proto__ === Object.prototype
Object instanceof Object // true
// 1. Object.__proto__ === Function.prototype
// 2. Object.__proto__.__proto__ === Function.prototype.__proto__ === Object.prototype
Function instanceof Function // true
Function instanceof Function // true
// Function.__proto__ === Function.prototype

Resumen: El operador instanceof se usa para verificar si la propiedad del prototipo del constructor de la derecha aparece en algún lugar de la cadena de prototipos de la izquierda. Representa una relación de herencia de cadena de prototipos.

object.create

El método Object.create () proporcionado por es5 crea un nuevo objeto. El primer parámetro acepta un objeto, que servirá como el objeto prototipo del objeto recién creado. El segundo parámetro opcional es el descriptor de propiedad (no se usa comúnmente, el valor predeterminado es indefinido )
Simulación:

function createObj（proto）{
    
    
	function F（）{
    
    }
	F.prototype = proto
	return new F()
}

Si desea generar un objeto que no herede ninguna propiedad, puede usar Object.create (null).
Si desea generar un objeto generado por el método literal habitual, debe apuntar su objeto prototipo a Object.prototype

let obj = Object.create（Object.prototype）
//  等价于
let obj = {
    
    }

nuevo operador

Al usar nuevo, qué sucede:

1. Cree un objeto nuevo y apunte su propiedad _proto_ a la propiedad prototype del constructor.
2. Apunte el this llamado por el constructor a este nuevo objeto y ejecute el constructor
3. Si el constructor devuelve el tipo de objeto Object (incluyendo Functolin, Array, Date, RegExg, Error, etc.), regresa normalmente; de ​​lo contrario, devuelve este nuevo objeto.

function newOperator(func,...args) {
    
    
	if(typeof func!== 'function') {
    
    
		console.log("第一个参数必须为函数，您传入的参数为",func)
		return
	}
	// 创建一个全新对象，并将其`__proto__`属性指向构造函数的`prototype`属性
	let newObj = Object.create(func.prototype)
	// 将构造函数调用的this指向这个新对象，并执行构造函数
	let result = func.apply(newObj,args)
	// 如果构造函数返回对象类型Object，则正常返回，否则返回这个新的对象
    return (result instanceof Object) ? result : newObj
}