1 /**
  2  * 判定数组是否包含指定目标
  3  * @param target
  4  * @param item
  5  * @returns {boolean}
  6  */
  7 function contains(target,item) {
  8     return target.indexOf(item) > -1;
  9 }
 10 
 11 /**
 12  * 移除数组中指定位置的元素，返回布尔表示成功与否
 13  * @param target
 14  * @param index
 15  * @returns {boolean}
 16  */
 17 function removeAt(target,index) {
 18     return !!target.splice(index,1).length;
 19 }
 20 
 21 /**
 22  * 移除数组中第一个匹配传参的那个元素，返回布尔表示成功与否
 23  * @param target
 24  * @param item
 25  * @returns {boolean}
 26  */
 27 function remove(target,item) {
 28     const index = target.indexOf(item);
 29     if (~index) {
 30         return removeAt(target,index);
 31     }
 32     return false;
 33 }
 34 
 35 /**
 36  * 对数组进行洗牌
 37  * @param array
 38  * @returns {array}
 39  */
 40 function shuffle(array) {
 41     let m = array.length, t, i;
 42     // While there remain elements to shuffle…
 43     while (m) {
 44         // Pick a remaining element…
 45         i = Math.floor(Math.random() * m--);
 46 
 47         // And swap it with the current element.
 48         t = array[m];
 49         array[m] = array[i];
 50         array[i] = t;
 51     }
 52     return array;
 53 }
 54 
 55 /**
 56  * 从数组中随机抽选一个元素出来
 57  * @param target
 58  * @returns {*}
 59  */
 60 function random(target) {
 61     return target[Math.floor(Math.random() * target.length)];
 62 }
 63 
 64 /**
 65  * 对数组进行平坦化处理，返回一个一维的新数组
 66  * @param target
 67  * @returns {Array}
 68  */
 69 function flatten (target) {
 70     let result = [];
 71     target.forEach(function(item) {
 72         if(Array.isArray(item)) {
 73             result = result.concat(flatten(item));
 74         } else {
 75             result.push(item);
 76         }
 77     });
 78     return result;
 79 }
 80 
 81 /**
 82  * 去重操作,有序状态
 83  * @param target
 84  * @returns {Array}
 85  */
 86 function unique(target) {
 87     let result = [];
 88     loop: for (let i = 0,n = target.length;i < n; i++) {
 89         for (let x = i + 1;x < n;x++) {
 90             if (target[x] === target[i]) {
 91                 continue loop;
 92             }
 93         }
 94         result.push(target[i]);
 95     }
 96     return result;
 97 }
 98 
 99 /**
100  * 去重操作，无序状态，效率最高
101  * @param target
102  * @returns {Array}
103  */
104 function unique1(target) {
105     let obj = {};
106     for (let i = 0,n = target.length; i < n;i++) {
107         obj[target[i]] = true;
108     }
109     return Object.keys(obj);
110 }
111 
112 /**
113  * 过滤属性中的null和undefined,但不影响原数组
114  * @param target
115  * @returns {Array.<T>|*}
116  */
117 function compat(target) {
118     return target.filter(function(el) {
119         return el != null;
120     })
121 }
122 
123 /**
124  * 根据指定条件（如回调或对象的某个属性）进行分组，构成对象返回。
125  * @param target
126  * @param val
127  * @returns {{}}
128  */
129 function groupBy(target,val) {
130     var result = {};
131     var iterator = isFunction(val) ? val : function(obj) {
132         return obj[val];
133     };
134     target.forEach(function(value,index) {
135         var key = iterator(value,index);
136         (result[key] || (result[key] = [])).push(value);
137     });
138     return result;
139 }
140 function isFunction(obj){
141     return Object.prototype.toString.call(obj) === ‘[object Function]‘;
142 }
143 
144 // 例子
145 function iterator(value) {
146    if (value > 10) {
147        return ‘a‘;
148    } else if (value > 5) {
149        return ‘b‘;
150    }
151    return ‘c‘;
152 }
153 var target = [6,2,3,4,5,65,7,6,8,7,65,4,34,7,8];
154 console.log(groupBy(target,iterator));
155 
156 
157 
158 /**
159  * 获取对象数组的每个元素的指定属性，组成数组返回
160  * @param target
161  * @param name
162  * @returns {Array}
163  */
164 function pluck(target,name) {
165     let result = [],prop;
166     target.forEach(function(item) {
167         prop = item[name];
168         if (prop != null) {
169             result.push(prop);
170         }
171     });
172     return result;
173 }
174 
175 /**
176  * 根据指定条件进行排序，通常用于对象数组
177  * @param target
178  * @param fn
179  * @param scope
180  * @returns {Array}
181  */
182 function sortBy(target,fn,scope) {
183     let array = target.map(function(item,index) {
184         return {
185             el: item,
186             re: fn.call(scope,item,index)
187         };
188     }).sort(function(left,right) {
189         let a = left.re, b = right.re;
190         return a < b ? -1 : a > b ? 1 : 0;
191     });
192     return pluck(array,‘el‘);
193 }
194 
195 /**
196  * 对两个数组取并集
197  * @param target
198  * @param array
199  * @returns {Array}
200  */
201 function union(target,array) {
202     return unique(target.concat(array));
203 }
204 
205 /**
206  * 对两个数组取交集
207  * @param target
208  * @param array
209  * @returns {Array.<T>|*}
210  */
211 function intersect(target,array) {
212     return target.filter(function(n) {
213         return ~array.indexOf(n);
214     })
215 }
216 
217 /**
218  * 返回数组中的最小值，用于数字数组
219  * @param target
220  * @returns {*}
221  */
222 function min(target) {
223     return Math.min.apply(0,target);
224 }
225 
226 /**
227  * 返回数组中的最大值，用于数字数组
228  * @param target
229  * @returns {*}
230  */
231 function max(target) {
232     return Math.max.apply(0,target);
233 }

 1 const _slice = Array.prototype.slice;
 2 Array.prototype.pop = function() {
 3     return this.splice(this.length - 1,1)[0];
 4 };
 5 Array.prototype.push = function() {
 6     this.splice.apply(this,[this.length,0].concat(_slice.call(arguments)));
 7     return this.length;
 8 };
 9 Array.prototype.shift = function() {
10     return this.splice(0,1)[0];
11 };
12 Array.prototype.unshift = function() {
13     this.splice.apply(this,
14         [0,0].concat(_slice.call(arguments)));
15     return this.length;
16 };