摘要：修復(fù)兼容等新方法。在第版時，被添加進(jìn)標(biāo)準(zhǔn)因此在某些實現(xiàn)環(huán)境中不被支持。是在最近的標(biāo)準(zhǔn)中新添加的方法所以一些舊版本的瀏覽器可能沒有實現(xiàn)該方法。算法假定和擁有它們的初始值。

修復(fù)IE兼容forEach、indexOf、filter、getComputedStyle等新方法。
補充：此文是從這里搜集來的developer.mozilla.org，只是個人做個筆記，為了方便以后對JSLite萬一要做兼容的時候行個方便。當(dāng)時懶連接地址就貼了一個，如果你要原地方找到方法，可以在developer.mozilla.org這個里面搜索。

  
修復(fù)IE，增加方法getComputedStyle為對象的窗口和getPropertyValue方法的對象，它返回的getComputedStyle

jsif (!window.getComputedStyle) {
    window.getComputedStyle = function(el, pseudo) {
        this.el = el;
        this.getPropertyValue = function(prop) {
            var re = /(-([a-z]){1})/g;
            if (prop == "float") prop = "styleFloat";
            if (re.test(prop)) {
                prop = prop.replace(re, function () {
                    return arguments[2].toUpperCase();
                });
            }
            return el.currentStyle[prop] ? el.currentStyle[prop] : null;
        }
        return this;
    }
}

  
在第 5 版時，some 被添加進(jìn) ECMA-262 標(biāo)準(zhǔn)；這樣導(dǎo)致某些實現(xiàn)環(huán)境可能不支持它。你可以把下面的代碼插入到腳本的開頭來解決此問題，從而允許在那些沒有原生支持它的實現(xiàn)環(huán)境中使用它。該算法是 ECMA-262 第 5 版中指定的算法，假定 Object 和 TypeError 擁有他們的初始值，且 fun.call 等價于 Function.prototype.call。

jsif (!Array.prototype.some){
  Array.prototype.some = function(fun /*, thisArg */)  {
    "use strict";
    if (this === void 0 || this === null)
      throw new TypeError();

    var t = Object(this);
    var len = t.length >>> 0;
    if (typeof fun !== "function")
      throw new TypeError();

    var thisArg = arguments.length >= 2 ? arguments[1] : void 0;
    for (var i = 0; i < len; i++)
    {
      if (i in t && fun.call(thisArg, t[i], i, t))
        return true;
    }

    return false;
  };
}

  
在第 5 版時，every 被添加進(jìn) ECMA-262 標(biāo)準(zhǔn)；因此在某些實現(xiàn)環(huán)境中不被支持。你可以把下面的代碼放到腳本的開頭來解決此問題，該代碼允許在那些沒有原生支持 every 的實現(xiàn)環(huán)境中使用它。該算法是 ECMA-262 第5版中指定的算法，假定 Object 和 TypeError 擁有它們的初始值，且 fun.call 等價于 Function.prototype.call。

jsif (!Array.prototype.every)
{
  Array.prototype.every = function(fun /*, thisArg */)
  {
    "use strict";

    if (this === void 0 || this === null)
      throw new TypeError();

    var t = Object(this);
    var len = t.length >>> 0;
    if (typeof fun !== "function")
        throw new TypeError();

    var thisArg = arguments.length >= 2 ? arguments[1] : void 0;
    for (var i = 0; i < len; i++)
    {
      if (i in t && !fun.call(thisArg, t[i], i, t))
        return false;
    }

    return true;
  };
}

  
map 是在最近的 ECMA-262 標(biāo)準(zhǔn)中新添加的方法；所以一些舊版本的瀏覽器可能沒有實現(xiàn)該方法。在那些沒有原生支持 map 方法的瀏覽器中，你可以使用下面的 Javascript 代碼來實現(xiàn)它。所使用的算法正是 ECMA-262，第 5 版規(guī)定的。假定Object, TypeError, 和 Array 有他們的原始值。而且 callback.call 的原始值也是 Function.prototype.call

js// Production steps of ECMA-262, Edition 5, 15.4.4.19
// Reference: http://es5.github.io/#x15.4.4.19
if (!Array.prototype.map) {

  Array.prototype.map = function(callback, thisArg) {

    var T, A, k;

    if (this == null) {
      throw new TypeError(" this is null or not defined");
    }

    // 1. Let O be the result of calling ToObject passing the |this| 
    //    value as the argument.
    var O = Object(this);

    // 2. Let lenValue be the result of calling the Get internal 
    //    method of O with the argument "length".
    // 3. Let len be ToUint32(lenValue).
    var len = O.length >>> 0;

    // 4. If IsCallable(callback) is false, throw a TypeError exception.
    // See: http://es5.github.com/#x9.11
    if (typeof callback !== "function") {
      throw new TypeError(callback + " is not a function");
    }

    // 5. If thisArg was supplied, let T be thisArg; else let T be undefined.
    if (arguments.length > 1) {
      T = thisArg;
    }

    // 6. Let A be a new array created as if by the expression new Array(len) 
    //    where Array is the standard built-in constructor with that name and 
    //    len is the value of len.
    A = new Array(len);

    // 7. Let k be 0
    k = 0;

    // 8. Repeat, while k < len
    while (k < len) {

      var kValue, mappedValue;

      // a. Let Pk be ToString(k).
      //   This is implicit for LHS operands of the in operator
      // b. Let kPresent be the result of calling the HasProperty internal 
      //    method of O with argument Pk.
      //   This step can be combined with c
      // c. If kPresent is true, then
      if (k in O) {

        // i. Let kValue be the result of calling the Get internal 
        //    method of O with argument Pk.
        kValue = O[k];

        // ii. Let mappedValue be the result of calling the Call internal 
        //     method of callback with T as the this value and argument 
        //     list containing kValue, k, and O.
        mappedValue = callback.call(T, kValue, k, O);

        // iii. Call the DefineOwnProperty internal method of A with arguments
        // Pk, Property Descriptor
        // { Value: mappedValue,
        //   Writable: true,
        //   Enumerable: true,
        //   Configurable: true },
        // and false.

        // In browsers that support Object.defineProperty, use the following:
        // Object.defineProperty(A, k, {
        //   value: mappedValue,
        //   writable: true,
        //   enumerable: true,
        //   configurable: true
        // });

        // For best browser support, use the following:
        A[k] = mappedValue;
      }
      // d. Increase k by 1.
      k++;
    }

    // 9. return A
    return A;
  };
}

  
filter 被添加到 ECMA-262 標(biāo)準(zhǔn)第 5 版中，因此在某些實現(xiàn)環(huán)境中不被支持?？梢园严旅娴拇a插入到腳本的開頭來解決此問題，該代碼允許在那些沒有原生支持 filter 的實現(xiàn)環(huán)境中使用它。該算法是 ECMA-262 第 5 版中指定的算法，假定 fn.call 等價于 Function.prototype.call 的初始值，且 Array.prototype.push 擁有它的初始值。

jsif (!Array.prototype.filter){
    Array.prototype.filter = function(fun /*, thisArg */){
        "use strict";
        if (this === void 0 || this === null)
            throw new TypeError();
        var t = Object(this);
        var len = t.length >>> 0;
        if (typeof fun !== "function")
            throw new TypeError();
        var res = [];
        var thisArg = arguments.length >= 2 ? arguments[1] : void 0;
        for (var i = 0; i < len; i++){
            if (i in t){
                var val = t[i];
                if (fun.call(thisArg, val, i, t))
                res.push(val);
            }
        }
        return res;
    };
}

jsif (!Function.prototype.bind) {
  Function.prototype.bind = function (oThis) {
    if (typeof this !== "function") {
      // closest thing possible to the ECMAScript 5 internal IsCallable function
      throw new TypeError("Function.prototype.bind - what is trying to be bound is not callable");
    }

    var aArgs = Array.prototype.slice.call(arguments, 1), 
        fToBind = this, 
        fNOP = function () {},
        fBound = function () {
          return fToBind.apply(this instanceof fNOP && oThis
                                 ? this
                                 : oThis || window,
                               aArgs.concat(Array.prototype.slice.call(arguments)));
        };

    fNOP.prototype = this.prototype;
    fBound.prototype = new fNOP();

    return fBound;
  };
}

jsif(!Array.indexOf){
    Array.prototype.indexOf = function(obj){              
        for(var i=0; i

forEach

  
forEach 是在最近被添加到 ECMA-262 標(biāo)準(zhǔn)的；這樣它可能在標(biāo)準(zhǔn)的其他實現(xiàn)中不存在，你可以在你調(diào)用 forEach 之前 插入下面的代碼，在本地不支持的情況下使用 forEach。該算法是 ECMA-262 第5版中指定的算法。算法假定 Object 和 TypeError  擁有它們的初始值。callback.call 等價于 Function.prototype.call。
developer.mozilla.org


js// Production steps of ECMA-262, Edition 5, 15.4.4.18
// Reference: http://es5.github.io/#x15.4.4.18
if (!Array.prototype.forEach) {  
    Array.prototype.forEach = function(fun /*, thisp*/){  
        var len = this.length;  
        if (typeof fun != "function")  
            throw new TypeError();  
        var thisp = arguments[1];  
        for (var i = 0; i < len; i++){  
            if (i in this)  
                fun.call(thisp, this[i], i, this);  
        }  
    };  
}