1 //1.js连接两个数组
2 var ArrayConcat = function ArrayConcat(arr) {
3 var _ref;
4 for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
5 args[_key - 1] = arguments[_key];
6 }
7
8 return (_ref = []).concat.apply(_ref, [arr].concat(args));
9 };
10 // console.log(ArrayConcat([1,4,7], [1, 2, 3, [4]],[8,9,[0]]));//[1,4,7,1,2,3,[4],8,9,[0]]
11 // console.log([1,4,7].concat([1,2,3,[4]],[8,9,[0]])); //[1,4,7,1,2,3,[4],8,9,[0]]
12
13
14 //2.从b创建一个Set，然后在a上使用Array.filter（）仅保留b中不包含的值。
15 var difference = function difference(a, b) {
16 var s = new Set(b);
17 return a.filter(function (x) {
18 return !s.has(x);
19 });
20 };
21 // console.log(difference([1, 2, 3], [1, 2])); //[3]
22 function kk(age) {
23 return age >= 3;
24 }
25 // console.log([1,2,3].filter(kk)); //[3]
26
27 //3.使用slice（）来偏移数组/字符串和indexOf（）以检查是否包含该值。 省略最后一个参数fromIndex，检查整个数组/字符串。
28 var includes = function includes(collection, val) {
29 var fromIndex = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
30 return collection.slice(fromIndex).indexOf(val) != -1;
31 };
32 // console.log(includes("i-love-China","China")); //true
33 // console.log(includes("[1,2,3,4]","[")); //true
34
35
36 //4.从b创建一个Set，然后在a上使用Array.filter（）仅保留b中包含的值。
37 var intersection = function intersection(a, b) {
38 var s = new Set(b);
39 return a.filter(function (x) {
40 return s.has(x);
41 });
42 };
43 //console.log(intersection([1,2,3,4],[3,4,5,6])); //[3,4]
44
45 //5.使用Array.filter（）查找返回truthy值的数组元素和使用Array.splice（）删除元素的Array.reduce（）。 使用三个参数（value，index，array）调用func。
46 var remove = function remove(arr, func) {
47 return Array.isArray(arr) ? arr.filter(func).reduce(function (acc, val) {
48 arr.splice(arr.indexOf(val), 1);
49 return acc.concat(val);
50 }, []) : [];
51 };
52 function cc(n) {
53 return n % 2 == 0;
54 }
55 // console.log(remove([2,3,4,5,6],cc));//[2,4,6]
56
57 //6.使用Math.random（）生成一个随机数，将其与长度相乘，并使用Math.floor（）将其四舍五入到最接近的整数。 此方法也适用于字符串。
58 var sample = function sample(arr) {
59 return arr[Math.floor(Math.random() * arr.length)];
60 };
61 // console.log(sample([23,45,67,6,78]));//78
62
63 //7.使用a和b的所有值创建一个Set并转换为数组。
64 //es6
65 //const union = (a, b) => Array.from(new Set([...a, ...b]));
66 function _toConsumableArray(arr) {
67 return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread();
68 }
69
70 function _nonIterableSpread() {
71 throw new TypeError("Invalid attempt to spread non-iterable instance");
72 }
73
74 function _iterableToArray(iter) {
75 if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter);
76 }
77
78 function _arrayWithoutHoles(arr) {
79 if (Array.isArray(arr)) {
80 for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) {
81 arr2[i] = arr[i];
82 }
83 return arr2;
84 }
85 }
86
87 var union = function union(a, b) {
88 return Array.from(new Set([].concat(_toConsumableArray(a), _toConsumableArray(b))));
89 };
90
91 // console.log(union([1,2,3,4,5],[3,4,5,6,8])); //[1,2,3,4,5,6,8]
92
93 //8.使用Array.filter（）创建一个排除所有给定值的数组。
94 //es6
95 //const without = (arr, ...args) => arr.filter(v => args.indexOf(v) === -1);
96 var without = function without(arr) {
97 for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
98 args[_key - 1] = arguments[_key];
99 }
100
101 return arr.filter(function (v) {
102 return args.indexOf(v) === -1;
103 });
104 };
105 //console.log(without([2,2,3,5,7],2,5)); //[3,7]
106
107 //9.使用Math.max.apply（）获取参数中最长的数组。 创建一个长度为返回值的数组，并使用带有map-function的Array.from（）创建一个分组元素数组。 如果参数数组的长度不同，则在未找到值的情况下使用undefined。
108 var zip = function zip() {
109 for (var _len = arguments.length, arrays = new Array(_len), _key = 0; _key < _len; _key++) {
110 arrays[_key] = arguments[_key];
111 }
112
113 var maxLength = Math.max.apply(null, arrays.map(function (a) {
114 return a.length;
115 }));
116 return Array.from({
117 length: maxLength
118 }).map(function (_, i) {
119 return Array.from({
120 length: arrays.length
121 }, function (_, k) {
122 return arrays[k][i];
123 });
124 });
125 };
126 //console.log(zip(['a','b','c'],[0,1,2],[true,false])); //[['a','0',true],['b',1,false],['c',2,undefined]]
127
128 //10.使用Array.reduce（）将每个值添加到累加器，使用值0初始化，除以数组的长度。
129 var average = function average(arr) {
130 return arr.reduce(function (acc, val) {
131 return acc + val;
132 }, 0) / arr.length;
133 };
134 //console.log(average([4,5,6,7,8,9])); //6.5
135
136 //11.使用Array.from（）创建一个新数组，该数组符合将生成的块数。 使用Array.slice（）将新数组的每个元素映射到一个大小的块。 如果原始数组无法均匀分割，则最终的块将包含其余元素。
137 var chunk = function chunk(arr, size) {
138 return Array.from({
139 length: Math.ceil(arr.length / size)
140 }, function (v, i) {
141 return arr.slice(i * size, i * size + size);
142 });
143 };
144 //console.log(chunk([1,2,3,4,5,6,7,8],3)); //[[1,2,3],[4,5,6],[7,8]];
145
146 //12.使用Array.filter（）过滤掉falsey值（false，null，0，“”，undefined和NaN）。
147 var compact = function compact(arr) {
148 return arr.filter(function (v) {
149 return v;
150 });
151 };
152 //console.log(compact([0,1,false,3,'23',NaN,'lla',45])); //[1, 3, "23", "lla", 45]
153
154 //13.每次遇到数组内的特定值时，使用Array.reduce（）递增计数器。
155 var countOccurrences = function countOccurrences(arr, value) {
156 return arr.reduce(function (a, v) {
157 return v === value ? a + 1 : a + 0;
158 }, 0);
159 };
160 //console.log(countOccurrences([2,4,5,2,5,2,4,8],2)); //3
161
162 //14.使用递归。 将Array.concat（）与空数组（[]）和扩展运算符（...）一起使用以展平数组。 递归地展平作为数组的每个元素。
163 //ES6
164 //const deepFlatten = arr => [].concat(...arr.map(v => Array.isArray(v) ? deepFlatten(v) : v));
165 function _toConsumableArray(arr) {
166 return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread();
167 }
168
169 function _nonIterableSpread() {
170 throw new TypeError("Invalid attempt to spread non-iterable instance");
171 }
172
173 function _iterableToArray(iter) {
174 if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter);
175 }
176
177 function _arrayWithoutHoles(arr) {
178 if (Array.isArray(arr)) {
179 for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) {
180 arr2[i] = arr[i];
181 }
182 return arr2;
183 }
184 }
185
186 var deepFlatten = function deepFlatten(arr) {
187 var _ref;
188
189 return (_ref = []).concat.apply(_ref, _toConsumableArray(arr.map(function (v) {
190 return Array.isArray(v) ? deepFlatten(v) : v;
191 })));
192 };
193 // console.log(deepFlatten([1,[2],[[3],4],5])); //[1, 2, 3, 4, 5]
194
195 //15.循环遍历数组，使用Array.shift（）删除数组的第一个元素，直到函数返回的值为true。 返回剩余的元素。
196 var dropElements = function dropElements(arr, func) {
197 while (arr.length > 0 && !func(arr[0])) {
198 arr.shift();
199 }
200
201 return arr;
202 };
203 function cc1(n) {
204 return n >= 3;
205 }
206 //console.log(dropElements([2,3,4,5,6],cc1)); //[3,4,5,6]
207
208 //16.使用Array.map（）将start（包含）和end（不包括）之间的值映射到value。 省略开始从第一个元素开始和/或结束到最后一个结束。
209 //理解：
210 //数组[1,2,3,4]对应i 0，1，2，3；如果满足1=<i<3，就使用“8”对应，否则原值输出
211 var fillArray = function fillArray(arr, value) {
212 var start = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
213 var end = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : arr.length;
214 return arr.map(function (v, i) {
215 return i >= start && i < end ? value : v;
216 });
217 };
218 //console.log(fillArray([1,2,3,4],'8',1,3));//[1,'8','8',4]
219
220 //17.将Array.filter（）用于仅包含唯一值的数组。
221 var filterNonUnique = function filterNonUnique(arr) {
222 return arr.filter(function (i) {
223 return arr.indexOf(i) === arr.lastIndexOf(i);
224 });
225 };
226 //console.log(filterNonUnique([1,1,2,2,3,3,3,5,6,8]));//[5,6,8]
227
228 //18.使用递归，每个深度级别将深度递减1。 使用Array.reduce（）和Array.concat（）来合并元素或数组。 基本情况，深度等于1停止递归。 省略第二个元素，深度仅变平至1（单个展平）。
229 var flattenDepth = function flattenDepth(arr) {
230 var depth = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
231 return depth != 1 ? arr.reduce(function (a, v) {
232 return a.concat(Array.isArray(v) ? flattenDepth(v, depth - 1) : v);
233 }, []) : arr.reduce(function (a, v) {
234 return a.concat(v);
235 }, []);
236 };
237 //console.log(flattenDepth([1,[2],[[[3],4],5]], 2));//[1,2,[3],4,5]
238
239 //19.使用Array.reduce（）获取数组中的所有元素，并使用concat（）来展平它们。
240 var flatten = function flatten(arr) {
241 return arr.reduce(function (a, v) {
242 return a.concat(v);
243 }, []);
244 };
245 //console.log(flatten([1,[2],3,4,[5,6,[7,8,9],10]]));//[1, 2, 3, 4, 5, 6, [7,8,9], 10]
246 //console.log(flatten([1,[2],3,4,[5,6,7,8,9,10]]));//[1,2,3,4,5,6,7,8,9,10]
247
248 //20.使用Math.max（）结合扩展运算符（...）来获取数组中的最大值。
249 //ES6
250 //const arrayMax = arr => Math.max(...arr);
251 function _toConsumableArray(arr) {
252 return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread();
253 }
254
255 function _nonIterableSpread() {
256 throw new TypeError("Invalid attempt to spread non-iterable instance");
257 }
258
259 function _iterableToArray(iter) {
260 if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter);
261 }
262
263 function _arrayWithoutHoles(arr) {
264 if (Array.isArray(arr)) {
265 for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) {
266 arr2[i] = arr[i];
267 }
268 return arr2;
269 }
270 }
271
272 var arrayMax = function arrayMax(arr) {
273 return Math.max.apply(Math, _toConsumableArray(arr));
274 };
275 //console.log(arrayMax([3,4,5,8,10]));//10
276
277 //21.使用Math.min（）结合扩展运算符（...）来获取数组中的最小值。
278 function _toConsumableArray(arr) {
279 return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread();
280 }
281
282 function _nonIterableSpread() {
283 throw new TypeError("Invalid attempt to spread non-iterable instance");
284 }
285
286 function _iterableToArray(iter) {
287 if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter);
288 }
289
290 function _arrayWithoutHoles(arr) {
291 if (Array.isArray(arr)) {
292 for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) {
293 arr2[i] = arr[i];
294 }
295 return arr2;
296 }
297 }
298
299 var arrayMin = function arrayMin(arr) {
300 return Math.min.apply(Math, _toConsumableArray(arr));
301 };
302 //console.log(arrayMin([3,4,5,8,10])); //3
303
304 //22.使用Array.map（）将数组的值映射到函数或属性名称。 使用Array.reduce（）创建一个对象，其中的键是从映射结果生成的。
305 var groupBy = function groupBy(arr, func) {
306 return arr.map(typeof func === 'function' ? func : function (val) {
307 return val[func];
308 }).reduce(function (acc, val, i) {
309 acc[val] = (acc[val] || []).concat(arr[i]);
310 return acc;
311 }, {});
312 };
313 //console.log(groupBy([6.1, 4.2, 6.3], Math.floor));//{4: [4.2], 6: [6.1, 6.3]}
314
315 //23.使用arr [0]返回传递的数组的第一个元素。
316 var head = function head(arr) {
317 return arr[0];
318 };
319 //console.log(head([3,4,5,6,7])); //3
320
321 //24.使用arr.slice（0，-1）返回除数组的最后一个元素之外的所有元素。
322 var initial = function initial(arr) {
323 return arr.slice(0, -1);
324 };
325 //console.log(initial([1,3,5,7,9]));//[1, 3, 5, 7]
326
327 //25.使用Array（end-start）创建所需长度的数组Array.map（）以填充范围内的所需值。 您可以省略start以使用默认值0。
328 var initializeArrayRange = function initializeArrayRange(end) {
329 var start = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
330 return Array.apply(null, Array(end - start)).map(function (v, i) {
331 return i + start;
332 });
333 };
334 //console.log(initializeArrayRange(6));//[0, 1, 2, 3, 4, 5]
335
336 //26.使用Array（n）创建所需长度的数组，fill（v）以使用所需的值填充它。 您可以省略值以使用默认值0。
337 var initializeArray = function initializeArray(n) {
338 var value = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
339 return Array(n).fill(value);
340 };
341 // console.log(initializeArray(7,5));//[5,5,5,5,5,5,5]
342
343 //27.使用arr.slice（-1）[0]获取给定数组的最后一个元素。
344 var last = function last(arr) {
345 return arr.slice(-1)[0];
346 };
347 //console.log(last([1,2,3,4,5])); //5
348
349 //28.找到数组的中间部分，使用Array.sort（）对值进行排序。 如果长度为奇数，则返回中点处的数字，否则返回两个中间数字的平均值。
350 var median = function median(arr) {
351 var mid = Math.floor(arr.length / 2),
352 nums = arr.sort(function (a, b) {
353 return a - b;
354 });
355 return arr.length % 2 !== 0 ? nums[mid] : (nums[mid - 1] + nums[mid]) / 2;
356 };
357 //console.log(median([-3,4,-2,0,4,7])); //2
358 //console.log(median([-3,4,-2,0,4,7,2.5]));//2.5
359
360 //29.使用Array.slice（）获取包含第一个元素的第n个元素的数组。 如果索引超出范围，则返回[]。 省略第二个参数n，得到数组的第一个元素。
361 var nth = function nth(arr) {
362 var n = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
363 return (n > 0 ? arr.slice(n, n + 1) : arr.slice(n))[0];
364 };
365 //console.log(nth([2,3,4,5,6]));//2
366 //console.log(nth([2,3,4,5,6],3));//5
367
368 //30.如果obj中存在键，则使用Array.reduce（）将过滤/拾取的键转换回具有相应键：值对的对象。
369 var pick = function pick(obj, arr) {
370 return arr.reduce(function (acc, curr) {
371 return curr in obj && (acc[curr] = obj[curr]), acc;
372 }, {});
373 };
374 //console.log(pick({ 'a': 1, 'b': '2', 'c': 3 }, ['a', 'c']));//{a: 1, c: 3}
375 //console.log(pick({'a':1}, ['a', 'c']));//{a: 1}
376
377 //31.使用Array.sort（）在比较器中使用Math.random（）重新排序元素。
378 var shuffle = function shuffle(arr) {
379 return arr.sort(function () {
380 return Math.random() - 0.5;
381 });
382 };
383 //console.log(shuffle([4,5,6,7,8,9])); //[5, 4, 7, 8, 9, 6] 随机数不固定
384
385 //32.使用filter（）删除不属于值的值，使用includes（）确定。
386 var similarity = function similarity(arr, values) {
387 return arr.filter(function (v) {
388 return values.includes(v);
389 });
390 };
391 //console.log(similarity([3,4,5,6,7,8],[6,7,8,9,0]));//[6,7,8]
392
393 //33.使用Array.reduce（）将每个值添加到累加器，使用值0初始化。
394 var sum = function sum(arr) {
395 return arr.reduce(function (acc, val) {
396 return acc + val;
397 }, 0);
398 };
399 //console.log(sum([3, 4, 5, 6, 7]));//25
400
401 //34.如果数组的长度大于1，则返回arr.slice（1），否则返回整个数组。
402 var tail = function tail(arr) {
403 return arr.length > 1 ? arr.slice(1) : arr;
404 };
405 //console.log(tail([2,3,4,5]));//[3,4,5]
406 //console.log(tail([2]));//[2]
407
408 //35.使用Array.slice（）创建一个数组切片，其中包含从末尾获取的n个元素。
409 var takeRight = function takeRight(arr) {
410 var n = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
411 return arr.slice(arr.length - n, arr.length);
412 };
413 //console.log(takeRight([1, 2, 3, 4, 5], 2));//[4,5]
414 //console.log(takeRight([1, 2, 3]));//[3]
415
416 //36.使用Array.slice（）创建一个数组切片，其中包含从头开始的n个元素。
417 var take = function take(arr) {
418 var n = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
419 return arr.slice(0, n);
420 };
421 //console.log(take([1,2,3,4,5,6],4)); //[1,2,3,4]
422 //console.log(take([1,2,3,4,5],0)); //[]
423
424 //-----------------------以上为ES5写法-----------------------------------
425
426 //37.使用ES6 Set和... rest运算符可以丢弃所有重复的值。
427 const unique = arr => [...new Set(arr)];
428 //console.log(unique([1,1,2,3,4,4,5,5,5,6,7,8,8,9])); //[1,2,3,4,5,6,7,8,9]
