JS原型 原型链

跑在最前面的这段话：

1.JS对象分类：

简单记忆：凡是通过new Function()创建的对象都是函数对象，其他均是普通对象。

2.只有函数对象才有prototype属性，这个属性是一个指针，指向一个对象(通过该构造函数创建实例对象的原型对象)，该属性的指向我们就可以叫做“原型”或者“原型对象”，即：

function Person() {};
Person.prototype;
//constructor:ƒ Person()
//__proto__:Object

 var A = Person.prototype;//将A记做原型对象

3.默认情况下，所有的原型或者原型对象都会自动获得一个constructor(构造函数)属性，该属性(是一个指针)指向该函数的构造函数，即：

Person.prototype.constructor == Person

3.js对象均有一个_proto_属性；但_proto_并非是一个规范属性，只是部分浏览器实现了此属性，对应的标准属性是[[Prototype]];

• 每个对象规定一个私有属性[[prototype]]，[[prototype]]所指向的对象也有一个[[prototype]]属性；
• 但是[[prototype]]语言使用者是无法访问的，不过FirFox的js引擎将其暴露出来，作为公有属性__proto__

4.函数对象和原型对象通过prototype和constructor属性进行相互关联；

5.constructor属性

constructor属性始终指向创建当前对象的构造函数。

    var arr=[1,2,3];
    console.log(arr.constructor); //function Array(){};
    var a={};
    console.log(arr.constructor);//function Object(){};
    var bool=false;
    console.log(bool.constructor);//function Boolean(){};
    var name="hello";
    console.log(name.constructor);//function String(){};
    var sayName=function(){}
    console.log(sayName.constrctor)//function Function(){}
    
    //通过构造函数创建instance
    function A(){}
    var a=new A();
    console.log(a.constructor);//function A();

   function Person(name){
        this.name=name;
    }
    Person.prototype.sayName=function(){
        console.log(this.name);
    }
    
    var person=new Person("lili");
    
    console.log(person.constructor); // function Person(){}
    console.log(Person.prototype.constructor);// function Person(){}
    console.log(Person.constructor); // function Function(){}

---

 1.构造函数：

function Foo(name,age){
  this.name = name;
  this.age = age;
  this.class = 'class-1';
  //return this; //默认有这一行，因此不必自己写
}
var f = new Foo('lili',22);

  

2.构造函数的扩展

先抛出一个名词：语法糖。

在计算机科学中，语法糖(syntactic sugar)是指编程语言中可以更容易的表达一个操作的语法，它可以使程序员更加容易去使用这门语言：操作可以变得更加清晰、方便，或者更加符合程序员的编程习惯。

简单理解就是代码的一种简洁写法，比如：

var a = {} 是 var a = new Object()的语法糖;
var a = [] 是 var a = new Array()的语法糖
function Foo(){...}   是var Foo = new Function(){..} 的语法糖

 

3.再抛出五条原型规则：

*所有的引用类型（数组、对象、函数）都具有对象特性，即可自由扩展属性，除了“null”以外；

var arr=[];arr.a=100;
var obj = {};obj.a=200;
function fn(){};fn.a=300;

console.log(arr);//[a: 100]
console.log(obj);//{a: 200}
console.log(fn.a);//200

*所有的引用类型（数组、对象、函数）都有一个__proto__属性（也称隐式原型属性），属性值是一个普通的对象；

var arr=[];arr.a=100;
var obj = {};obj.a=200;
function fn(){};fn.a=300;

console.log(arr.__proto__);//[constructor: ƒ, concat: ƒ, pop: ƒ, push: ƒ, shift: ƒ, …]

console.log(obj.__proto__);//{constructor: ƒ, __defineGetter__: ƒ, __defineSetter__: ƒ, hasOwnProperty: ƒ, __lookupGetter__: ƒ, …}

console.log(fn.__proto__);//ƒ () { [native code] }

*所有的函数都有一个prototype属性（也称显式原型属性），属性值也是一个普通的对象;

var arr=[];arr.a=100;
var obj = {};obj.a=200;
function fn(){};fn.a=300;

console.log(arr.__proto__);//[constructor: ƒ, concat: ƒ, pop: ƒ, push: ƒ, shift: ƒ, …]

console.log(obj.__proto__);//{constructor: ƒ, __defineGetter__: ƒ, __defineSetter__: ƒ, hasOwnProperty: ƒ, __lookupGetter__: ƒ, …}

console.log(fn.__proto__);//ƒ () { [native code] }

console.log(arr.prototype);//undefined 没有prototype属性

console.log(fn.prototype);//{constructor: ƒ}

*所有的引用类型（数组、对象、函数）的__proto__属性（即隐式原型属性）指向它的构造函数的" prototype " 属性值（即显显式原型）（===）。

*当试图得到一个对象的某个属性时，如果这个对象本身没有这个属性，那么会在它的隐式原型属性__proto__（即它的构造函数的prototype）中一直往上找寻找该属性，但不会查找自身的prototype，（原型链的形成是真正靠_proto_而非prototype属性）；这也就是原型链的形成过程（下图中的红色线条表示的过程）

//构造函数
function Foo(name,age){
   this.name=name;
}
Foo.prototype.alertName = function(){
  alert(this.name);
}
//创建实例
var f = new Foo('lili');
f.printName = function(){
  console.log(this.name);
}
//test
f.printName();//lili
f.alertName();//lili

实例f中本身有个printName属性，打印出来的console.log(this.name)自然就是创建时传进去的"lili";而alertName属性在构造函数Foo中并没有，于是顺着实列的隐式原型属性__proto__（即其构造函数的prototype属性）找，便找到了alert(this.name)这句。