1 /**
  2  * 数组通用扩展方法
  3  *
  4  * @author lixiangqian 20130419
  5  */
  6 ;(function() {
  7     /**
  8      * 查看数组中是否包含value值项
  9      *
 10      * @param {String}
 11      *            value 要搜索值
 12      * @param {Number}
 13      *            fromIndex 开始搜索下标(可选)
 14      * @param {Number}
 15      *            toIndex 结束搜索下标(可选)
 16      * @return {Boolean} 找到返回true，否则返回false
 17      */
 18     Array.prototype.contain = function(value, fromIndex, toIndex) {
 19         fromIndex = fromIndex || 0;
 20         toIndex = toIndex || (this.length - 1);
 21         fromIndex = fromIndex > toIndex ? toIndex : fromIndex;
 22         toIndex = toIndex >= this.length ? this.length - 1 : toIndex;
 23         for ( var i = fromIndex; i <= toIndex; i++) {
 24             if (this[i] == value) {
 25                 return true;
 26             }
 27         }
 28         return false;
 29     };
 30
 31     /**
 32      * 去掉数组中重复值
 33      *
 34      * @returns {Array} 返回一个没有重复值的数组
 35      */
 36     Array.prototype.unique = function() {
 37         var aCache = {};
 38         var _tmpArray = [];
 39         for ( var i = 0; i < this.length; i++) {
 40             if (!aCache[this[i]]) {
 41                 aCache[this[i]] = true;
 42                 _tmpArray.push(this[i]);
 43             }
 44         }
 45         return _tmpArray;
 46     };
 47
 48     /**
 49      * 重写数组toString方法,将数组中元素转换为字符串形式,元素跟元素之间用seperator分割
 50      *
 51      * @param {String}
 52      *            seperator(可选,默认:',')
 53      * @returns {String}
 54      */
 55     Array.prototype.toString = function(seperator) {
 56         return this.join(seperator || ',');
 57     };
 58
 59     /**
 60      * 返回在此数组中第一次出现指定元素处的索引，从指定的索引开始搜索
 61      *
 62      * @param {Any}
 63      *            value 指定元素
 64      * @param {Number}
 65      *            fromIndex 开始搜索的索引(可选,默认为0)
 66      * @returns {Number} 找到返回所在数组索引,否则返回-1
 67      */
 68     Array.prototype.indexOf = function(value, fromIndex) {
 69         if (typeof value == 'undefined')
 70             return -1;
 71         var _len = this.length - 1;
 72         fromIndex = fromIndex || 0;
 73         for ( var i = fromIndex; i <= _len; i++) {
 74             if (this[i] == value) {
 75                 return i;
 76             }
 77         }
 78         return -1;
 79     };
 80
 81     /**
 82      * 返回指定元素在此数组中最后一次出现处的索引，从指定的索引开始反向搜索
 83      *
 84      * @param {Any}
 85      *            value 指定元素
 86      * @param {Number}
 87      *            fromIndex 开始搜索的索引(可选,默认为0)
 88      * @returns {Number} 找到返回所在数组索引,否则返回-1
 89      */
 90     Array.prototype.lastIndexOf = function(value, fromIndex) {
 91         if (typeof value == 'undefined')
 92             return -1;
 93         var _len = this.length - 1;
 94         fromIndex = fromIndex || 0;
 95         for ( var i = _len; i >= fromIndex; i++) {
 96             if (this[i] == value) {
 97                 return i;
 98             }
 99         }
100         return -1;
101     };
102
103     /**
104      * 过滤数组元素 对数组中每个元素执行fnCallBack方法进行过滤
105      *
106      * @param ${Function}
107      *            fnCallBack (当前元素所在数组索引,当前元素,数组) 过滤回调方法 方法返回false,此元素将被过滤掉
108      * @returns {Array} 返回过滤后数组
109      */
110     Array.prototype.filter = function(fnCallBack) {
111         if (typeof fnCallBack == 'function') {
112             var _tmpArray = [];
113             var _len = this.length - 1;
114             for ( var i = 0; i <= _len; i++) {
115                 if (fnCallBack.call(this[i], i, this[i], this)) {
116                     _tmpArray.push(this[i]);
117                 }
118             }
119             return _tmpArray;
120         }
121         return this;
122     };
123
124     /**
125      * 遍历数组元素
126      *
127      * @param fnCallBack
128      *            回调函数 fnCallBack(当前元素所在数组索引,当前元素,数组)
129      * @returns {Array} 返回当前数组,以便进行链式操作 如：arr.each(fn).toString();
130      */
131     Array.prototype.each = function(fnCallBack) {
132         if (typeof fnCallBack == 'function') {
133             var _len = this.length - 1;
134             for ( var i = 0; i <= _len; i++) {
135                 fnCallBack.call(this[i], i, this[i], this);
136             }
137         }
138         return this;
139     };
140 })();