_.chunk(array, [size=1])

原始碼 npm 套件

建立一個陣列，將元素分割成長度為 size 的群組。如果 array 無法平均分割，最後一個區塊將會是剩餘的元素。

自

3.0.0

參數

1. array (Array): 要處理的陣列。
2. [size=1] (number): 每個區塊的長度

傳回

(Array): 傳回新的區塊陣列。

範例

_.chunk(['a', 'b', 'c', 'd'], 2);
// => [['a', 'b'], ['c', 'd']]
 
_.chunk(['a', 'b', 'c', 'd'], 3);
// => [['a', 'b', 'c'], ['d']]

_.compact(array)

原始碼 npm 套件

建立一個移除所有假值的新陣列。假值包括 false、null、0、""、undefined 和 NaN。

自

0.1.0

參數

1. array (陣列): 要壓縮的陣列。

傳回

(陣列): 傳回過濾後的新陣列。

範例

_.compact([0, 1, false, 2, '', 3]);
// => [1, 2, 3]

_.concat(array, [values])

原始碼 npm 套件

建立一個新陣列，將 array 與任何其他陣列和/或值串接。

自

4.0.0

參數

1. array (陣列): 要串接的陣列。
2. [values] (...*): 要串接的值。

傳回

(陣列): 傳回串接後的新陣列。

範例

var array = [1];
var other = _.concat(array, 2, [3], [[4]]);
 
console.log(other);
// => [1, 2, 3, [4]]
 
console.log(array);
// => [1]

_.difference(array, [values])

原始碼 npm 套件

使用 SameValueZero 進行相等性比較，建立一個 array 值的陣列，其中不包含其他給定陣列中的值。結果值的順序和參考取決於第一個陣列。

注意：與 _.pullAll 不同，此方法會傳回一個新陣列。

自

0.1.0

參數

1. 陣列 (陣列)：要檢查的陣列。
2. [值] (...陣列)：要排除的值。

傳回

(陣列): 傳回過濾後的新陣列。

範例

_.difference([2, 1], [2, 3]);
// => [1]

_.differenceBy(array, [values], [iteratee=_.identity])

原始碼 npm 套件

此方法類似於 _.difference，但它會接受 iteratee，並針對 array 和 values 的每個元素呼叫它，以產生用於比較它們的準則。結果值的順序和參考是由第一個陣列決定的。iteratee 會以一個引數呼叫
(value).

注意：與 _.pullAllBy 不同，此方法會傳回一個新的陣列。

自

4.0.0

參數

1. 陣列 (陣列)：要檢查的陣列。
2. [值] (...陣列)：要排除的值。
3. [iteratee=_.identity] (函式)：每個元素呼叫的 iteratee。

傳回

(陣列): 傳回過濾後的新陣列。

範例

_.differenceBy([2.1, 1.2], [2.3, 3.4], Math.floor);
// => [1.2]
 
// The `_.property` iteratee shorthand.
_.differenceBy([{ 'x': 2 }, { 'x': 1 }], [{ 'x': 1 }], 'x');
// => [{ 'x': 2 }]

_.differenceWith(array, [values], [comparator])

原始碼 npm 套件

此方法類似於 _.difference，但它會接受 comparator，並呼叫它來比較 array 和 values 的元素。結果值的順序和參考是由第一個陣列決定的。comparator 會以兩個引數呼叫：(arrVal, othVal)。

注意：與 _.pullAllWith 不同，此方法會傳回一個新的陣列。

自

4.0.0

參數

1. 陣列 (陣列)：要檢查的陣列。
2. [值] (...陣列)：要排除的值。
3. [comparator] (函式)：每個元素呼叫的 comparator。

傳回

(陣列): 傳回過濾後的新陣列。

範例

var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];
 
_.differenceWith(objects, [{ 'x': 1, 'y': 2 }], _.isEqual);
// => [{ 'x': 2, 'y': 1 }]

_.drop(array, [n=1])

原始碼 npm 套件

建立一個 array 的切片，從開頭捨棄 n 個元素。

自

0.5.0

參數

1. array (陣列)：要查詢的陣列。
2. [n=1] (數字)：要捨棄的元素數量。

傳回

(陣列)：傳回 array 的切片。

範例

_.drop([1, 2, 3]);
// => [2, 3]
 
_.drop([1, 2, 3], 2);
// => [3]
 
_.drop([1, 2, 3], 5);
// => []
 
_.drop([1, 2, 3], 0);
// => [1, 2, 3]

_.dropRight(array, [n=1])

原始碼 npm 套件

建立一個 array 的切片，從結尾捨棄 n 個元素。

自

3.0.0

參數

1. array (陣列)：要查詢的陣列。
2. [n=1] (數字)：要捨棄的元素數量。

傳回

(陣列)：傳回 array 的切片。

範例

_.dropRight([1, 2, 3]);
// => [1, 2]
 
_.dropRight([1, 2, 3], 2);
// => [1]
 
_.dropRight([1, 2, 3], 5);
// => []
 
_.dropRight([1, 2, 3], 0);
// => [1, 2, 3]

_.dropRightWhile(array, [predicate=_.identity])

原始碼 npm 套件

建立一個 array 的切片，排除從結尾捨棄的元素。元素會捨棄直到 predicate 傳回假值。此謂詞會呼叫三個參數：(value, index, array)。

自

3.0.0

參數

1. array (陣列)：要查詢的陣列。
2. [predicate=_.identity] (函式)：每個反覆呼叫的函式。

傳回

(陣列)：傳回 array 的切片。

範例

var users = [
  { 'user': 'barney',  'active': true },
  { 'user': 'fred',    'active': false },
  { 'user': 'pebbles', 'active': false }
];
 
_.dropRightWhile(users, function(o) { return !o.active; });
// => objects for ['barney']
 
// The `_.matches` iteratee shorthand.
_.dropRightWhile(users, { 'user': 'pebbles', 'active': false });
// => objects for ['barney', 'fred']
 
// The `_.matchesProperty` iteratee shorthand.
_.dropRightWhile(users, ['active', false]);
// => objects for ['barney']
 
// The `_.property` iteratee shorthand.
_.dropRightWhile(users, 'active');
// => objects for ['barney', 'fred', 'pebbles']

_.dropWhile(array, [predicate=_.identity])

原始碼 npm 套件

建立一個 array 的切片，排除從開頭捨棄的元素。元素會捨棄直到 predicate 傳回假值。此謂詞會呼叫三個參數：(value, index, array)。

自

3.0.0

參數

1. array (陣列)：要查詢的陣列。
2. [predicate=_.identity] (函式)：每個反覆呼叫的函式。

傳回

(陣列)：傳回 array 的切片。

範例

var users = [
  { 'user': 'barney',  'active': false },
  { 'user': 'fred',    'active': false },
  { 'user': 'pebbles', 'active': true }
];
 
_.dropWhile(users, function(o) { return !o.active; });
// => objects for ['pebbles']
 
// The `_.matches` iteratee shorthand.
_.dropWhile(users, { 'user': 'barney', 'active': false });
// => objects for ['fred', 'pebbles']
 
// The `_.matchesProperty` iteratee shorthand.
_.dropWhile(users, ['active', false]);
// => objects for ['pebbles']
 
// The `_.property` iteratee shorthand.
_.dropWhile(users, 'active');
// => objects for ['barney', 'fred', 'pebbles']

_.fill(array, value, [start=0], [end=array.length])

原始碼 npm 套件

使用 value 填入 array 的元素，從 start 開始，但不包含 end。

注意：此方法會變更 array。

自

3.2.0

參數

1. array (陣列)：要填入的陣列。
2. value (*)：用於填入 array 的值。
3. [start=0] (數字)：開始位置。
4. [end=array.length] (數字)：結束位置。

傳回

(陣列)：傳回 array。

範例

var array = [1, 2, 3];
 
_.fill(array, 'a');
console.log(array);
// => ['a', 'a', 'a']
 
_.fill(Array(3), 2);
// => [2, 2, 2]
 
_.fill([4, 6, 8, 10], '*', 1, 3);
// => [4, '*', '*', 10]

_.findIndex(array, [predicate=_.identity], [fromIndex=0])

原始碼 npm 套件

此方法類似於 _.find，但它會傳回 predicate 傳回真值的元素的第一個索引，而不是元素本身。

自

1.1.0

參數

1. 陣列 (陣列)：要檢查的陣列。
2. [predicate=_.identity] (函式)：每個反覆呼叫的函式。
3. [fromIndex=0] (數字)：開始搜尋的索引。

傳回

(數字)：傳回找到的元素的索引，否則傳回 -1。

範例

var users = [
  { 'user': 'barney',  'active': false },
  { 'user': 'fred',    'active': false },
  { 'user': 'pebbles', 'active': true }
];
 
_.findIndex(users, function(o) { return o.user == 'barney'; });
// => 0
 
// The `_.matches` iteratee shorthand.
_.findIndex(users, { 'user': 'fred', 'active': false });
// => 1
 
// The `_.matchesProperty` iteratee shorthand.
_.findIndex(users, ['active', false]);
// => 0
 
// The `_.property` iteratee shorthand.
_.findIndex(users, 'active');
// => 2

_.findLastIndex(array, [predicate=_.identity], [fromIndex=array.length-1])

原始碼 npm 套件

此方法類似於 _.findIndex，但它會從右至左迭代 collection 的元素。

自

2.0.0

參數

1. 陣列 (陣列)：要檢查的陣列。
2. [predicate=_.identity] (函式)：每個反覆呼叫的函式。
3. [fromIndex=array.length-1] (數字)：開始搜尋的索引。

傳回

(數字)：傳回找到的元素的索引，否則傳回 -1。

範例

var users = [
  { 'user': 'barney',  'active': true },
  { 'user': 'fred',    'active': false },
  { 'user': 'pebbles', 'active': false }
];
 
_.findLastIndex(users, function(o) { return o.user == 'pebbles'; });
// => 2
 
// The `_.matches` iteratee shorthand.
_.findLastIndex(users, { 'user': 'barney', 'active': true });
// => 0
 
// The `_.matchesProperty` iteratee shorthand.
_.findLastIndex(users, ['active', false]);
// => 2
 
// The `_.property` iteratee shorthand.
_.findLastIndex(users, 'active');
// => 0

_.flatten(array)

原始碼 npm 套件

將 array 展平一層。

自

0.1.0

參數

1. array (陣列)：要展平的陣列。

傳回

(陣列)：傳回新的扁平陣列。

範例

_.flatten([1, [2, [3, [4]], 5]]);
// => [1, 2, [3, [4]], 5]

_.flattenDeep(array)

原始碼 npm 套件

遞迴扁平化 array。

自

3.0.0

參數

1. array (陣列)：要展平的陣列。

傳回

(陣列)：傳回新的扁平陣列。

範例

_.flattenDeep([1, [2, [3, [4]], 5]]);
// => [1, 2, 3, 4, 5]

_.flattenDepth(array, [depth=1])

原始碼 npm 套件

遞迴扁平化 array 最多 depth 次。

自

4.4.0

參數

1. array (陣列)：要展平的陣列。
2. [depth=1] (數字)：最大遞迴深度。

傳回

(陣列)：傳回新的扁平陣列。

範例

var array = [1, [2, [3, [4]], 5]];
 
_.flattenDepth(array, 1);
// => [1, 2, [3, [4]], 5]
 
_.flattenDepth(array, 2);
// => [1, 2, 3, [4], 5]

_.fromPairs(pairs)

原始碼 npm 套件

_.toPairs 的反函式；此方法傳回一個由 key-value pairs 組成的物件。

自

4.0.0

參數

1. pairs (陣列)：key-value 成對資料。

傳回

(物件)：傳回新的物件。

範例

_.fromPairs([['a', 1], ['b', 2]]);
// => { 'a': 1, 'b': 2 }

_.head(array)

原始碼 npm 套件

取得 array 的第一個元素。

自

0.1.0

別名

_.first

參數

1. array (陣列)：要查詢的陣列。

傳回

(*)：傳回 array 的第一個元素。

範例

_.head([1, 2, 3]);
// => 1
 
_.head([]);
// => undefined

_.indexOf(array, value, [fromIndex=0])

原始碼 npm 套件

取得 array 中第一次出現 value 的索引，使用 SameValueZero 進行相等性比較。如果 fromIndex 為負數，則將其用作從 array 結尾的偏移量。

自

0.1.0

參數

1. 陣列 (陣列)：要檢查的陣列。
2. 值 (*)：要搜尋的值。
3. [fromIndex=0] (數字)：開始搜尋的索引。

傳回

(數字)：傳回配對值的索引，否則傳回 -1。

範例

_.indexOf([1, 2, 1, 2], 2);
// => 1
 
// Search from the `fromIndex`.
_.indexOf([1, 2, 1, 2], 2, 2);
// => 3

_.initial(陣列)

來源 npm 套件

取得 陣列 中除了最後一個元素之外的所有元素。

自

0.1.0

參數

1. array (陣列)：要查詢的陣列。

傳回

(陣列)：傳回 array 的切片。

範例

_.initial([1, 2, 3]);
// => [1, 2]

_.intersection([陣列])

來源 npm 套件

使用 SameValueZero 進行相等性比較，建立一個包含所有給定陣列中唯一值的陣列。結果值的順序和參照由第一個陣列決定。

自

0.1.0

參數

1. [陣列] (...陣列)：要檢查的陣列。

傳回

(陣列)：傳回相交值的陣列。

範例

_.intersection([2, 1], [2, 3]);
// => [2]

_.intersectionBy([陣列], [迭代器=_.identity])

來源 npm 套件

這個方法類似於 _.intersection，但它接受 迭代器，會呼叫每個 陣列 的每個元素來產生比較標準。結果值的順序和參照由第一個陣列決定。迭代器會呼叫一個參數
(value).

自

4.0.0

參數

1. [陣列] (...陣列)：要檢查的陣列。
2. [iteratee=_.identity] (函式)：每個元素呼叫的 iteratee。

傳回

(陣列)：傳回相交值的陣列。

範例

_.intersectionBy([2.1, 1.2], [2.3, 3.4], Math.floor);
// => [2.1]
 
// The `_.property` iteratee shorthand.
_.intersectionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');
// => [{ 'x': 1 }]

_.intersectionWith([陣列], [比較器])

來源 npm 套件

此方法類似於 _.intersection，但它接受用於比較 arrays 元素的 comparator。結果值的順序和參照由第一個陣列決定。比較器使用兩個參數呼叫：(arrVal, othVal)。

自

4.0.0

參數

1. [陣列] (...陣列)：要檢查的陣列。
2. [comparator] (函式)：每個元素呼叫的 comparator。

傳回

(陣列)：傳回相交值的陣列。

範例

var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];
var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }];
 
_.intersectionWith(objects, others, _.isEqual);
// => [{ 'x': 1, 'y': 2 }]

_.join(array, [separator=','])

原始碼 npm 套件

將 array 中的所有元素轉換為以 separator 分隔的字串。

自

4.0.0

參數

1. array (陣列)：要轉換的陣列。
2. [separator=','] (字串)：元素分隔符號。

傳回

(字串)：傳回合併的字串。

範例

_.join(['a', 'b', 'c'], '~');
// => 'a~b~c'

_.last(array)

原始碼 npm 套件

取得 array 的最後一個元素。

自

0.1.0

參數

1. array (陣列)：要查詢的陣列。

傳回

(*)：傳回 array 的最後一個元素。

範例

_.last([1, 2, 3]);
// => 3

_.lastIndexOf(array, value, [fromIndex=array.length-1])

原始碼 npm 套件

此方法類似於 _.indexOf，但它從右到左迭代 array 的元素。

自

0.1.0

參數

1. 陣列 (陣列)：要檢查的陣列。
2. 值 (*)：要搜尋的值。
3. [fromIndex=array.length-1] (數字)：開始搜尋的索引。

傳回

(數字)：傳回配對值的索引，否則傳回 -1。

範例

_.lastIndexOf([1, 2, 1, 2], 2);
// => 3
 
// Search from the `fromIndex`.
_.lastIndexOf([1, 2, 1, 2], 2, 2);
// => 1

_.nth(array, [n=0])

來源 npm 套件

取得 array 中索引為 n 的元素。如果 n 為負數，則會傳回從結尾開始數起的第 n 個元素。

自

4.11.0

參數

1. array (陣列)：要查詢的陣列。
2. [n=0] (數字): 要傳回的元素索引。

傳回

(*): 傳回 array 中的第 n 個元素。

範例

var array = ['a', 'b', 'c', 'd'];
 
_.nth(array, 1);
// => 'b'
 
_.nth(array, -2);
// => 'c';

_.pull(array, [values])

來源 npm 套件

使用 SameValueZero 進行相等比較，從 array 中移除所有指定的數值。

注意：與 _.without 不同，此方法會變更 array。請使用 _.remove 根據謂詞從陣列中移除元素。

自

2.0.0

參數

1. array (陣列): 要修改的陣列。
2. [values] (...*): 要移除的數值。

傳回

(陣列)：傳回 array。

範例

var array = ['a', 'b', 'c', 'a', 'b', 'c'];
 
_.pull(array, 'a', 'c');
console.log(array);
// => ['b', 'b']

_.pullAll(array, values)

來源 npm 套件

此方法類似於 _.pull，但它接受一個要移除數值的陣列。

注意：與 _.difference 不同，此方法會變更 array。

自

4.0.0

參數

1. array (陣列): 要修改的陣列。
2. values (陣列): 要移除的數值。

傳回

(陣列)：傳回 array。

範例

var array = ['a', 'b', 'c', 'a', 'b', 'c'];
 
_.pullAll(array, ['a', 'c']);
console.log(array);
// => ['b', 'b']

_.pullAllBy(array, values, [iteratee=_.identity])

原始碼 npm 套件

此方法類似於 _.pullAll，但它接受 `iteratee`，會針對 `array` 和 `values` 的每個元素呼叫它，以產生用於比較它們的準則。iteratee 會使用一個參數呼叫：(value)。

注意：與 _.differenceBy 不同，此方法會變更 `array`。

自

4.0.0

參數

1. array (陣列): 要修改的陣列。
2. values (陣列): 要移除的數值。
3. [iteratee=_.identity] (函式)：每個元素呼叫的 iteratee。

傳回

(陣列)：傳回 array。

範例

var array = [{ 'x': 1 }, { 'x': 2 }, { 'x': 3 }, { 'x': 1 }];
 
_.pullAllBy(array, [{ 'x': 1 }, { 'x': 3 }], 'x');
console.log(array);
// => [{ 'x': 2 }]

_.pullAllWith(array, values, [comparator])

原始碼 npm 套件

此方法類似於 _.pullAll，但它接受 `comparator`，會呼叫它來比較 `array` 和 `values` 的元素。comparator 會使用兩個參數呼叫：(arrVal, othVal)。

注意：與 _.differenceWith 不同，此方法會變更 `array`。

自

4.6.0

參數

1. array (陣列): 要修改的陣列。
2. values (陣列): 要移除的數值。
3. [comparator] (函式)：每個元素呼叫的 comparator。

傳回

(陣列)：傳回 array。

範例

var array = [{ 'x': 1, 'y': 2 }, { 'x': 3, 'y': 4 }, { 'x': 5, 'y': 6 }];
 
_.pullAllWith(array, [{ 'x': 3, 'y': 4 }], _.isEqual);
console.log(array);
// => [{ 'x': 1, 'y': 2 }, { 'x': 5, 'y': 6 }]

_.pullAt(array, [indexes])

原始碼 npm 套件

從 `array` 中移除對應於 `indexes` 的元素，並傳回一個已移除元素的陣列。

注意：與 _.at 不同，此方法會變更 `array`。

自

3.0.0

參數

1. array (陣列): 要修改的陣列。
2. [indexes] (...(number|number[]))：要移除元素的索引。

傳回

(陣列)：傳回已移除元素的新陣列。

範例

var array = ['a', 'b', 'c', 'd'];
var pulled = _.pullAt(array, [1, 3]);
 
console.log(array);
// => ['a', 'c']
 
console.log(pulled);
// => ['b', 'd']

_.remove(array, [predicate=_.identity])

原始碼 npm 套件

從 array 中移除所有 predicate 傳回真值的元素，並傳回已移除元素的陣列。此謂詞會使用三個參數呼叫：(value, index, array)。

注意：與 _.filter 不同，此方法會變更 array。請使用 _.pull 根據值從陣列中移除元素。

自

2.0.0

參數

1. array (陣列): 要修改的陣列。
2. [predicate=_.identity] (函式)：每個反覆呼叫的函式。

傳回

(陣列)：傳回已移除元素的新陣列。

範例

var array = [1, 2, 3, 4];
var evens = _.remove(array, function(n) {
  return n % 2 == 0;
});
 
console.log(array);
// => [1, 3]
 
console.log(evens);
// => [2, 4]

_.reverse(array)

原始碼 npm 套件

反轉 array，使第一個元素變成最後一個，第二個元素變成倒數第二個，以此類推。

注意：此方法會變更 array，且基於 Array#reverse。

自

4.0.0

參數

1. array (陣列): 要修改的陣列。

傳回

(陣列)：傳回 array。

範例

var array = [1, 2, 3];
 
_.reverse(array);
// => [3, 2, 1]
 
console.log(array);
// => [3, 2, 1]

_.slice(array, [start=0], [end=array.length])

原始碼 npm 套件

建立 array 從 start 到 end（不包含 end）的切片。

注意：此方法用於取代 Array#slice，以確保傳回密集陣列。

自

3.0.0

參數

1. array (陣列)：要切片的陣列。
2. [start=0] (數字)：開始位置。
3. [end=array.length] (數字)：結束位置。

傳回

(陣列)：傳回 array 的切片。

_.sortedIndex(array, value)

原始碼 npm 套件

使用二元搜尋來決定應將 value 插入 array 的最低索引，以維持其排序順序。

自

0.1.0

參數

1. array (陣列): 要檢查的已排序陣列。
2. value (*): 要評估的值。

傳回

(數字): 傳回應將 value 插入 array 的索引。

範例

_.sortedIndex([30, 50], 40);
// => 1

_.sortedIndexBy(array, value, [iteratee=_.identity])

原始碼 npm 套件

此方法類似於 _.sortedIndex，但它接受 iteratee，會針對 value 和 array 的每個元素呼叫此函式來計算其排序排名。呼叫 iteratee 時只會傳入一個參數：(value)。

自

4.0.0

參數

1. array (陣列): 要檢查的已排序陣列。
2. value (*): 要評估的值。
3. [iteratee=_.identity] (函式)：每個元素呼叫的 iteratee。

傳回

(數字): 傳回應將 value 插入 array 的索引。

範例

var objects = [{ 'x': 4 }, { 'x': 5 }];
 
_.sortedIndexBy(objects, { 'x': 4 }, function(o) { return o.x; });
// => 0
 
// The `_.property` iteratee shorthand.
_.sortedIndexBy(objects, { 'x': 4 }, 'x');
// => 0

_.sortedIndexOf(array, value)

原始碼 npm 套件

此方法類似於 _.indexOf，但它會對已排序的 array 執行二元搜尋。

自

4.0.0

參數

1. 陣列 (陣列)：要檢查的陣列。
2. 值 (*)：要搜尋的值。

傳回

(數字)：傳回配對值的索引，否則傳回 -1。

範例

_.sortedIndexOf([4, 5, 5, 5, 6], 5);
// => 1

_.sortedLastIndex(array, value)

原始碼 npm 套件

此方法類似於 _.sortedIndex，但它會傳回在 `array` 中插入 `value` 以維持其排序順序時應使用的最高索引。

自

3.0.0

參數

1. array (陣列): 要檢查的已排序陣列。
2. value (*): 要評估的值。

傳回

(數字): 傳回應將 value 插入 array 的索引。

範例

_.sortedLastIndex([4, 5, 5, 5, 6], 5);
// => 4

_.sortedLastIndexBy(array, value, [iteratee=_.identity])

原始碼 npm 套件

此方法類似於 _.sortedLastIndex，但它會接受 `iteratee`，而 `iteratee` 會針對 `value` 和 `array` 的每個元素呼叫，以計算其排序排名。`iteratee` 會使用一個引數呼叫：(value)。

自

4.0.0

參數

1. array (陣列): 要檢查的已排序陣列。
2. value (*): 要評估的值。
3. [iteratee=_.identity] (函式)：每個元素呼叫的 iteratee。

傳回

(數字): 傳回應將 value 插入 array 的索引。

範例

var objects = [{ 'x': 4 }, { 'x': 5 }];
 
_.sortedLastIndexBy(objects, { 'x': 4 }, function(o) { return o.x; });
// => 1
 
// The `_.property` iteratee shorthand.
_.sortedLastIndexBy(objects, { 'x': 4 }, 'x');
// => 1

_.sortedLastIndexOf(array, value)

原始碼 npm 套件

此方法類似於 _.lastIndexOf，但它會對已排序的 `array` 執行二元搜尋。

自

4.0.0

參數

1. 陣列 (陣列)：要檢查的陣列。
2. 值 (*)：要搜尋的值。

傳回

(數字)：傳回配對值的索引，否則傳回 -1。

範例

_.sortedLastIndexOf([4, 5, 5, 5, 6], 5);
// => 3

_.sortedUniq(array)

原始碼 npm 套件

此方法類似於 _.uniq，但它專門設計並最佳化用於已排序的陣列。

自

4.0.0

參數

1. 陣列 (陣列)：要檢查的陣列。

傳回

(陣列)：傳回新的不重複陣列。

範例

_.sortedUniq([1, 1, 2]);
// => [1, 2]

_.sortedUniqBy(array, [iteratee])

原始碼 npm 套件

此方法類似於 _.uniqBy，但針對已排序陣列進行設計和最佳化。

自

4.0.0

參數

1. 陣列 (陣列)：要檢查的陣列。
2. [iteratee] (函式): 依序呼叫每個元素的迭代函式。

傳回

(陣列)：傳回新的不重複陣列。

範例

_.sortedUniqBy([1.1, 1.2, 2.3, 2.4], Math.floor);
// => [1.1, 2.3]

_.tail(array)

原始碼 npm 套件

取得 array 中除了第一個元素以外的所有元素。

自

4.0.0

參數

1. array (陣列)：要查詢的陣列。

傳回

(陣列)：傳回 array 的切片。

範例

_.tail([1, 2, 3]);
// => [2, 3]

_.take(array, [n=1])

原始碼 npm 套件

建立一個 array 切片，其中包含從開頭取出的 n 個元素。

自

0.1.0

參數

1. array (陣列)：要查詢的陣列。
2. [n=1] (數字): 要取出的元素數量。

傳回

(陣列)：傳回 array 的切片。

範例

_.take([1, 2, 3]);
// => [1]
 
_.take([1, 2, 3], 2);
// => [1, 2]
 
_.take([1, 2, 3], 5);
// => [1, 2, 3]
 
_.take([1, 2, 3], 0);
// => []

_.takeRight(array, [n=1])

原始碼 npm 套件

建立一個 array 切片，其中包含從結尾取出的 n 個元素。

自

3.0.0

參數

1. array (陣列)：要查詢的陣列。
2. [n=1] (數字): 要取出的元素數量。

傳回

(陣列)：傳回 array 的切片。

範例

_.takeRight([1, 2, 3]);
// => [3]
 
_.takeRight([1, 2, 3], 2);
// => [2, 3]
 
_.takeRight([1, 2, 3], 5);
// => [1, 2, 3]
 
_.takeRight([1, 2, 3], 0);
// => []

_.takeRightWhile(array, [predicate=_.identity])

原始碼 npm 套件

建立一個 array 切片，其中包含從結尾取出的元素。元素會持續取出，直到 predicate 傳回假值為止。此謂詞會呼叫三個參數：(value, index, array)。

自

3.0.0

參數

1. array (陣列)：要查詢的陣列。
2. [predicate=_.identity] (函式)：每個反覆呼叫的函式。

傳回

(陣列)：傳回 array 的切片。

範例

var users = [
  { 'user': 'barney',  'active': true },
  { 'user': 'fred',    'active': false },
  { 'user': 'pebbles', 'active': false }
];
 
_.takeRightWhile(users, function(o) { return !o.active; });
// => objects for ['fred', 'pebbles']
 
// The `_.matches` iteratee shorthand.
_.takeRightWhile(users, { 'user': 'pebbles', 'active': false });
// => objects for ['pebbles']
 
// The `_.matchesProperty` iteratee shorthand.
_.takeRightWhile(users, ['active', false]);
// => objects for ['fred', 'pebbles']
 
// The `_.property` iteratee shorthand.
_.takeRightWhile(users, 'active');
// => []

_.takeWhile(array, [predicate=_.identity])

原始碼 npm 套件

建立一個 array 的切片，包含從開頭取出的元素。元素會持續取出，直到 predicate 傳回假值為止。此謂詞會使用三個參數呼叫：(value, index, array)。

自

3.0.0

參數

1. array (陣列)：要查詢的陣列。
2. [predicate=_.identity] (函式)：每個反覆呼叫的函式。

傳回

(陣列)：傳回 array 的切片。

範例

var users = [
  { 'user': 'barney',  'active': false },
  { 'user': 'fred',    'active': false },
  { 'user': 'pebbles', 'active': true }
];
 
_.takeWhile(users, function(o) { return !o.active; });
// => objects for ['barney', 'fred']
 
// The `_.matches` iteratee shorthand.
_.takeWhile(users, { 'user': 'barney', 'active': false });
// => objects for ['barney']
 
// The `_.matchesProperty` iteratee shorthand.
_.takeWhile(users, ['active', false]);
// => objects for ['barney', 'fred']
 
// The `_.property` iteratee shorthand.
_.takeWhile(users, 'active');
// => []

_.union([arrays])

原始碼 npm 套件

建立一個由所有給定陣列中唯一值的順序陣列，使用 SameValueZero 進行相等性比較。

自

0.1.0

參數

1. [陣列] (...陣列)：要檢查的陣列。

傳回

(Array)：傳回已結合值的陣列。

範例

_.union([2], [1, 2]);
// => [2, 1]

_.unionBy([arrays], [iteratee=_.identity])

原始碼 npm 套件

此方法類似於 _.union，但它接受 iteratee，會針對每個 arrays 的元素呼叫此函式，以產生用於計算唯一性的準則。結果值會從值出現的第一個陣列中選取。此謂詞會使用一個參數呼叫
(value).

自

4.0.0

參數

1. [陣列] (...陣列)：要檢查的陣列。
2. [iteratee=_.identity] (函式)：每個元素呼叫的 iteratee。

傳回

(Array)：傳回已結合值的陣列。

範例

_.unionBy([2.1], [1.2, 2.3], Math.floor);
// => [2.1, 1.2]
 
// The `_.property` iteratee shorthand.
_.unionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');
// => [{ 'x': 1 }, { 'x': 2 }]

_.unionWith([arrays], [comparator])

原始碼 npm 套件

此方法類似於 _.union，但它接受 comparator，會呼叫此函式來比較 arrays 的元素。結果值會從值出現的第一個陣列中選取。此比較器會使用兩個參數呼叫：(arrVal, othVal)。

自

4.0.0

參數

1. [陣列] (...陣列)：要檢查的陣列。
2. [comparator] (函式)：每個元素呼叫的 comparator。

傳回

(Array)：傳回已結合值的陣列。

範例

var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];
var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }];
 
_.unionWith(objects, others, _.isEqual);
// => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 1 }]

_.uniq(array)

原始碼 npm 套件

建立一個陣列的重複值移除版本，使用 SameValueZero 進行相等性比較，其中只保留每個元素的第一個出現。結果值的順序由它們在陣列中出現的順序決定。

自

0.1.0

參數

1. 陣列 (陣列)：要檢查的陣列。

傳回

(陣列)：傳回新的不重複陣列。

範例

_.uniq([2, 1, 2]);
// => [2, 1]

_.uniqBy(array, [iteratee=_.identity])

原始碼 npm 套件

此方法類似於 _.uniq，但它接受 iteratee，該 iteratee 會對 array 中的每個元素呼叫，以產生計算唯一性的準則。結果值的順序由它們在陣列中出現的順序決定。iteratee 會使用一個引數呼叫
(value).

自

4.0.0

參數

1. 陣列 (陣列)：要檢查的陣列。
2. [iteratee=_.identity] (函式)：每個元素呼叫的 iteratee。

傳回

(陣列)：傳回新的不重複陣列。

範例

_.uniqBy([2.1, 1.2, 2.3], Math.floor);
// => [2.1, 1.2]
 
// The `_.property` iteratee shorthand.
_.uniqBy([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }], 'x');
// => [{ 'x': 1 }, { 'x': 2 }]

_.uniqWith(array, [comparator])

原始碼 npm 套件

此方法類似於 _.uniq，但它接受 comparator，該 comparator 會呼叫來比較 array 的元素。結果值的順序由它們在陣列中出現的順序決定。比較器會使用兩個引數呼叫：(arrVal, othVal)。

自

4.0.0

參數

1. 陣列 (陣列)：要檢查的陣列。
2. [comparator] (函式)：每個元素呼叫的 comparator。

傳回

(陣列)：傳回新的不重複陣列。

範例

var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 2 }];
 
_.uniqWith(objects, _.isEqual);
// => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]

_.unzip(array)

原始碼 npm 套件

此方法類似於 _.zip，但它接受群組元素的陣列，並建立一個將元素重新群組為其壓縮前設定的陣列。

自

1.2.0

參數

1. array (陣列)：要處理的群組元素陣列。

傳回

(陣列)：傳回重新群組元素的新陣列。

範例

var zipped = _.zip(['a', 'b'], [1, 2], [true, false]);
// => [['a', 1, true], ['b', 2, false]]
 
_.unzip(zipped);
// => [['a', 'b'], [1, 2], [true, false]]

_.unzipWith(array, [iteratee=_.identity])

原始碼 npm 套件

此方法類似於 _.unzip，但它接受 iteratee 來指定應如何合併重新群組的值。iteratee 會呼叫每個群組的元素：(...group)。

自

3.8.0

參數

1. array (陣列)：要處理的群組元素陣列。
2. [iteratee=_.identity] (函式)：用來合併重新群組值的函式。

傳回

(陣列)：傳回重新群組元素的新陣列。

範例

var zipped = _.zip([1, 2], [10, 20], [100, 200]);
// => [[1, 10, 100], [2, 20, 200]]
 
_.unzipWith(zipped, _.add);
// => [3, 30, 300]

_.without(array, [values])

原始碼 npm 套件

使用 SameValueZero 進行相等比較，建立一個排除所有給定值的陣列。

注意：與 _.pull 不同，此方法會傳回一個新陣列。

自

0.1.0

參數

1. 陣列 (陣列)：要檢查的陣列。
2. [values] (...*)：要排除的值。

傳回

(陣列): 傳回過濾後的新陣列。

範例

_.without([2, 1, 2, 3], 1, 2);
// => [3]

_.xor([arrays])

原始碼 npm 套件

建立一個唯一值的陣列，這是給定陣列的對稱差集。結果值順序由它們在陣列中出現的順序決定。

自

2.4.0

參數

1. [陣列] (...陣列)：要檢查的陣列。

傳回

(陣列): 傳回過濾後的新陣列。

範例

_.xor([2, 1], [2, 3]);
// => [1, 3]

_.xorBy([arrays], [iteratee=_.identity])

來源 npm 套件

此方法類似於 _.xor，但它接受 `iteratee`，它會針對每個 `arrays` 的每個元素呼叫，以產生用於比較它們的準則。結果值順序由它們在陣列中出現的順序決定。iteratee 會使用一個參數呼叫：(value)。

自

4.0.0

參數

1. [陣列] (...陣列)：要檢查的陣列。
2. [iteratee=_.identity] (函式)：每個元素呼叫的 iteratee。

傳回

(陣列): 傳回過濾後的新陣列。

範例

_.xorBy([2.1, 1.2], [2.3, 3.4], Math.floor);
// => [1.2, 3.4]
 
// The `_.property` iteratee shorthand.
_.xorBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');
// => [{ 'x': 2 }]

_.xorWith([arrays], [comparator])

來源 npm 套件

此方法類似於 _.xor，但它接受 `comparator`，它會呼叫來比較 `arrays` 的元素。結果值順序由它們在陣列中出現的順序決定。comparator 會使用兩個參數呼叫：(arrVal, othVal)。

自

4.0.0

參數

1. [陣列] (...陣列)：要檢查的陣列。
2. [comparator] (函式)：每個元素呼叫的 comparator。

傳回

(陣列): 傳回過濾後的新陣列。

範例

var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];
var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }];
 
_.xorWith(objects, others, _.isEqual);
// => [{ 'x': 2, 'y': 1 }, { 'x': 1, 'y': 1 }]

_.zip([arrays])

來源 npm 套件

建立一個群組元素的陣列，第一個包含給定陣列的第一個元素，第二個包含給定陣列的第二個元素，以此類推。

自

0.1.0

參數

1. [arrays] (...Array)：要處理的陣列。

傳回

(Array)：傳回群組元素的新陣列。

範例

_.zip(['a', 'b'], [1, 2], [true, false]);
// => [['a', 1, true], ['b', 2, false]]

_.zipObject([props=[]], [values=[]])

原始碼 npm 套件

此方法類似於 _.fromPairs，但它接受兩個陣列，一個是屬性識別碼，另一個是對應的值。

自

0.4.0

參數

1. [props=[]] (陣列): 屬性識別碼。
2. [values=[]] (陣列): 屬性值。

傳回

(物件)：傳回新的物件。

範例

_.zipObject(['a', 'b'], [1, 2]);
// => { 'a': 1, 'b': 2 }

_.zipObjectDeep([props=[]], [values=[]])

原始碼 npm 套件

此方法類似於 _.zipObject，但它支援屬性路徑。

自

4.1.0

參數

1. [props=[]] (陣列): 屬性識別碼。
2. [values=[]] (陣列): 屬性值。

傳回

(物件)：傳回新的物件。

範例

_.zipObjectDeep(['a.b[0].c', 'a.b[1].d'], [1, 2]);
// => { 'a': { 'b': [{ 'c': 1 }, { 'd': 2 }] } }

_.zipWith([arrays], [iteratee=_.identity])

原始碼 npm 套件

此方法類似於 _.zip，但它接受 iteratee 來指定如何合併分組值。iteratee 會呼叫每個分組的元素：(...group)。

自

3.8.0

參數

1. [arrays] (...Array)：要處理的陣列。
2. [iteratee=_.identity] (函式): 合併分組值的函式。

傳回

(Array)：傳回群組元素的新陣列。

範例

_.zipWith([1, 2], [10, 20], [100, 200], function(a, b, c) {
  return a + b + c;
});
// => [111, 222]

_.countBy(collection, [iteratee=_.identity])

原始碼 npm 套件

建立一個物件，其金鑰是由執行 collection 中每個元素的 iteratee 結果產生的。每個金鑰的對應值是 iteratee 傳回金鑰的次數。iteratee 會呼叫一個引數：(value)。

自

0.5.0

參數

1. collection (陣列|物件)：要迭代的集合。
2. [iteratee=_.identity] (函式)：轉換金鑰的迭代器。

傳回

(物件)：傳回組成的聚合物件。

範例

_.countBy([6.1, 4.2, 6.3], Math.floor);
// => { '4': 1, '6': 2 }
 
// The `_.property` iteratee shorthand.
_.countBy(['one', 'two', 'three'], 'length');
// => { '3': 2, '5': 1 }

_.every(collection, [predicate=_.identity])

原始碼 npm 套件

檢查 predicate 是否對 collection 的所有元素傳回真值。一旦 predicate 傳回假值，就會停止迭代。此謂詞會以三個參數呼叫：(value, index|key, collection)。

注意：此方法會對空集合傳回 true，因為空集合的元素一切都為真。

自

0.1.0

參數

1. collection (陣列|物件)：要迭代的集合。
2. [predicate=_.identity] (函式)：每個反覆呼叫的函式。

傳回

(布林值)：如果所有元素都通過謂詞檢查，則傳回 true，否則傳回 false。

範例

_.every([true, 1, null, 'yes'], Boolean);
// => false
 
var users = [
  { 'user': 'barney', 'age': 36, 'active': false },
  { 'user': 'fred',   'age': 40, 'active': false }
];
 
// The `_.matches` iteratee shorthand.
_.every(users, { 'user': 'barney', 'active': false });
// => false
 
// The `_.matchesProperty` iteratee shorthand.
_.every(users, ['active', false]);
// => true
 
// The `_.property` iteratee shorthand.
_.every(users, 'active');
// => false

_.filter(collection, [predicate=_.identity])

原始碼 npm 套件

迭代 collection 的元素，傳回一個陣列，其中包含 predicate 傳回真值的元素。此謂詞會以三個參數呼叫：(value, index|key, collection)。

注意：與 _.remove 不同，此方法會傳回一個新的陣列。

自

0.1.0

參數

1. collection (陣列|物件)：要迭代的集合。
2. [predicate=_.identity] (函式)：每個反覆呼叫的函式。

傳回

(陣列)：傳回新的過濾陣列。

範例

var users = [
  { 'user': 'barney', 'age': 36, 'active': true },
  { 'user': 'fred',   'age': 40, 'active': false }
];
 
_.filter(users, function(o) { return !o.active; });
// => objects for ['fred']
 
// The `_.matches` iteratee shorthand.
_.filter(users, { 'age': 36, 'active': true });
// => objects for ['barney']
 
// The `_.matchesProperty` iteratee shorthand.
_.filter(users, ['active', false]);
// => objects for ['fred']
 
// The `_.property` iteratee shorthand.
_.filter(users, 'active');
// => objects for ['barney']

_.find(collection, [predicate=_.identity], [fromIndex=0])

原始碼 npm 套件

遍歷 collection 的元素，傳回第一個 predicate 傳回真值的元素。此謂詞會使用三個參數呼叫：(值、索引或金鑰、collection)。

自

0.1.0

參數

1. collection (陣列或物件)：要檢查的 collection。
2. [predicate=_.identity] (函式)：每個反覆呼叫的函式。
3. [fromIndex=0] (數字)：開始搜尋的索引。

傳回

(*)：傳回配對的元素，否則傳回 undefined。

範例

var users = [
  { 'user': 'barney',  'age': 36, 'active': true },
  { 'user': 'fred',    'age': 40, 'active': false },
  { 'user': 'pebbles', 'age': 1,  'active': true }
];
 
_.find(users, function(o) { return o.age < 40; });
// => object for 'barney'
 
// The `_.matches` iteratee shorthand.
_.find(users, { 'age': 1, 'active': true });
// => object for 'pebbles'
 
// The `_.matchesProperty` iteratee shorthand.
_.find(users, ['active', false]);
// => object for 'fred'
 
// The `_.property` iteratee shorthand.
_.find(users, 'active');
// => object for 'barney'

_.findLast(collection, [predicate=_.identity], [fromIndex=collection.length-1])

原始碼 npm 套件

此方法類似 _.find，但會從右到左遍歷 collection 的元素。

自

2.0.0

參數

1. collection (陣列或物件)：要檢查的 collection。
2. [predicate=_.identity] (函式)：每個反覆呼叫的函式。
3. [fromIndex=collection.length-1] (數字)：要開始搜尋的索引。

傳回

(*)：傳回配對的元素，否則傳回 undefined。

範例

_.findLast([1, 2, 3, 4], function(n) {
  return n % 2 == 1;
});
// => 3

_.flatMap(collection, [iteratee=_.identity])

原始碼 npm 套件

透過對 collection 中的每個元素執行 iteratee，並壓平對應的結果，建立一個壓平的陣列。此謂詞會使用三個參數呼叫：(值、索引或金鑰、collection)。

自

4.0.0

參數

1. collection (陣列|物件)：要迭代的集合。
2. [iteratee=_.identity] (函式)：每次反覆運算呼叫的函式。

傳回

(陣列)：傳回新的扁平陣列。

範例

function duplicate(n) {
  return [n, n];
}
 
_.flatMap([1, 2], duplicate);
// => [1, 1, 2, 2]

_.flatMapDeep(collection, [iteratee=_.identity])

原始碼 npm 套件

此方法類似於 _.flatMap，但會遞迴扁平化對應的結果。

自

4.7.0

參數

1. collection (陣列|物件)：要迭代的集合。
2. [iteratee=_.identity] (函式)：每次反覆運算呼叫的函式。

傳回

(陣列)：傳回新的扁平陣列。

範例

function duplicate(n) {
  return [[[n, n]]];
}
 
_.flatMapDeep([1, 2], duplicate);
// => [1, 1, 2, 2]

_.flatMapDepth(collection, [iteratee=_.identity], [depth=1])

原始碼 npm 套件

此方法類似於 _.flatMap，但會遞迴扁平化對應的結果，最多到 depth 次。

自

4.7.0

參數

1. collection (陣列|物件)：要迭代的集合。
2. [iteratee=_.identity] (函式)：每次反覆運算呼叫的函式。
3. [depth=1] (數字)：最大遞迴深度。

傳回

(陣列)：傳回新的扁平陣列。

範例

function duplicate(n) {
  return [[[n, n]]];
}
 
_.flatMapDepth([1, 2], duplicate, 2);
// => [[1, 1], [2, 2]]

_.forEach(collection, [iteratee=_.identity])

原始碼 npm 套件

遍歷 collection 的元素，並對每個元素呼叫 iteratee。iteratee 會呼叫三個參數：(value, index|key, collection)。iteratee 函式可以透過明確傳回 false 來提早結束遍歷。

注意：與其他「集合」方法一樣，具有「length」屬性的物件會像陣列一樣遍歷。若要避免這種行為，請使用 _.forIn 或 _.forOwn 來遍歷物件。

自

0.1.0

別名

_.each

參數

1. collection (陣列|物件)：要迭代的集合。
2. [iteratee=_.identity] (函式)：每次反覆運算呼叫的函式。

傳回

(*)：傳回 collection。

範例

_.forEach([1, 2], function(value) {
  console.log(value);
});
// => Logs `1` then `2`.
 
_.forEach({ 'a': 1, 'b': 2 }, function(value, key) {
  console.log(key);
});
// => Logs 'a' then 'b' (iteration order is not guaranteed).

_.forEachRight(collection, [iteratee=_.identity])

原始碼 npm 套件

這個方法類似 _.forEach，但會從右到左遍歷 `collection` 的元素。

自

2.0.0

別名

_.eachRight

參數

1. collection (陣列|物件)：要迭代的集合。
2. [iteratee=_.identity] (函式)：每次反覆運算呼叫的函式。

傳回

(*)：傳回 collection。

範例

_.forEachRight([1, 2], function(value) {
  console.log(value);
});
// => Logs `2` then `1`.

_.groupBy(collection, [iteratee=_.identity])

原始碼 npm 套件

建立一個物件，其金鑰是由執行 `collection` 中每個元素的 `iteratee` 結果產生的。已分組值的順序由它們在 `collection` 中出現的順序決定。每個金鑰對應的值是一個負責產生該金鑰的元素陣列。iteratee 會呼叫一個參數：(value)。

自

0.1.0

參數

1. collection (陣列|物件)：要迭代的集合。
2. [iteratee=_.identity] (函式)：轉換金鑰的迭代器。

傳回

(物件)：傳回組成的聚合物件。

範例

_.groupBy([6.1, 4.2, 6.3], Math.floor);
// => { '4': [4.2], '6': [6.1, 6.3] }
 
// The `_.property` iteratee shorthand.
_.groupBy(['one', 'two', 'three'], 'length');
// => { '3': ['one', 'two'], '5': ['three'] }

_.includes(collection, value, [fromIndex=0])

原始碼 npm 套件

檢查 `value` 是否在 `collection` 中。如果 `collection` 是字串，會檢查 `value` 是否是其子字串，否則會使用 SameValueZero 進行相等比較。如果 `fromIndex` 為負值，會用作從 `collection` 結尾的偏移量。

自

0.1.0

參數

1. collection (Array|Object|string)：要檢查的集合。
2. 值 (*)：要搜尋的值。
3. [fromIndex=0] (數字)：開始搜尋的索引。

傳回

(布林值)：如果找到 value，則傳回 true，否則傳回 false。

範例

_.includes([1, 2, 3], 1);
// => true
 
_.includes([1, 2, 3], 1, 2);
// => false
 
_.includes({ 'a': 1, 'b': 2 }, 1);
// => true
 
_.includes('abcd', 'bc');
// => true

_.invokeMap(collection, path, [args])

原始碼 npm 套件

呼叫 collection 中每個元素的 path 方法，傳回呼叫每個方法的結果陣列。任何其他引數都會提供給每個呼叫的方法。如果 path 是函式，則會針對 collection 中的每個元素呼叫該函式，並將 this 繫結到該元素。

自

4.0.0

參數

1. collection (陣列|物件)：要迭代的集合。
2. path (陣列|函式|字串)：要呼叫的方法路徑，或每個反覆運算呼叫的函式。
3. [args] (...*)：呼叫每個方法的引數。

傳回

(陣列)：傳回結果陣列。

範例

_.invokeMap([[5, 1, 7], [3, 2, 1]], 'sort');
// => [[1, 5, 7], [1, 2, 3]]
 
_.invokeMap([123, 456], String.prototype.split, '');
// => [['1', '2', '3'], ['4', '5', '6']]

_.keyBy(collection, [iteratee=_.identity])

原始碼 npm 套件

建立一個物件，其金鑰是由執行 collection 中每個元素的 iteratee 結果產生的。每個金鑰對應的值是產生該金鑰的最後一個元素。iteratee 會呼叫一個引數：(value)。

自

4.0.0

參數

1. collection (陣列|物件)：要迭代的集合。
2. [iteratee=_.identity] (函式)：轉換金鑰的迭代器。

傳回

(物件)：傳回組成的聚合物件。

範例

var array = [
  { 'dir': 'left', 'code': 97 },
  { 'dir': 'right', 'code': 100 }
];
 
_.keyBy(array, function(o) {
  return String.fromCharCode(o.code);
});
// => { 'a': { 'dir': 'left', 'code': 97 }, 'd': { 'dir': 'right', 'code': 100 } }
 
_.keyBy(array, 'dir');
// => { 'left': { 'dir': 'left', 'code': 97 }, 'right': { 'dir': 'right', 'code': 100 } }

_.map(collection, [iteratee=_.identity])

原始碼 npm 套件

建立一個值陣列，方法是執行 collection 中的每個元素的 iteratee。iteratee 會呼叫三個引數
(值, 索引|金鑰, 集合).

許多 lodash 方法受到保護，可作為 _.every、_.filter、_.map、_.mapValues、_.reject 和 _.some 等方法的迭代函數。

受到保護的方法為
ary、chunk、curry、curryRight、drop、dropRight、every、fill、invert、parseInt、random、range、rangeRight、repeat、sampleSize、slice、some、sortBy、split、take、takeRight、template、trim、trimEnd、trimStart 和 words

自

0.1.0

參數

1. collection (陣列|物件)：要迭代的集合。
2. [iteratee=_.identity] (函式)：每次反覆運算呼叫的函式。

傳回

(陣列)：傳回新的對應陣列。

範例

function square(n) {
  return n * n;
}
 
_.map([4, 8], square);
// => [16, 64]
 
_.map({ 'a': 4, 'b': 8 }, square);
// => [16, 64] (iteration order is not guaranteed)
 
var users = [
  { 'user': 'barney' },
  { 'user': 'fred' }
];
 
// The `_.property` iteratee shorthand.
_.map(users, 'user');
// => ['barney', 'fred']

_.orderBy(collection, [iteratees=[_.identity]], [orders])

原始碼 npm 套件

此方法類似於 _.sortBy，但允許指定用於排序的迭代函數的排序順序。如果未指定 orders，所有值都按遞增順序排序。否則，請指定「desc」順序，表示對應值的遞減排序，或指定「asc」順序，表示對應值的遞增排序。

自

4.0.0

參數

1. collection (陣列|物件)：要迭代的集合。
2. [iteratees=[_.identity]] (Array[]|Function[]|Object[]|string[])：用於排序的迭代函數。
3. [orders] (字串陣列)：iteratees 的排序順序。

傳回

(陣列)：傳回新的已排序陣列。

範例

var users = [
  { 'user': 'fred',   'age': 48 },
  { 'user': 'barney', 'age': 34 },
  { 'user': 'fred',   'age': 40 },
  { 'user': 'barney', 'age': 36 }
];
 
// Sort by `user` in ascending order and by `age` in descending order.
_.orderBy(users, ['user', 'age'], ['asc', 'desc']);
// => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 40]]

_.partition(collection, [predicate=_.identity])

原始碼 npm 套件

建立一個元素陣列，分成兩組，第一組包含 predicate 傳回真值的元素，第二組包含 predicate 傳回假值的元素。此謂詞會呼叫一個參數：(value)。

自

3.0.0

參數

1. collection (陣列|物件)：要迭代的集合。
2. [predicate=_.identity] (函式)：每個反覆呼叫的函式。

傳回

(陣列)：傳回已分組元素的陣列。

範例

var users = [
  { 'user': 'barney',  'age': 36, 'active': false },
  { 'user': 'fred',    'age': 40, 'active': true },
  { 'user': 'pebbles', 'age': 1,  'active': false }
];
 
_.partition(users, function(o) { return o.active; });
// => objects for [['fred'], ['barney', 'pebbles']]
 
// The `_.matches` iteratee shorthand.
_.partition(users, { 'age': 1, 'active': false });
// => objects for [['pebbles'], ['barney', 'fred']]
 
// The `_.matchesProperty` iteratee shorthand.
_.partition(users, ['active', false]);
// => objects for [['barney', 'pebbles'], ['fred']]
 
// The `_.property` iteratee shorthand.
_.partition(users, 'active');
// => objects for [['fred'], ['barney', 'pebbles']]

_.reduce(collection, [iteratee=_.identity], [accumulator])

原始碼 npm 套件

將 collection 縮減為一個值，此值是執行 collection 中每個元素透過 iteratee 的累積結果，其中每個後續呼叫都會提供前一個的傳回值。如果未提供 accumulator，則 collection 的第一個元素會用作初始值。呼叫 iteratee 時會提供四個參數
(accumulator, value, index|key, collection).

許多 lodash 方法都受到保護，可用作 _.reduce、_.reduceRight 和 _.transform 等方法的 iteratee。

受到保護的方法為
assign、defaults、defaultsDeep、includes、merge、orderBy 和 sortBy

自

0.1.0

參數

1. collection (陣列|物件)：要迭代的集合。
2. [iteratee=_.identity] (函式)：每次反覆運算呼叫的函式。
3. [accumulator] (*)：初始值。

傳回

(*)：傳回累積值。

範例

_.reduce([1, 2], function(sum, n) {
  return sum + n;
}, 0);
// => 3
 
_.reduce({ 'a': 1, 'b': 2, 'c': 1 }, function(result, value, key) {
  (result[value] || (result[value] = [])).push(key);
  return result;
}, {});
// => { '1': ['a', 'c'], '2': ['b'] } (iteration order is not guaranteed)

_.reduceRight(collection, [iteratee=_.identity], [accumulator])

原始碼 npm 套件

此方法類似於 _.reduce，但從右到左迭代 collection 的元素。

自

0.1.0

參數

1. collection (陣列|物件)：要迭代的集合。
2. [iteratee=_.identity] (函式)：每次反覆運算呼叫的函式。
3. [accumulator] (*)：初始值。

傳回

(*)：傳回累積值。

範例

var array = [[0, 1], [2, 3], [4, 5]];
 
_.reduceRight(array, function(flattened, other) {
  return flattened.concat(other);
}, []);
// => [4, 5, 2, 3, 0, 1]

_.reject(collection, [predicate=_.identity])

原始碼 npm 套件

與 _.filter 相反；此方法傳回 collection 中 predicate 不傳回真值的元素。

自

0.1.0

參數

1. collection (陣列|物件)：要迭代的集合。
2. [predicate=_.identity] (函式)：每個反覆呼叫的函式。

傳回

(陣列)：傳回新的過濾陣列。

範例

var users = [
  { 'user': 'barney', 'age': 36, 'active': false },
  { 'user': 'fred',   'age': 40, 'active': true }
];
 
_.reject(users, function(o) { return !o.active; });
// => objects for ['fred']
 
// The `_.matches` iteratee shorthand.
_.reject(users, { 'age': 40, 'active': true });
// => objects for ['barney']
 
// The `_.matchesProperty` iteratee shorthand.
_.reject(users, ['active', false]);
// => objects for ['fred']
 
// The `_.property` iteratee shorthand.
_.reject(users, 'active');
// => objects for ['barney']

_.sample(collection)

原始碼 npm 套件

從 collection 中取得一個隨機元素。

自

2.0.0

參數

1. collection (Array|Object)：要取樣的集合。

傳回

(*)：傳回隨機元素。

範例

_.sample([1, 2, 3, 4]);
// => 2

_.sampleSize(collection, [n=1])

原始碼 npm 套件

從 collection 中取得 n 個隨機元素，其鍵值唯一，最多到 collection 的大小。

自

4.0.0

參數

1. collection (Array|Object)：要取樣的集合。
2. [n=1] (number)：要取樣的元素數量。

傳回

(Array)：傳回隨機元素。

範例

_.sampleSize([1, 2, 3], 2);
// => [3, 1]
 
_.sampleSize([1, 2, 3], 4);
// => [2, 3, 1]

_.shuffle(collection)

原始碼 npm 套件

使用 費雪-耶茲洗牌法 的版本，建立一個洗牌後的數值陣列。

自

0.1.0

參數

1. collection (陣列|物件): 要洗牌的集合。

傳回

(陣列): 傳回新的洗牌陣列。

範例

_.shuffle([1, 2, 3, 4]);
// => [4, 1, 3, 2]

_.size(collection)

原始碼 npm 套件

取得 collection 的大小，對於類陣列的值傳回其長度，或對於物件傳回可列舉的字串鍵值屬性的數量。

自

0.1.0

參數

1. collection (Array|Object|string)：要檢查的集合。

傳回

(數字): 傳回集合的大小。

範例

_.size([1, 2, 3]);
// => 3
 
_.size({ 'a': 1, 'b': 2 });
// => 2
 
_.size('pebbles');
// => 7

_.some(collection, [predicate=_.identity])

原始碼 npm 套件

檢查 predicate 是否對 collection 的任何元素傳回真值。一旦 predicate 傳回真值，就會停止反覆運算。此謂詞會以三個參數呼叫：(value, index|key, collection)。

自

0.1.0

參數

1. collection (陣列|物件)：要迭代的集合。
2. [predicate=_.identity] (函式)：每個反覆呼叫的函式。

傳回

(布林值): 如果任何元素通過謂詞檢查，則傳回 true，否則傳回 false。

範例

_.some([null, 0, 'yes', false], Boolean);
// => true
 
var users = [
  { 'user': 'barney', 'active': true },
  { 'user': 'fred',   'active': false }
];
 
// The `_.matches` iteratee shorthand.
_.some(users, { 'user': 'barney', 'active': false });
// => false
 
// The `_.matchesProperty` iteratee shorthand.
_.some(users, ['active', false]);
// => true
 
// The `_.property` iteratee shorthand.
_.some(users, 'active');
// => true

_.sortBy(collection, [iteratees=[_.identity]])

原始碼 npm 套件

建立一個陣列，依據執行每個集合元素的每個迭代函式結果，以遞增順序排序。此方法執行穩定排序，也就是說，它會保留相等元素的原始排序順序。迭代函式會呼叫一個參數：(值)。

自

0.1.0

參數

1. collection (陣列|物件)：要迭代的集合。
2. [iteratees=[_.identity]] (...(Function|Function[]))：用來排序的迭代函式。

傳回

(陣列)：傳回新的已排序陣列。

範例

var users = [
  { 'user': 'fred',   'age': 48 },
  { 'user': 'barney', 'age': 36 },
  { 'user': 'fred',   'age': 40 },
  { 'user': 'barney', 'age': 34 }
];
 
_.sortBy(users, [function(o) { return o.user; }]);
// => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 40]]
 
_.sortBy(users, ['user', 'age']);
// => objects for [['barney', 34], ['barney', 36], ['fred', 40], ['fred', 48]]

_.now()

原始碼 npm 套件

取得自 Unix 紀元（1970 年 1 月 1 日 00:00:00 UTC）以來已經過的毫秒數時間戳記。

自

2.4.0

傳回

(數字)：傳回時間戳記。

範例

_.defer(function(stamp) {
  console.log(_.now() - stamp);
}, _.now());
// => Logs the number of milliseconds it took for the deferred invocation.

_.after(n, func)

原始碼 npm 套件

_.before 的反向操作；此方法會建立一個函式，在被呼叫 n 次或更多次後，才會呼叫 func。

自

0.1.0

參數

1. n (數字)：呼叫 func 之前的呼叫次數。
2. func (函式)：要限制的函式。

傳回

(函式)：傳回新的受限制函式。

範例

var saves = ['profile', 'settings'];
 
var done = _.after(saves.length, function() {
  console.log('done saving!');
});
 
_.forEach(saves, function(type) {
  asyncSave({ 'type': type, 'complete': done });
});
// => Logs 'done saving!' after the two async saves have completed.

_.ary(func, [n=func.length])

原始碼 npm 套件

建立一個函式，呼叫 func，最多有 n 個參數，忽略任何其他參數。

自

3.0.0

參數

1. func (函式): 要限制參數的函式。
2. [n=func.length] (數字): 參數上限。

傳回

(函式): 傳回新的限制函式。

範例

_.map(['6', '8', '10'], _.ary(parseInt, 1));
// => [6, 8, 10]

_.before(n, func)

原始碼 npm 套件

建立一個函式，呼叫 func，使用建立函式的 this 繫結和參數，同時呼叫次數少於 n 次。後續呼叫建立的函式會傳回最後一次 func 呼叫的結果。

自

3.0.0

參數

1. n (數字): 不再呼叫 func 的呼叫次數。
2. func (函式)：要限制的函式。

傳回

(函式)：傳回新的受限制函式。

範例

jQuery(element).on('click', _.before(5, addContactToList));
// => Allows adding up to 4 contacts to the list.

_.bind(func, thisArg, [partials])

原始碼 npm 套件

建立一個函式，呼叫 func，使用 thisArg 的 this 繫結，並將 partials 預先加到它接收到的參數。

_.bind.placeholder 值，在單一建置中預設為 _，可用作部分套用參數的佔位符。

注意：與原生 Function#bind 不同，此方法不會設定繫結函式的「長度」屬性。

自

0.1.0

參數

1. func (函數)：要綁定的函數。
2. thisArg (*)：func 的 this 繫結。
3. [partials] (...*)：要部分套用的參數。

傳回

(函數)：傳回新的繫結函數。

範例

function greet(greeting, punctuation) {
  return greeting + ' ' + this.user + punctuation;
}
 
var object = { 'user': 'fred' };
 
var bound = _.bind(greet, object, 'hi');
bound('!');
// => 'hi fred!'
 
// Bound with placeholders.
var bound = _.bind(greet, object, _, '!');
bound('hi');
// => 'hi fred!'

_.bindKey(object, key, [partials])

來源 npm 套件

建立一個函數，它會呼叫 object[key] 的方法，並將 partials 預先加入它所接收的參數中。

此方法與 _.bind 的不同之處，在於它允許繫結函數參照可能會重新定義或尚未存在的方法。請參閱 Peter Michaux 的文章 以取得更多詳細資料。

_.bindKey.placeholder 值，在單體建置中預設為 _，可以用作部分套用參數的佔位符。

自

0.10.0

參數

1. object (物件)：要呼叫方法的物件。
2. key (字串)：方法的鍵。
3. [partials] (...*)：要部分套用的參數。

傳回

(函數)：傳回新的繫結函數。

範例

var object = {
  'user': 'fred',
  'greet': function(greeting, punctuation) {
    return greeting + ' ' + this.user + punctuation;
  }
};
 
var bound = _.bindKey(object, 'greet', 'hi');
bound('!');
// => 'hi fred!'
 
object.greet = function(greeting, punctuation) {
  return greeting + 'ya ' + this.user + punctuation;
};
 
bound('!');
// => 'hiya fred!'
 
// Bound with placeholders.
var bound = _.bindKey(object, 'greet', _, '!');
bound('hi');
// => 'hiya fred!'

_.curry(func, [arity=func.length])

來源 npm 套件

建立一個函數，它接受 func 的參數，並呼叫 func 傳回其結果，如果已提供至少 arity 個參數，或傳回一個函數，它接受 func 的剩餘參數，依此類推。如果 func.length 不足夠，則可以指定 func 的 arity。

_.curry.placeholder 值，在單一建置中預設為 _，可用作已提供引數的佔位符。

注意：此方法不會設定已封裝函式的「長度」屬性。

自

2.0.0

參數

1. func (函式)：要封裝的函式。
2. [arity=func.length] (數字)：func 的 arity。

傳回

(函式)：傳回新的已封裝函式。

範例

var abc = function(a, b, c) {
  return [a, b, c];
};
 
var curried = _.curry(abc);
 
curried(1)(2)(3);
// => [1, 2, 3]
 
curried(1, 2)(3);
// => [1, 2, 3]
 
curried(1, 2, 3);
// => [1, 2, 3]
 
// Curried with placeholders.
curried(1)(_, 3)(2);
// => [1, 3, 2]

_.curryRight(func, [arity=func.length])

來源 npm 套件

此方法類似於 _.curry，但引數會以 _.partialRight 的方式套用至 func，而非 _.partial。

_.curryRight.placeholder 值，在單一建置中預設為 _，可用作已提供引數的佔位符。

注意：此方法不會設定已封裝函式的「長度」屬性。

自

3.0.0

參數

1. func (函式)：要封裝的函式。
2. [arity=func.length] (數字)：func 的 arity。

傳回

(函式)：傳回新的已封裝函式。

範例

var abc = function(a, b, c) {
  return [a, b, c];
};
 
var curried = _.curryRight(abc);
 
curried(3)(2)(1);
// => [1, 2, 3]
 
curried(2, 3)(1);
// => [1, 2, 3]
 
curried(1, 2, 3);
// => [1, 2, 3]
 
// Curried with placeholders.
curried(3)(1, _)(2);
// => [1, 2, 3]

_.debounce(func, [wait=0], [options={}])

來源 npm 套件

建立一個延遲函式，延遲呼叫 func，直到距離延遲函式上次呼叫經過 wait 毫秒後。延遲函式附帶一個 cancel 方法，用於取消延遲的 func 呼叫，以及一個 flush 方法，用於立即呼叫它們。提供 options 以指示是否應在 wait 超時時間的開始或結束邊緣呼叫 func。func 會使用提供給延遲函式的最後一個引數呼叫。延遲函式的後續呼叫會傳回最後一個 func 呼叫的結果。

注意：如果 leading 和 trailing 選項為 true，則僅當在 wait 超時時間內多次呼叫延遲函式時，才會在超時的結束邊緣呼叫 func。

如果 wait 為 0 且 leading 為 false，則會延遲 func 呼叫，直到下一個滴答，類似於超時時間為 0 的 setTimeout。

請參閱 David Corbacho 的文章，以瞭解 _.debounce 和 _.throttle 之間的差異。

自

0.1.0

參數

1. func (函式)：要延遲的函式。
2. [wait=0] (數字)：要延遲的毫秒數。
3. [options={}] (物件)：選項物件。
4. [options.leading=false] (布林值)：指定在超時的開始邊緣呼叫。
5. [options.maxWait] (數字)：允許延遲呼叫 func 的最長時間。
6. [options.trailing=true] (布林值)：指定在逾時結束時呼叫。

傳回

(函式)：傳回新的防彈函式。

範例

// Avoid costly calculations while the window size is in flux.
jQuery(window).on('resize', _.debounce(calculateLayout, 150));
 
// Invoke `sendMail` when clicked, debouncing subsequent calls.
jQuery(element).on('click', _.debounce(sendMail, 300, {
  'leading': true,
  'trailing': false
}));
 
// Ensure `batchLog` is invoked once after 1 second of debounced calls.
var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });
var source = new EventSource('/stream');
jQuery(source).on('message', debounced);
 
// Cancel the trailing debounced invocation.
jQuery(window).on('popstate', debounced.cancel);

_.defer(func, [args])

原始碼 npm 套件

延遲呼叫 func，直到目前呼叫堆疊清除為止。呼叫時會將任何其他引數提供給 func。

自

0.1.0

參數

1. func (函式)：要延遲的函式。
2. [args] (...*)：呼叫 func 時要使用的引數。

傳回

(數字)：傳回計時器 ID。

範例

_.defer(function(text) {
  console.log(text);
}, 'deferred');
// => Logs 'deferred' after one millisecond.

_.delay(func, wait, [args])

原始碼 npm 套件

在 wait 毫秒後呼叫 func。呼叫時會將任何其他引數提供給 func。

自

0.1.0

參數

1. func (函式)：要延遲的函式。
2. wait (數字)：要延遲呼叫的毫秒數。
3. [args] (...*)：呼叫 func 時要使用的引數。

傳回

(數字)：傳回計時器 ID。

範例

_.delay(function(text) {
  console.log(text);
}, 1000, 'later');
// => Logs 'later' after one second.

_.flip(func)

原始碼 npm 套件

建立一個函式，呼叫 func 時會反轉引數。

自

4.0.0

參數

1. func (函數)：要反轉參數的函數。

傳回

(函數)：傳回新的反轉函數。

範例

var flipped = _.flip(function() {
  return _.toArray(arguments);
});
 
flipped('a', 'b', 'c', 'd');
// => ['d', 'c', 'b', 'a']

_.memoize(func, [resolver])

原始碼 npm 套件

建立一個函數，將 func 的結果記憶化。如果提供了 resolver，它會根據傳遞給記憶化函數的參數，來決定用於儲存結果的快取金鑰。預設情況下，傳遞給記憶化函數的第一個參數會用作對應快取金鑰。func 會使用記憶化函數的 this 繫結來呼叫。

注意：快取會在記憶化函數上公開為 cache 屬性。它可以透過將 _.memoize.Cache 建構函式替換為實作 clear、delete、get、has 和 set 等 Map 方法介面的實例，來自訂建立方式。

自

0.1.0

參數

1. func (函數)：要記憶化其輸出的函數。
2. [resolver] (函數)：用於解析快取金鑰的函數。

傳回

(函數)：傳回新的記憶化函數。

範例

var object = { 'a': 1, 'b': 2 };
var other = { 'c': 3, 'd': 4 };
 
var values = _.memoize(_.values);
values(object);
// => [1, 2]
 
values(other);
// => [3, 4]
 
object.a = 2;
values(object);
// => [1, 2]
 
// Modify the result cache.
values.cache.set(object, ['a', 'b']);
values(object);
// => ['a', 'b']
 
// Replace `_.memoize.Cache`.
_.memoize.Cache = WeakMap;

_.negate(predicate)

原始碼 npm 套件

建立一個函數，用來否定謂詞 func 的結果。func 謂詞會使用建立函數的 this 繫結和參數來呼叫。

自

3.0.0

參數

1. predicate (函數)：要否定的謂詞。

傳回

(函數)：傳回新的否定函數。

範例

function isEven(n) {
  return n % 2 == 0;
}
 
_.filter([1, 2, 3, 4, 5, 6], _.negate(isEven));
// => [1, 3, 5]

_.once(func)

原始碼 npm 套件

建立一個函式，限制只能呼叫 func 一次。重複呼叫函式會傳回第一次呼叫的值。func 會以建立函式的 this 繫結和參數來呼叫。

自

0.1.0

參數

1. func (函式)：要限制的函式。

傳回

(函式)：傳回新的受限制函式。

範例

var initialize = _.once(createApplication);
initialize();
initialize();
// => `createApplication` is invoked once

_.overArgs(func, [transforms=[_.identity]])

原始碼 npm 套件

建立一個函式，以轉換後的參數呼叫 func。

自

4.0.0

參數

1. func (Function): 要包裝的函式。
2. [transforms=[_.identity]] (...(Function|Function[])): 參數轉換。

傳回

(Function): 傳回新的函式。

範例

function doubled(n) {
  return n * 2;
}
 
function square(n) {
  return n * n;
}
 
var func = _.overArgs(function(x, y) {
  return [x, y];
}, [square, doubled]);
 
func(9, 3);
// => [81, 6]
 
func(10, 5);
// => [100, 10]

_.partial(func, [partials])

原始碼 npm 套件

建立一個函式，以 partials 預先附加到它接收到的參數來呼叫 func。此方法類似於 _.bind，但它不會變更 this 繫結。

_.partial.placeholder 值，在單體建構中預設為 _，可用作部分套用引數的佔位符。

注意：此方法不會設定部分套用函式的「長度」屬性。

自

0.2.0

參數

1. func (函式)：要將引數部分套用的函式。
2. [partials] (...*)：要部分套用的參數。

傳回

(函式)：傳回新的部分套用函式。

範例

function greet(greeting, name) {
  return greeting + ' ' + name;
}
 
var sayHelloTo = _.partial(greet, 'hello');
sayHelloTo('fred');
// => 'hello fred'
 
// Partially applied with placeholders.
var greetFred = _.partial(greet, _, 'fred');
greetFred('hi');
// => 'hi fred'

_.partialRight(func, [partials])

原始碼 npm 套件

此方法類似於 _.partial，但部分套用的引數會附加到它接收到的引數。

_.partialRight.placeholder 值，在單體建構中預設為 _，可用作部分套用引數的佔位符。

注意：此方法不會設定部分套用函式的「長度」屬性。

自

1.0.0

參數

1. func (函式)：要將引數部分套用的函式。
2. [partials] (...*)：要部分套用的參數。

傳回

(函式)：傳回新的部分套用函式。

範例

function greet(greeting, name) {
  return greeting + ' ' + name;
}
 
var greetFred = _.partialRight(greet, 'fred');
greetFred('hi');
// => 'hi fred'
 
// Partially applied with placeholders.
var sayHelloTo = _.partialRight(greet, 'hello', _);
sayHelloTo('fred');
// => 'hello fred'

_.rearg(func, indexes)

原始碼 npm 套件

建立一個函式，呼叫 func 時，引數會根據指定的 indexes 排列，其中第一個索引的引數值會提供為第一個引數，第二個索引的引數值會提供為第二個引數，以此類推。

自

3.0.0

參數

1. func (函式)：要為其重新排列引數的函式。
2. indexes (...(數字|數字陣列))：已排列的引數索引。

傳回

(Function): 傳回新的函式。

範例

var rearged = _.rearg(function(a, b, c) {
  return [a, b, c];
}, [2, 0, 1]);
 
rearged('b', 'c', 'a')
// => ['a', 'b', 'c']

_.rest(func, [start=func.length-1])

原始碼 npm 套件

建立一個函式，呼叫 func 時，會使用建立的函式的 this 繫結，並將從 start 開始的引數提供為陣列。

注意：此方法基於 rest 參數。

自

4.0.0

參數

1. func (函數)：要套用 rest 參數的函數。
2. [start=func.length-1] (數字)：rest 參數的開始位置。

傳回

(Function): 傳回新的函式。

範例

var say = _.rest(function(what, names) {
  return what + ' ' + _.initial(names).join(', ') +
    (_.size(names) > 1 ? ', & ' : '') + _.last(names);
});
 
say('hello', 'fred', 'barney', 'pebbles');
// => 'hello fred, barney, & pebbles'

_.spread(func, [start=0])

原始碼 npm 套件

建立一個函數，會使用建立函數的 this 繫結和一個陣列引數來呼叫 func，非常類似於 Function#apply。

注意：此方法基於 展開運算子。

自

3.2.0

參數

1. func (函數)：要展開引數的函數。
2. [start=0] (數字)：展開的開始位置。

傳回

(Function): 傳回新的函式。

範例

var say = _.spread(function(who, what) {
  return who + ' says ' + what;
});
 
say(['fred', 'hello']);
// => 'fred says hello'
 
var numbers = Promise.all([
  Promise.resolve(40),
  Promise.resolve(36)
]);
 
numbers.then(_.spread(function(x, y) {
  return x + y;
}));
// => a Promise of 76

_.throttle(func, [wait=0], [options={}])

原始碼 npm 套件

建立一個受限函式，每隔 wait 毫秒才會呼叫 func 一次。受限函式會附帶一個 cancel 方法，用於取消延遲的 func 呼叫，以及一個 flush 方法，用於立即呼叫它們。提供 options 以指示 func 是否應在 wait 超時時間的前緣和/或後緣呼叫。func 會呼叫受限函式提供的最後一個參數。後續呼叫受限函式會傳回最後一個 func 呼叫的結果。

注意：如果 leading 和 trailing 選項為 true，則只有在 wait 超時期間呼叫受限函式多次時，才會在超時的後緣呼叫 func。

如果 wait 為 0 且 leading 為 false，則會延遲 func 呼叫，直到下一個滴答，類似於超時時間為 0 的 setTimeout。

請參閱 David Corbacho 的文章，以了解 _.throttle 和 _.debounce 之間的差異。

自

0.1.0

參數

1. func (函式)：要受限的函式。
2. [wait=0] (數字)：要將呼叫受限為多少毫秒的數字。
3. [options={}] (物件)：選項物件。
4. [options.leading=true] (布林值)：指定在超時的前緣呼叫。
5. [options.trailing=true] (布林值)：指定在逾時結束時呼叫。

傳回

(函式)：傳回新的受限函式。

範例

// Avoid excessively updating the position while scrolling.
jQuery(window).on('scroll', _.throttle(updatePosition, 100));
 
// Invoke `renewToken` when the click event is fired, but not more than once every 5 minutes.
var throttled = _.throttle(renewToken, 300000, { 'trailing': false });
jQuery(element).on('click', throttled);
 
// Cancel the trailing throttled invocation.
jQuery(window).on('popstate', throttled.cancel);

_.unary(func)

原始碼 npm 套件

建立一個函式，接受最多一個參數，忽略任何額外的參數。

自

4.0.0

參數

1. func (函式): 要限制參數的函式。

傳回

(函式): 傳回新的限制函式。

範例

_.map(['6', '8', '10'], _.unary(parseInt));
// => [6, 8, 10]