原型、原型链、constructor

/*
对应名称
prototype  原型
__proto__  原型链（原型的链接点，当作一个指针、结点）
从属关系
prototype -> 函数的一个属性：对象 {}
__proto__ -> 对象的Object的一个属性：对象 {}
对象的__proto__保存着该对象的构造函数的prototype
*/

function Test() {
    this.a = 1;
}
const test = new Test(); 

// 沿着原型链从底层向高层逐渐继承
Test.prototype.b = 2;
Object.prototype.c = 4;
/* 
test {
    a: 1,
    __proto__: Test.prototype = {
        b: 2, 
        __proto__: Object.prototype = {
            c: 4,
            __proto__: null
        }
    }
}
*/


// Function Object: 都既是函数又是对象
console.log(Test.__proto__ === Function.prototype);
// const Test = new Function();
console.log(Function);
console.log(Function.prototype.constructor === Function);
console.log(Function.__proto__ === Function.prototype);// 这是函数底层的规定

const obj = {};
// const obj = new Object(); // function
console.log(typeof Object); // function
console.log(Object.__proto__);
console.log(Object.__proto__ === Function.prototype);
console.log(Object.__proto__ === Function.__proto__);
// 由此我们可以得出一个结论,Function是最顶层,Function生万物,且Function自己构造了自己(相当于在顶层封端)


// 判断属性是否存在的方法
// object.hasOwnProperty("")可以判断属性是否是实例属性
console.log(test.hasOwnProperty("a")); //true
console.log(test.hasOwnProperty("b")); //false
console.log(test.hasOwnProperty("c")); //false

// in操作符可以判断属性是否在链上
console.log('a' in test);
console.log('b' in test);
console.log('c' in test);

// instance可以判断对象是不是构造函数的实例
console.log(test instanceof Test);


// constructor的两个用法,用于构造函数的prototype或实例
console.log(Test.prototype.constructor === Test);
console.log(test.constructor === Test);
// test.constructor => 实例化test对象的构造函数
// => 是指向的意思
// Test.prototype也是一个对象

// 类的实例化对象的constructor也等于该类
// class Person{}
// let p1 = new Person();
// console.log(p1.constructor === Person ); // ture