原型链

我心飞翔 分类:javascript

普通对象和函数对象

通过new Function()生成函数并为其指定函数名,通过函数名来进行调用,其实就是我们通常所说的函数。函数对象一般有两种 构造函数和普通函数。

  	function F1() { };
        const f2 = function () { };
	const f1=new  F1();

        console.log(typeof F1); //构造函数 
        console.log(typeof f2); //普通函数 

        

        // 以下为内置构造器 function 构造器名称(){}
        // 可以通过new的方式生产实例对象
        console.log(typeof Object);
        console.log(typeof Function);
        console.log(typeof Number);
        console.log(typeof String);
        console.log(typeof Boolean);
        console.log(typeof Date);
        console.log(typeof BigInt);
        console.log(typeof Date);
        console.log(typeof RegExp);
        console.log(typeof Promise);
 

对象:属性的集合。所有的对象都是通过函数来创建的。

	function F1() { };
	const o1 = {};
        const o2 = new Object();
        const o3 = new F1();

	
	console.log(typeof o1); //字面量对象 其实是new Object()语法糖 
        console.log(typeof o2); //实例对象 
        console.log(typeof o3); //实例对象
	

       //比较特殊的内置对象Math JSON
       console.log(typeof Math);//object
       console.log(JSON);//object


 

原型对象

每个对象都有 proto 属性,但只有函数对象才有 prototype 属性

原型对象是包含特定类型的所有实例共享的属性和方法,Function.prototype比较特殊,他是所有函数对象的原型对象,他是函数对象

       function Person(name, age) {
            this.name = name
            this.age = age
        }
        
        const person1 = new Person('赵子龙', 18)
        console.log(person1.prototype);//undefined
        console.log(Object.getPrototypeOf(Person));//function (){}
        console.log(Function.prototype.prototype);//undefined
        console.log(Object.getPrototypeOf(函数对象) === Function.prototype);//true

 

原型三角关系

原型链

所有对象的 proto 都指向其构造器的 prototype

 	function Person(name, age) {
            this.name = name
            this.age = age
            this.say = function () {
                console.log('hello word');
            }
        }
        const person1 = new Person('赵子龙', 18)
        console.log(Object.getPrototypeOf(person1));//person1的原型对象
        console.log(Person.prototype);//构造函数的原型对象
        console.log(Person.prototype === Object.getPrototypeOf(person1))//二者恒等
        //构造函数的原型对象有一个指针指向构造函数本身
        console.log(Person.prototype.constructor === Person);
 

所有函数对象proto都指向Function.prototype,它是一个空函数

Number.__proto__ === Function.prototype  // true

Boolean.__proto__ === Function.prototype // true

String.__proto__ === Function.prototype  // true

Object.__proto__ === Function.prototype  // true

Function.__proto__ === Function.prototype // true

Array.__proto__ === Function.prototype   // true

RegExp.__proto__ === Function.prototype  // true

Error.__proto__ === Function.prototype   // true

Date.__proto__ === Function.prototype    // true


 

Function.prototype也是一个对象,他也能访问到对象的属性和方法

    console.log(Object.prototype === Object.getPrototypeOf(Function.prototype));//true
 

闭环

函数对象和普通对象都可以访问到构造器Object的原型对象里的方法,普通对象和函数对象最后在Object构造器的原型对象的原型对象形成闭环,Object构造器的原型对象的原型对象为null,到此原型链结束

原型链

访问一个对象的某个属性时,首先在对象本身的属性上查找,如果没找到,就会去当前对象的原型对象中查找,如果原型对象中依然没有找到,会继续在原型对象的原型中查找(原型也是对象,也有它自己的原型)依次类推,直到找到属性/方法 或null为止。这样一层层向上查找的链式结构就形成了所谓的“原型链”。

需要注意是靠_Proto_形成原型链而不是prototype

	const Fn = function () { };
        Object.prototype.a = function () { console.log('这是函数A') };
        Function.prototype.b = function () { console.log('这是函数B') }
        const f = new Fn(); 
        //f.a() f.b()//? F.a()//? F.b()//?思考一下
 

君埋泉下泥销骨,我寄人间雪满头。

回复

我来回复
  • 暂无回复内容