Prototipo, cadena de prototipos, evaluación del tipo de datos.

Un prototipo se define como un objeto que proporciona propiedades compartidas a otros objetos . Las instancias de funciones pueden compartir propiedades y métodos en el prototipo.

cadena prototipo

`引用类型：``proto(隐式原型)`Propiedades, los valores de propiedad son propiedades de objeto , los valores de propiedad son objetos
`函数：prototype(原型)`

const o = {
  a: 1,
  b: 2,
  // __proto__ 设置了 [[Prototype]]。它在这里被指定为另一个对象字面量。
  __proto__: {
    b: 3,
    c: 4,
    __proto__: {
      d: 5,
    },
  },
};

// { a: 1, b: 2 } ---> { b: 3, c: 4 } ---> { d: 5 } ---> Object.prototype ---> null

console.log(o.d); // 5

Función: También es una función en sí misma.

console.log(Function.prototype === Function.__proto__); // true

La función en sí es una función. Todas las funciones son instancias de Función. Entonces la función es una instancia de la función.

Métodos relacionados

persona.prototipo.isPrototypeOf(stu)

Object.getPrototypeOf( objeto ) reemplaza el objeto obsoleto._ _ proto _ _

Object.create(instancia) crea un nuevo objeto utilizando un objeto existente como prototipo

Object.hasOwn (obj, propiedad): determina si es propiedad suya

solicitud

nuevo

var a=1;
function fn1(){
  var a=2;
  console.log(this.a+a);
}
//f1并没有被作为对象的方法调用, this 指向全局对象,在浏览器中是 window
f1();//3 

function fn2(){
  var a=10;
  fn1();
}
//在 fn2 函数内部调用 fn1 函数，但是 fn1 函数内部的 this 仍然指向全局对象 window，因为 fn1 并没有被作为方法调用。
fn2();//3 

var fn3=function(){
  this.a=3;
}
fn3.prototype={
  a:4
}
var fn33=new fn3();
fn1.call(fn33)
//5

Decorador de funciones: agrega lógica adicional antes o después de ejecutar una función

Function.prototype.before=function(beforefn){
  return ()=>{
    beforefn.apply(this,arguments)
    return this.apply(this,arguments)
  }
}
Function.prototype.after=function(afterfn){
  return ()=>{
    var res=this.apply(this,arguments)
    afterfn.apply(this,arguments)
    return res;
  }
}

var func=function(){
  console.log(1)
}.before(function(){
  console.log(2)
}).after(function(){
  console.log(3)
})
func()//213

Determinar el tipo de datos

operador

typeof: determina el tipo de datos básicos

typeof null=Las etiquetas de tipo de objeto son todas 000

`实例` instancia de `构造函数`: determina la cadena del prototipo y`isPrototypeOf`

Object.prototype.isPrototypeOf({})// true
{} instanceof Object// true
Object instanceof Object//true
Function instanceof Function//true

método

`构造函数.`prototipo.: `isPrototypeOf(实例)` Determinar la cadena del prototipo.

( datos ).constructor === Tipo de datos : no contiene tipos heredados

Pantalla: toString, valueOf excepto nulo, indefinido

valueOf: convierte `this` valor en objeto . Excepto Date , se devuelven los datos en sí.

consola.log

Insertar descripción de la imagen aquí

toString: anula la conversión de tipo del objeto . consola.log