arguments和prototype以及constructor

arguments 

argument 可以把传入函数的参数变成一个伪数组 

    <script>
        function sum(){
            console.log(arguments);
        }
        sum(10,2,3);
    </script>

prototype 原型

创建一个构造函数,在创建的时候就可以给构造函数添加一些原型函数和原型变量,但是么每一次实例化对象的时候,都会开辟单独空间,也就是说每个实例化对象的函数都是不相等的,这个时候比较浪费内存,我们可以在创建构造函数后,使用prototype来对构造函数创建共用的存储空间,prototype就相当于是一个公共的存储空间,所有实例化对象所引用的都是一个地方的内容,不需要再重新开辟空间去存储函数或者变量,更优化

        // 给Object原型中添加一个函数
        Object.prototype.newStr = function(str){
            console.log(str);
        };
        // 给Object原型中添加一个函数
        Object.prototype.texts = "自定义的新变量<br>";

        var obj1 = new Object();

        var obj2 = new Object();

        console.log(obj1.texts === obj2.texts); //true

prototype 可以对对象原型进行修改,修改后从此原型创建的对象 都会带有自定义的参数和函数,例如 :

    <script>

        // 给Object原型中添加一个函数
        Object.prototype.newStr = function(str){
            console.log(str);
        };
        // 给Object原型中添加一个函数
        Object.prototype.texts = "自定义的新变量<br>";

        var obj1 = new Object();
        obj1.newStr("要新创建的函数");

        var obj2 = new Object();
        obj2.newStr("第二次创建的新函数");

        document.write(obj1.texts);
        document.write(obj2.texts);

    </script>

    <script>

        var obj = new Object();
        Object.prototype.ext = "你好";

        /**
         *  obj.__proto__  等于 Object.prototype
         * */
        console.log(obj.__proto__);     //从实例化对象的角度,找到其构造函数的原型内容
        console.log(Object.prototype);  //从构造函数的角度,找到其自己的原型内容
        console.log(obj.constructor);   //找到实例化对象的构造函数的名字


    </script>

constructor

constructor 可以找到对象的原型,

 

彻底理解JavaScript原型链（一）—__proto__的默认指向

JavaScript的原型链系统着实让人头痛，在查阅了各种资料之后，终于总结出了基于几条通用规则和少数例外情况的js原型链逻辑，下面就让我们来一起看看是怎样的一个原理。

虽然JavaScript里一切皆对象，但为了理解原型链系统，我们需要将JavaScript的对象分为对象和函数两大类。在此基础上，JavaScript的原型链逻辑遵从以下通用规则：

通用规则

1. 对象有__proto__属性，函数有prototype属性；

2. 对象由函数生成;

3. 生成对象时，对象的__proto__属性指向函数的prototype属性。

在没有手动修改__proto__属性的指向时，以上三条便是JavaScript默认原型链指向逻辑。

下面我们来从最一般的情况开始，逐步深入的详细解释一下：

1. 一般情况

创建空对象时，实际上我们是用Object函数来生成对象的：
>var o = {}
>o.__proto__ === Object.prototype
true

我们也可以显式的使用Object函数来创建对象：
>var o = Object()
o.__proto__ === Object.prototype
true

当我们使用函数来创建自定义的对象时，上面的规则同样适用：
>function MyObj(){}
>typeof MyObj
"function"
>var mo = new MyObj()
>mo.__proto__ === MyObj.prototype
true

2. 函数对象

既然JavaScript里“一切皆对象”，那函数自然也是对象的一种。对于函数作为对象来说，上面的规则同样适用：

函数对象都是由Function函数生成的：
>function fn(){}
>fn.__proto__ === Function.prototype
true

我们可以看到，把函数当做对象时，生成它的函数就是 Function函数。那Function函数本身呢？同样适用！

Function函数本身作为对象时，生成它的函数是他自身！
>Function.__proto__ === Function.prototype
true

同样我们知道，Object函数也是一个函数对象，那么它是否符合上面的规则呢？当然！

Object函数既然是函数，那生成它的函数自然是Function函数咯：
>Object.__proto__ === Function.prototype
true

3. prototype是谁？

好了，现在我们知道，对象的__proto__属性是从生成它的函数的prototype那里得来的，那我们不禁要问，函数的prototype又是谁？

一般函数默认的prototype是系统自动生成的一个对象：
>function fn(){}
>typeof fn.prototype
"object"
>fn.prototype
{constructor: ƒ}
    constructor: ƒ fn()
    __proto__: Object

>fn.prototype.constructor === fn
true
>fn.prototype.__proto__ === Object.prototype
true

一般函数默认的prototype是一个类型为"object"的对象，它有两个属性：constructor和 __proto__。其中constructor属性指向这个函数自身，__proto__属性指向Object.prototype，这说明一般函数的prototype属性是由Object函数生成的。

4. 特殊情况

前面我们特别强调了是一般函数，那不一般的函数是谁呢？当然是Object函数和Function函数！
先来看Object.prototype:

>typeof Object.prototype
"object"
>Object.prototype
{constructor: ƒ, __defineGetter__: ƒ, __defineSetter__: ƒ, hasOwnProperty: ƒ, __lookupGetter__: ƒ, …}
    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属性不一样的是，它多了一大堆方法，这些方法都是JavaScript对象的系统默认方法。
再仔细看，好像少了什么，对了，Object函数的prototype属性里没有__proto__属性，我们试着把它的__proto__属性打出来看看：

>Object.prototype.__proto__
null

这就是Object函数特殊情况了：Object.prototype.__proto__ === null，我们知道，这就是JavaScript原型链的终点了。
为什么要这样设定呢？
typeof Object.prototype === "object"，说明它是一个Object对象，如果它由Object函数生成，于是按照我们上面的通用规则，就该是Object.prototype.__proto__ === Object.prototype。
啊哈，问题出现了，Object.prototype.__proto__属性指向了它自身，这样以__proto__属性构成的原型链就再也没有终点了！所以为了让原型链有终点，在原型链的最顶端，JavaScript规定了Object.prototype.__proto__ === null。

好，现在再来看Function函数吧：

>typeof Function.prototype
"function"

一上来就不走寻常路，Function函数的prototype属性是一个"function"类型的对象，而不像其他函数是类型为"object"的对象。那是个什么样的函数呢？

>Function.prototype
ƒ () { [native code] }

函数内部是[native code]，也就是系统编译好的二进制代码函数，这就暂时没法深究了。现在让我们来看看我们最关心的__proto__属性：

>Function.prototype.__proto__
{constructor: ƒ, __defineGetter__: ƒ, __defineSetter__: ƒ, hasOwnProperty: ƒ, __lookupGetter__: ƒ, …}
    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，让我们来试试：

>Function.prototype.__proto__ === Object.prototype
true

果然就是它！
按照我们最开始提出的通用规则，一个"function"类型的对象，应该是由Function函数生成的，那它的prototype属性应该指向Function.prototype，也就是Function.prototype.__proto__ === Function.prototype。和Object函数同样的问题出现了：循环引用。所以JavaScript规定Function.prototype.__proto__ === Object.prototype，这样既避免了出现循环引用，又让__proto__构成的原型链指向了唯一的终点：Object.prototype.__proto__ === null。

5. 总结

至此，我们从最一般的对象一直追溯到了Object函数和Function函数，并找在原型链的顶端发现了两个例外情况，也知道了这两个例外个规定是为了让__proto__构成的原型链存在一个唯一的终点。

现在我们再来看这张JavaScript原型链的图，是不是一目了然了呢？

JavaScript的原型链系统

作者：two2to
链接：https://www.jianshu.com/p/686b61c4a43d
來源：简书
简书著作权归作者所有，任何形式的转载都请联系作者获得授权并注明出处。

 

创建对象的几种方式

*对象，是javascript中非常重要的一个梗，是否能透彻的理解它直接关系到你对整个javascript体系的基础理解，说白了，javascript就是一群对象在搅。。（哔！）。 
常用的几种对象创建模式*

使用new关键字创建

最基础的对象创建方式，无非就是和其他多数语言一样说的一样：没对象，你new一个呀！ 
var gf = new Object(); 
gf.name = "tangwei"; 
gf.bar = "c++"; 
gf.sayWhat = function() { 
console.log(this.name + "said:love you forever"); 
}

使用字面量创建

这样似乎妥妥的了，但是宅寂的geek们岂能喜欢如此复杂和low土的定义变量的方式，作为一门脚本语言那应该有和其他兄弟们一样的范儿，于是出现了对象字面量的定义方式： 
var gf = { 
name : "tangwei", 
bar : "c++", 
sayWhat : function() { 
console.log(this.name + "said:love you forever"); 
} 
}

工厂模式

实际上这是我们在实际中最常用的对象定义方式，但是我要有好多拥有相似属性的对象（想想都让人激动。。。）怎么办呢？那要是一个个的定义，就会产生大量的代码，何不建个工厂，批量的生产出我们的对象呢，于是，javascript世界中第一个充气娃。。。不，“工厂模式”诞生了！ 
function createGf(name, bar) { 
var o = new Object(); 
o.name = name; 
o.bar = bar; 
o.sayWhat = function() { 
alert(this.name + "said:love you forever"); 
} 
return o; 
} 
var gf1 = createGf("bingbing","d"); 
var gf2 = createGf("mimi","a");

构造函数

工厂模式解决了多个相似对象的创建问题，但是问题又来了，这些对象都是Object整出来的，怎么区分它们的对象具体类型呢？这时候我们就需要切换到另一种模式了，构造函数模式： 
function Gf(name,bar){ 
this.name = name; 
this.bar = bar; 
this.sayWhat = function(){ 
alert(this.name + "said:love you forever"); 
} 
} 
var gf1 = new Gf("vivian","f"); 
var gf2 = new Gf("vivian2","f"); 
这里我们使用一个大写字母开头的构造函数替代了上例中的createGf，注意按照约定构造函数的首字母要大写。在这里我们创建一个新对象，然后将构造函数的作用域赋给新对象，调用构造函数中的方法。 
上面的方式似乎没什么不妥，但是我们可以发现，两个实例中调用的构造函数中的sayWhat方法不是同一个Function实例： 
console.log(gf1.sayWhat == gf2.sayWhat); //false 
调用同一个方法，却声明了不同的实例，实在浪费资源。我们可以优化一下将sayWhat函数放到构造函数外面声明： 
function Gf(name,bar){ 
this.name = name; 
this.bar = bar; 
this.sayWhat = sayWhat 
} 
function sayWhat(){ 
alert(this.name + "said:love you forever"); 
} 
这样解决了，多个实例多次定义同一个方法实例的问题，但是新问题又来了，我们定义的sayWhat是一个全局作用域的方法，但这个方法其实是没法直接调用的，这就有点矛盾了。如何更优雅的定义一个具备一定封装性的对象呢？我们来看一下javascript原型对象模式。

原型对象模式

理解原型对象 
当我们创建一个函数时，该函数就会具备一个prototype属性，这个属性指向通过构造函数创建的那个函数的原型对象。通俗点讲原型对象就是内存中为其他对象提供共享属性和方法的对象。 
 
在原型模式中，不必再构造函数中定义实例属性，可以将属性信息直接赋予原型对象： 
function Gf(){ 
Gf.prototype.name = "vivian"; 
Gf.prototype.bar = "c++"; 
Gf.prototype.sayWhat = function(){ 
alert(this.name + "said:love you forever"); 
} 
} 
var gf1 = new Gf(); 
gf1.sayWhat(); 
var gf2 = new Gf();

和构造函数不同的是这里新对象的属性和方法是所有实例都可以共享的，换句话说gf1和gf2访问的是同一份属性和方法。原型对象中除了我们赋予的属性外，还有一些内置的属性，所有原型对象都具备一个constructor属性，这个属性是一个指向包含prototype属性函数的一个指针（敢不敢再绕点！）。通过一幅图我们来清楚的理一下这个绕口的流程： 

所有的对象都有一个原型对象（prototype），原型对象中有一个constructor属性指向包含prototype属性的函数，Gf的实例gf1和gf2都包含一个内部属性指向原型对象（在firefox浏览器中表现为私有属性proto），当我们访问一个对象中的属性时，首先会询问实例对象中有没有该属性，如果没有则继续查找原型对象。

使用原型对象

在前面的示例中，我们注意到在为原型对象添加属性时，需要每个都增加Gf.prototype，这个工作很重复，在上面对象的创建模式中，我们知道可以通过字面量的形式创建一个对象，这里我们也可以改进一下： 
function Gf(){} 
Gf.prototype = { 
name : "vivian", 
bar : "c++", 
sayWhat : function(){ 
alert(this.name + "said:love you forever"); 
} 
} 
这里有一个地方需要特别注意下，constructor属性不再指向对象Gf，因为每定义一个函数，就会同时为其创建一个prototype对象，这个对象也会自动获取一个新的constructor属性，这个地方我们使用Gf.prototype本质上覆写了原有的prototype对象，因此constructor也变成了新对象的constructor属性，不再指向Gf，而是Object: 
var gf1 = new Gf(); 
console.log(gf1.constructor == Gf);//false 
console.log(gf1.constructor == Object)//true 
一般情况下，这个微妙的改变是不会对我们造成影响的，但如果你对constructor有特殊的需求，我们也可以显式的指定下Gf.prototype的constructor属性： 
Gf.prototype = { 
constructor : Gf, 
name : "vivian", 
bar : "c++", 
sayWhat : function() { 
alert(this.name + "said:love you forever"); 
} 
} 
var gf1 = new Gf(); 
console.log(gf1.constructor == Gf);//true 
通过对原型对象模式的初步了解，我们发现所有的实例对象都共享相同的属性，这是原型模式的基本特点，但往往对于开发者来说这是把“双刃剑”，在实际开发中，我们希望的实例应该是具备自己的属性，这也是在实际开发中很少有人单独使用原型模式的主要原因。

构造函数和原型组合模式

在实际开发中，我们可以使用构造函数来定义对象的属性，使用原型来定义共享的属性和方法，这样我们就可以传递不同的参数来创建出不同的对象，同时又拥有了共享的方法和属性。 
function Gf(name,bar){ 
this.name = name; 
this.bar = bar; 
} 
Gf.prototype = { 
constructor : Gf, 
sayWhat : function() { 
alert(this.name + "said:love you forever"); 
} 
} 
var gf1 = new Gf("vivian", "f"); 
var gf2 = new Gf("vivian1", "c");