JavaScript原型prototype

1、JavaScript构造函数

构造函数的写法

function Car(size,color){
    this.size = size;
    this.color = color;
    this.run = function(){
                   console.log("run");
               }
}

var Car = function(size,color){
    this.size = size;
    this.color = color;
    this.run = function(){
                   console.log("run");
               }
}

注：构造函数中定义的属性，在该函数建立的对象中是不存在的。

方法写在构造函数的内部或外部

//函数内的方法
function Car(size,color){
    this.size = size;
    this.color = color;
    this.run = function(){
                   console.log("run");
               }
}


//prototype上的方法
function Car(size,color){
    this.size = size;
    this.color = color;
}

Car.prototype.run = function(){
    console.log("run");
}

//另外一种写法
Car.prototype = {
    run: function(){
        console.log("run");
    }
}

prototype的使用

Car.prototype = {
    run: function(){
        console.log("run");
    }
}

//与上面直接使用对象字面量赋值不一样，下面的方式使用函数表达式赋值
//这种方式的好处是能够封装私有的function，能够达到public/private的效果
Car.prototype = function(){
    return {
        run: function(){console.log("run");}
    }
}
//问：若是不使用return返回一个对象，上面的方式会出错吗？

2、Function和Object对象

建立函数的两种方式

var func = function(){}

var func = new Function(){}

//function关键字等价于new Function

使用typeof输出一个对象的类型

alert(typeof(Function))); 
alert(typeof(new Function())); 
alert(typeof(Array)); 
alert(typeof(Object)); 
alert(typeof(new Array())); 
alert(typeof(new Date())); 
alert(typeof(new Object())); 

//前四条语句都会返回“function”，后三条返回“object”
//因而可知 new Function返回的仍是一个Function对象
//Object也是函数.由于Object的结构是function Object(){native code}.

3、prototype、__proto__、constructor

prototype是Function才有的属性，注意Function的实例也是Function

__proto__是Object对象中的属性，Firefox暴露出该属性

constructor是Object对象中的属性，指向构造函数。

4、定义函数、建立对象的过程

• 定义一个函数F，JavaScript解释器会为该函数添加一个prototype属性，并建立一个prototype对象，函数的prototype属性的值是指向该prototype对象的引用；
• prototype对象中添加一个constructor属性，指向该函数；
• 使用函数F建立对象，为该对象添加一个__proto__属性，指向F的prototype对象，该对象也具备constructor属性，constuctor属性能够用来判断对象的类型是否相同，可是constructor属性是可变的，因此并不必定正确，instanceof操做符更可靠。

• var Person = function () { };
  var p = new Person();
  
  //建立对象的过程以下
  
  var p={};
  p.__proto__=Person.prototype;
  Person.call(p);
  
  //使用call()函数是，this指针指向谁

   

5、原型链的顶端为null

console.log(Object.prototype);//Object
console.log(Object.prototype.protoype);//undefined
console.log(Object.prototype.__proto__);//null

console.log(Function.prototype);//ƒ () { [native code] }
console.log(Function.prototype.protoype);//undefined
console.log(Function.prototype.__proto__);
/*{
constructor:ƒ Object()
hasOwnProperty:ƒ hasOwnProperty()
isPrototypeOf:ƒ isPrototypeOf()
propertyIsEnumerable:ƒ propertyIsEnumerable()
toLocaleString:ƒ toLocaleString()
toString:ƒ toString()
valueOf:ƒ valueOf()
__defineGetter__:ƒ __defineGetter__()
__defineSetter__:ƒ __defineSetter__()
__lookupGetter__:ƒ __lookupGetter__()
__lookupSetter__:ƒ __lookupSetter__()
get __proto__:ƒ __proto__()
set __proto__:ƒ __proto__()
}
*/

首先要明确一点，原型链是指对象的原型链，因此原型链上的全部节点都是对象，不能是字符串、数字、布尔值等原始类型。

另外，规范要求原型链必须是有限长度的(从任一节点出发，通过有限步骤后必须到达一个终点。显然也不能有环。)

那么，应该用什么对象做为终点呢？很显然应该用一个特殊的对象。

好吧，Object.prototype确实是个特殊对象，咱们先假设用它作终点。那么考虑一下，当你取它的原型时应该怎么办？即

Object.prototype.__proto__;

应该返回什么？

取一个对象的属性时，可能发生三种状况：

1. 若是属性存在，那么返回属性的值。

2. 若是属性不存在，那么返回undefined。

3. 无论属性存在仍是不存在，有可能抛异常。

咱们已经假设Object.prototype是终点了，因此看起来不能是状况1。另外，抛出异常也不是好的设计，因此也不是状况3。那么状况2呢，它不存在原型属性，返回undefined怎么样？也很差，由于返回undefined一种解释是原型不存在，可是也至关于原型就是undefined。这样，在原型链上就会存在一个非对象的值。

因此，最佳选择就是null。一方面，你无法访问null的属性，因此起到了终止原型链的做用；另外一方面，null在某种意义上也是一种对象，即空对象，由于null一开始就是为表示一个“空”的对象存在的。这样一来，就不会违反“原型链上只能有对象”的约定。

因此，“原型链的终点是null”虽然不是必须不可的，可是倒是最合理的。

---------------------------------------------

 

function 和prototype自己都含__proto__,其实自己也都是对象，本身继承过来的，他们2个也是基本类型的实例。http://www.cnblogs.com/danghuijian/p/3755755.html

 

原生类型包括：number，string, bool, null, undefined；

非原生类型包括（对象类型）：object, array, function