javascript 超级数组对象

此类依赖于第一类工厂。

下面的东西基本给IE用的

var dom = {},//命名空间
     slice = Array.prototype.slice;
     dom.mixin = function (obj, bag) {
       if (arguments.length === 1) {
         bag = obj;
         obj = this;
       };
       if (obj && bag && typeof bag === 'object') {
         for (var p in bag) {
           if(bag.hasOwnProperty(p))
             obj[p] = bag[p];
         }
       };
       if (!+"\v1") {//IE不能在for...in循环中遍历toString与valueOf属性，需要单独处理
         var t = bag.toString,v = bag.valueOf,op = Object.prototype;
         if (bag.hasOwnProperty("toString") && typeof t === "function" && t !== op.toString)
           obj.toString = t;
         if (bag.hasOwnProperty("valueOf") && typeof v === "function" && v !== op.valueOf)
           obj.valueOf = v;
       }
       return obj;
     };
     dom.factory = function(obj){//第一类工厂
       var init = obj.init,
       klass = function() {
         //如果传入参数与当前类是同一类型，则直接返回
         if(arguments.length === 1 && arguments[0] instanceof klass)
           return arguments[0];
         return new klass.fn.init(arguments);
       }
       klass.fn = klass.prototype = {
         init :init,
         constructor: klass
       };
       klass.fn.init.prototype = klass.fn;
       delete obj.klass;delete obj.init;
       dom.mixin(klass.fn, obj);
       //用于扩展原型方法
       klass.mixin = function(bag){
         dom.mixin(this.fn,bag);
         return this;
       };
       klass.alias = function(oldName, newName){
         var bag = {};
         if (dom.isString(oldName) && dom.isString(newName)){
           var method = this.fn[oldName]
           if (!!method){
             bag[newName] = method;
             return this.mixin(bag);
           };
         };
         //如果是一个属性包，如Hash.alias({keyOf: 'indexOf', hasValue: 'contains'});
         bag = oldName;
         for (var name in bag)
           if(bag.hasOwnProperty(name))
             this.alias(name,bag[name]);
         return this;
       };
       klass.staticizeWithout = function(arr){
         var conditions = {},keys = arr || [],me = this;
         for(var i=0,n = keys.length;i<n;i++){
           conditions[keys[i]] = 1;
         }
         dom.each(me.fn,function(method, name){
           if(!conditions[name] && dom.isFunction(me.fn[name]) && dom.isUndefined(me[name])&&
             name !== 'init' && name !== 'toString' && name !== 'valueOf' ){
             me[name] = function () {
               var args = dom.toArray(arguments),
               caller = args.shift();
               method.name = name; //为其泛化方法添加一个name属性
               return method.apply(me(caller), args);
             }
           }
         });
         return me;
       }
       return klass;
     };
     dom.mixin(new function(){
       var _toString = Object.prototype.toString,
       _slice = Array.prototype.slice,
       _push = Array.prototype.push,
       is = function(obj,type) {
         return _toString.call(obj).match(/^\[object\s(.*)\]$/)[1] === type;
       }
       return {
         isArray: function (obj) {
           return is(obj,"Array");
         },
         isFunction: function (obj) {
           return is(obj,"Function") ;
         },
         isNumber: function (obj) {
           return is(obj,"Number") ;
         },
         isString: function (obj) {
           return is(obj,"String") ;
         },
         isUndefined: function (obj) {
           return  obj === void(0);
         },
         each: function (obj, fn, bind) {
           for (var key in obj) //只遍历本地属性
             if (obj.hasOwnProperty(key))
               fn.call(bind, obj[key], key, obj);
         },
         isArrayLike : function (obj) {//包括Array
           if(dom.isArray(obj) || obj.callee) return true;
           if(is(obj,'NodeList')) return true;
           if(is(obj,'HTMLCollection')) return true;
           //不能为字符串,不能为window,具有length属性
           if(dom.isNumber(obj.length) && !dom.isString(obj) && !obj.eval){
             if(obj.nextNode || obj.item)
               return true;
             var n = obj.length - 1 < 0 ? 0 : obj.length - 1 ;
             //如果是具有数字键或length属性的对象,如jQuery对象
             if(obj.hasOwnProperty(n) && obj.hasOwnProperty(0))
               return true
             return false;
           }
           return false;
         },
         toArray : function (arr) { //把普通对象变成原生数组对象
           if(arguments.length === 0 || arr === null){
             return [];
           }else if(arr.callee){//如果是Arguments对象
             return _slice.call(arr);
           }else if(dom.isArray(arr)){//如果Array对象返回一个克隆
             return arr.concat();
           }else if(dom.isArrayLike(arr)){
             try{//jQuery对象，dom对象，el.getElementsByTagName得到的HTMLCollection
               //与el.childNodes得到的NodeList
               return _slice.call(arr);
             }catch(e){//IE用slice处理元素或节点集合会出错，只能慢慢拷贝
               var ret = [], i = arr.length;
               while (i) ret[--i] = arr[i]; //Clone数组
               return ret;
             }
           }else {//普通函数，单个元素节点，字符串，数字，window对象
             return [arr];
           }
         },
         setArray: function (els) { //把普通对象变成类数组对象
           this.length = 0;
           _push.apply(this, els);
           return this;
         }
       }
     });

其核心函数：

var array = dom.factory({
   init: function (obj) {
     //这里的obj总是为Arguments对象
     if (obj.length === 1) {
       var first = obj[0];
       if (dom.isArray(first)) {
         //将原生数组变成超级数组
         this.setArray(first);
       } else if (dom.isNumber(first)) {
         //用一个数字初始化成数组，再用此数组变成超级数组
         this.setArray(Array(first));
       } else if (dom.isArrayLike(first)) {
         //将类组数转化为原生数组，再将原生数组变成超级数组
         this.setArray(this.toArray(first));
       } else {//如果传入单个字符串，window，函数
         this.setArray([first]);
       }
     } else {//如果传入的是1,2,3,4，
       this.setArray(this.toArray(obj));
     }
   },
   toString: function () { //返回一个字符串
     return this.valueOf().toString();
   },
   valueOf: function () {//获得里面的数组对象
     return  slice.call(this);
   },
   get: function (index) {//获得里面的数组对象或数组元素
     return arguments.length ? this[index]: this.valueOf();
   },
   setArray: dom.setArray,
   toArray: dom.toArray
 });

<!doctype html>
<html dir="ltr" lang="zh-CN" >
  <head id="head">
    <meta charset="utf-8"/>
    <title>超级数组对象 by司徒正美</title>
    <script src="http://common.cnblogs.com/script/jquery.js" type="text/javascript"></script>
    <script type="text/javascript" charset="utf-8">
       var dom = {},//命名空间
      slice = Array.prototype.slice;
      dom.mixin = function (obj, bag) {
        if (arguments.length === 1) {
          bag = obj;
          obj = this;
        };
        if (obj && bag && typeof bag === 'object') {
          for (var p in bag) {
            if(bag.hasOwnProperty(p))
              obj[p] = bag[p];
          }
        };
        if (!+"\v1") {//IE不能在for...in循环中遍历toString与valueOf属性，需要单独处理
          var t = bag.toString,v = bag.valueOf,op = Object.prototype;
          if (bag.hasOwnProperty("toString") && typeof t === "function" && t !== op.toString)
            obj.toString = t;
          if (bag.hasOwnProperty("valueOf") && typeof v === "function" && v !== op.valueOf)
            obj.valueOf = v;
        }
        return obj;
      };
      dom.factory = function(obj){//第一类工厂
        var init = obj.init,
        klass = function() {
          //如果传入参数与当前类是同一类型，则直接返回
          if(arguments.length === 1 && arguments[0] instanceof klass)
            return arguments[0];
          return new klass.fn.init(arguments);
        }
        klass.fn = klass.prototype = {
          init :init,
          constructor: klass
        };
        klass.fn.init.prototype = klass.fn;
        delete obj.klass;delete obj.init;
        dom.mixin(klass.fn, obj);
        //用于扩展原型方法
        klass.mixin = function(bag){
          dom.mixin(this.fn,bag);
          return this;
        };
        klass.alias = function(oldName, newName){
          var bag = {};
          if (dom.isString(oldName) && dom.isString(newName)){
            var method = this.fn[oldName]
            if (!!method){
              bag[newName] = method;
              return this.mixin(bag);
            };
          };
          //如果是一个属性包，如Hash.alias({keyOf: 'indexOf', hasValue: 'contains'});
          bag = oldName;
          for (var name in bag)
            if(bag.hasOwnProperty(name))
              this.alias(name,bag[name]);
          return this;
        };
        klass.staticizeWithout = function(arr){
          var conditions = {},keys = arr || [],me = this;
          for(var i=0,n = keys.length;i<n;i++){
            conditions[keys[i]] = 1;
          }
          dom.each(me.fn,function(method, name){
            if(!conditions[name] && dom.isFunction(me.fn[name]) && dom.isUndefined(me[name])&&
              name !== 'init' && name !== 'toString' && name !== 'valueOf' ){
              me[name] = function () {
                var args = dom.toArray(arguments),
                caller = args.shift();
                method.name = name; //为其泛化方法添加一个name属性
                return method.apply(me(caller), args);
              }
            }
          });
          return me;
        }
        return klass;
      };
      dom.mixin(new function(){
        var _toString = Object.prototype.toString,
        _slice = Array.prototype.slice,
        _push = Array.prototype.push,
        is = function(obj,type) {
          return _toString.call(obj).match(/^\[object\s(.*)\]$/)[1] === type;
        }
        return {
          isArray: function (obj) {
            return is(obj,"Array");
          },
          isFunction: function (obj) {
            return is(obj,"Function") ;
          },
          isNumber: function (obj) {
            return is(obj,"Number") ;
          },
          isString: function (obj) {
            return is(obj,"String") ;
          },
          isUndefined: function (obj) {
            return  obj === void(0);
          },
          each: function (obj, fn, bind) {
            for (var key in obj) //只遍历本地属性
              if (obj.hasOwnProperty(key))
                fn.call(bind, obj[key], key, obj);
          },
          isArrayLike : function (obj) {//包括Array
            if(dom.isArray(obj) || obj.callee) return true;
            if(is(obj,'NodeList')) return true;
            if(is(obj,'HTMLCollection')) return true;
            //不能为字符串,不能为window,具有length属性
            if(dom.isNumber(obj.length) && !dom.isString(obj) && !obj.eval){
              if(obj.nextNode || obj.item)
                return true;
              var n = obj.length - 1 < 0 ? 0 : obj.length - 1 ;
              //如果是具有数字键或length属性的对象,如jQuery对象
              if(obj.hasOwnProperty(n) && obj.hasOwnProperty(0))
                return true
              return false;
            }
            return false;
          },
          toArray : function (arr) { //把普通对象变成原生数组对象
            if(arguments.length === 0 || arr === null){
              return [];
            }else if(arr.callee){//如果是Arguments对象
              return _slice.call(arr);
            }else if(dom.isArray(arr)){//如果Array对象返回一个克隆
              return arr.concat();
            }else if(dom.isArrayLike(arr)){
              try{//jQuery对象，dom对象，el.getElementsByTagName得到的HTMLCollection
                //与el.childNodes得到的NodeList
                return _slice.call(arr);
              }catch(e){//IE用slice处理元素或节点集合会出错，只能慢慢拷贝
                var ret = [], i = arr.length;
                while (i) ret[--i] = arr[i]; //Clone数组
                return ret;
              }
            }else {//普通函数，单个元素节点，字符串，数字，window对象
              return [arr];
            }
          },
          setArray: function (els) { //把普通对象变成类数组对象
            this.length = 0;
            _push.apply(this, els);
            return this;
          }
        }
      });

</script>
  </head>
  <body>
    <form>
      <input type="button" value="提交3">
      <input type="button" value="提交2">
      <input type="button" value="提交3">
    </form>
    <p>测试各种生成方式！</p>

</body>
</html>

其他方法

//为超级数组对象添加原生数组对象的泛化方法
dom.each("pop,push,reverse,shift,sort,unshift,join,indexOf, \
        lastIndexOf,forEach,every,some,reduce,reduceRight".match(/\w+/g),
function (name) {
  if (dom.isFunction(Array.prototype[name]))
    array.fn[name] = Array.prototype[name];
});
dom.each({
  //为超级数组对象添加自定义方法与改造了的泛化方法
  concat: function () {
    var arr = slice.call(this),
    ret;
    if (arguments.length === 1) {
      var first = arguments[0]
      if (first instanceof dom.array) {
        ret = arr.concat(first.valueOf())
      } else {
        ret = arr.concat(first)
      }
    } else {
      var args = this.toArray(arguments);
      ret = arr.concat(args)
    }
    return array(ret);
  },
  splice: function () {//改变原对象
    var args = this.toArray(arguments),
    arr = this.valueOf(),
    ret = Array.prototype.splice.apply(arr, args);
    this.setArray(arr); //修正原数组
    return array(ret); //返回被删除元素组成的数组
  },
  slice: function () {//不会改变原对象
    var args = this.toArray(arguments),
    arr = this.valueOf(),
    ret = slice.apply(arr, args);
    return array(ret);
  },
  inArray: function (el) {
    if(Array.indexOf){
      return this.valueOf().indexOf(el) !== -1;
    }
    for (var i = 0, n = this.length; i < n; i++)
      if (this[i] === el) return true;
    return false;
  },
  indexOf: function (el, index) {
    var n = this.length,
    i = index == null ? 0 : index < 0 ? Math.max(0, n + index) : index;
    for (; i < n; i++)
      if (i in this && this[i] === el) return i;
    return -1
  },
  //返回在数组中搜索到的与给定参数相等的元素的最后（最大）索引。
  lastIndexOf: function (el, index) {
    var n = this.length,
    i = index == null ? n - 1 : index;
    if (i < 0) i = Math.max(0, n + i);
    for (; i >= 0; i--)
      if (i in this && this[i] === el) return i;
    return -1
  },
  //对数组中的每个元素都执行一次指定的函数（fn）
  forEach: function (fn, bind) {
    for (var i = 0, n = this.length; i < n; i++)
      i in this && fn.call(bind, this[i], i, this)
  },
  //对数组中的每个元素都执行一次指定的函数（f），并且创建一个新的超级数组，
  //该数组元素是所有回调函数执行时返回值为 true 的原数组元素。
  filter: function (fn, bind) {
    if (Array.filter) {
      return array(this.valueOf().filter(fn, bind));
    } else {
      var results = array();
      this.forEach( function(value, index) {
        fn.call(bind, value, index, this) && results.push(value);
      });
      return results;
    }
  },
  without:function(){//去掉与传入参数相同的元素
    var args = array(arguments)
    return this.filter(function (el) {
      return !args.contains(el);
    });
  },
  one : function(fn,bind){//类似上面，但只返回一个匹配者
    for (var i = 0, n = this.length; i < n; i++)
      if(i in this && fn.call(bind, this[i], i, this))
        return this[i]
    return null;
  },
  //对数组中的每个元素都执行一次指定的函数（f），将它们的返回值放到一个新的超级数组
  map: function (fn, bind) {
    if (Array.map) {
      return array(this.valueOf().map(fn, bind))
    } else {
      var results = array();
      this.forEach(function(value, index) {
        results.push(fn.call(bind, value, index, this));
      });
      return results;
    }
  },
  //如果数组中每一个元素都满足参数中提供的测试函数，则返回真。
  every: function (fn,bind) {
    for (var i = 0, n = this.length; i < n; i++)
      if (i in this && !fn.call(bind, this[i], i, this)) return false;
    return true
  },
  //如果数组中至少有一个元素满足参数函数的测试，则返回真。
  some: function (fn, bind) {
    for (var i = 0, n = this.length; i < n; i++)
      if (i in this && fn.call(bind, this[i], i, this)) return true;
    return false
  },
  // 用回调函数迭代地将数组简化为单一的值。
  // 如果指定了可选参数 initial，该参数将被当成是数组中的第一个值来处理，
  // 或者如果数组为空的话就作为最终返回值。如果数组为空并且没有传递
  // initial 参数，则返回 null。
  // 它回调函数的定义function(previousValue, currentValue, index, array){}
  // 相当于Prototype中的inject
  reduce: function (fn, initial, bind) {
    if (this.length == 0) return initial;
    var i = initial !== undefined ? 0 : 1;
    var ret = initial !== undefined ? initial : this[0];
    for (var n = this.length; i < n; i++)
      ret = fn.call(bind, ret, this[i], i, this);
    return ret;
  },
  reduceRight: function (fn, initial, bind) {
    if (this.length == 0) return initial;
    var i = initial !== undefined ? this.length - 1 : this.length - 2;
    var ret = initial !== undefined ? initial : this[this.length - 1];
    for (; i >= 0; i--) {
      ret = fn.call(bind, ret, this[i], i, this);
    }
    return ret;
  },
  isEmpty: function () {
    return this.length == 0;
  },
  //如果不指明位置，默认是插在最前面
  insertAt: function (item, position) {
    this.splice(position, 0, item);
    return this;
  },
  //http://msdn.microsoft.com/zh-cn/library/bb383786.aspx
  //移除 Array 对象中某个元素的第一个匹配项。
  remove: function (item) {
    var index = this.indexOf(item);
    if (index != -1) this.removeAt(index);
    return item;
  },
  //移除 Array 对象中指定位置的元素。
  removeAt: function (index) {
    return this.splice(index, 1)
  },
  //将数组对象变成普通对象,以传入数组的元素作为键，原来数组的元素作为值
  toObject: function (keys) {
    var obj = {},length,i;
    if(!!keys && dom.isArray(keys)){
      length = Math.min(this.length, keys.length);
      for(i = 0; i < length; i++)
        obj[keys[i]] = this[i];
    }else{
      for(i = 0,length=this.length;i<length;i++)
        obj[i] = this[i]
    }
    return obj;
  },
  first: function () {
    return this[0];
  },
  last: function () {
    return this[this.length - 1];
  },
  clear: function () {
    for (var i = this.length - 1; i >= 0; i--)
      delete this[i];
    this.length = 0;
    return this;
  },
  swap: function (index1, index2) {
    var arr = this;
    if (index1 < 0) index1 += arr.length; // starting from the end
    if (index2 < 0) index2 += arr.length;
    arr[index1] = arr[index1] ^ arr[index2];
    arr[index2] = arr[index2] ^ arr[index1];
    arr[index1] = arr[index1] ^ arr[index2];
    return this;
  },
  shuffle: function () {
    // Jonas Raoni Soares Silva
    //http://jsfromhell.com/array/shuffle [v1.0]
    for (var j, x, i = this.length; i;
    j = parseInt(Math.random() * i), x = this[--i], this[i] = this[j], this[j] = x);
    return this;
  },
  max: function () {
    return Math.max.apply({}, this.valueOf());
  },
  min: function () {
    return Math.min.apply({}, this.valueOf());
  },
  compact: function () {
    return this.filter(function (el) {
      return el != null;
    });
  },
  difference: function (other) {
    var len = Math.max(this.length, other.length),
    i, p, ret = array(),
    diff = {};
    for (i = 0; i < len; i++) {
      if (i < this.length) diff[this[i]] = diff[this[i]] ? 2 : 1;
      if (i < other.length) diff[other[i]] = diff[other[i]] ? 2 : 1;
    }
    for (p in diff)
      if (diff[p] == 1) ret.push(p);
    return ret;
  },
  flatten: function () {
    var _flatten = function () {
      for (var ret = [], i = 0, n = arguments.length; i < n; i++) {
        var el = arguments[i];
        dom.isArray(el) ? ret.push.apply(ret, _flatten.apply(null, el)) : ret.push(el)
      }
      return ret
    };
    var arr = _flatten(this.valueOf());
    this.setArray(arr);
    return this;
  },
  norepeat: function () {//返回数组中只出现过一次的元素
    var arr = this.valueOf(),results=[];
    for(var i=0,n=arr.length,tmp={};i<n;i++){
      tmp[arr[i]]?tmp[arr[i]]++:(tmp[arr[i]]=1);
    }
    for(var p in tmp){
      if(tmp[p]===1)
        results.push(p);
    }
    return array(results);
  },
  ensure: function (item) { //如果原来数组不存在就合并它
    if (!this.inArray(item)) this.push(item);
    return this;
  },
  combine: function (array) { //取两个数组的并集
    for (var i = 0, l = array.length; i < l; i++)
      this.ensure(array[i]);
    return this;
  },
  unique: function () { //取数组中唯一的元素并放进新数组中返回
    return array().combine(this);
  }
},function(method,name){
  if(!dom.isFunction(array.fn[name])){
    array.fn[name] = method;
  }
});
array.alias({
  forEach:"each",
  inArray:"contains"
});
array.staticizeWithout(['toArray','setArray']);
dom.array = array;

下面测试代码：

<!doctype html>
<html dir="ltr" lang="zh-CN" >
  <head id="head">
    <meta charset="utf-8"/>
    <title>超级数组对象 by司徒正美</title>

window.onload = function(){
        var assert = document.getElementById("assert");
        if(!assert){
          assert = document.createElement("ul");
          assert.i = 0;
          var item = document.createElement("li");
          document.body.insertBefore(assert,null);
        }
        var test = function(str){
          var li = item.cloneNode(false);
          assert.appendChild(li);
          li.innerHTML = str;
          assert.i++;
          li.style.backgroundColor = assert.i%2 === 1? "#e6e6e6" : "#D0E4FC";
        };

test("以下将对var a = array(3,2,1,4,5)进行测试")
        var a = array(3,2,1,4,5);
        test(a);
        test("测试pop函数")
        test(a.pop());
        test("测试push函数")
        test(a.push(6))
        test("测试reverse函数")
        test(a.reverse());
        test("测试shift函数")
        test(a.shift());
        test("测试sort函数")
        test(a.sort());
        test("测试unshift函数,将新加的参数添加到原数组的首部")
        test(a.unshift(5));
        test("测试join函数")
        test(a.join("★"))
        test("测试slice函数")
        test(a.slice(1,3));
        test("测试indexOf函数")
        test(a.indexOf(1));
        test("测试lastIndexOf函数")
        test(a.lastIndexOf(1));
        test("测试forEach函数")
        a.forEach(function(v){
          test(v+100);
        });
        test("测试every函数")
        test(a.every(function(v){
          return v > 3;
        }));
        test("测试some函数")
        test(a.some(function(v){
          return v > 3;
        }));
        test("测试one函数")
        test(a.one(function(v){
          return v > 3;
        }));
        test("测试reduce函数")
        test(a.reduce(function(p,c){
          return p+c;
        }));
        test("测试reduceRight函数")
        test(a.reduceRight(function(p,c){
          return p+c;
        }));
        test("测试concat函数")
        test(a.concat(7));
        test("传入一个参数  "+a.concat(7));
        test("传入两个参数  "+a.concat(7,8));
        test("传入零个参数  "+a.concat())
        var b = [9,10]
        test("传入一个数组对象  "+a.concat(b))
        var c = ['aa','bb']
        test("传入一个超级数组对象  "+a.concat(c))
        test("测试splice函数");
        test("--------------")
        test(a)
        test(a.splice(0,2,0,1));
        test(a);
        test("测试inArray函数");
        test(a.inArray(1));
        test(a.contains(1));
        test("测试isEmpty 函数");
        test(a.isEmpty());
        test(array().isEmpty());
        test("测试insertAt函数");
        test("长度 "+a.length)
        test(a.insertAt([1,2]));
        test("长度 "+a.length)
        test("测试remove函数");
        test("长度 "+a.length)
        test(a.remove(0));
        test("长度 "+a.length)
        test("测试removeAt函数");
        test("长度 "+a.length)
        test(a.removeAt(0));
        test(a)
        test("测试toObject函数(以传入数组的元素作为键)");
        b = a.toObject(['aa','bb','cc','dd']);
        test(b.aa+"  "+b.bb+"  "+b.cc+"  "+b.dd);
        test("测试first函数");
        test(a.first())
        test("测试last函数");
        test(a.last());
        test("测试clear函数");
        test("长度 "+array(c).clear().length);
        test("测试swap函数");
        test(a)
        test(a.swap(1,2));
        test("测试swap函数");
        test(a);
        test(a.shuffle());
        test("测试max函数");
        test(a.max());
        test("测试min函数");
        test(a.min());
        test("测试compact函数 ::  var d = array('a',null,2,4,undefined,'sdf');");
        var d = array('a',null,2,4,undefined,'sdf');
        test(d);
        test(d.compact())
        test("测试without");
        test(a);
        test(a.without(3,4));
        test("测试difference");
        test(a.difference([2,3,5]))
        test("测试flatten ::  var e = array(1,2,[3,4,[5,6]]);");
        var e = array(1,2,[3,4,[3,6]]);
        test(e.length);
        var f = e.flatten();
        test(f.length);
        test("测试norepeat函数");
        test(f.norepeat());
        test("测试unique函数");
        test(f.unique());
        test("测试ensure函数");
        test(a);
        test(a.ensure(4));
        test(a.ensure(5));
        test("测试combine函数");
        test(a.combine([4,5,6,7,8]))
        test(a.combine(array(7,8,9,10)))
        //max min compact pluck  flatten norepeat ensure combine unique
      }

</script>
  </head>
  <body>

</body>
</html>

超级数组对象
pop	同Array.pop
push	同Array.push
reverse	同Array.reverse,不过返回的是超级数组
sort	同Array.sort,不过返回的是超级数组
splice	同Array.splice,不过返回的是超级数组
slice	同Array.slice,不过返回的是超级数组
join	同Array.join
unshift	同Array.unshift,将新加的参数添加到原对象的前面
shift	同Array.shift
indexOf	返回给定元素在超级数组中的索引值，没有则返回-1
lastIndexOf	返回给定元素在超级数组中的索引值，没有则返回-1,只不过这次是从后面数起
forEach或each	类似Array.forEach，迭代执行回调函数
map	类似Array.map，迭代执行回调函数，把执行结果放到一个新超级数组对象返回
filter	类似Array.filter，迭代执行回调函数，把符合条件的键值对放到一个新超级数组对象返回
every	类似Array.every，如果所有元素都满足回调函数，为真
some	类似Array.some，只要有一个满足回调函数就为真
one	类似Array.one，返回第一个满足回调函数的元素
without	过滤与传入参数相同的元素，放进一个新超级数组返回
reduce	用回调函数迭代地将数组简化为单一的值。如果指定了可选参数 initial，该参数将被当成是数组中的第一个值来处理，或者如果数组为空的话就作为最终返回值。如果数组为空并且没有传递 initial 参数，则返回 null。回调函数的样子应该为function(previousValue, currentValue, index, array){}
reduceRight	同reduce，不过自右到左执行
isEmpty	判断对象是否为空
insertAt	在指定的索引值后插入新元素
remove	移除第一个与参数相同的元素
removeAt	移除指定位置上的元素
toObject	以传入数组的元素作为键，原超级数组的值作为值，构造一个普通对象
first	返回第一个元素
last	返回最后一个元素
clear	清空所有元素
swap	交换两个索引值上的元素
shuffle	对超级数组的元素进行乱序
max	取得数值最大的元素
min	取得数值最小的元素
compact	移除超级数组中的null元素与undefined元素
flatten	对超级数组进行平整化处理，确保是一维的超级数组
norepeat	以超级数组形式返回超级数组中所有只出现过一次的元素，
unique	去掉超级数组中的重复元素
ensure	只有原超级数组中没有此元素才允许加入它，返回新的超级对象
inArray与contains	检测超级数组是否已存在与参数相同的元素
combine	与传入（超级）数组取并集
difference	与传入（超级）数组取并集后再减去它的交集，换言之，取对方都没有的元素组成的一个新的超级对象