摘要：這個(gè)屬性本身又是一個(gè)類型的對(duì)象，原型對(duì)象都包含一個(gè)指向構(gòu)造函數(shù)的指針，而每一個(gè)實(shí)例也都包含一個(gè)指向原型對(duì)象內(nèi)部的指針。

前陣子忙于準(zhǔn)備CET-6，沒(méi)時(shí)間更新文章，之后大概一個(gè)月將忙于準(zhǔn)備期末考，也應(yīng)該不會(huì)更新了，今天趁周末有時(shí)間再更新一篇最近研究的一些東西吧。

function inner(){
    console.log(arguments.callee);//指向擁有這個(gè)arguments對(duì)象的函數(shù)，即inner()
    console.log(arguments.callee.caller);//這個(gè)屬性保存著調(diào)用當(dāng)前函數(shù)的函數(shù)的引用,即outer()
    console.log(inner.caller);//[Function: outer]
}

function outer(){
    inner();
}
outer();

callee放回正在執(zhí)行的函數(shù)本身的引用，它是arguments的一個(gè)屬性
caller 返回一個(gè)函數(shù)的引用，這個(gè)函數(shù)調(diào)用了當(dāng)前的函數(shù)。

嚴(yán)格模式下，不允許訪問(wèn)arguments.callee和arguments.caller屬性，主要體現(xiàn)在arguments.[[Get]]內(nèi)部方法

嚴(yán)格模式下，arguments，arguments.callee，arguments.caller，arguments.callee.caller也不允許再被賦值。如下代碼所示：

"use strict";
// 兩次都是1
void function fn(a) {
    console.log(arguments[0]);
    a = 2;
    console.log(arguments[0]);
}(1);


//function(){}(); 會(huì)運(yùn)行錯(cuò)誤, 如下可以正確被運(yùn)行.

void function(){
    console.log("hi");//hi
}();

在使用立即執(zhí)行的函數(shù)表達(dá)式時(shí)，可以利用 void 運(yùn)算符讓 JavaScript 引擎把一個(gè)函數(shù)識(shí)別成函數(shù)表達(dá)式而不是函數(shù)聲明（語(yǔ)句）。

var add = function (a,b) {
    console.log(arguments.length);//3,表示實(shí)參長(zhǎng)度
    console.log(arguments.callee.length);//2，表示形參長(zhǎng)度
};

add(1,2,3);

slice有兩個(gè)用法，一個(gè)是String.slice，一個(gè)是Array.slice，第一個(gè)返回的是字符串，第二個(gè)返回的是數(shù)組。

Array.prototype.slice.call(arguments)能夠?qū)?b>arguments轉(zhuǎn)成數(shù)組，那么就是arguments.toArray().slice();

因?yàn)?b>arguments并不是真正的數(shù)組對(duì)象，只是與數(shù)組類似而已，所以它并沒(méi)有slice這個(gè)方法，而Array.prototype.slice.call(arguments)可以理解成是將arguments轉(zhuǎn)換成一個(gè)數(shù)組對(duì)象，讓arguments具有slice()方法。 比如：

 var arr = [1,2,3,4];
 console.log(Array.prototype.slice.call(arr,2));//[3,4]

同樣，還有Array.prototype.forEach.call()，forEach() 方法讓數(shù)組的每一項(xiàng)都執(zhí)行一次給定的函數(shù)。

我們可以用String()來(lái)確定某一變量是否是null或者undefined

var a , b = null;
String(a);//undefined
String(b);//null

直接調(diào)用String()作為方法時(shí)，將會(huì)執(zhí)行類型轉(zhuǎn)換，返回經(jīng)過(guò)toString(value)得到的字符串字面量（與new String()不同），或者空字符串（""）.

打開(kāi)控制臺(tái)，你可以看到window對(duì)象的一系列屬性和方法：

var a = function () {};
console.log(typeof a);//function

var b = new function () {};
console.log(typeof b);//object

var c = new Function ();
console.log(typeof c);//function

new function 是一個(gè)JavaScript中用戶自定義的對(duì)象

var obj = function (name) {
    this.name = name;
};
var b = new obj("trigkit4");
console.log(b.name);  

//false
console.log(Boolean(""));//false
console.log(Boolean(null));//false
console.log(Boolean(undefined));//false
console.log(Boolean(0));//false
console.log(Boolean(false));//false
console.log(Boolean(NaN));//false

//true
console.log(Boolean(" "));//true    
console.log(Boolean("NaN"));//true

除了false，null，undefined，空字符串""，數(shù)字0和NaN以外，其他所有值都被當(dāng)做是真，包括true，字符串""里包含的值，以及所有對(duì)象。

valueOf()和toString()方法是所有ECMAScript對(duì)象擁有的內(nèi)置方法。操作對(duì)象時(shí)，valueOf()和toString()會(huì)被隱式的調(diào)用。

//valueOf()
console.log(Object.valueOf());//[Function: Object]
console.log(Object.prototype.valueOf());//{}

var boo = new Boolean(1);
console.log(boo.valueOf());//true

var bar = Boolean(0);
console.log(bar.valueOf());//false

var str = String("trigkit4");
console.log(str.valueOf());//trigkit4

console.log(null.valueOf());//TypeError
console.log(undefined.valueOf());//TypeError

//toString()
console.log(Object.prototype.toString());//[object Object]
console.log(Object.toString());//function Object() { [native code] }
Object.prototype.toString.call(null);//[object Null]
Object.prototype.toString.call(undefined);//[object Undefined]
{a: "b"}.toString();//[object Object]

valueOf()方法的目的是將對(duì)象轉(zhuǎn)換成最有意義的原始值([[PrimitiveValue]])。即ECMAScript的5種基本類型中的三種，布爾值、數(shù)字、字符串。

當(dāng)valueOf方法被調(diào)用時(shí)，會(huì)調(diào)用內(nèi)置的ToObject，并將this作為參數(shù)傳進(jìn)去。ToObject檢測(cè)會(huì)根據(jù)參數(shù)類型進(jìn)行數(shù)值的轉(zhuǎn)換：

Undefined - 拋出TypeError異常
Null - 拋出TypeError異常
Boolean - 創(chuàng)建一個(gè)Boolean對(duì)象，調(diào)用ToBoolean生成[[PrimitiveValue]]
Number - 創(chuàng)建一個(gè)Number對(duì)象，調(diào)用ToNumber生成[[PrimitiveValue]]
String - 創(chuàng)建一個(gè)String對(duì)象，調(diào)用ToString生成[[PrimitiveValue]]
Object - 對(duì)象本身

ECMAScript對(duì)象的大多數(shù)操作的轉(zhuǎn)換結(jié)果是字符串，這兩個(gè)方法的結(jié)果是相同的。但是如果操作的對(duì)象為Number、Boolean或者Date，結(jié)果就不同了。

var foo = {
    toString: function () {
        return "foo";
    },
    valueOf: function () {
        return 5;
    }
};

console.log(foo + "bar"); // 5bar
console.log([foo, "bar"].join("")); // foobar

在這個(gè)上下文環(huán)境中，我們使用"+"操作符來(lái)使字符串連接，但是，foo并沒(méi)有使用toString來(lái)轉(zhuǎn)換成字符串，它使用valueOf轉(zhuǎn)換成一個(gè)number，這并不是我們想要的，
但它是如何工作的，這是+運(yùn)算符的算術(shù)和字符串連接超載的副作用。"+"操作符有一個(gè)明確的處理過(guò)程：

1.評(píng)估左手側(cè)，并得到該值。
2.評(píng)估右手側(cè)，并獲得該值。
3.同時(shí)在左手和右手側(cè)調(diào)用ToPrimitive（無(wú)提示）
4.如果任何原始值是一個(gè)字符串，然后跳到7。
5.在這兩個(gè)值調(diào)用ToNumber。
6.返回值的總和。
7.在這兩個(gè)值調(diào)用toString。
8.返回的值連接起來(lái)

alert(1); 
setTimeout("alert(2)", 0); 
alert(3); 

執(zhí)行順序?yàn)椋?，3，2，雖然延時(shí)了0ms

setTimeout 0  //正常情況下javascript都是按照順序執(zhí)行的。但是我們可能讓該語(yǔ)句
后面的語(yǔ)句執(zhí)行完再執(zhí)行本身，這時(shí)就可以用到setTimeout延時(shí)0ms來(lái)實(shí)現(xiàn)了。

cookie可以跨越一個(gè)域名下的多個(gè)網(wǎng)頁(yè)，但不能跨越多個(gè)域名使用。

document.cookie = “user = 值;expires = 過(guò)期時(shí)間;path = 路徑訪問(wèn);
domain = 域名訪問(wèn);secure = 安全的https限制通信"

設(shè)置cookie我們一般都封裝成一個(gè)函數(shù)：

function addCookie(sName,sValue,day) {
    var expireDate = new Date();
    expireDate.setDate(expireDate.getDate()+day);;
//設(shè)置失效時(shí)間
    document.cookie = escape(sName) + "=" + escape(sValue) +";
    expires=" + expireDate.toGMTString();6 //escape()漢字轉(zhuǎn)成unicode編碼,toGMTString() 把日期對(duì)象轉(zhuǎn)成字符串
} 

為了刪除一個(gè)cookie，可以將其過(guò)期時(shí)間設(shè)定為一個(gè)過(guò)去的時(shí)間，例如：

//獲取當(dāng)前時(shí)間
    var date=new Date();
//將date設(shè)置為過(guò)去的時(shí)間
    date.setTime(date.getTime()-10000);
//將userId這個(gè)cookie刪除
    document.cookie="userId=828; expires="+date.toGMTString();

到現(xiàn)在為止，所有的cookie都是單會(huì)話cookie，即瀏覽器關(guān)閉后這些cookie將會(huì)丟失，事實(shí)上這些cookie僅僅是存儲(chǔ)在內(nèi)存中，而沒(méi)有建立相應(yīng)的硬盤(pán)文件。
在實(shí)際開(kāi)發(fā)中，cookie常常需要長(zhǎng)期保存，例如保存用戶登錄的狀態(tài)。這可以用下面的選項(xiàng)來(lái)實(shí)現(xiàn)：

document.cookie="userId=828; expiress=GMT_String";

其中GMT_String是以GMT格式表示的時(shí)間字符串，這條語(yǔ)句就是將userId這個(gè)cookie設(shè)置為GMT_String表示的過(guò)期時(shí)間，超過(guò)這個(gè)時(shí)間，cookie將消失，不可訪問(wèn)。例如：如果要將cookie設(shè)置為10天后過(guò)期，可以這樣實(shí)現(xiàn)：

對(duì)象和函數(shù)可以如數(shù)組一樣，用屬性名或方法名作為下標(biāo)來(lái)訪問(wèn)：

//對(duì)象的創(chuàng)建
function MyFunc(){}
var obj1 = new MyFunc();//使用new操作符，借助MyFun函數(shù)，就創(chuàng)建了一個(gè)對(duì)象
var obj2 = new MyFunc;//函數(shù)也可以沒(méi)有括號(hào)，但仍將調(diào)用該函數(shù)

可以把上面的代碼改寫(xiě)成這種等價(jià)形式：

function MyFunc(){};
var obj1 = {};//創(chuàng)建一個(gè)對(duì)象
MyFunc.call(obj1);//將obj1對(duì)象作為this指針調(diào)用MyFunc函數(shù)

通過(guò)自執(zhí)行的匿名函數(shù)你可以把所有原本屬于全局的變量都隱藏起來(lái)：

//創(chuàng)建一個(gè)新的匿名函數(shù)，作為包裝
(function () {
    //變量原本應(yīng)該是全局的
    var msg = "Thanks for visiting";
    
    window.onunload = function () {
        console.log(msg);
    };
})();

上下文對(duì)象是通過(guò)this變量體現(xiàn)的，這個(gè)變量永遠(yuǎn)指向當(dāng)前代碼所處的對(duì)象中。

var obj = {
    yes : function(){
        //this == obj
        this.val = true;
    },
    no : function(){
        this.val = false;
    }
};
console.log(obj.val == null);//true
//執(zhí)行了yes函數(shù)后，將val屬性與"obj"對(duì)象關(guān)聯(lián)起來(lái)
obj.yes();
console.log(obj.val == true);//true

    //公共正則表達(dá)式處理函數(shù)
    String.prototype.Regular = function(reg){
        var result = true;
        if(this.length > 0){       
            if(!reg.test(this)){   
                result = false;
            }  
        } 
        return result;
    }
    
    //.trim()方法
     String.prototype.trim = function () {
        return this.replace(/(^s*)|(s*$)/g,"");
};

^表示字符串必須以后面的規(guī)則開(kāi)頭，而(^s*) 表示的就是以0個(gè)空格或者多個(gè)空格開(kāi)頭，后面的(s*$) 的意思就是, 以0個(gè)空格或者多個(gè)空格結(jié)尾。

    //判斷輸入內(nèi)容是否為空
    String.prototype.isNull = function(){  
        return this.trim().length == 0 ? true : false; 
    } 
    
    //判斷輸入的字符是否為英文字母數(shù)字下劃線
    String.prototype.isVersion = function(){    
        var reg = /^([a-zA-Z_])([a-zA-Z0-9_.])*$/;  
        return this.Regular(reg);
    }
    
   // 判斷輸入的字符串，不包括單引號(hào)
   String.prototype.isString = function(){    
        var reg = /^[^"]*$/; 
        return this.Regular(reg); 
    }
    
  //判斷輸入的字符是否為英文字母  
    String.prototype.isLetter = function(){   
       var reg = /^[a-zA-Z]+$/;  
       return this.Regular(reg);
   }     

function User(){}
var me = new User();
console.log(me.constructor);//[Function: User]

//用前一個(gè)對(duì)象的Constructor引用來(lái)創(chuàng)建一個(gè)新的User對(duì)象
var you = new me.constructor();
console.log(me.constructor == you.constructor);//true

function Parent(){}
 var o = Object.create(Parent.prototype);
 console.log(o instanceof Parent);//true
 console.log(o instanceof Object);//true
 console.log(Object.prototype.toString.call(o));//[object Object]

“數(shù)據(jù)屬性”是可獲取且可設(shè)置值的屬性。 數(shù)據(jù)屬性描述符包含 value 特性，以及 writable、enumerable 和 configurable 特性。 如果未指定最后三個(gè)特性，則它們默認(rèn)為 false。

     
function Parent(){}
var o = Object.create(Parent);
console.log(o instanceof Parent);//false
console.log(o instanceof Object);//true  

另外一個(gè)實(shí)例

var book1 = {
    title:"JS高級(jí)程序設(shè)計(jì)",
    pages : 1001,
    getTitle:function(){
        console.log(this.title);
    }
};
var book2 = Object.create(book1,{
    //title會(huì)成為所創(chuàng)建對(duì)象的數(shù)據(jù)屬性
    title:{
        configurable:true,
        enumerable:true,
        value:"JS權(quán)威指南",
        wratable:true
    }
});
book1.getTitle();  //"JS高級(jí)程序設(shè)計(jì)"
book2.getTitle();  //"JS權(quán)威指南"

console.log(book1.hasOwnProperty("getTitle"));  //true
console.log("pages" in book2);  //true
console.log(book2.hasOwnProperty("getTitle"));  //false
console.log(book1.isPrototypeOf(book2));//true

再看另一個(gè)例子：

function Constructor(){}
obj = new Constructor();
// 上面的一句就相當(dāng)于:
obj = Object.create(Constructor.prototype);
console.log(obj);//{}
console.log(Object.create(Constructor.prototype));//{}

console.log(obj instanceof Constructor);//true
console.log(Constructor.prototype.isPrototypeOf(obj));//true

var foo;
foo = {};
// 以字面量方式創(chuàng)建的空對(duì)象就相當(dāng)于:
foo = Object.create(Object.prototype);

另外：

console.log(Object.prototype);//{}
console.log(Object.create(Object.prototype));//{}

通過(guò)Object.create(Object.prototype) 創(chuàng)建的實(shí)例對(duì)象就繼承了Object原型下的屬性和方法。

javascript所有function類型的對(duì)象都有一個(gè)prototype屬性。這個(gè)prototype屬性本身又是一個(gè)object類型的對(duì)象，原型對(duì)象都包含一個(gè)指向構(gòu)造函數(shù)的指針，而每一個(gè)實(shí)例也都包含一個(gè)指向原型對(duì)象內(nèi)部的指針。

參考：https://developer.mozilla.org...

function User(){}

var u1 = new User();
console.log(u1.prototype);//使用對(duì)象實(shí)例無(wú)法訪問(wèn)到prototype
console.log(User.prototype);//{},使用構(gòu)造函數(shù)名訪問(wèn)prototype
console.log(u1.__proto__);//{},使用對(duì)象實(shí)例訪問(wèn)prototype的指針

//使用字面量的方式創(chuàng)建原型對(duì)象，這里{}就是對(duì)象
User.prototype = {
    name : "trigkit4",
    age : 22
};

使用構(gòu)造函數(shù)創(chuàng)建原型對(duì)象和使用字面量創(chuàng)建對(duì)象在使用上基本相同，但還是有些區(qū)別，字面量創(chuàng)建的方式使用constructor屬性不會(huì)指向?qū)嵗?，而?huì)指向Object，構(gòu)造函數(shù)創(chuàng)建的方式則相反

function User(){}
User.prototype = {
    name : "trigkit4",
    age : 22
};
var u1 = new User();
console.log(u1.constructor);//function Object() {[native code]}
console.log(u1 instanceof User);//true
console.log(u1.constructor == User);//false
console.log(u1.constructor == Object);//true

//如果想讓字面量方式的constructor指向?qū)嵗龑?duì)象，可以這么做：
User.prototype = {
    constructor : User;
}

字面量方式為什么constructor會(huì)指向Object？因?yàn)?b>User.prototype = {};這種寫(xiě)法其實(shí)就是創(chuàng)建了一個(gè)新對(duì)象：

function User(){}

User.prototype = {
    constructor : User
};
var u1 = new User();
console.log(User.constructor);//[Function: Function]
console.log(u1.constructor == User);//true

另一個(gè)例子：

 (function () {
    
        console.log(Object.prototype);//{}
        console.log(Array.prototype);//[]
        console.log(Array.prototype.push);//[Function: push]
        console.log(Function.prototype);//[Function: Empty]
        console.log(Function.prototype.bind);//[Function: bind]
    
      
    })();

在toString()方法被調(diào)用時(shí),會(huì)執(zhí)行下面的操作步驟:

如果this的值為undefined,則返回"[object Undefined]".
如果this的值為null,則返回"[object Null]".
讓O成為調(diào)用ToObject(this)的結(jié)果.
讓class成為O的內(nèi)部屬性[[Class]]的值.
返回三個(gè)字符串"[object ", class, 以及 "]"連接后的新字符串.

由于 JavaScript 中一切都是對(duì)象，任何都不例外，對(duì)所有值類型應(yīng)用Object.prototype.toString.call()

方法結(jié)果如下：

console.log(Object.prototype.toString.call(123)) //[object Number]        
console.log(Object.prototype.toString.call("123")) //[object String]      
console.log(Object.prototype.toString.call(undefined)) //[object Undefined] 
console.log(Object.prototype.toString.call(true)) //[object Boolean]      
console.log(Object.prototype.toString.call({})) //[object Object]        
console.log(Object.prototype.toString.call([])) //[object Array]      
console.log(Object.prototype.toString.call(function(){})) //[object Function]

?
所有類型都會(huì)得到不同的字符串，幾乎完美。
在JavaScript中,想要判斷某個(gè)對(duì)象值屬于哪種內(nèi)置類型,最靠譜的做法就是通過(guò)Object.prototype.toString方法.

//創(chuàng)建一個(gè)名為"Class"的全局對(duì)象
var Class = {
    //它只有一個(gè)函數(shù)，其作用是創(chuàng)建一個(gè)新的對(duì)象構(gòu)造函數(shù)
    create: function(){
        //創(chuàng)建一個(gè)匿名的對(duì)象構(gòu)造函數(shù)
        return function () {
            //調(diào)用它本身的初始化方法
            this.initialize.apply(this,arguments);
        }
    }
};

//給Object對(duì)象添加一個(gè)新的靜態(tài)方法，它的作用是把屬性從一個(gè)對(duì)象復(fù)制到另一個(gè)中
Object.extend = function (destination,source) {
    //遍歷所有要擴(kuò)展的屬性
    for(property in source){
        //然后將他們添加到目標(biāo)對(duì)象中
        destination[property] = source[property];
    }
};

function aFunc(){}//或者var aFunc = function(){};

aFunc.oProperty = "函數(shù)的一個(gè)屬性";
aFunc.aMethod = function(){
    console.log("函數(shù)的一個(gè)方法");
};

console.log(aFunc["oProperty"]);//將函數(shù)當(dāng)成數(shù)組以屬性名作為下標(biāo)來(lái)訪問(wèn)屬性
console.log(aFunc["aMethod"]());//將函數(shù)當(dāng)數(shù)組以方法名作為下標(biāo)來(lái)調(diào)用方法

//遍歷函數(shù)的所有屬性和方法
for(var s in aFunc){
    console.log(s + "is a "+typeof(aFunc[s]));
}

function Constructor(msg){
    this.Message = msg;

    //私有屬性
    var separator = "-";
    var owner = this;

    //私有方法
    function alertMessage(){
        console.log(owner.Message);
    }
    alertMessage();

    //特權(quán)方法（也是公有方法）
    this.aptMessage = function (str) {
        this.Message += separator + str;
        alertMessage();
    }
}

//公有方法
Constructor.prototype.clearMessage = function (str) {
    this.Message = "";
};

//靜態(tài)屬性
Constructor.name = "trigkit4";

//靜態(tài)方法
Constructor.alertName = function (name) {
    console.log(this.name);
};

由于私有和特權(quán)成員在函數(shù)的內(nèi)部，因此它們會(huì)被帶到函數(shù)的每個(gè)實(shí)例中。   
公有的原型成員是對(duì)象藍(lán)圖的一部分，適用于通過(guò)new關(guān)鍵字實(shí)例化的該對(duì)象的每個(gè)實(shí)例 靜態(tài)成員只適用于對(duì)象的一個(gè)特殊實(shí)例

function Constructor(){
    //私有和特權(quán)成員
}

//公有方法
Constructor.prototype = {
    propertyA: "value1",
    propertyB: "value2",
    methodA: function(){},
    methodB: function(){}
};

var node = parentNode.removeChild(node);

node = null;//設(shè)置為空，釋放空間
CollectGarbage();//IE,回收資源