underscore.jsリファレンス

諸々の初心者が公式リファレンスを確認中。
不明点多し。
自分用メモ。

**_.XXX(　)内の[]はオプショナル *は複数設定OKの意味**
**[context]の意味を調べ中・・・**

 - サンプルは自分が公式やら諸々見て試したものをそのまま
 - 不明点は？が満載（教え・・t・）
 - 公式リファレンスのリストを遡って確認したので、下の方に色々書いている
 - ところどころ、参考サイトをメモ

#Collection
##_.each(list, iteratee, [context]) 
listの数分iteratee関数が実行される。
引数は(element, index, list)の順になる。
objectの時の引数は(value, key, list)の順になる。
どちらも最後のlistは省略しても大丈夫みたい。

Alias: forEach　（_.forEachでも使える）

```javascript

 var list = [1, 2, 3];
 var func = function(element, index, list){
   console.log( index + ':' +element );
 }
 _.each(list, func);//=> 0:1 1:2 2:3

 var obj = [
   {name: 'Moe', age: 30},
   {name: 'Curly', age: 40},
   {name: 'Larry', age: 50}
 ]
 var func = function(value, key, obj){
   console.log( key + ':' + value.name );
 }
 _.each(obj, func);//=>0:Moe 1:Curly 2:Larry
```

##_.map(list, iteratee, [context])
listの要素をiteratee関数で処理した結果の配列を作成する

listがハッシュ配列の場合、iterateeの引数は(value, indexかkey, list)の順になるが、
最後のlistは省略しても大丈夫みたい。
Alias: collect　（_.collectでも使える）

```javascript

 var show = _.map([1, 2, 3], function(value){ return value * 3; });
 console.log(show);//=> [3, 6, 9]

 var show = _.map({one: 1, two: 2, three: 3}, function(value, key){ return value * 3; });
 console.log(show);//=> [3, 6, 9]

 var show = _.map([[1, 2], [3, 4]], _.first);//_.first=配列の最初の1文字を取得
 console.log(show);//=> [1, 3]

 var arr = {one: 1, two: 2, three: 3};
 var show = _.map(arr, function(value, key, arr){ return value * 3; });
 console.log(show);//=> [3, 6, 9]
```

##_.reduce(list, iteratee, [memo], [context]) 

listの要素をひとつに集める。iterateeで値を保持する。
[memo]はiteratee関数の引数memoに入る初期値。

Aliases: inject, foldl　（_.injecctや_.foldlでも使える）

```javascript

 var sum = _.reduce([1, 2, 3], function(memo, num){ return memo + num; }, 10);
 console.log(sum);//=> 16

 var list = [[0, 1], [2, 3], [4, 5]];
 var flat = _.reduce(list, function(a, b) { return a.concat(b); });
 console.log(flat);//=> [0, 1, 2, 3, 4, 5]
```

##_.reduceRight(list, iteratee, [memo], [context])
listの要素を末尾からひとつに集める。iterateeで値を保持する。
[memo]はiteratee関数の引数memoに入る初期値。

Alias: foldr　（_.foldrでも使えるけど、Javascriptでは便利じゃないらしい）

```javascript
 var list = [[0, 1], [2, 3], [4, 5]];
 var flat = _.reduceRight(list, function(a, b) { return a.concat(b); }, []);
 console.log(flat);//=> [4, 5, 2, 3, 0, 1]
```

##_.find(list, predicate, [context])
predicateの結果に合致した最初のlistの要素を返す。
合致するものがなければundefinedで返す。

Alias: detect　（_.detectでも使える）

```javascript

 var even = _.find([1, 2, 3, 4, 5, 6], function(num){ return num % 2 == 0; });
 console.log(even);//=> 2

 var even = _.find([1, 3, 5], function(num){ return num % 2 == 0; });
 console.log(even);//=> undefined
```

##_.filter(list, predicate, [context])
listの要素で、predicateの結果に合致したものを配列にして返す。
合致するものがなければ空[]で返す。

Alias: select　（_.selectでも使える）

```javascript

 var evens = _.filter([1, 2, 3, 4, 5, 6], function(num){ return num % 2 == 0; });
 console.log(evens)//=> [2, 4, 6]
```

##_.findWhere(list, properties) 
listの配列要素内で、propertiesの{key: value}のペアが合致した最初のものだけを配列で返す。
もし、listが空か結果がなければ、undefinedを返す。

```javascript
 var arr =[
   {lang:'English', age: 30, name: 'Moe'},
   {lang:'English', age: 40, name: 'Curly'},
   {lang:'English', age: 30, name: 'Richard'},
   {lang:'Spanish', age: 30, name: 'Larry'},
   {lang:'Spanish', age: 30, name: 'Joe'}
 ];
 var show = _.findWhere(arr,{lang:'English', age: 30});
 console.log(show);//=> [{lang: "English", age: 30, name: "Moe"}

 var arr2 = [];
 var show = _.findWhere(arr2,{lang:'English', age: 30});
 console.log(show);//=> undefined```
```

##_.where(list, properties) 
listの配列要素内で、propertiesの{key: value}のペアが合致したものを配列で返す。
もし結果がなければ、空[]で返す。

```javascript

 var arr =[
   {lang:'English', age: 30, name: 'Moe'},
   {lang:'English', age: 40, name: 'Curly'},
   {lang:'English', age: 30, name: 'Richard'},
   {lang:'Spanish', age: 30, name: 'Larry'},
   {lang:'Spanish', age: 30, name: 'Joe'}
 ];
 var show = _.where(arr,{lang:'English', age: 30});
 console.log(show);//=> [{lang: "English", age: 30, name: "Moe"}, {lang: "English", age: 30, name: "Richard"}]
```

##_.reject(list, predicate, [context]) 
listの要素からpredicateの条件に合わなかったものを配列で返す。

```javascript

 var odds = _.reject([1, 2, 3, 4, 5, 6], function(num){ return num % 2 == 0; });
 console.log(odds);//=> [1, 3, 5]
```

##_.every(list, [predicate], [context]) 
listの要素内に真偽値で全てがポジティブだったら、trueが返る。
predicateの結果に、全てが合えばtrueが返る。

Alias: all　（_.allでも使える）

```javascript

 var show = _.every([2, 4, 5], function(num) { return num % 2 == 0; });
 console.log(show);//=> false

 var show = _.every([1, -1, 'yes', true, {}, []]);
 console.log(show);// => true

 var show = _.every([1, -1, 'yes', true, {}, [], 0]);
 console.log(show);// => false

 var show = _.every([3, 5, 7], isPrime);//素数判定
 console.log(show);//=> true
```

##_.some(list, [predicate], [context]) 
listの要素内に真偽値でtrueがひとつでもあればtrueが返る。
predicateの結果に、どれかひとつでも合えばtrueが返る。

Alias: any　（_.anyでも使える） 

```javascript

 var show = _.some([null, 0, 'yes', false]);
 console.log(show);// => true

 var show = _.some([null, 0, NaN, false, '', undefined]);
 console.log(show);// => false

 var show = _.some([1, 2, 4], isPrime);//素数判定
 console.log(show);//=> true

 var show = _.some([1, 4, 6, 8], isPrime);//素数判定
 console.log(show);//=> false
```

##_.contains(list, value, [fromIndex]) 
list内の要素にvalueがあればtrueを返す。
配列の時は、[fromIndex]に値を入れると、その配列indexから探し始める。

Aliases: include, includes　（_.includeや_.includesでも使える）

```javascript

 var show = _.contains([1, 2, 3], 3);
 console.log(show);//=> true

 var show = _.contains([1, 2, 3, 4, 5], 3, 3);
 console.log(show);//=> false(配列内の3はindex[2]なのでfalse)
```

##_.invoke(list, methodName, *arguments) 
listの要素にmethodNameで指定した関数を実行する。
*argumentsは指定した関数が呼び出されたときに、一緒に呼び出される。
でもjoinの時以外の使い方が不明
invoke(呼び出す)

```javascript

 var show = _.invoke([[5, 1, 7], [3, 2, 1]], 'sort');
 console.log(show);//=> [[1, 5, 7], [1, 2, 3]]

 var show = _.invoke([[5, 1, 7], [3, 2, 1]], 'join');
 console.log(show);//=> ["5,1,7", "3,2,1"]

 var show = _.invoke([[5, 1, 7], [3, 2, 1]], 'join' , '&');
 console.log(show);//=> ["5&1&7", "3&2&1"]
```

##_.pluck(list, propertyName) 
_.mapの良く使うやつを便利にしたもの。
listのハッシュ配列をpropertyNameでピックアップして配列で返す。
要素のkey==propertyName。
pluck（引き抜く）

```javascript

 var stooges = [
   {name: 'moe', age: 40}, 
   {name: 'larry', age: 50}, 
   {name: 'curly', age: 60}
 ];
 var show = _.pluck(stooges, 'name');
 console.log(show);//=> ["moe", "larry", "curly"]
```

##_.max(list, [iteratee], [context]) 
listの中の最大値を返す。
listがオブジェクト配列であれば、iterateeで合致したオブジェクトを返す。

```javascript

 var numbers = [10, 5, 100, 2, 1000];
 var show = _.max(numbers);
 console.log(show);//=> 1000

 var numbers = [10, 5, 100, 2, 1000, false, true, 'Moe'];
 var show = _.max(numbers);
 console.log(show);//=> 1000

 var stooges = [
   {name: 'moe', age: 40}, 
   {name: 'larry', age: 50}, 
   {name: 'curly', age: 60}
 ];
 var show = _.max(stooges,function(stooge){ return stooge.age; });
 console.log(show);//=> {name: "curly", age: 60}
```

##_.min(list, [iteratee], [context]) 
listの中の最小値を返す。
listがオブジェクト配列であれば、iterateeで合致したオブジェクトを返す。
数値以外のものは無視すると書いてあったけど、falseは結果で出る？？

```javascript

 var numbers = [10, 5, 100, 2, 1000];
 var show = _.min(numbers);
 console.log(show);//=> 2

 var numbers = [10, 5, 100, 2, 1000, false, true, 'Moe'];
 var show = _.min(numbers);
 console.log(show);//=> false

 var stooges = [
   {name: 'moe', age: 40}, 
   {name: 'larry', age: 50}, 
   {name: 'curly', age: 60}
 ];
 var show = _.min(stooges,function(stooge){ return stooge.age; });
 console.log(show);//=> {name: "moe", age: 40}
```

##_.sortBy(list, iteratee, [context]) 
listの要素をiterateeの条件に合ったkey順にソートする。
降順にしたいときはiterateeのreturn関数に-を入れる
iterateeにはkeyを入れてもOK

```javascript

 var show = _.sortBy([1, 2, 3, 4, 5, 6], function(num){ return Math.sin(num); });
 console.log(show);//=> [5, 4, 6, 3, 1, 2]

 var show = _.sortBy([1, 2, 3, 4, 5, 6], function(num){ return -Math.sin(num); });
 console.log(show);//=> [2, 1, 3, 6, 4, 5]

 var stooges = [
   {name: 'moe', age: 40}, 
   {name: 'larry', age: 50}, 
   {name: 'curly', age: 60}
 ];

 var show = _.sortBy(stooges, 'name');
 console.log(show);//=> [{name: 'curly', age: 60}, {name: 'larry', age: 50}, {name: 'moe', age: 40}]

 var show = _.sortBy(stooges, 'age');
 console.log(show);//=> [{name: "moe", age: 40}, {name: "larry", age: 50}, {name: "curly", age: 60}]

 var show = _.sortBy(stooges, function(element){return -element.age;});
 console.log(show);//=> [{name: "curly", age: 60}, {name: "larry", age: 50}, {name: "moe", age: 40}]
```

##_.groupBy(list, iteratee, [context])
listの要素をiterateeで合致したグループに分けて返す。

```javascript

 var show = _.groupBy([1.3, 2.1, 2.4], function(num){ return Math.floor(num); });
 console.log(show);//=> {1: [1.3], 2: [2.1, 2.4]}

 var show = _.groupBy(['one', 'two', 'three'], 'length');
 console.log(show);//=> {3: ["one", "two"], 5: ["three"]}

 var show = _.groupBy([1, 2, 3, 4, 5], isPrime);
 console.log(show);//=> {false: [1, 4], true: [2, 3, 5]}
```

##_.indexBy(list, iteratee, [context]) 
iterateeで合致するキーのオブジェクトを配列で返す。
ひとつしか結果が得られないので、同じものがあると、後勝ちになる。
もし、同じものがないと分かっていれば使えるが、そうでない場合はGroupByが良い。

```javascript

 var stooges = [
   {name: 'moe', age: 40}, 
   {name: 'larry', age: 50}, 
   {name: 'curly', age: 60},
   {name: 'Richard', age: 40}, 
 ];

 var show = _.indexBy(stooges, 'age');
 console.log(show);//=>{40: {name: "Richard", age: 40},50: {name: "larry", age: 50},60: {name: "curly", age: 60}}
```

##_.countBy(list, iteratee, [context]) 
listの要素をiterateeで合致するグループに分けて、その数をカウントして返す。
groupByと似ているが、こちらはグループ化した数だけを返す。

```javascript

 var func = function(num) {
  return num % 2 == 0 ? 'even': 'odd';
}
 var show = _.countBy([1, 2, 3, 4, 5], func);
 console.log(show);//=> {odd: 3, even: 2}

 var show = _.countBy([1, 2, 3, 4, 5], isPrime);//素数判定
 console.log(show);//=> {false: 2, true: 3}```
```

##_.shuffle(list) 
リスト内をシャッフルした配列を返す。
オブジェクトの場合はvalueを返す。

```javascript

 var show = _.shuffle([1, 2, 3, 4, 5, 6]);
 console.log(show);//=> [2, 3, 5, 1, 6, 4]

 var show = _.shuffle({ one : 1, two : 2, three : 3 });
 console.log(show);//=> [1, 3, 2]
```

##_.sample(list, [n]) 
list内の要素をランダムに取り出す。
[n]が指定されていれば、その数分の要素を入れた配列を返す。

```javascript

 var show = _.sample([1, 2, 3, 4, 5, 6]);
 console.log(show);//=> 5

 var show = _.sample([1, 2, 3, 4, 5, 6], 2);
 console.log(show);//=> [3, 2]
```

##_.toArray(list) 
リアルな配列を返す。
引数を配列に入れるときに便利。

```javascript

 var show = _.toArray([1, 2, 3, 4]);
 console.log(show);//=>[1, 2, 3, 4]

 var fun = function(n){
   return _.toArray(n).slice(1);
 }

 var show = _.each([1, 2, 3], fun);
 console.log(show);//=> [1, 2, 3]
```

##_.size(list) 
listの要素の数を返す。

```javascript

 var show = _.size([1, 2, 3, 4, 5]);
 console.log(show);//=> 5

 var show = _.size({one: 1, two: 2, three: 3});
 console.log(show);//=> 3

 var show = _.size({one: 1, two: 2, three: function(){ }});
 console.log(show);//=> 3
```

##_.partition(list, predicate) 
listの要素を、predicateの条件と合うか合わないかで配列を分けて返す。

```javascript

 var show = _.partition([0, 1, 2, 3, 4, 5], isPrime);//素数判定
 console.log(show);//=> [[2, 3, 5],[0, 1, 4]]

 var func = function(n){
   return n % 2 === 0
 };
 var show = _.partition([0, 1, 2, 3, 4, 5], func);
 console.log(show);//=> [[0, 2, 4],[1, 3, 5]]
```

##_.compact(list) 
listから全てのネガティブ値を削除して返す。
削除されるもの⇒　false, null, 0, "", undefined, NaN

```javascript

 var show = _.compact([0, 1, false, 2, '', 3]);
 console.log(show);//=> [1, 2, 3]
```

#Arrays
##_.first(array, [n])
array配列の最初の要素を返す。 
[n]を指定すると、その数分先頭から要素をとって配列で返す。

Aliases: head, take　（_.headと_.takeでも使える）

```javascript

 var show = _.first([5, 4, 3, 2, 1]);
 console.log(show);//=> 5

 var show = _.first([5, 4, 3, 2, 1], 2);
 console.log(show);//=> [5, 4]
```

##_.initial(array, [n]) 
array配列の最後の要素を削除して返す。
[n]を指定すると、その数分末尾から削除して返す。

```javascript

 var show = _.initial([5, 4, 3, 2, 1]);
 console.log(show);//=> [5, 4, 3, 2]   

 var show = _.initial([5, 4, 3, 2, 1], 2);
 console.log(show);//=> [5, 4, 3]
```

##_.last(array, [n]) 
array配列の最後の要素を返す。
[n]を指定すると、その数分末尾からの要素を返す。

```javascript

 var show = _.last([5, 4, 3, 2, 1]);
 console.log(show);//=> 1

 var show = _.last([5, 4, 3, 2, 1], 2);
 console.log(show);//=> [2, 1]
```

##_.rest(array, [index])
array配列の最初のひとつを外した配列を返す。
[index]を指定すると、その数分外す。

Aliases: tail, drop 　（_.tailと_.dropでも使える）

```javascript

 var show = _.rest([5, 4, 3, 2, 1]);
 console.log(show);//=> [4, 3, 2, 1]

 var show = _.rest([5, 4, 3, 2, 1], 2);
 console.log(show);//=> [3, 2, 1]
```

##_.flatten(array, [shallow]) 
ネストされた配列を全て1次元配列にする。
[shallow]がtrueの時は、ひとつだけネストを外す。

```javascript

 var show = _.flatten([1, [2], [3, [[4]]]]);
 console.log(show)//=> [1, 2, 3, 4];

 var show = _.flatten([1, [2], [3, [[4]]] ], true);
 console.log(show)//=> [1, 2, 3, [[4]]];

 var show = _.flatten([ [[1], [2]], [3, [4]] ], true);
 console.log(show)//=> [[1], [2], 3, [4] ];
```

##_.without(array, *values) 
valuesで指定した値を削除したarray配列のコピーを返す。
valuesには配列の指定はできない。

```javascript

 var show = _.without([1, 2, 1, 0, 3, 1, 4], 0, 1);
 console.log(show);//=>[2, 3, 4]
```

##_.union(*arrays) 
全てのarray配列の要素で被らないものを配列にして返す。
要素の並びは、書いてあるarray順に付け足される。

```javascript

 var show = _.union([1, 2, 3], [101, 2, 1, 10], [2, 1]);
 console.log(show);//=>[1, 2, 3, 101, 10]

 var show = _.union([1, 2, 3], [1, 2, 3, 10], [1, 2, 3, 4]);
 console.log(show);//=>[1, 2, 3, 10, 4]
```

##_.intersection(*arrays) 
array配列の全ての要素で被る要素をピックアップして配列で返す。
最初のarr配列が基礎。並びはそれになる。

```javascript

 var show = _.intersection([1, 2, 3], [101, 2, 1, 10], [2, 1]);
 console.log(show);//=> [1, 2]
```

##_.difference(array, *others) 
array配列内の*othersで被らない要素を配列に入れて返す。
_.withoutと似ているが、あくまで、第1引数のarray配列がメインになる。

```javascript

 var show = _.difference([1, 2, 3, 4, 5], [5, 2, 10]);
 console.log(show);//=> [1, 3, 4]

 var show = _.difference([1, 2, 3, 4, 5], [1, 2, 3],[1, 2, 3, 4]);
 console.log(show);//=> [5]
```

##_.uniq(array, [isSorted], [iteratee])
array配列内の同じ要素を排除して配列を作成する。
最初の要素が優先される。
配列がソートされていれば、[isSorted]をtrueにすると処理が早くなる。
でもtrueにした時に[iteratee]に何か入っていないと、全ての値を返すので注意。
[isSorted]に関数を入れても動く。
Alias: unique　（_.uniqueでも使える）

```javascript

 var show = _.uniq([1, 2, 1, 4, 1, 3]);
 console.log(show);//=>[1, 2, 4, 3]

 var arr = [
   {name: 'Moe', age: 30},
   {name: 'Curly', age: 40},
   {name: 'Larry', age:30},
   {name: 'Moe', age:60}
 ];
 var show = _.uniq(arr, true, 'name');
 console.log(show);//=> [{name: "Moe", age: 30},{name: "Curly", age: 40},{name: "Larry", age: 30}]

 var func = function(element){
   return element.age;
 }
 var show = _.uniq(arr, func);
 console.log(show);//=> [{name: "Moe", age: 30},{name: "Curly", age: 40},{name: "Moe", age: 60}]
```

##_.zip(*arrays) 
複数の配列をひとつにまとめる。
_.zip.applyは_.unzipと同じ動きをする。
飛び出した分はundefinedで穴埋めされる

```javascript
 var arr1 = [1, 2, 3];
 var arr2 = ['A', 'B', 'C'];
 var arr3 = ['a', 'b', 'c'];

 var newArr = _.zip(arr1, arr2, arr3);
 console.log(newArr);//=> [[1, "A", "a"],[2, "B", "b"],[3, "C", "c"]]

 var show = _.zip.apply(_,newArr);
 console.log(show);//=> [[1, 2, 3],["A", "B", "C"],["a", "b", "c"]]

 var show = _.unzip(newArr);
 console.log(show);//=> [[1, 2, 3],["A", "B", "C"],["a", "b", "c"]]
```

##_.unzip(array) 
各配列の要素の順番ごとに新しい配列を作成する。
_.zip.applyと同じ。

```javascript
 var arr = [[1, "A", "a"],[2, "B", "b"],[3, "C", "c"]];
 var show = _.unzip(arr);
 console.log(show);//=> [[1, 2, 3],["A", "B", "C"],["a", "b", "c"]]
```

##_.object(list, [values]) 
listの要素がkeyになる{key, value}のシングル配列を作成する。
valuesが多い分は無視される。listが多い分は、valueにundefinedが入る。
同じkeyがあれば、後勝ちとなる。
　　多次元配列の場合はvaluesの入力不要。３つ目の要素は無視される。

```javascript

 var show = _.object(['moe', 'larry', 'curly'], [30, 40, 50, 60]);
 console.log(show);//=> {moe: 30, larry: 40, curly: 50}

 var show = _.object(['moe', 'larry', 'curly', 'Richard'], [30, 40, 50]);
 console.log(show);//=> {moe: 30, larry: 40, curly: 50, Richard: undefined}

 var show = _.object([['moe', 30], ['larry', 40], ['curly', 50]]);
 console.log(show);//=> {moe: 30, larry: 40, curly: 50}

 var show = _.object([['moe', 30, 50], ['larry', 40, 60], ['curly', 50, 70]]);
 console.log(show);//=> {moe: 30, larry: 40, curly: 50}
```

##_.chunk(array, length) 
array配列の要素を、lengthの数毎に分ける。

```javascript

 var arr = array = [ 1, 2, 3, 4, 5, 6, 7, 8 ];
 var show = _.chunk(arr, 2);
 console.log(show);//=> [[1, 2],[3, 4],[5, 6],[7, 8]]
```

##_.indexOf(array, value, [isSorted]) 
array配列内にvalueの値があれば、最初に現れたその配列indexを返す。
[isSorted]はarray配列がソート済みならtrueを入れると処理が早くなる。
数字を入力したら、その配列index以降から探し始める。
結果がなければ-1を返す。
Array.indexOfとほぼ同じ。

```javascript

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

 var show = _.indexOf([1, 2, 3], 2, true);
 console.log(show);//=> 1

 var show = _.indexOf([1, 2, 3], 2, 2);
 console.log(show);//=> -1 // not found
```

##_.lastIndexOf(array, value, [fromIndex])
array配列内を末尾から探して、valueの値があれば、最初に現れたその配列indexを返す。
[fromIndex]を指定したら、その配列index以降から探し始める。
結果がなければ-1を返す。

```javascript

 var show = _.lastIndexOf([1, 2, 3, 1, 2, 3], 2);
 console.log(show);//=> 4

 var show = _.lastIndexOf([1, 2, 3, 1, 2, 3], 2, 2);
 console.log(show);//=> 1
```

##_.sortedIndex(array, value, [iteratee], [context]) 
array配列内に、valueを入れるときに、どこに入るのかの最初に現れた配列indexを返す。
[iteratee]に優先したい配列のkeyを入れたら、それでソートして、何番目に入るかを返す。

```javascript

 var show = _.sortedIndex([10, 20, 30, 40, 50], 35);
 console.log(show) //=> 3

 var stooges = [{name: 'moe', age: 40}, {name: 'curly', age: 60}];
 var show = _.sortedIndex(stooges, {name: 'larry', age: 50}, 'age');
 console.log(show)//=> 1
```

##_.findIndex(array, predicate, [context])
_.indexOfに似ている。
predicateに一致するものがarray配列内にあれば、最初に現れた配列indexを返す。
なければ-1を返す。

[isPrimeの素数判定には素数判定のjs使用](https://gist.github.com/think49/675313/c9abb72fd87fa3309e42fe8613597f0b014d669b))

```javascript

 var show = _.findIndex([4, 6, 8, 12], isPrime);
 console.log(show);//=> -1 // not found

 var show = _.findIndex([4, 6, 7, 12], isPrime);
 console.log(show);//=> 2
```

##_.findLastIndex(array, predicate, [context]) 
_.findIndexの逆から探しバージョン。
predicateに設定した関数の値が、array配列内にあれば、
最初に現れた配列のindexを返す。indexは配列内の番号。arr[0]の0の部分。

```javascript

 var users = [{'id': 1, 'name': 'Bob', 'last': 'Brown'},
  {'id': 2, 'name': 'Ted', 'last': 'White'},
  {'id': 3, 'name': 'Frank', 'last': 'James'},
  {'id': 4, 'name': 'Ted', 'last': 'Jones'}];

 var show = _.findLastIndex(users, {
  name: 'Ted'
   });
 console.log(show)//=> 3
 ```

##_.range([start], stop, [step]) 
整数の配列が自由にできる。
[start]を含む数から（指定がなければデフォルト0）stopの数未満。
[step]を指定したら、その数分飛ばして表示。マイナスも指定可能

```javascript

 var show = _.range(10);
 console.log(show)//=> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

 var show = _.range(1, 11);
 console.log(show)//=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

 var show = _.range(0, 30, 5);
 console.log(show)//=> [0, 5, 10, 15, 20, 25]

 var show = _.range(0, -10, -1);
 console.log(show)//=> [0, -1, -2, -3, -4, -5, -6, -7, -8, -9]

 var show = _.range(0);
 console.log(show)//=> []
```

#Functions
##_.bind(function, object, *arguments) 
function関数のthisをobjectに入れる。
*argumentsはオプショナルで複数 , で末尾に付け足す。

```javascript

 var func = function(argument, num){
   return argument + num + '回 ' + this.name + ': ' + this.age + '歳';
 };
 func = _.bind(func, {name: 'moe',age: 50}, '関数の引数になる', 5);
 console.log(func());//=> 関数の引数になる5回 moe: 50歳
```

##_.bindAll(object, *methodNames) 
methodNamesで指定したメソッドだけbindする。未指定なら全メソッドが対象。
複数の関数をオブジェクトにバインドする。イベントハンドラーに関数をバインドするときに便利。
第一引数に指定したオブジェクトAがあった時、Aがもつ関数プロパティのthisをAにしてしまう関数
？？？？？？？？？？？？？？？？？

```javascript

 var obj = {
   val: "hoge",
   print: function() { console.log(this.val); },
   set: function(v) { this.val = v; },
   get: function() { return this.val; }
 };
 console.log(obj.print());
 _.bindAll(obj, "print", "set"); // 指定のメソッドについてbind
```

##_.partial(function, *arguments) 
function関数の引数を部分適用した新しい関数をつくれる。
_.bindに似ている。
飛ばしたい引数があれば _ を代わりに書く。

```javascript

 function mathSum(num1, num2){
   return num1 + num2;
 }
 var show = mathSum(1, 3);
 console.log(show);//=> 4

 var num1Is5 = _.partial(mathSum, 5);
 var show = num1Is5(3);
 console.log(show);//=> 8

 var num2Is4 = _.partial(mathSum, _, 4);
 var show = num2Is4(7);
 console.log(show);//=> 11
 ```

##_.memoize(function, [hashFunction]) 
関数の計算結果をキャッシュする。
hasFunctionは、結果を保存する時のkeyとして使われる。
hasFunctionを指定しなければ、関数の引数がkeyとなる。

```javascript

 var fibonacci = _.memoize(function(n) {
   return n < 2 ? n: fibonacci(n - 1) + fibonacci(n - 2);
 }); 
 console.log(fibonacci(10));
```

##_.delay(function, wait, *arguments) 
非常にsetTimeoutに似たもの。
waitミリ秒待った後にfunction関数が実行される。
*argumentsはオプショナルで、function関数の引数に入れられる。

```javascript

 var log = _.bind(console.log, console);
 _.delay(log, 3000, 'logged later');//=> 3秒待機後にlogged later表示
```

##_.defer(function, *arguments) 
コールスタックが空になるまで処理を待つ。
setTimeout　delay = 0と似たような感じ。
めっちゃ時間がかかる計算とか、重いHTMLページを表示するときに便利。
*argumentsはオプショナルで、function関数の引数に入れられる。

```javascript

 var func = function(msg){
   console.log(msg);
 }
 var show = function(){
   console.log('aaa');
   _.defer(func, 'bbb');//=> bbb
   console.log('ccc');
 }
 show();//=> aaa, ccc, bbbの順で表示
```

##_.throttle(function, wait, [options]) 
連続して何度も実行しようとしても、waitoミリ秒後からしかfunction関数が実行できない。
初回はwaitミリ秒待たずにすぐに表示される。
[options]を{leading: false}にすると、初回もwaitミリ秒待ってから実行される。
[options]を{trailing: false}にすると、waitミリ秒内に次の呼び出しがあれば、
実行がキャンセルされる。これが一番使いやすそう。
キャンセルしたいときは、show.cancel()と書く

```javascript

 var func = function() {
   console.log('xxx');
 }
 var show = _.throttle(func, 3000);
 window.addEventListener('resize', show);//=>初回はすぐ実行。3秒後に再実行される

 var show = _.throttle(func, 3000, {leading: false});
 window.addEventListener('resize', show);//=>初回も3秒待つ

 var show = _.throttle(func, 3000, {trailing: false});
 window.addEventListener('resize', show);//=>初回はすぐ実行。
 ```

##_.debounce(function, wait, [immediate]) 
初回もfuncfionの関数がwaitミリ秒待機して実行される。
[immediate]をtrueにすると、最初に関数が実行される。
フォームのsubmitボタンを何度も押されないように設定したりするとか？

```javascript

 function func(){
   console.log('xxx')
 };
 var show = _.debounce(func, 3000);

 show();//=> リロードして3秒後に表示
 //window.addEventListener('resize', show);//=> ブラウザの大きさを変えて3秒後に表示
```

##_.once(function)
1回しか関数を実行できない。

```javascript

 var func = function(n){
   console.log("show "+ n + " times");
 }
 var show = _.once(func);
 show(1);//=> show 1 times
 show(2);//=> 実行されない
 show(3);//=> 実行されない
```

##_.after(count, function) 
countに設定した数からしか、functionの関数が実行されない。

```javascript

 var func = function(n){
   console.log("show "+ n + " times");
 }
 var show = _.after(3, func);
 show(1);//=> 実行されない
 show(2);//=> 実行されない
 show(3);//=> show 3 times
```

##_.before(count, function) 
countに設定した数-1回まで、functionの関数が実行される。
書いても実行されない。

```javascript

 var func = function(n){
   console.log("show "+ n + " times");
 }
 var show = _.before(3, func);
 show(1);//=> show 1 times
 show(2);//=> show 2 times
 show(3);//=> 実行されない
```

##_.wrap(function, wrapper) 
functionをwrapper関数の中に包む。
wrapper関数では、function関数の前後に処理を加えられる。

```javascript

 var hello = function(name) { return "hello: " + name; };
 hello = _.wrap(hello, function(func) {
   return "before, " + func("moe") + ", after";
 });
 console.log(hello());//=> before, hello: moe, after

 var main = function(name) { return name; };
 var before = function(greet) { return greet; };
 var after = function(question) {return question; };
 var func = function(func) {
   return before("hello ") + func("moe ") + after("What's up?");
 };
 var show = _.wrap(main, func);
 console.log(show());//=> hello moe What's up?
```

##_.negate(predicate) 
 predicateの戻り値の真偽値を反対にする。

```javascript

 isFalt = _.negate(Boolean);
 var show = _.find([-2, -1, 0, 1, 2], isFalt);
 console.log(show);//=> 0

 var func = function(n){ return n > 0; }
 var result = _.negate(func);
 var show = _.filter([-2, -1, 0, 1, 2], result);
 console.log(show);//=> [-2, -1, 0]
 ```

##_.compose(*functions) 
関数をリストアップして、ひとつにまとめる。
例えば、 関数f()と関数g()と関数h()を_.compose(f,g,h)とした場合、

```
f(
  g(
    h()
  )
)
```


という入れ子状態になる。
compose（集められた素材がものを構成する）

```javascript

 var greet= function(name){
   return "hi: " + name;
 };
 var exclaim  = function(statement){
   return statement.toUpperCase() + "!";
 };
 var welcome = _.compose(greet, exclaim);
 var show = welcome('moe');
 console.log(show);//=> 'hi: MOE!
```

##_.restArguments(function, [startIndex]) 
ES6でいう、[Rest parameters](https://developer.mozilla.org/ja/docs/Web/JavaScript/Reference/Functions/rest_parameters)
いくつ引数が入るかわからないものも、対応するよーみたいなのか。
公式の例を試してもエラーになるので・・・。
？？？？？？？？？？？？？？

```javascript
   
 var raceResults = _.restArguments(function(gold, silver, bronze, everyoneElse) {
   _.each(everyoneElse, sendConsolations);
 });

 raceResults("Dopey", "Grumpy", "Happy", "Sneezy", "Bashful", "Sleepy", "Doc");
```   

#Object
##_.keys(object) 
オブジェクトのkeyを配列で返す。プロトタイプは返さない。

```javascript

 function Stooge(name,age) {
   this.name = name;
   this.age = age;
 }
 Stooge.prototype.silly = true;
 var show = _.keys(new Stooge("Moe",50));
 console.log(show);//=> ["name", "age"]
```

##_.allKeys(object) 
オブジェクトの全てのkeyを配列で返す。プロトタイプも返す。

```javascript

 function Stooge(name) {
   this.name = name;
 }
 Stooge.prototype.silly = true;
 var show = _.allKeys(new Stooge("Moe"));
 console.log(show);//=> ["name", "silly"]
```

##_.values(object) 
オブジェクト自身が持っている全ての値を配列で返す。
prototypeは入らないらしい。

```javascript

 var show = _.values({one: 1, two: 2, three: 3});
 console.log(show);//=> [1, 2, 3]
```

##_.mapObject(object, iteratee, [context]) 
_.mapみたいなものだけど、オブジェクトのためのもの。
interateeの中で変化した結果を返す。

```javascript

 var func = function(value, key){
   return value + 5;
 };
 var show = _.mapObject({start: 5, end: 12}, func);
 console.log(show);//=>{start: 10, end: 17}
```

##_.pairs(object) 
[key, value]を1セットにして、配列にする。
._objectの逆

```javascript
 var show = _.pairs({one: 1, two: 2, three: 3});
 console.log(show);//=> [["one", 1], ["two", 2], ["three", 3]]
```

##_.invert(object) 
オブジェクトのkeyとvalueを逆にする。
valueはユニーク（被りがない）で、シリアライズ化されていないといけない。
関数が入っても、被っても、エラーにはならない。

```javascript

 var show = _.invert({Moe: "Moses", Larry: "Louis", Curly: "Jerome"});
 console.log(show);//=>{Moses: "Moe", Louis: "Larry", Jerome: "Curly"}

 //4が被っている
 var show = {1: 'a', 2: 'b', 3: 'c', 4: 'a'};
 console.log(_.invert(show));//=>{a: "4", b: "2", c: "3"}
```

##_.create(prototype, props) 
新しいオブジェクトをプロパティと一緒に作る。
prototypeに入れたオブジェクトが、__proto__で入る。

```javascript
 function Stooge(){};
 var show = _.create(Stooge.prototype, {name: "Moe"});
 console.log(show);//=> Stooge {name: "Moe"}

 function Stooge(name, age){
   this.name = name;
   this.age = age;
 };

 var newStooge = new Stooge('Curly',50);
 console.log(newStooge);//=> Stooge {name: "Curly", age: 50}

 var show = _.create(newStooge, {name: "Moe"});
 console.log(show);//=> Stooge {name: "Moe"}

 var obj1 = {
   name: 'Moe',
   age: 50,
   favdrink: 'cola'
 };
 var obj2 = {
   name: 'Curly',
   age: 30,
   favfood: 'pizza'
 };
 var show = _.create(obj1, obj2);
 console.log(show);//=> {name: "Curly", age: 30, favfood: "pizza"}
 console.log(show.__proto__.name);//=> Moe
 console.log(_.allKeys(show));//=> ["name", "age", "favfood", "favdrink"]
```

##_.functions(object)
objectに含まれているすべてのメソッド名を昇順に並び替えて配列で返す。
Alias: methods　（_.methodsでも使える） 

```javascript

 var show = _.functions(jQuery);
 console.log(show);//=>  ["Animation", "Callbacks", "Deferred" ...

 var show = _.functions(_);
 console.log(show);//=>  ["after", "all", "allKeys", ...

 var show = _.methods(_);
 console.log(show);//=>  ["after", "all", "allKeys", ...
 ```

##_.findKey(object, predicate, [context]) 
predicateで指定した値と合致したobjectのkeyを返す。
predicateには関数が入る。

predicate(名）述語だけど、この場合は前提の意？)

```javascript

 var obj = {name: "Moe", age: 50};
 var func = function(value, key, obj) {
   return value === "Moe";
   //return _.isNumber(value);//数字のvalueを指定
   //return _.isString(value);//文字のvalueを指定
 };

 var show = _.findKey(obj, func);
 console.log(show);//=> value == "Moe"時name
                   //_.isNumber(value)時 age
                   //_.isString(value)時 name
```

##_.extend(destination, *sources) 
sourcesオブジェクトの全プロパティをdestinationオブジェクトにシャローコピー。
ネストされたオブジェクトや配列は参照コピーになる。
同じ引数があった場合は、上書きされる。
destination object(対象物)

```javascript

 var show = _.extend({name: 'moe'}, {age: 50});
 console.log(show);//=>{name: "moe", age: 50}

 var show = _.extend({name: 'moe'}, {name: 'Curly',age: 50});
 console.log(show);//=>{name: "Curly", age: 50}
```

##.extendOwn(destination, *sources) 
動きはextendみたいだけど、sourcesオブジェクトのプロパティまでコピーしない。
（_.extendはコピーする）

Alias: assign 　（_.assignでも同じく使える）
[Underscore.jsおさらい5(Objects)](https://edgegram.hatenablog.jp/entry/2016/03/07/172623)
[underscoreコードリーディング（extendOwn）](https://qiita.com/ikasumi_wt/items/c7706ef6953fe207d710)

```javascript

 var fruit = { banana: 'yellow' };
 var fruits = Object.create(fruit);

 var show = _.extend({ apple: 'red' }, fruits);
 console.log(show);//=> {apple: "red", banana: "yellow"}

 var show = _.extendOwn({ apple: 'red' }, fruits);
 console.log(show);//=> {apple: "red"}
```

##_.pick(object, *keys) 
*keysで指定したkeyの{key:value}をピックアップする。
*keysには複数のkeyを入れたり、関数を入れることができる。

```javascript

 var show = _.pick({name: 'moe', age: 50, userid: 'moe1'}, 'userid');
 console.log(show);//=> {userid: "moe1"}

 var show = _.pick({name: 'moe', age: 50, userid: 'moe1'}, 'name','age');
 console.log(show);//=> {name: "moe", age: 50}

 var show = _.pick({name: 'moe', age: 50, userid: 'moe1'}, 
 function(value, key, object) { 
   return _.isNumber(value);//数字のvalueを指定
   return _.isString(value);//文字のvalueを指定
 });
 console.log(show);//=> _.isNumber(value)時{age: 50}
                   //=> _.isString(value)時{name: "moe", userid: "moe1"}
```

##_.omit(object, *keys)
*keysで指定したkeyの{key:value}が削除される。
*keysには複数のkeyを入れたり、関数を入れることができる。

```javascript

 var show = _.omit({name: 'moe', age: 50, userid: 'moe1'}, 'userid');
 console.log(show);//=> {name: "moe", age: 50}

 var show = _.omit({name: 'moe', age: 50, userid: 'moe1'}, 'name','age');
 console.log(show);//=> {userid: "moe1"}

 var show = _.omit({name: 'moe', age: 50, userid: 'moe1'}, 
 function(value, key, object) { 
   return _.isNumber(value);//数字のvalueを指定
   return _.isString(value);//文字のvalueを指定
 });
 console.log(show);//=> _.isNumber(value)時{name: "moe", userid: "moe1"}
                   //=> _.isString(value)時{age: 50}
```

##_.defaults(object, *defaults) 
objectに*defaultsに記入したプロパティを持っていない時、上書きする。
持っていたら、元からあるものが保持される。

```javascript

 var iceCream = {flavor: "chocolate"};
 var show = _.defaults(iceCream, {flavor: "vanilla", sprinkles: "lots"});
 console.log(show);//=> {flavor: "chocolate", sprinkles: "lots"}

 var iceCream = {flavor: "vanilla", sprinkles: "lots"};
 var show = _.defaults(iceCream, {flavor: "grape", sprinkles: "less"});
 console.log(show);//=> {flavor: "vanilla", sprinkles: "lots"}
```

##_.clone(object) 
plain objectをシャローコピーする。
ネストされているものや配列、not plain objectは参照コピーになる。
[シャローコピー、ディープコピーとは](https://teratail.com/questions/94661)

**シャローコピー**=オブジェクトがメモリ上の同じデータ(インスタンス変数)を参照

```javascript:PlainObject

let a = {aaa : 1}
let b = new Object()
```

```javascript:NotPlainObject

let C = function(){}
let d = new C()
```

```javascript

 var obj = {name: 'moe',
 fears: {
   worst: 'spider'
 }
   };

 var cloneObj = _.clone(obj);

 //参照コピー
 obj.fears.worst = 'bugs';
 console.log(obj.fears.worst);//=> bugs
 console.log(cloneObj.fears.worst);//=> bugs

 //シャローコピー
 obj.name = 'curly';
 console.log(obj.name);//=> curly
 console.log(cloneObj.name);//=>moe
```

##_.tap(object, interceptor) 
_.chainメソッド内で使う。
そのchainメソッド内に割り込んで、途中結果を取るためのもの。
interceptor(狙撃機、遮るもの)

```javascript

 var show = _.chain([1,2,3,200])
 .filter(function(num) { return num % 2 == 0; })
 .tap(console.log)//=> [2, 200]
 .map(function(num) { return num * num })
 .value();

 console.log(show);//=>[4, 40000]
```

##_.has(object, key) 
object内にkeyが含まれていればtrueを返す。
object.hasOwnProperty(key)と同じ結果だけど、
こっちのほうが安全らしい。

```javascript

 var stooge = {a: 1, b: 2, c: 3};
 var show = _.has(stooge, "b");
 console.log(show);//=> true

 console.log(stooge.hasOwnProperty("b"));
```

##_.property(path) 
pathで指定したkeyに一致するvalueが返ってくる。
Google翻訳さんによれば・・・
渡されたオブジェクトの指定されたプロパティを返す関数を返します。 
pathは、ディーププロパティフェッチのために、単純キーとして、
またはオブジェクトキーの配列または配列インデックスとして指定できます。

```javascript

 var stooge = {name: 'moe'};
 var show = _.property('name')(stooge);
 console.log(show);//=>moe

 var stooges = {
  moe: {
   fears: {
    worst: 'Spiders'
   }
  },
  curly: {
   fears: {
    worst: 'Moe'
   }
  }
 };
 var show = _.property(['curly', 'fears', 'worst'])(stooges);
 console.log(show);//=>Moe
```

##_.propertyOf(object) 
**_.propertyの逆の書き方**
  _.property('name')(stooge)
  _.propertyOf(stooge)('name')
keyからvalueを探して表示。

```javascript
 var stooge = {name: 'Moe'};
 var show = _.propertyOf(stooge)('name');
 console.log(show);//=> Moe
```

##_.matcher(attrs)
attrsの{key:value}に同じものがあるかを見る。
attrsには複数のkeyとvalueを設定できる。
[underscoreコードリーディング（matcher）](https://qiita.com/ikasumi_wt/items/214fba3534d95aca1536)

Alias: matches　（_.matchesでも同じく使える）

```javascript

 var match = _.matcher({name: 'Moe', age: 20});
 var show = match({age: 20, sex: "female", name: "Moe"});
 console.log(show);//=> true;

 var match = _.matcher({name: 'Moe'});
 var show = match({age: 20, sex: "female"});
 console.log(show);//=> false;

//_.matches使ってみる
 var match = _.matches({name: 'Moe', age: 20});
 var show = match({age: 20, sex: "female", name: "Moe"});
 console.log(show);//=> true;
 ```

##_.isEqual(object, other) 
めっちゃ深く比較するらしい。中身をちゃんと見る。

===は外側も比較してしまう（ここでいうなら、stoogeかcloneが違うからfalseになる)
外側をひっくるめて代入すればtrueになるが・・・
例）
var example = {name: 'moe', luckyNumbers: [13, 27, 34]};
var example2 = example;
var equal2 = example === example2;
console.log(equal2);//=> true

```javascript

 var stooge = {name: 'moe', luckyNumbers: [13, 27, 34]};
 var clone  = {name: 'moe', luckyNumbers: [13, 27, 34]};
 var show = _.isEqual(stooge, clone);
 console.log(show);//=> true

 var equal = stooge === clone;
 console.log(equal);//=> false

 var stooge = {name: 'moe', luckyNumbers: [13, 27, 34]};
 var clone  = {name:'moe',luckyNumbers:[13, 27, 34]};
 var show = _.isEqual(stooge, clone);
 console.log(show);//=> true
```

##_.isMatch(object, properties) 
propertiesに設定したkeyとvalueの値がobject内に含まれていたらtrueを返す。
でもpropertiesに文字列とか数字とかを入力してもtrueで返るので注意。

```javascript

 var stooge = {name: 'moe', age: 32};
 var show = _.isMatch(stooge, {age: 32});
 console.log(show);//=> true

 var stooge = {name: 'moe', age: 32};
 var show = _.isMatch(stooge, 'ages');
 console.log(show);//=> true
 ```

##_.isEmpty(object) 
オブジェクトの値が何もなければtrueを返す。
とにかく、列挙できる値がなければtrueになる。

```javascript

 var func = function(){};
 var show = _.isEmpty(func);
 console.log(show);//=> true

 var obj = {};
 var show = _.isEmpty(obj);
 console.log(show);//=> true

 var arr = [];
 var show = _.isEmpty(arr);
 console.log(show);//=> true

 var str = '';
 var show = _.isEmpty(str);
 console.log(show);//=> true
```

##_.isElement(object) 
objectがDOMのelementならtrueを返す。

```javascript
   
 var el = document.getElementById('for_isElement');
 var show = _.isElement(el);
 console.log(show);//=> true

 var el = document.getElementsByTagName('body');
 var show = _.isElement(el[0]);
 console.log(show);//=> true
```

##_.isArray(object) 
objectが配列ならtrueを返す。
配列の中身が空でもtrueになる。多次元配列でもtrueになる。

```javascript

 var arr = [1, 2, 3];
 var show = _.isArray(arr);
 console.log(show);//=> true

 var arr = new Array();
 var show = _.isArray(arr);
 console.log(show);//=> true 
 ```

##_.isObject(value) 
valueがオブジェクトならtrueを返す。
javaScriptのarry配列やfunction関数は全部オブジェクト扱い。
Strings文字列やnumbers数値は違う。

```javascript

 var func = function(){};
 var show = _.isObject(func);
 console.log(show);//=> true

 var arr = [1, 2, 3];
 var show = _.isObject(arr);
 console.log(show);//=> true

 var obj = {key: 'val'};
 var show = _.isObject(obj);
 console.log(show);//=> true

 var newObj = new Object();
 var show = _.isObject(newObj);
 console.log(show);//=> true

 var str = "abc";
 var show = _.isObject(str);
 console.log(show);//=> false

 var num = 1;
 var show = _.isObject(num);
 console.log(show);//=> false
```

##_.isArguments(object) 
objectがargumentsならtrueを返す。
argument（関数へ渡された引数を含む、関数内のみアクセス可能な配列）
arguments objectというのは仮引数で渡されたｘが自動的に入れられるobjectのこと。

function example(x) {
  console.log(x); //=> 1
  console.log(arguments[0]); //=> 1
  console.log(arguments[1]); //=> 2
  console.log(arguments[2]); //=> 3
}
example(1,2,3)←無限に入れられる。
単体で返してもだめで、オブジェクトでreturnしないとtrueにならない。

```javascript

 function example() {
   console.log(arguments); //=> [1, callee: ƒ, Symbol(Symbol.iterator): ƒ]
   return _.isArguments(arguments);
 }
 var show = example(1);
 console.log(show);//=> true

 function noexample() {
   return _.isArguments(arguments[0]);
 }
 var show = noexample(1);
 console.log(show);//=> false
```

##_.isFunction(object) 
objectが関数ならtrueを返す。

```javascript

 var func = function x(){};
 var show = _.isFunction(func);
 console.log(show);//=> true;
```

##_.isString(object) 
objectがString型（文字列）ならtrueを返す。

```javascript

 var str = 'moe';
 var show = _.isString(str);
 console.log(show);//=> true
```

##_.isNumber(object) 
objectが数値かNaNだったらtrueを返す。
注意！NaNでもtrue！(NaNの説明は_.isNaNを参照)
ただし、ここでいうNaNは従来の定義となる。

```javascript
   
 var num = 1;
 var show = _.isNumber(num);
 console.log(show);//=> true

 var nan = 0 * 'a';//=> NaN
 var show = _.isNumber(nan);
 console.log(show);//=> true
```

##_.isFinite(object) 
objectが有限個な数値だったらtrueを返す。
finity(有限)⇔infinity(無限)

javascriptでは無限値＝Number.POSITIVE_INFINITY（正の無限値）
正数を無限値で割ったら-0になる。 

```javascript

 var infinity = Number.POSITIVE_INFINITY;
 var finity = 1/infinity;
 var show = _.isFinite(finity);
 console.log(show);//=> true

 var show = _.isFinite(infinity);
 console.log(show);//=> false
```

##_.isBoolean(object) 
objectがboolean型(trueかfalse)だったらtrue

```javascript

 var x = 1 === 1;
 var show = _.isBoolean(x);
 console.log(show);//=> true

 var x = function (){
   return true;
 }
 var show = _.isBoolean(x());
 console.log(show);//=> true
 ```

##_.isDate(object) 
objectが日付型だったらtrueを返す。
手で日付作ってもfalse。new Date('2019-01-01')みたいに設定するとtrue。

```javascript

var show = _.isDate(new Date());
console.log(show);//=> true

var show = _.isDate('2019-01-01');
console.log(show);//=> false

var show = _.isDate(new Date('2019-01-01'));
console.log(show);//=> true
```

##_.isRegExp(object) 
objectがRegExp(正規表現)ならtrue

```javascript

 var nameRegExp = /moe/;
 var show = _.isRegExp(nameRegExp);
 console.log(show);
```

##_.isError(object) 
objectの内容がエラーで入ってきてるんだったらtrueを返す。

```javascript
 try {
   var n = 0;
   if( n < 5 ) {
     throw new Error('Error');
   }
 } catch (err) {
   console.log(_.isError(err));//=> true
 }
```

##_.isSymbol(object) 
objectがSymbolだったらtrueを返す。

シンボルはそれ自身とのみ等しくなる、ユニークなID。
シンボルはオブジェクトのプロパティキーとして使用できる。
[ECMAScript6にシンボルができた理由](https://qiita.com/naruto/items/312adeb6145eb6221be7)

ちなみに、シンボルは文字型じゃなくシンボル型。
typeof symbol =>symbol

```javascript

const symbol = Symbol('xxx');
const show = _.isSymbol(symbol);
console.log(show);//=> true
```

##_.isMap(object) 
objectがmapだったらtrueを返す。

マップとは、キーと値の組み合わせからなる抽象データ型。
他の言語では連想配列などと呼ばれることも。
 [MapとSetについて：js-primer](https://jsprimer.net/basic/map-and-set/)

```javascript

const map = new Map([["key1", "value1"], ["key2", "value2"]]);
const show = _.isMap(map);
sconsole.log(show);//=> true
```

##_.isWeakMap(object)
objectがWeakMapだったらtrueを返す。

[WeakMap、WeakSetで「弱い参照」を使えるようになったぞ](https://ginpen.com/2017/12/21/weakmap/)
新しい概念。メモリ対策らしい？

```javascript

const weakMap = new WeakMap();
const show = _.isWeakMap(weakMap);
console.log(show);//=> true
```

##_.isSet(object) 
objectがsetだったらtrueを返す。

セットとは、重複する値がないことを保証したコレクション
(重複値があっても、それをカウントしない)
配列と違って要素は順序をもたず、インデックスによるアクセスはできない。
参照は_.isMapと同じ

```javascript

const set = new Set(["value1", "value2"]);
const show = _.isSet(set);
console.log(show);//=> true
```

##_.isWeakSet(object) 
objectがWeakSetだったらtrueを返す。
詳しくはWeakMapの参照確認
データが重複していないか確認する為のセット？

```javascript

const weakset  = new WeakSet([{name: "Curly"}]);
const show = _.isWeakSet(weakset);
console.log(show);//=> true
```

##_.isNaN(object) 

NaNか、且つ数値だったらtrueを返す。
非数値かどうかを判定しているのではなく、引数が「NaN」かどうかを判定している。
NaN(Not a number＝非数値)

要注意！javascriptに元からある、isNaN()とは違う。
isNaN()は文字列でも強制的に数値に変換して、NaNになりそうだったらtrueになる。

NaNとは、数値（実数）であることが期待される演算や処理の結果が
数値として表せないものになったことを示す特殊な表現
[NaN（非数）とは：IT-用語辞典](http://e-words.jp/w/NaN.html)

```javascript

var show = _.isNaN(NaN);
console.log(show);//=> true

var show = isNaN(NaN);
console.log(show);//=> true

var show = _.isNaN(undefined);
console.log(show);//=> false

var show = isNaN(undefined);
console.log(show);//=> true

var y = "0 * 0";
var show = _.isNaN(y);
console.log(show);//=> false

var z = "0 * 0";
var show = isNaN(z);
console.log(show);//=> true
```

##_.isNull(object) 
引数に入っているオブジェクトの値がnullだったらtrueを返す。
nullはnullって明示的に入れないとだめ。
[nullとundefinedの違い](https://www.sejuku.net/blog/28461#undefinednull)

```javascript

var x = null;
var show = _.isNull(x);
console.log(show);//=> true

var y = 1;
var show = _.isNull(y);
console.log(show);//=> false

var z = {};
var show = _.isNull(z);
console.log(show);//=> false

var show = _.isNull(non);
console.log(show);//=> ReferenceErrorになる
```

##_.isUndefined(value) 
引数が「undefined」だったらtrueを返す。
undefinedは初期化されていない変数のこと。

```javascript

var x;
var show = _.isUndefined(x);
console.log(show);//=> true

var y = 1;
var show = _.isUndefined(y);
console.log(show);//=> false

var z = null;
var show = _.isUndefined(z);
console.log(show);//=> false

Utility*/
```

##_.noConflict()
アンダースコアのオブジェクトを他の名前でも使えるようにする。
他ライブラリとの衝突防止。もし被りそうならこれを使う。
conflict(対立、矛盾、衝突)

```javascript

var underS = _.noConflict();

//_.random(1, 5)と同じ様に使える
var show = underS.random(1, 5);
console.log(show);//=> 1だったり3だったり
```

##_.identity(value) 
引数の値をそのまま返す。
f(x) = x　という計算を中でしているらしい。
underscore的にはiterateeのデフォルト判定として使って欲しいらしい。
（iterateeはデータを取得しながら回すループを簡単に書くためのものだそう）
恒等関数 (identity function)というらしいよ。

```javascript

//公式例↓ constantと同じ・・・
var stooge = {name: 'moe'};
var show = stooge === _.identity(stooge);
console.log(show);//=> true

var show = _.identity("a, b, c");
console.log(show);//=> a, b, c
```

##_.constant(value) 
引数と同じ関数の値をそのまま返す。
_.constant(stooge)()　には　stoogeの{name: 'moe'}　がそのまま入っている。
なので、比べたら同じになる

```javascript

var stooge = {name: 'moe'};
var show = stooge === _.constant(stooge)();
console.log(show);//=> true

//関数でも同じ
var stooge = function(){ console.log("test")}
var show = stooge === _.constant(stooge)();
console.log(show);//=> true
```

##_.noop()
渡される引数に関係なく、undefinedを返す。
function(){}　が挿入されるらしい。
noopはno operationの事。
コールバック関数の初期化に役立つ？
？？？？？？？？

```javascript

//公式例↓
obj.initialize = _.noop;
```

##_.times(n, iteratee, [context]) 
nに書かれた数字分、iterateeに書かれる関数を繰り返す。
繰り返される関数の引数には 0 から n - 1 までの整数値が入る。
返り値は繰り返される関数の結果を格納した配列。
iterate（～を繰り返す）

```javascript

function call(n){
  return n * 2;
}
var show = _.times(3, call);
console.log(show);//=> [0, 2, 4]
```

##_.random(min, max) 
ランダムな数字を作成
minには最初の数字(以上)
maxには最大の数字(以下)
もし、引数がひとつしかなければ、minには「0」が自動挿入される。

```javascript

var show = _.random(1, 5);
console.log(show);//=> 1だったり3だったり

var show = _.random(5);
console.log(show);//=> 0だったり3だったり
```

##_.mixin(object) 
自分でアンダースコア関数を作成できる。

```javascript

_.mixin({
  uppercase: function(string){
return string.toUpperCase();
  }
});
var show = _("moe").uppercase();
console.log(show);//=> MOE
```

##_.iteratee(value, [context]) 
ほかの関数と合わせて使う?????????

```javascript

var show = _.iteratee(function(n) { return n * 2; });
console.log(show(2));//=> 4

//文字列であればキーの値を返す
var data = [{name: 'Curly'},{name: 'Larry'}, {name: 'Moe'}];
var show = _.map(data, _.iteratee('name'));
console.log(show);//=> ["Curly", "Larry", "Moe"]

//オブジェクトであればキーと値が一致すればtrueを返す
var show = _.map(data, _.iteratee({name: 'Moe'}));
console.log(show);//=> [false, false, true]
```

##_.uniqueId([prefix]) 
uniqueIdを使ってる分、勝手に番号が昇順で振られる。
引数の省略可能prefixには最初に表示したい文字を入れる。

```javascript

var show = _.uniqueId('contact_');
console.log(show);//=> contact_1

var prefix = 'hp';
var show = _.uniqueId(prefix);
console.log(show);//=> hp2
```

##_.escape(string)
` &, <, >, ", ```, ' `
↓　置き換える
` &amp;, &lt;, &gt;, &quot;, &#96;, &#x27; `

```javascript

var show = _.escape('Curly, Larry & Moe');
sconsole.log(show);//=> Curly, Larry &amp; Moe
```

##_.unescape(string)
_.escape()の逆

` &amp;, &lt;, &gt;, &quot;, &#96;, &#x27;`
↓　置き換える
` &, <, >, ", ```, ' `

```javascript

var show = _.unescape('Curly, Larry &amp; Moe');
console.log(show);//=> Curly, Larry & Moe
```

##_.result(object, property, [defaultValue])
オブジェクトのプロパティを指定したらその値を返す

```javascript

var object = {
  cheese: 'crumpets',
  stuff: function(){
return 'nonsense';
  }
};

var show = _.result(object, 'cheese');
console.log(show);//=> crumpets

var show = _.result(object, 'stuff');
console.log(show);//=> nonsense

var show = _.result(object, 'meat', 'ham');
console.log(show);//=> ham
```

##_.now()
ミリ秒で現時刻を取得
日時の比較とかに使う
jsのDate.now()や(new Date).getTime()と同じ

```javascript

console.log(_.now()); //=> 1549421648040
```

##_.template
<% %> →スクリプトも動くforとかifを差し込む時に使うのが多い 
<%= %>→タグがそのまま表示
<%- %>→タグはエスケープされて表示

```javascript

var compiled = _.template("hello: <%= name %>");
var show = compiled({name:'<b>moe</b>'});
console.log(show);//=> <b>moe</b>

var compiled = _.template("<b><%- value %></b>");
var show = compiled({value : '<script>'});   
console.log(show);//=> <script>

var compiled = _.template("<% print('Hello ' + epithet); %>");//epithet(あだ名)
var show = compiled({epithet: "stooge"});//stooge(ボケ役,太鼓持ち)
console.log(show);//=> Hello stooge
```

書き方を変えたければ↓・・・

```javascript

_.templateSettings = {
  interpolate: /\{\{(.+?)\}\}/g
}; //interpolate(補間,差し挟む,付け加える)

var template = _.template("Hello {{ name }}!");
var show = template({name : "Mustache"});
console.log(show);//=> Hello Mustache!

var show = _.template("Using 'with' : <%= data.answer %>", {variable: 'data'})
  ({answer: 'no'});
console.log(show);//=> Using 'with' no
```

#とても勉強になったサイト
[Underscore.jsおさらい](https://edgegram.hatenablog.jp/archive/category/Underscore.js)
[便利機能満載のライブラリUnderscore.js](http://d.hatena.ne.jp/ninoseki/20110414/1302786001)
[Underscore JS 日本語リファレンス]
(http://www.elder-flower.com/underscore_js.html)