SOURCE

//继承 - js中是依靠原型链进行实现的
// 理解：原型模式
/**
 * 每个函数都有一个prototype属性，这个属性是一个指针，指向一个对象，
 * 而这个对象的用途是包含可以由特定类型的所有实例共享的属性和方法。
 * prototype就是通过构造函数而创建的那个对象实例的原型对象。
 * 所有对象实例共享原型对象上的属性和方法。
 * **/

function Person() {
    this.name = 'hi'
    // delete this.name //删除这个属性就可以恢复访问到原型中的name
    console.log('---', this)
}

Person.prototype.name = 'Nico';
Person.prototype.age = '21';
Person.prototype.sayName = function () {
    console.log(this.name)
}

var person1 = new Person()
//没有打印Nico,这种情况被称为"属性遮蔽 (property shadowing)"
//先搜索实例上是否有sayName,没有搜索原型。
person1.sayName() //hi  

//关于原型和实例的几个方法
console.log(Object.getPrototypeOf(person1)) //返回原型对象
//hasOwnProperty 检测xx属性是否在实例中，还是存在于原型中
console.log('hasOwnProperty-name--', person1.hasOwnProperty('name'))
console.log('hasOwnProperty--age-', Person.hasOwnProperty('age'))
//获取原型属性的描述符,必须在原型对象上调用Objet.getOwnPropertyDescriptor方法
console.log('getOwnPropertyDescriptor --', Object.getOwnPropertyDescriptor(Person.prototype, 'age'))
//in 操作符 - 通过对象能够访问给定属性的时候，返回true，无论该属性是实例中的还是原型中的。
//结合函数hasOwnProperty和in操作符，可以判断原型上是否有此属性。
function hasPrototypeProperty(object, name) {
    return !object.hasOwnProperty(name) && (name in object)
}
console.log('hasPrototypeProperty----',hasPrototypeProperty(person1,'age'))
//原型字面量
function Test(){}
Test.prototype={
    age:21,
    name:'nico',
    //constructor:Test,//如果这个值很重要，手动指回去，但此时的constructor就变为可枚举的，默认是不可枚举的。
    sayName:function(){
        console.log('Test',this.name)
    }
}
//对象字面量形式创建原型对象，本质上完全重写了默认的原型对象，因此constructor不再指向Test而是Object对象。
console.log('Test prototype ---',Test.prototype.constructor)
let test1 = new Test()

//此时constructor 无法确定对象的类型了。
//instanceof 仍旧确定对象的类型
console.log('instanceof----',test1 instanceof Test)
//原型的动态性-实例与原型之间是松散的连接关系

//寄生构造函数
function SpecialArray(){
  var values = new Array();
  values.push.apply(values,arguments);
  values.toPipedString = function(){
    return this.join("|");
  }
  return values ;
}

var colors = new SpecialArray('red','blue')
console.log(colors.toPipedString(),colors.constructor)