30-seconds-of-code提供了大量精彩的函數片段，你可以花30s或者更短的時間來理解這些代碼段，理解這些函數的應用相信對自己會有一定的幫助。
本系列只涉及數組處理方面函數，為了方便閱讀，每篇8-10條，總計10篇，**生產環境慎用!**,**生產環境慎用!**,**生產環境慎用!**重要的事情說三遍。

all

如果所提供的判定函數對集合中的所有元素都返回true，則返回true，否則返回false。
使用Array.prototype.every()來測試集合中所有元素是否都基于fn返回true。第二個參數fn可以缺省，使用Boolean作為默認值，等價于return new Boolean(x)。

every(fn) 方法使用fn檢測數組中的所有元素：

• 如果數組中檢測到有一個元素不滿足，則整個表達式返回 false ，且剩余的元素不會再進行檢測。
• 如果所有元素都滿足條件，則返回 true。

/**
 * @name all
 * @param {Array} arr 
 * @param {Function} fn 
 * @returns {Boolean}
 */
const all = (arr, fn = Boolean) => arr.every(fn);

all([1, 2, 3]); // true
all([0]); // false
all([2, 3, 4], x => x > 1); // true

allEqual

檢查數組內所有元素是否都相等。
用Array.prototype.every()檢查是否數組中的所有元素都和數組中第一個元素相同。

/**
 * @name allEqual
 * @param {Array} arr 
 * @returns {Boolean}
 */
const allEqual = arr => arr.every(val => val === arr[0]);

allEqual([1, 2, 3, 4, 5, 6]); // false
allEqual([1, 1, 1, 1]); // true

any

如果提供的判定函數對集合中至少一個元素返回true，則返回true，否則返回false。
使用Array.prototype.some()來測試集合中所有元素是否都基于fn返回true。第二個參數fn可以缺省，使用Boolean作為默認值，等價于return new Boolean(x)。

some(fn) 方法使用fn檢測數組中的所有元素：

• 如果有一個元素滿足條件，則表達式返回true , 剩余的元素不會再執行檢測。
• 如果沒有滿足條件的元素，則返回false。

/**
 * @name any
 * @param {Array} arr 
 * @param {Function} fn 
 * @returns {Boolean}
 */
const any = (arr, fn = Boolean) => arr.some(fn);

any([1, 2, 3], x => x > 2); // true
any([1, 2, 3], x => x > 4); // false
any([0]); // false

arrayToCSV

將一個二維數組轉化為一個用逗號分隔的字符串。
使用Array.prototype.map()和Array.prototype.join(delimiter)將單獨的一維數組組合成字符串。使用Array.prototype.join('\n')將所有行組合成CSV字符串，用新的一行分隔字符串。第二個參數delimiter可以缺省,使用,作為默認分隔符。

map(fn)方法將原數組中的每個元素調用fn后，返回返回值組成的新數組。

/**
 * @name arrayToCSV
 * @param {Array} arr 
 * @param {String} delimiter 
 * @returns {String}
 */
const arrayToCSV = (arr, delimiter = ',') =>
    arr.map(v => v.map(x => `'${x}'`).join(delimiter)).join('\n');

arrayToCSV([['x', 'y'], ['a', 'b', 'c']]); // "'x','y'/n'a','b','c'"
arrayToCSV([[1, 2, 3], ['a', 'b', 'c']], ';')// "'1';'2';'3'/n'a';'b';'c'"

bifurcate

將值拆分成兩組。如果一個元素在filter中是true，則在集合中對應的元素屬于第一個組，否則它就屬于第二個組。
使用Array.prototype.reduce()和Array.prototype.push()并根據filter向組中添加元素。

reduce(callback,[initialValue])方法為數組中的每一個元素依次執行回調函數（不包括數組中被刪除或從未被賦值的元素），返回一個具體的結果。

• callback （執行數組中每個值的函數，包含四個參數）
  • previousValue （第一項的值或者上一次疊加的結果值，或者是提供的初始值（initialValue））
  • currentValue （數組中當前被處理的元素）
  • index （當前元素在數組中的索引）
  • array （數組本身）
• initialValue （作為第一次調用 callback 的第一個參數，可以控制返回值的格式）

注：根據bifurcate表現，箭頭函數函數體中，代碼用()包裹，用,隔開，返回最后一句代碼，mdn上未提供該寫法。

/**
 * @name bifurcate
 * @param {Array} arr 
 * @param {Array} filter 
 * @returns {Array}
 */
const bifurcate = (arr, filter) =>
    arr.reduce((acc, val, i) => (acc[filter[i] ? 0 : 1].push(val), acc), [[], []]);
    
bifurcate(['beep', 'boop', 'foo', 'bar'], [true, true, false, true]); // [ [ 'beep', 'boop', 'bar' ], [ 'foo' ] ]

bifurcateBy

根據判定函數將值拆分成兩組，判定函數指定輸入集合中的元素屬于哪一個組。如果判定函數返回true，則在集合中對應的元素屬于第一個組，否則它就屬于第二個組。
使用Array.prototype.reduce()和Array.prototype.push()并根據fn向組中添加元素。

/**
 * @name bifurcateBy
 * @param {Array} arr 
 * @param {Function} fn 
 * @returns {Array}
 */
const bifurcateBy = (arr, fn) =>
    arr.reduce((acc, val, i) => (acc[fn(val, i) ? 0 : 1].push(val), acc), [[], []]);

bifurcateBy(['beep', 'boop', 'foo', 'bar'], x => x[0] === 'b'); //[ [ 'beep', 'boop', 'bar' ], [ 'foo' ] ]

chunk

將數組拆分為指定大小的更小的數組。
使用Array.from()創建一個新數組，這個數組長度長度為生成的塊的數量。使用Array.prototype.slice()將新數組的每一個元素映射到長度為size的塊中。如果原始屬組不能被平均分，最后一個數組將會包含剩余元素。

/**
 * @name chunk
 * @param {Array} arr 
 * @param {Number} size 
 * @returns {Array}
 */
const chunk = (arr, size) => 
    Array.from({ length: Math.ceil(arr.length / size) }, (v, i) => 
        arr.slice(size * i, size * i + size)
    );

chunk([1, 2, 3, 4, 5], 2); // [ [ 1, 2 ], [ 3, 4 ], [ 5 ] ]

compact

移除數組中的false值。
使用Array.prototype.filter()來過濾掉false值(false, null,0,"", undefined, and NaN)。

filter(fn) 方法創建一個新數組, 其包含通過所提供函數實現的測試的所有元素。

/**
 * @name compact
 * @param {Array} arr 
 * @returns {Array}
 */
const compact = arr => arr.filter(Boolean);

compact([0, 1, false, 2, '', 3, 'a', 'e' * 23, NaN, 's', 34]); // [ 1, 2, 3, 'a', 's', 34 ]

countBy

根據給定函數對數組的元素進行分組，并返回每個組中元素的數量。
使用Array.prototype.map()將數組中的值映射到一個方法或者屬性名。通過Array.prototype.reduce()創建一個對象，對象的屬性由前面的映射結果生成。

/**
 * @name countBy
 * @param {Array} arr 
 * @param {*} fn 
 * @returns {Object}
 */
const countBy = (arr, fn) => 
    arr.map(typeof fn === 'function' ? fn : val => val[fn]).reduce((acc, val) => {
        acc[val] = (acc[val] || 0) + 1;
        return acc;
    }, {});

countBy([6.1, 4.2, 6.3], Math.floor); // { '4': 1, '6': 2 }
countBy(['one', 'two', 'three'], 'length'); // { '3': 2, '5': 1 }

countOccurrences

計算數組中的值出現的次數。
每次你遇見數組中的某個具體值，就用Array.prototype.reduce()來增加計數器。

/**
 * @name countOccurrences
 * @param {Array} arr 
 * @param {*} val 
 * @returns {Number}
 */
const countOccurrences = (arr, val) => arr.reduce((a, v) => v === val ? a + 1 : a, 0);

countOccurrences([1, 1, 2, 1, 2, 3], 1); // 3

第一篇就此結束ヾ(?°?°?)??