摘要：的作用相當(dāng)于，將其轉(zhuǎn)換為布爾值。用于判斷一個(gè)變量是否某個(gè)對(duì)象的實(shí)例，如返回同時(shí)也會(huì)返回返回布爾值，如果為，則返回，否則返回的結(jié)果。

Underscore.js 沒有對(duì)原生 JavaScript 對(duì)象進(jìn)行擴(kuò)展,而是通過調(diào)用 _() 方法進(jìn)行封裝，一旦封裝完成，原生 JavaScript 對(duì)象便成為一個(gè) Underscore 對(duì)象。

// Is a given variable an object?
    _.isObject = function(obj) {
        var type = typeof obj;
        return type === "function" || type === "object" && !!obj;
    };

這是underscore.js的判斷給定變量是否是object的一段源碼。 我們知道typeof會(huì)返回如下六個(gè)值：

1. "undefined" --- 這個(gè)值未定義；
2. "boolean"    --- 這個(gè)值是布爾值；
3. "string"        --- 這個(gè)值是字符串；
4. "number"     --- 這個(gè)值是數(shù)值；
5. "object"       --- 這個(gè)值是對(duì)象或null；
6. "function"    --- 這個(gè)值是函數(shù)。  

而&&的優(yōu)先級(jí)要高與||。!!的作用相當(dāng)于Boolean()，將其轉(zhuǎn)換為布爾值。

// Is a given value a DOM element?
    _.isElement = function(obj) {
        return !!(obj && obj.nodeType === 1);
    };

同樣!!相當(dāng)于Boolean()的作用，nodeType === 1則說明是元素節(jié)點(diǎn)，屬性attr是2 ，文本text是3

    
測(cè)試

firstChild屬性

var t = document.getElementById("test").firstChild;
alert(t.nodeType);//3
alert(t.nodeName);//#test
alert(t.nodeValue);//測(cè)試

文本節(jié)點(diǎn)也算是一個(gè)節(jié)點(diǎn)，所以p的子節(jié)點(diǎn)是文本節(jié)點(diǎn)，所以返回3

isArray = Array.isArray ||
            function(object){ return object instanceof Array }   

Array.isArray() 方法：如果一個(gè)對(duì)象是數(shù)組就返回true，如果不是則返回false。

instanceof 用于判斷一個(gè)變量是否某個(gè)對(duì)象的實(shí)例，如

var a= [];
alert(a instanceof Array);//返回 true

同時(shí) alert(a instanceof Object) 也會(huì)返回 true

isArray 返回布爾值，如果Array.isArray為true，則返回true，否則返回object instanceof Array的結(jié)果。

class2type = {},

function type(obj) {
        return obj == null ? String(obj) :
        class2type[toString.call(obj)] || "object"
    }

    function isFunction(value) { return type(value) == "function" }
    function isWindow(obj)     { return obj != null && obj == obj.window }
    function isDocument(obj)   { return obj != null && obj.nodeType == obj.DOCUMENT_NODE }
    function isObject(obj)     { return type(obj) == "object" }

class2type是一個(gè)空對(duì)象，實(shí)際上一個(gè)什么都沒有的空對(duì)象是這樣創(chuàng)建的Object.create(null);

我們可以通過Object.prototype.toString.call()方法來(lái)判斷數(shù)據(jù)類型，例如：

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]  

首先如果參數(shù)obj是undefined或null，則通過String(obj)轉(zhuǎn)換為對(duì)應(yīng)的原始字符串“undefined”或“null”。

然后class2type[toString.call(obj)]首先借用Object的原型方法toString()來(lái)獲取obj的字符串表示，返回值的形式是 [object class]，其中的class是內(nèi)部對(duì)象類。

然后從對(duì)象class2type中取出[object class]對(duì)應(yīng)的小寫字符串并返回；如果未取到則一律返回“object。

get: function(idx){
            return idx === undefined ? slice.call(this) : this[idx >= 0 ? idx : idx + this.length]
        },
    

取集合中對(duì)應(yīng)指定索引的值，如果idx小于0,則idx等于idx+length,length為集合的長(zhǎng)度.

可能你剛看到slice.call(this)會(huì)覺得很納悶，其實(shí)不僅是zepto.js的源碼，包括jQuery，backbone的源碼都是這么寫的，只不過它們?cè)谧铋_頭做了聲明：

var push = array.push;
var slice = array.slice;
var splice = array.splice;

所以slice.call(this)其實(shí)還是Array.slce.call(this)

 
  //為對(duì)象添加 class 屬性值
    
   addClassName: function(element, className) {
        element = $(element);
        Element.removeClassName(element, className);
        element.className += " " + className;
    },

    
   //為對(duì)象移除 class 屬性值
     
    removeClassName: function(element, className) {
        element = $(element);
        if (!element)
            return;
        var newClassName = "";
        var a = element.className.split(" ");
        for (var i = 0; i < a.length; i++) {
            if (a[i] != className) {
                if (i > 0)
                    newClassName += " ";
                newClassName += a[i];
            }
        }
        element.className = newClassName;
    },

因?yàn)?b>addClassName依賴于removeClassName()，所以先分析后者，$()是先將元素封裝成prototype對(duì)象，

if(!element)  return

這句的意思就是如果元素對(duì)象不存在，則忽略不再繼續(xù)執(zhí)行的意思，也就是終止的意思。

split() 方法用于把一個(gè)字符串分割成字符串?dāng)?shù)組。

如果把空字符串 ("") 用作 分隔符，那么 該對(duì)象 中的每個(gè)字符之間都會(huì)被分割。

//是否擁有 class 屬性值

hasClassName: function(element, className) {
    element = $(element);
    if (!element)
        return;
    var a = element.className.split(" ");
    for (var i = 0; i < a.length; i++) {
        if (a[i] == className)
            return true;//返回正確的處理結(jié)果
    }
    return false;//返回錯(cuò)誤的處理結(jié)果
},    

/**
 * 為兼容舊版本的瀏覽器增加 Array 的 push 方法。
 */
if (!Array.prototype.push) {
    Array.prototype.push = function() {
        var startLength = this.length;//this指代Array
        for (var i = 0; i < arguments.length; i++)
            this[startLength + i] = arguments[i];//this依舊指代Array
        return this.length;
    }
}

!Array.prototype.push如果為true，說明瀏覽器不支持該方法，則往下執(zhí)行。this[startLength + i] = arguments[i]將傳遞進(jìn)來(lái)的每個(gè)參數(shù)依次放入數(shù)組中，最后返回?cái)?shù)組的長(zhǎng)度

訪問對(duì)象可以使用(.)表示法，也可以使用[]來(lái)訪問，同樣訪問數(shù)組元素也是

jQuery源碼太多關(guān)聯(lián)了，所以不好多帶帶拿出來(lái)做分析，就舉一兩個(gè)簡(jiǎn)單的例子吧：

jQuery.prototype = {
    toArray: function() {
            return slice.call( this );
        },
}

Array.prototype.slice.call(arguments)能將具有length屬性的對(duì)象轉(zhuǎn)成數(shù)組，也就是說其目的是將arguments對(duì)象的數(shù)組提出來(lái)轉(zhuǎn)化為數(shù)組。例如：

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ù)組類似而已，所以它并沒有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
這是我們想要的基對(duì)象名稱

prototype
這可以被認(rèn)為是一個(gè)數(shù)組的實(shí)例方法的命名空間

slice
這提取數(shù)組的一部分并返回新的數(shù)組，并沒有開始和結(jié)束索引，它只是返回一個(gè)數(shù)組的拷貝

call
這是一個(gè)非常有用的功能，它允許你從一個(gè)對(duì)象調(diào)用一個(gè)函數(shù)并且使用它在另一個(gè)上下文環(huán)境

下面的寫法是等效的：

Array.prototype.slice.call == [].slice.call

看這個(gè)例子：

 
object1 = {
    name:"frank",
    greet:function(){
        alert("hello "+this.name)
    }
};

object2 = {
    name:"trigkit4"
};

// object2沒有g(shù)reet方法
// 但我們可以從object1中借來(lái)

 object1.greet.call(object2);//彈出hello trigkit4

分解一下就是object1.greet運(yùn)行彈出hello + "this.name"，然后object2對(duì)象冒充，this就指代object2

var t = function(){
    console.log(this);// String [ "t", "r", "i", "g", "k", "i", "t", "4" ]
    console.log(typeof this);  //  Object
    console.log(this instanceof String);  // true
};
t.call("trigkit4");

call(this)指向了所傳進(jìn)去的對(duì)象。

在Object.prototype中已經(jīng)包含了一些方法：

    1.toString ( )

    2.toLocaleString ( )

    3.valueOf ( )

    4.hasOwnProperty (V)

    5.isPrototypeOf (V)

    6.propertyIsEnumerable (V)

jQuery.fn.extend({
    on: function( types, selector, data, fn, /*INTERNAL*/ one ) {
        var type, origFn;

        // Types can be a map of types/handlers
        if ( typeof types === "object" ) {
            // ( types-Object, selector, data )
            if ( typeof selector !== "string" ) {
                // ( types-Object, data )
                data = data || selector;
                selector = undefined;

            }
        }
})


jQuery.extend(object) ：為擴(kuò)展jQuery類本身.為類添加新的方法。

jQuery.fn.extend(object) ：給jQuery對(duì)象添加方法。

!= 在表達(dá)式兩邊的數(shù)據(jù)類型不一致時(shí),會(huì)隱式轉(zhuǎn)換為相同數(shù)據(jù)類型,然后對(duì)值進(jìn)行比較.
!== 不會(huì)進(jìn)行類型轉(zhuǎn)換,在比較時(shí)除了對(duì)值進(jìn)行比較以外，還比較兩邊的數(shù)據(jù)類型, 它是恒等運(yùn)算符===的非形式。

on : function(){} 是js對(duì)象字面量的寫法

{鍵:值,鍵:值}語(yǔ)法中的“健/值”會(huì)成為對(duì)象的靜態(tài)成員。如果給某個(gè)“健”指定的值是一個(gè)匿名函數(shù)，那么該函數(shù)就會(huì)變成對(duì)象的靜態(tài)方法；否則就是對(duì)象的一個(gè)靜態(tài)屬性。

type: function( obj ) {
            if ( obj == null ) {
                return obj + "";
            }
            return typeof obj === "object" || typeof obj === "function" ?
            class2type[ toString.call(obj) ] || "object" :
                typeof obj;
        },

前面已經(jīng)分析了，class2type = {};所以class2type[ toString.call(obj) ] =
{}.toString.call(obj)。它的作用是改變toString的this指向?yàn)?b>object的實(shí)例。