lodash自分用メモ Array

lodashは見ておこうと思い立ち、サイトの日本語メモを作成しました。

↓ lodashのES6で書くとこうなるというのはこちらのサイト

You Might Not Need Lodash

https://youmightnotneed.com/lodash/


## Array(配列操作)

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

配列を引数の数で分割する

公式）Creates an array of elements split into groups the length of size. If array can't be split evenly, the final chunk will be the remaining elements.

```javascript
_.chunk(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'], 2);
// [["a","b"],["c","d"],["e","f"],["g","h"]]
```

### `_.compact(array)`

配列の中から `false`、`null`、`NaN`、`undefined` を取り除く

公式）Creates an array with all falsey values removed. The values false, null, 0, "", undefined, and NaN are falsey.

```javascript
_.compact([0, 1, false, true, null, 2, '', 3, NaN, undefined])
// [1,true,2,3]
```

### `_.concat(array, [values])`

配列を連結させる

公式）Creates a new array concatenating array with any additional arrays and/or values.

```javascript
let arrayA = [1, 2, 3]
let arrayB = _.concat(arrayA, 4, 5, 6)
let arrayC = _.concat(arrayA, [4, 5, 6])

arrayB // [1,2,3,4,5,6]]
arrayC // [1,2,3,4,5,6]]

let arrayD = _.concat(arrayA, [4, 5, 6, [7, 8, 9]])

arrayD // [1,2,3,4,5,6,[7,8,9]]
```


### `_.difference(array, [values])`

２つの配列を比較して、含まれない値を取り出す
第一引数に比較したい配列、第二引数に比較対象となる配列を入れる

公式）Creates an array of array values not included in the other given arrays using SameValueZero for equality comparisons. The order and references of result values are determined by the first array.

```javascript
_.difference(['花子', '太郎', '次郎', '三郎'], ['一郎', '花子'])
// ["太郎","次郎","三郎"]
```

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

`_.difference` と近い。引数に比較対象の配列と、比較する基準を入れる。

公式）This method is like _.difference except that it accepts iteratee which is invoked for each element of array and values to generate the criterion by which they're compared. The order and references of result values are determined by the first array. The iteratee is invoked with one argument:

```javascript
_.differenceBy([2.1, 1.2], [2.3, 3.4], Math.floor)
// [1.2]

_.differenceBy([{ id: 1, name: '花子' }, { id: 2, name: '太郎' }, { id: 3, name: '次郎' }], [{ id: 2, access: '東京' }, { id: 3, access: '神奈川' }], 'id')
// [{ id: 1, name: '花子' }]
```

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

２つの配列を比較して違う値だけを取り出す。`_.differenceBy`に近いけど若干違い、比較基準を入れる。

公式）This method is like _.difference except that it accepts comparator which is invoked to compare elements of array to values. The order and references of result values are determined by the first array. The comparator is invoked with two arguments: (arrVal, othVal).

```javascript
let arrayA = [{ 'id': 1, 'name': '花子' }, { 'id': 2, 'name': '太郎' }, { 'id': 3, 'name': '次郎' }];
let arrayB = [{ 'id': 1, 'name': '花子' }];

_.differenceWith(arrayA, arrayB, _.isEqual)
// [{"id":2,"name":"太郎"},{"id":3,"name":"次郎"}]

// こんな感じでも指定できる
const customComparator = (a, b) => {
	return a.id === b.id && a.name === b.name
}
_.differenceWith(arrayA, arrayB, customComparator)
// [{"id":2,"name":"太郎"},{"id":3,"name":"次郎"}]
```

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

配列から、先頭からn個分削除した配列を作る
n個指定しないとデフォルト1

公式）Creates a slice of array with n elements dropped from the beginning.

```javascript
_.drop([1, 2, 3, 4, 5], 3)
// [4, 5]

_.drop([1, 2, 3, 4, 5], 5)
// []
```

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

配列から、末尾からn個分削除した配列を作る
n個指定しないとデフォルト1

公式）Creates a slice of array with n elements dropped from the end.

```javascript
_.dropRight([1, 2, 3, 4, 5], 2)
// [1, 2, 3]

_.dropRight([1, 2, 3, 4, 5], 5)
// []
```

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

配列の先頭から、比較基準がfalseになるまで削除していって、
残りの配列を作る

公式）Creates a slice of array excluding elements dropped from the beginning. Elements are dropped until predicate returns falsey. The predicate is invoked with three arguments: (value, index, array).


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

配列の末尾から、比較基準がfalseになるまで削除していって、
残りの配列を作る

公式）Creates a slice of array excluding elements dropped from the end. Elements are dropped until predicate returns falsey. The predicate is invoked with three arguments: (value, index, array).

```javascript
let arrayA = [
  { 'id': 1, 'active': true },
  { 'id': 2, 'active': true },
  { 'id': 3, 'active': false },
  { 'id': 4, 'active': true },
  { 'id': 5, 'active': false },
];

_.dropWhile(arrayA, ['active', true]) // ①
_.dropWhile(arrayA, ['active', false]) // ②

_.dropRightWhile(arrayA, ['active', true]) // ③
_.dropRightWhile(arrayA, ['active', false]) // ④

// ① [{"id":3,"active":false},{"id":4,"active":true},{"id":5,"active":false}]

// ② [{"id":1,"active":true},{"id":2,"active":true},{"id":3,"active":false},{"id":4,"active":true},{"id":5,"active":false}]

// ③[{"id":1,"active":true},{"id":2,"active":true},{"id":3,"active":false},{"id":4,"active":true},{"id":5,"active":false}]

// ④ [{"id":1,"active":true},{"id":2,"active":true},{"id":3,"active":false},{"id":4,"active":true}]
```

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

配列を第２引数の値で埋める。
第３引数にスタート位置、第四引数に埋める数を決められる。lengthを決めるとき、最後の値は変わらない。

公式）Fills elements of array with value from start up to, but not including, end.

```javascript
let array = [1, 2, 3, 4, 5]

_.fill(array, '') // ["","","","",""]
_.fill(array, 'a') // ["a","a","a","a","a"]

_.fill(Array(5), '') // ["","","","",""]
_.fill(Array(5), '2') // ["2","2","2","2","2"]

// 開始位置 1番目
// 埋めるlengthを3にした時、実際埋まるのは2つ
_.fill([2, 4, 6, 8, 10], '*', 1, 3)
// [2,"*","*",8,10]
```

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

配列から引数に渡した比較対象に該当する値のindexを返す。
先頭から検索して一番最初に合致したindexだけ返す。

公式）This method is like _.find except that it returns the index of the first element predicate returns truthy for instead of the element itself.



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

`_.findIndex`と使い方が同じで、末尾から検索

公式）This method is like _.findIndex except that it iterates over elements of collection from right to left.

```javascript
let arrayA = [
  { 'id': 1, 'active': true },
  { 'id': 2, 'active': true },
  { 'id': 3, 'active': false },
  { 'id': 4, 'active': true },
  { 'id': 5, 'active': false },
];

// 該当する値がなかったら`-1`を返す
_.findIndex(arrayA, { 'user': '花子', 'active': false });
_.findLastIndex(arrayA, { 'user': '花子' }) // -1

_.findIndex(arrayA, { 'id': 2, 'active': true }); // 1
_.findIndex(arrayA, { 'active': false }); // 2
_.findLastIndex(arrayA, { 'active': true }) // 3
```

### `_.flatten(array)`

複数ある配列から、単一レベル減らす（例を見た方が早い）

公式）Flattens array a single level deep.

```javascript
let grid = [
  [1, 2, 3],
  [4, 5, 6],
  [7, 8, 9]
]

_.flatten(grid)
// [1,2,3,4,5,6,7,8,9]

```

### `_.flattenDeep(array)`、`_.flattenDepth(array, [depth=1])`

`_.flattenDeep`は全てのレベルがフラットになる。
`_.flattenDepth` を使うと、フラットにしたいレベルの引数に指定できる。

公式）Recursively flattens array.

```javascript
_.flattenDeep([1, [2, [3, [4]], 5]]);
// [1, 2, 3, 4, 5]

let array = [1, [2, [3, [4]], 5]];

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

### `_.fromPairs(array)`

２つの配列のkey、valueからオブジェクトを生成してくれる


公式）The inverse of _.toPairs; this method returns an object composed from key-value pairs.

```javascript
_.fromPairs([['id', 1], ['name', '花子']]);
// {"id":1,"name":"花子"}
```

### `_.head(array)`

配列の１番目の要素を取得

公式）Gets the first element of array.

```javascript
_.head([1, 2, 3]); // 1
```

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

配列から、指定したvalueに１番目に合致した値のindexを返す。
第３引数に検索スタートのindexを指定できる。負の場合は末尾から。

公式）Gets the index at which the first occurrence of value is found in array using SameValueZero for equality comparisons. If fromIndex is negative, it's used as the offset from the end of array.

```javascript
_.indexOf([1, 2, 1, 2], 2) // 1

_.indexOf([1, 2, 1, 2], 2, 2) // 3

_.indexOf([1, 2, 1, 2, 1, 2, 1, 2], 2, -1) // 7

_.indexOf([1, 2, 1, 2, 1, 2, 1, 2], 3) // -1
```

### `_.initial(array)`

配列の末尾だけ取り除いた、残りの配列を返す。

公式）Gets all but the last element of array.

```javascript
_.initial([1, 2, 3, 4]) // [1,2,3]
```

### `_.intersection([arrays])`

複数の配列から、共通の値を取得する

公式）Creates an array of unique values that are included in all given arrays using SameValueZero for equality comparisons. The order and references of result values are determined by the first array.

```javascript
_.intersection([1, 2, 3], [5, 2, 1, 4], [2, 1])
// [1, 2]
```

### `_.intersectionBy([arrays], [iteratee=_.identity])`

配列同士を比較する。

公式）This method is like _.intersection except that it accepts iteratee which is invoked for each element of each arrays to generate the criterion by which they're compared. The order and references of result values are determined by the first array. The iteratee is invoked with one argument:

```javascript
_.intersectionBy([2.1, 1.2], [2.3, 3.4], Math.floor);
// [2.1]
```

```javascript
let arrayA = [
  { id: '1', skill: 'css' },
  { id: '2', skill: 'javascript' },
  { id: '3', skill: 'php' }
]

let arrayB = [
  { id: '4', address: '千葉' },
  { id: '5', address: '東京' },
  { id: '1', address: '神奈川' }
]

let result = _.intersectionBy(arrayA, arrayB, 'id')

result // [{"id":"1","skill":"css"}]
```

### `_.intersectionWith([arrays], [comparator])`

配列を比較して合致する値を取り出す。
`_.differenceWith(array, [values], [comparator])`は異なる値を取り出したのに対し、これは合致するのを取り出してくれる。

公式）This method is like _.intersection except that it accepts comparator which is invoked to compare elements of arrays. The order and references of result values are determined by the first array. The comparator is invoked with two arguments: (arrVal, othVal).

```javascript
let arrayA = [{ 'id': 1, 'name': '花子' }, { 'id': 2, 'name': '太郎' }, { 'id': 3, 'name': '次郎' }];
let arrayB = [{ 'id': 1, 'name': '花子' }];

_.differenceWith(arrayA, arrayB, _.isEqual)
// [{"id":2,"name":"太郎"},{"id":3,"name":"次郎"}]
_.intersectionWith(arrayA, arrayB, _.isEqual);
// [{"id":1,"name":"花子"}]
```

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

配列内のすべての要素を、引数の値で区切ってつなげる。

公式）Converts all elements in array into a string separated by separator.

```javascript
_.join(['a', 'b', 'c'], ' - ') // a - b - c
```

### `_.last(array)`

配列の最後の要素を取り出す。

公式）Gets the last element of array.


```javascript
_.last([1, 2, 3]); // 3
```

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

配列の末尾から、渡したvalueにマッチする値のindexを返す。

公式）This method is like _.indexOf except that it iterates over elements of array from right to left.

```javascript
_.lastIndexOf([1, 2, 3, 1, 2, 3], 2) // 4

_.lastIndexOf([1, 2, 3, 1, 2, 3], 2, 3) // 1
```

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

配列から、指定したインデックスの値を取り出す。負の値（`-n`）で渡すと末尾からのindexになる。

公式）Gets the element at index n of array. If n is negative, the nth element from the end is returned.

```javascript
let array = ['a', 'b', 'c', 'd']

_.nth(array, 1) // 'b'

_.nth(array, -1) // 'd'
```

### `_.pull(array, [values])`

配列から指定して値をすべて削除した残りを返す。

公式）Removes all given values from array using SameValueZero for equality comparisons.


### `_.pullAll(array, values)`

`_.pull`とは違い、取り除く値を配列で指定できる。

公式）This method is like _.pull except that it accepts an array of values to remove.

```javascript
let array = ['a', 'b', 'c', 'a', 'b', 'c'];

_.pull(array, 'a') // ["b","c","b","c"]
_.pull(array, 'a', 'b') // ["c","c"]
// NG: _.pull(array, ['a'])

_.pullAll(array, ['a']) // ["b","c","b","c"]
_.pullAll(array, ['a', 'b']) // ["c","c"]
```

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

使い方は`_.pull`と同じく、渡した値をすべて取り除いた値を返す。引数に削除したいkeyを指定。

公式）This method is like _.pullAll except that it accepts iteratee which is invoked for each element of array and values to generate the criterion by which they're compared. The iteratee is invoked with one argument: (value).

```javascript
let arrayA = [
  { 'id': 1, 'address': '東京' },
  { 'id': 2, 'address': '埼玉' },
  { 'id': 3, 'address': '千葉' },
  { 'id': 4, 'address': '東京' },
];
let arrayB = [
  { 'address': '東京' }
];
_.pullAllBy(arrayA, arrayB, 'address')
// [{"id":2,"address":"埼玉"},{"id":3,"address":"千葉"}]
```

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

`_.pullAllBy`と使い方はほぼ一緒。

公式）This method is like _.pullAll except that it accepts comparator which is invoked to compare elements of array to values. The comparator is invoked with two arguments: (arrVal, othVal).

```javascript
let arrayA = [
  { 'id': 1, 'address': '東京' },
  { 'id': 2, 'address': '埼玉' },
  { 'id': 3, 'address': '千葉' },
  { 'id': 4, 'address': '東京' },
];
let arrayB = [
   { 'id': 2, 'address': '埼玉' }
];
let arrayC = [
   { 'address': '東京' },
];

_.pullAllWith(arrayA, arrayB, _.isEqual)
// [{"id":1,"address":"東京"},{"id":3,"address":"千葉"},{"id":4,"address":"東京"}]

const customComparator = (a, b) => {
	return a.address === b.address
}
_.pullAllWith(arrayA, arrayC, customComparator)
// [{"id":2,"address":"埼玉"},{"id":3,"address":"千葉"}]
```

### `_.pullAt(array, [indexes])`

配列から指定したindexを取り除いた残りを返す。

公式）Removes elements from array corresponding to indexes and returns an array of removed elements.

```javascript
let array = ['a', 'b', 'c', 'd', 'e', 'f'];
let pulled = _.pullAt(array, [1, 3])

pulled // ["b","d"]

array // ["a","c","e","f"]
```

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

公式）Removes all elements from array that predicate returns truthy for and returns an array of the removed elements. The predicate is invoked with three arguments: (value, index, array).

```javascript
let array = ['foo', 27, 'man', 42, 'chew']
_.remove(array, function(el) {
	return typeof el === 'number'
})

array // ["foo","man","chew"]
```

```javascript
let enemy = [
  { id: '1', hp: 12, maxHP: 50 },
  { id: '2', hp: 0, maxHP: 50 },
  { id: '3', hp: 50, maxHP: 50 }
]

_.remove(enemy, function(e) {
  return e.hp <= 0
})

enemy // [{"id":"1","hp":12,"maxHP":50},{"id":"3","hp":50,"maxHP":50}]
```

### `_.reverse(array)`

配列の反転

公式）Reverses array so that the first element becomes the last, the second element becomes the second to last, and so on.

```javascript
let array = [1, 2, 3]
_.reverse(array) // [3, 2, 1]
```

### `_.slice(array, [start=0], [end=array.length])`

配列から、指定したindex以降の配列を返す。切り出すlengthも引数に渡せる。

公式）Creates a slice of array from start up to, but not including, end.

```javascript
_.slice([1, 2, 3, 4, 5], 0, 1) // [1]
_.slice([1, 2, 3, 4, 5], 0, 3) // [1, 2, 3]
_.slice([1, 2, 3, 4, 5], 2) // [3, 4, 5]
```

### `_.sortedIndex(array, value)`

第二引数の値が配列のどこに入れられるかindexを返す。

公式）Uses a binary search to determine the lowest index at which value should be inserted into array in order to maintain its sort order.

```javascript
let arrayA = [10, 20, 30, 40, 50]
_.sortedIndex(arrayA, 35) // 3
```

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

配列のどこに入れられるかを返す。

公式）This method is like _.sortedIndex except that it accepts iteratee which is invoked for value and each element of array to compute their sort ranking. The iteratee is invoked with one argument: (value).

```javascript
let arrayB = [
  { name: '花子', age: 20 },
  { name: '太郎', age: 30 },
  { name: '二郎', age: 40 }
]
let arrayC = { name: '三郎',  age: 25 }

_.sortedIndexBy(arrayB, arrayC, 'age') // 1
```

### `_.sortedIndexOf(array, value)`

…どう使えば良いのか分からなかったデス。。

### `_.sortedUniq(array)`

配列内で、隣り合う値が等しかった時重複を消してくれる。

公式）This method is like _.uniq except that it's designed and optimized for sorted arrays.

```javascript
_.sortedUniq([1, 1, 2]); // [1,2]

_.sortedUniq([1, 2, 2, 2, 2, 3, 4, 4, 5]); // [1,2,3,4,5]

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

_.sortedUniq(['花子', '花子', '太郎', '太郎', '次郎', '花子']); // ["花子","太郎","次郎","花子"]
```

### `_.sortedUniqBy(array, [iteratee])`

`_.sortedUniq`に比較対象をセットできる。

公式）This method is like _.uniqBy except that it's designed and optimized for sorted arrays.

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

let array = [
  { x: 1, y: 1 },
  { x: 1, y: 1 },
  { x: 2, y: 2 },
  { x: 2, y: 2 }
]
_.sortedUniqBy(array, 'x')
// [{"x":1,"y":1},{"x":2,"y":2}]
```

### `_.tail(array)`

配列の最初の要素だけ取り除いて返す。

公式）Gets all but the first element of array.

```javascript
_.tail([1, 2, 3]); // [2, 3]
```

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

配列の１番目からn個目までスライスした配列を返す。

公式）Creates a slice of array with n elements taken from the beginning.

```javascript
_.take([1, 2, 3, 4, 5, 6], 2); // [1, 2]
```

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

末尾からn個目までスライスした配列を返す。

公式）Creates a slice of array with n elements taken from the end.

```javascript
_.takeRight([1, 2, 3, 4, 5], 2); // [4, 5]
```

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

配列の末尾から、指定した比較値とfalseになるまでの値を返す。

公式）Creates a slice of array with elements taken from the end. Elements are taken until predicate returns falsey. The predicate is invoked with three arguments: (value, index, array).

```javascript
let arrayA = [
  { 'id': 1, 'active': true },
  { 'id': 2, 'active': true },
  { 'id': 3, 'active': false },
  { 'id': 4, 'active': true },
  { 'id': 5, 'active': false },
];

// 'active'がfalseの値を、'true'になるまで末尾から取り出す。
_.takeRightWhile(arrayA, ['active', false])
// [{"id":5,"active":false}]

// 上で出てきた`_.dropWhile`に何となく似ている。
_.dropWhile(arrayA, ['active', false])
// [{"id":1,"active":true},{"id":2,"active":true},{"id":3,"active":false},{"id":4,"active":true},{"id":5,"active":false}]

_.takeRightWhile(arrayA, ['active', true]) // []
```

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

`_.takeRightWhile`と使い方は一緒で、配列の先頭からfalseになるまで返す。

公式）Creates a slice of array with elements taken from the beginning. Elements are taken until predicate returns falsey. The predicate is invoked with three arguments: (value, index, array).

```javascript
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])`

配列の重複を弾きつつ、いい感じに集合した配列を返す。

公式）Creates an array of unique values, in order, from all given arrays using SameValueZero for equality comparisons.

```javascript
_.union([2], [1, 2]); // [2, 1]

_.union([1, 2, 3, 4, 5, 6, 7], [5, 6, 7]) // [1,2,3,4,5,6,7]

// 変数に入れるときはこう
let array = [[1,2,3,4], [5,6,7], [], [8,9], []]
let union = _.union.apply(null, array);
union // [1,2,3,4,5,6,7,8,9]
```

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

比較したいkeyをセットできる。

公式）This method is like _.union except that it accepts iteratee which is invoked for each element of each arrays to generate the criterion by which uniqueness is computed. Result values are chosen from the first array in which the value occurs. The iteratee is invoked with one argument:

```javascript
let arrayA = [
  { 'id': 1, 'address': '東京' },
  { 'id': 2, 'address': '埼玉' },
  { 'id': 3, 'address': '千葉' },
  { 'id': 4, 'address': '東京' },
  { 'id': 5, 'address': '埼玉' }
];

// 'address'のvalueが等しいとき、重複した値は配列の最初の値にまとめられる。
_.unionBy(arrayA, 'address')
// [{"id":1,"address":"東京"},{"id":2,"address":"埼玉"},{"id":3,"address":"千葉"}]
```

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

`_.union`と同じく、配列の重複をなくしていい感じに配列を整形してくれる。関数使える。

公式）This method is like _.union except that it accepts comparator which is invoked to compare elements of arrays. Result values are chosen from the first array in which the value occurs. The comparator is invoked with two arguments: (arrVal, othVal).

```javascript
let arrayA = [
  { 'id': 1, 'address': '東京' },
  { 'id': 2, 'address': '千葉' },
  { 'id': 3, 'address': '埼玉' },
];

let arrayB = [
  { 'id': 3, 'address': '埼玉' },
  { 'id': 4, 'address': '神奈川' },
  { 'id': 5, 'address': '東京' },
]

_.unionWith(arrayA, arrayB,  _.isEqual)
// [{"id":1,"address":"東京"},{"id":2,"address":"千葉"},{"id":3,"address":"埼玉"},{"id":4,"address":"神奈川"},{"id":5,"address":"東京"}]
```


### `_.uniq(array)`

配列から一意な値を取得する

公式）Creates a duplicate-free version of an array, using SameValueZero for equality comparisons, in which only the first occurrence of each element is kept. The order of result values is determined by the order they occur in the array.

```javascript
_.uniq([1, 2, 1, 3, 1]); // [1, 2, 3]
```

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

`_.uniq`と使い方は一緒。引数に配列で取得したいkeyを指定できる。


公式）This method is like _.uniq except that it accepts iteratee which is invoked for each element in array to generate the criterion by which uniqueness is computed. The order of result values is determined by the order they occur in the array. The iteratee is invoked with one argument:

```javascript
_.uniqBy([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }], 'x');
// [{"x":1},{"x":2}]

_.uniqBy([2.1, 1.2, 2.3], Math.floor); // [2.1, 1.2]
```

```javascript
let objA = {
    id: 1,
    foreignKey: 1,
    name: 'objA',
    sort_order: 1
};
let objB = {
    id: 2,
    foreignKey: 1,
    name: 'objB',
    sort_order: 2
};
let objC = {
    id: 1, // idがobjAと重複!
    foreignKey: 1,
    name: 'objB',
    sort_order: 3
};


let result = _.uniqBy([objA, objB, objC], 'id');
result
// [{"id":1,"foreignKey":1,"name":"objA","sort_order":1},{"id":2,"foreignKey":1,"name":"objB","sort_order":2}]
```

### `_.uniqWith(array, [comparator])`

使い方は`_.uniq`と一緒。[comparator]で比較基準になる関数を入れる。

公式）This method is like _.uniq except that it accepts comparator which is invoked to compare elements of array. The order of result values is determined by the order they occur in the array.The comparator is invoked with two arguments: (arrVal, othVal).

```javascript
let objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 2 }];

_.uniqWith(objects, _.isEqual); // [{"x":1,"y":2},{"x":2,"y":1}]
```

```javascript
let Array = [
  {
    id: '123',
    name: 'John',
    someKey: '1234'
  },
  {
    id: '123',
    name: 'John',
    someKey: '12345'
  }
]

let result = _.uniqWith(Array, function(arrVal, othVal) {
  return arrVal.id === othVal.id;
});

// 最初の配列に集約
result // [{"id":"123","name":"John","someKey":"1234"}]
```


### `_.unzip(array)`

グループ化された配列を圧縮前に再グループ化する。（例を見た方が早い。）

公式）This method is like _.zip except that it accepts an array of grouped elements and creates an array regrouping the elements to their pre-zip configuration.

```javascript
// 一度`_.zip`を使って配列をグループ化する。
let zipped = _.zip(['a', 'b'], [1, 2], [true, false]);
// [['a', 1, true], ['b', 2, false]]

_.unzip(zipped);
// [["a","b"],[1,2],[true,false]]
```

```javascript
let firstValue = [
  ['Tony', 42, 'passed'],
  ['Andrew', 19, 'failed'],
  ['Bart', 31, 'passed']
];
let result = _.unzip(firstValue);

result
// [["Tony","Andrew","Bart"],[42,19,31],["passed","failed","passed"]]
```

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

基本的には`_.unzipWith`と使い方は一緒だけど、再グループ化された結果を組み合わせる方法を指定できる。

公式）This method is like _.unzip except that it accepts iteratee to specify how regrouped values should be combined. The iteratee is invoked with the elements of each group: (...group).

```javascript
let zipped = _.zip([1, 2], [10, 20], [100, 200]);

_.unzipWith(zipped, _.add); // [3,30,300]
```

### `_.without(array, [values])`

配列から指定された値を全て取り除いた値だけを返す。

公式）Creates an array excluding all given values using SameValueZero for equality comparisons.

```javascript
_.without([1, 2, 1, 0, 3, 1, 4], 0, 1); // [2, 3, 4]


const items = [1, 2 , 3, 4]
const itemsToRemove = [3, 4, 5]

// 下はNGな書き方！
const NGresult = _.without(items, itemsToRemove)
NGresult // [1,2,3,4]

// 下のように書きましょう
const result = _.without(items, ...itemsToRemove)
result // [1,2]
```

### `_.xor([arrays])`

複数の配列から、重複している値だけ取り除いた、ユニークな値を返す。

公式）Creates an array of unique values that is the symmetric difference of the given arrays. The order of result values is determined by the order they occur in the arrays.

```javascript
_.xor([2, 1], [2, 3]); // [1, 3]

var firstValue = [[1, 0, 5, 4],[1, 0, 5, 2], [1, 0, 5, 8]];
var result = _.xor(firstValue[0], firstValue[1], firstValue[2]);

result // [4,2,8]

var array1 = [1, 2, 3, 4];
var array2 = [2, 3, 4, 9];
var array3 = [1, 3, 4, 5];

_.xor (array1, array2, array3); // [9,5]
```

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

`_.xor`と使い方は一緒だけど、比較基準となるkeyを入れる。

公式）This method is like _.xor except that it accepts iteratee which is invoked for each element of each arrays to generate the criterion by which by which they're compared. The order of result values is determined by the order they occur in the arrays. The iteratee is invoked with one argument: (value).

```javascript
_.xorBy([2.1, 1.2], [2.3, 3.4], Math.floor);
// [1.2, 3.4]
_.xorBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');
// [{ 'x': 2 }]

let arrayA = [{ id: 1, busNum: '1234' }, { id: 2, busNum: '4567' }]
let arrayB = [{ id: 1, busNum: '2344' }, { id: 2, busNum: '1234' }]

let result = _.xorBy(arrayA, arrayB, 'busNum')
result // [{"id":2,"busNum":"4567"},{"id":1,"busNum":"2344"}]
```

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

`_.xor`と使い方は一緒だけど、[comparator]を入れる。

公式）This method is like _.xor except that it accepts comparator which is invoked to compare elements of arrays. The order of result values is determined by the order they occur in the arrays. The comparator is invoked with two arguments: (arrVal, othVal).

```javascript
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])`

複数の配列の同じ順番の値を取り出し、新しい配列をグループ化してくれる。
１番目同士、２番目同士、…という感じ。

公式）Creates an array of grouped elements, the first of which contains the first elements of the given arrays, the second of which contains the second elements of the given arrays, and so on.

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

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

2の配列からオブジェクトを生成してくれる。
１つ目の配列にはkeyとなる値、２つ目の配列に対応する値とし、並び順に生成。

公式）This method is like _.fromPairs except that it accepts two arrays, one of property identifiers and one of corresponding values.

```javascript
_.zipObject( [‘fred’, ‘barney’], [30, 40] ); // { ‘fred’: 30, ‘barney’: 40 }
```

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

`_.zipObject`と使い方は一緒だけど、ネストしたい配列を生成したい場合は、階層を指定できる。

公式）This method is like _.zipObject except that it supports property paths.

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

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

`_.zip`と使い方は一緒。配列を並び順から新しい配列を生成する時、生成後の整形について指定できる。

公式）This method is like _.zip except that it accepts iteratee to specify how grouped values should be combined. The iteratee is invoked with the elements of each group: (...group).

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


ここまで書いてみて（途中ヤケになってしまったけど）、正直使い所が分からないものだらけだったのですが笑、それはまだ実戦で活かしていないだけ…と信じて、
配列だけでなく他のも見ていくことにします。（心が折れかけてイマス。。）