概要

下記公式サイトのドキュメントに基づき、利用頻度順に記載しています。

lodash documentation

公式サイトの変更履歴

javascript/lodash’s changelog at AllMyChanges.com, release notes tracker

メソッドベースではなく、やりたいことベースに項目を作成しています。
メソッドベースの仕様は公式サイトをご覧下さい。

対象lodashバージョン: 4.11.1

Contents

共通

iterateeについて

Arrayの場合は(値, index, 全体)をイテレートする

_.map([10, 20, 30], (v, i, o) => `v=${v},  i=${i},  o=${o[0]}-${o[1]}-${o[2]}`)
// -> [ 'v=10,  i=0,  o=10-20-30',
//      'v=20,  i=1,  o=10-20-30',
//      'v=30,  i=2,  o=10-20-30' ]

Objectの場合は(値, key, 全体)をイテレートする

_.map({id: 1, name:"一郎"}, (v, k, o) => `v=${v},  k=${k},  o=${o.id}:${o.name}`)
// -> [ 'v=1,  k=id,  o=1:一郎', 'v=一郎,  k=name,  o=1:一郎' ]

comparatorについて

引数は2つ。

頻繁に使う

[map] コレクションの各要素に処理を加える

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

項目
引数 Array / Object
戻り Array
x
Immutable o
Chainable o
_.map([1, 2, 3], x => x*x)
// -> [ 1, 4, 9 ]
_.map({id: 1, name:"一郎"}, (v, k) => `${k}は${v}`)
// -> [ 'idは1', 'nameは一郎' ]

Array(Object)で特定キーだけの配列を作る (以前のpluck)

let array = [
    {id: 1, name: "一郎"},
    {id: 2, name: "二郎"}
];
_.map(array, 'name')
// -> [ '一郎', '二郎' ]

[filter] コレクションから条件に一致する要素のみを抽出する

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

項目
引数 Array / Object
戻り Array
reject
Immutable o
Chainable o
_.filter([1, 2, 3], x => x > 1)
// -> [ 2, 3 ]
_.filter({id: 1, age: 20}, x => x > 10)
// -> [ 20 ]
let array = [
    {id: 1, name: "一郎", age: 10},
    {id: 2, name: "二郎", age: 15},
    {id: 3, name: "三郎", age: 15}
];
_.filter(array, {"age": 15})
// -> [ { id: 2, name: '二郎', age: 15 },
//      { id: 3, name: '三郎', age: 15 } ]
_.filter(array, {"age": 15, "id": 2})
// -> [ { id: 2, name: '二郎', age: 15 } ]

文字列指定でプロパティが存在する要素のみを抽出する

let array = [
    {id: 1, name: "一郎", age: 10},
    {id: 2, name: "二郎", age: 15},
    {id: 3, name: "三郎"}
];
_.filter(array, "age")
// -> [ { id: 1, name: '一郎', age: 10 },
//      { id: 2, name: '二郎', age: 15 } ]

[reject] コレクションから条件に一致する要素を除外する

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

項目
引数 Array / Object
戻り Array
filter
Immutable o
Chainable o

具体例はfilterを参照。全てが逆になる。

[find] コレクションから条件に一致する最初の要素を抽出する

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

項目
引数 Array / Object
戻り *
findLast
Immutable o
Chainable x
_.find([1, 2, 3], x => x > 1)
// -> 2
_.find({id: 1, name: "一郎", age: 10}, x => x > 0)
// -> 1
let array = [
    {id: 1, name: "一郎", age: 10},
    {id: 2, name: "二郎", age: 15},
    {id: 3, name: "三郎", age: 15}
];
_.find(array, {name: "二郎"})
// -> { id: 2, name: '二郎', age: 15 }

[uniq] 配列から重複する値を削除する

_.uniq(array)

項目
引数 Array
戻り Array
x
Immutable o
Chainable o
_.uniq([1, 2, 3, 2, 1])
// -> [1, 2, 3]

[uniqBy] 配列に処理を加えた結果重複する値を削除する

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

項目
引数 Array
戻り Array
x
Immutable o
Chainable o
_.uniqBy(['a', 'ab', 'abc', 'A', 'AB'], x => x.length)
// -> [ 'a', 'ab', 'abc' ]

[uniqWith] 重複判定を指定した上で配列から重複する値を削除する

_.uniqWith(array, [comparator])

項目
引数 Array
戻り Array
x
Immutable o
Chainable o
_.uniq([{"id": 1}, {"id": 1}], _.isEqual)
// -> [ { id: 1 }, { id: 1 } ]
_.uniqWith([{"id": 1}, {"id": 1}], _.isEqual)
// -> [ { id: 1 } ]

[zip] 複数の配列を縦にグルーピングする

_.zip([arrays])

項目
引数 …Array
戻り Array
unzip
Immutable o
Chainable o
// 配列ネストが1段深くなる
_.zip(['hello', 'thank you', 'good bye'], ['こんにちは', 'ありがとう', 'さようなら'])
// -> [ [ 'hello', 'こんにちは' ],
//      [ 'thank you', 'ありがとう' ],
//      [ 'good bye', 'さようなら' ] ]

[unzip] 配列の配列を縦にグルーピングする

_.unzip(array)

項目
引数 Array
戻り Array
zip
Immutable o
Chainable o
// 配列ネストは変わらない
_.unzip(
    [[ 'hello', 'こんにちは' ],
     [ 'thank you', 'ありがとう' ],
     [ 'good bye', 'さようなら' ]]
)
// -> [ [ 'hello', 'thank you', 'good bye' ],
//      [ 'こんにちは', 'ありがとう', 'さようなら' ] ]

[zipObject] キーの配列と値の配列からオブジェクトを作成する

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

項目
引数
戻り Object
x
Immutable o
Chainable o
_.zipObject(['id', 'name', 'age'], [1, "一郎",  10])
// -> { id: 1, name: '一郎', age: 10 }

[groupBy] コレクションの各要素を特定条件でグルーピングする

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

項目
引数 Array / Object
戻り Object
x
Immutable o
Chainable o
_.groupBy(['a', 'aa', 'aaa', 'b', 'bb'], x => x.length)
// -> { '1': [ 'a', 'b' ], '2': [ 'aa', 'bb' ], '3': [ 'aaa' ] }

[includes] コレクションに要素が含まれるか判定する

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

項目
引数 Array / Object / String
戻り boolean
x
Immutable o
Chainable x
_.includes([1, 2, 3], 2)
// -> true
_.includes([1, 2, 3], 4)
// -> false
_.includes({id: 1, name: "一郎"}, "一郎")
// -> true
_.includes({id: 1, name: "一郎"}, "name")
// -> false

[size] コレクションのサイズを求める

_.size(collection)

項目
引数 Array / Object
戻り number
x
Immutable o
Chainable x

Stringの長さも求められたが仕様書には書かれていない。

_.size([1, 2, 3, 4, 5])
// -> 5
_.size({id: "001", name:"一郎"})
// -> 2

[sortBy] コレクションを昇順ソートする

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

項目
引数 Array / Object
戻り Array
x
Immutable o
Chainable o
_.sortBy([2, 1, 7, 4])
// -> [1, 2, 4, 7]
let array = [
    {id: 3, name: "三郎", age: 15},
    {id: 2, name: "二郎", age: 15},
    {id: 1, name: "一郎", age: 10}
];
_.sortBy(array, 'id')
// -> [ { id: 1, name: '一郎', age: 10 },
//      { id: 2, name: '二郎', age: 15 },
//      { id: 3, name: '三郎', age: 15 } ]
_.sortBy(array, 'age')
// -> [ { id: 1, name: '一郎', age: 10 },
//      { id: 3, name: '三郎', age: 15 },
//      { id: 2, name: '二郎', age: 15 } ]

複数条件の指定

_.sortBy(array, ['age', 'id'])
// -> [ { id: 1, name: '一郎', age: 10 },
//      { id: 2, name: '二郎', age: 15 },
//      { id: 3, name: '三郎', age: 15 } ]
_.sortBy(array, 'age', 'id')
// -> [ { id: 1, name: '一郎', age: 10 },
//      { id: 2, name: '二郎', age: 15 },
//      { id: 3, name: '三郎', age: 15 } ]

[orderBy] コレクションを昇順/降順ソートする

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

sortByとの違いはorderを指定できること。

項目
引数 Array / Object
戻り Array
x
Immutable o
Chainable o
_.orderBy([2, 1, 7, 4])
// -> [1, 2, 4, 7]
let array = [
    {id: 3, name: "三郎", age: 15},
    {id: 2, name: "二郎", age: 15},
    {id: 1, name: "一郎", age: 10}
];
_.orderBy(array, 'id')
// -> [ { id: 1, name: '一郎', age: 10 },
//      { id: 2, name: '二郎', age: 15 },
//      { id: 3, name: '三郎', age: 15 } ]
_.orderBy(array, 'id', 'desc')
// -> [ { id: 3, name: '三郎', age: 15 },
//      { id: 2, name: '二郎', age: 15 },
//      { id: 1, name: '一郎', age: 10 } ]

複数条件の指定

_.orderBy(array, ['age', 'id'])
// -> [ { id: 1, name: '一郎', age: 10 },
//      { id: 2, name: '二郎', age: 15 },
//      { id: 3, name: '三郎', age: 15 } ]
_.orderBy(array, ['age', 'id'], ['desc', 'asc'])
// -> [ { id: 2, name: '二郎', age: 15 },
//      { id: 3, name: '三郎', age: 15 },
//      { id: 1, name: '一郎', age: 10 } ]

[ceil] 数値を切り上げる

_.ceil(n, [precision=0])

項目
引数 number
戻り number
floor
Immutable o
Chainable x
_.ceil(1);
// -> 1
_.ceil(1.5);
// -> 2
_.ceil(1.555, 2);
// -> 1.56
_.ceil(1555, -2);
// -> 1600

[floor] 数値を切り捨てる

_.floor(n, [precision=0])

項目
引数 number
戻り number
ceil
Immutable o
Chainable x
_.flor(1);
// -> 1
_.flor(1.5);
// -> 1
_.flor(1.555, 2);
// -> 1.55
_.flor(1555, -2);
// -> 1500

[max] 配列の最大値を求める

_.max(array)

項目
引数 array
戻り *
min
Immutable o
Chainable x
_.max([1, 5, 3])
// -> 5
_.max(["aa", "a", "aaa"])
// -> aaa

[maxBy] 配列に処理を加えた結果の最大値を求める

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

項目
引数 array
戻り *
minBy
Immutable o
Chainable x
_.maxBy([1, 3, -5], x => x*x)
// -> -5

[min] 配列の最小値を求める

_.min(array)

項目
引数 array
戻り *
max
Immutable o
Chainable x

具体例はmaxを参照

[minBy] 配列に処理を加えた結果の最小値を求める

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

項目
引数 array
戻り *
maxBy
Immutable o
Chainable x

具体例はmaxByを参照

[sum] 配列を合計する

_.sum(array)

項目
引数 array
戻り number
x
Immutable o
Chainable x
_.sum([1, 2, 3])
// -> 6

[sumBy] 配列に処理を加えた結果を合計する

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

項目
引数 array
戻り number
x
Immutable o
Chainable x
_.sumBy([1, 2, 3], x => x*x)
// -> 14

[inRange] 指定範囲内に含まれるか判定する

_.inRange(n, [start=0], end)

項目
引数 number
戻り boolean
x
Immutable o
Chainable x

xが(a <= x < b)を満たすか。

_.inRange(9, 10, 100);
// -> false
_.inRange(10, 10, 100);
// -> true
_.inRange(99, 10, 100);
// -> true
_.inRange(100, 10, 100);
// -> false

[get] オブジェクトの任意のパスから値を取得し、存在しない場合はデフォルト値を返す

_.get(object, path, [defaultValue])

項目
引数 Object
戻り *
set
Immutable o
Chainable x
let spot = {
    name: "東京駅 丸の内口",
    ruby: "とうきょうえき まるのうちぐち",
    stations: [
        {
            id: 123,
            name: "東京"
        }
    ]
};

_.get(spot, 'name');
// -> 東京駅 丸の内
_.get(spot, 'stations[0].id');
// -> 123
_.get(spot, ['stations', 0, 'id']);
// -> 123
_.get(spot, 'stations[0].ruby');
// -> undefined
_.get(spot, 'stations[0].ruby', "rubyのデフォルト値");
// -> rubyのデフォルト値

[mapValues] オブジェクトのキーを固定したまま値のみを変換する

__.mapValues(object, [iteratee=_.identity])

項目
引数 Object
戻り Object
mapKeys
Immutable o
Chainable o
let object = {
    ichiro: "一郎",
    jiro: "二郎",
    suburo: "三郎"
};

_.mapValues(object, v => v + "*")
// -> { ichiro: '一郎*', jiro: '二郎*', suburo: '三郎*' }

たまに使う

[flatten] 配列の要素を1階層フラット化する

_.flatten(array)

項目
引数 Array
戻り Array
x
Immutable o
Chainable o
_.flatten([1, 2, [3, [4, 5]]])
// -> [ 1, 2, 3, [ 4, 5 ] ]

[flattenDeep] 配列の要素をフラット化する

_.flattenDeep(array)

項目
引数 Array
戻り Array
x
Immutable o
Chainable o
_.flattenDeep([1, 2, [3, [4, 5]]])
// -> [ 1, 2, 3, 4, 5 ]

[flatMap] コレクションの各要素に処理を加えて1階層フラット化する

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

項目
引数 Array / Object
戻り Array
x
Immutable o
Chainable o

コレクションを1階層フラット化してから処理を加えるわけではない。

_.flatMap([1, 2, 3], x => [[x]])
// -> [ [ 1 ], [ 2 ], [ 3 ] ]

_.map([1, 2, 3], x => [[x]])
// -> [ [ [ 1 ] ], [ [ 2 ] ], [ [ 3 ] ] ]

[flatMapDeep] コレクションの各要素に処理を加えてフラット化する

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

項目
引数 Array / Object
戻り Array
x
Immutable o
Chainable o

コレクションをフラット化してから処理を加えるわけではない。

_.flatMapDeep([1, 2, 3], x => [[x]])
// -> [ 1, 2, 3 ]

_.flatMap([1, 2, 3], x => [[x]])
// -> [ [ 1 ], [ 2 ], [ 3 ] ]

[head] 配列の先頭の要素を返却する

_.head(array)

項目
引数 Array
戻り *
last
Immutable o
Chainable x
_.head([1, 2, 3])
// -> 1

[last] 配列の最後の要素を返却する

_.last(array)

項目
引数 Array
戻り *
head
Immutable o
Chainable x
_.last([1, 2, 3])
// -> 3

[without] 配列から指定した要素を削除する

_.without(array, [values])

項目
引数 Array
戻り Array
x
Immutable o
Chainable o
_.without([1, 2, 2, 3, 3, 4], 2, 4)
// -> [1, 3, 3]
_.without([1, 2, 2, 3, 3, 4], ...[2, 4])
// -> [1, 3, 3]

[slice] 配列の指定範囲を切り取る

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

項目
引数 Array
戻り Array
x
Immutable o
Chainable o

startは含む、endは含まない。

_.slice([10, 11, 12, 13, 14], 1, 3)
// -> [ 11, 12 ]

[take] 配列の先頭から指定した要素数だけ切り出す

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

項目
引数 Array
戻り Array
takeRight
Immutable o
Chainable o
_.take([1, 2, 3, 4, 5], 2)
// -> [1, 2]
_.take([1, 2, 3, 4, 5], 77777)
// -> [1, 2, 3, 4, 5]

[takeRight] 配列の末尾から指定した要素数だけ切り出す

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

項目
引数 Array
戻り Array
take
Immutable o
Chainable o
_.takeRight([1, 2, 3, 4, 5], 2)
// -> [4, 5]
_.takeRight([1, 2, 3, 4, 5], 77777)
// -> [1, 2, 3, 4, 5]

[union] 和集合を求める

_.union([arrays])

項目
引数 …Array
戻り Array
x
Immutable o
Chainable o
_.union([1, 2, 3], [2, 3, 4], [3, 4, 5])
// -> [1, 2, 3, 4, 5]

[difference] 差集合を求める

_.difference(array, arrays)

項目
引数 Array
戻り Array
x
Immutable o
Chainable o
_.difference([1, 2, 3, 4, 5], [1, 2])
// -> [3, 4, 5]
_.difference([1, 2, 3, 4, 5], [1, 2], [4, 5])
// -> [ 3 ]

[intersection] 積集合を求める

_.intersection([arrays])

項目
引数 …Array
戻り Array
x
Immutable o
Chainable o
_.intersection(
        [1, 2, 3, 4, 5, 6],
        [0, 2, 3, 4, 7, 8],
        [0, 2, 3, 6, 7, 8]
)
// -> [2, 3]

[xor] 排他的論理和を求める

_.xor([arrays])

項目
引数 …Array
戻り Array
x
Immutable o
Chainable o
_.xor([2, 3, 4], [3, 4, 5])
// -> [2, 5]

[zipWith] 複数の配列を縦にグルーピングして処理を施した配列を作成する

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

項目
引数 …Array
戻り Array
unzipWith
Immutable o
Chainable o

ネストの深さは変わらない。

_.zipWith(
    ['hello', 'thank you', 'good bye'],
    ['こんにちは', 'ありがとう', 'さようなら'],
    (x, y) => `${x} <---> ${y}`
)
// -> [ 'hello <---> こんにちは',
//      'thank you <---> ありがとう',
//      'good bye <---> さようなら' ]

[unzipWith] 配列の配列を縦にグルーピングして処理を施した配列を作成する

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

項目
引数 Array
戻り Array
zipWith
Immutable o
Chainable o

ネストが1段階浅くなる。

_.unzipWith(
    [['hello', 'こんにちは'],
     ['thank you', 'ありがとう'],
     ['good bye', 'さようなら']],
    (x, y, z) => `${x} <---> ${y} <---> ${z}`
)
// -> [ 'hello <---> thank you <---> good bye',
//      'こんにちは <---> ありがとう <---> さようなら' ]

[at] オブジェクトから指定したプロパティの要素を抽出する

_.at(collection, [paths])

※ 公式サイトではobjectだけど状況的にcollectionを受けつけると思われる

項目
引数 Array/ Object
戻り Array
x
Immutable o
Chainable o
_.at([10, 20, 30], 1)
// -> [ 20 ]
_.at([10, 20, 30], 1, 2)
// -> [ 20, 30 ]
_.at([10, 20, 30], [1, 2])
// -> [ 20, 30 ]
let obj = {
    id: 1,
    name: "一郎",
    favorites: [
        {
            fruit: {level: 1},
            sport: {level: 2}
        }
    ]
};

_.at(obj, 'name')
// -> [ '一郎' ]
_.at(obj, 'favorites[0].sport.level')
// -> [ 2 ]

[countBy] コレクションに処理を加えた結果をグルーピングしてカウントする

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

項目
引数 Array / Object
戻り Object
x
Immutable o
Chainable o
_.countBy([1, 5, 5, 10, 10])
// -> { '1': 1, '5': 2, '10': 2 }
_.countBy([1, 5, 10, 15, 20], x => x % 5)
// -> { '0': 4, '1': 1 }
_.countBy({id: "1", name: "一郎", age: "10"}, "length")
// -> { '1': 1, '2': 2 }

[every] コレクションの要素が全て条件を満たすか判定する

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

項目
引数 Array / Object
戻り boolean
some
Immutable o
Chainable x
_.every([true, true, true])
// -> true
_.every([true, true, false])
// -> false
_.every([1, 2, 3, 4, 5], x => x < 10)
// -> true
_.every([1, 2, 3, 4, 5], x => x < 3)
// -> false

[some] コレクションの要素が少なくとも1つ条件を満たすか判定する

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

項目
引数 Array / Object
戻り boolean
every
Immutable o
Chainable x
_.some([false, false, false])
// -> false
_.some([true, false, false])
// -> true
_.some([1, 2, 3, 4, 5], x => x < 2)
// -> true
_.some([1, 2, 3, 4, 5], x => x < 1)
// -> false

[forEach] コレクションの各要素に対して先頭から処理を行う

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

項目
引数 Array / Object
戻り *
forEachRight
Immutable o
Chainable x
_.forEach([1, 2, 3, 4, 5], x => console.log(x))
// -> 1
//    2
//    3
//    4
//    5
//    [ 1, 2, 3, 4, 5 ]

[reduce] コレクションの各要素を特定処理で先頭から集約する

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

項目
引数 Array / Object
戻り *
reduceRight
Immutable o
Chainable x
_.reduce(["a", "b", "c"], (accumulated, n) => accumulated + n)
// -> abc
_.reduce(["a", "b", "c"], (accumulated, n) => accumulated + n, "===>")
// -> ===>abc

[reduceRight] コレクションの各要素を特定処理で末尾から集約する

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

項目
引数 Array / Object
戻り *
reduce
Immutable o
Chainable x
_.reduceRight(["a", "b", "c"], (accumulated, n) => accumulated + n)
// -> cba

[sample] コレクションから1つの要素をランダムで抽出する

_.sample(collection)

項目
引数 Array / Object
戻り *
x
Immutable o
Chainable x
_.sample([1, 2, 3, 4, 5])
// -> ? ({1, 2, 3, 4, 5}のいずれか)
_.sample({id: "001", name: "一郎"})
// -> ? ({001, 一郎}のいずれか)

[sampleSize] コレクションから任意の数だけ要素をランダムで抽出する

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

項目
引数 Array / Object
戻り Array
x
Immutable o
Chainable o
_.sampleSize([1, 2, 3, 4, 5], 3)
// -> ? ({1, 2, 3, 4, 5}のいずれか3つ)

[shuffle] コレクションの要素をランダムに並び替える

_.shuffle(collection)

項目
引数 Array / Object
戻り Array
x
Immutable o
Chainable o
_.shuffle([1, 2, 3, 4, 5])
// -> ? ({1, 2, 3, 4, 5}の順番がランダムに並び変わった配列)
_.shuffle({id: "001", name: "tadashi"})
// -> ? (['001', 'tadashi'] or ['tadashi', '001'])

[assign] オブジェクトのプロパティを追加/上書きする

_.assign(object, [sources])

項目
引数 Object
戻り Object
x
Immutable x
Chainable o

変数を第2引数移行にすることでImmutableを担保することも可能。
ただ、上書きの場合は意図した動作にならないので、追加の場合は非推奨。
defaultsを使った方がいいかも。

let object = {
    id: "001",
    name: "一郎",
    sex: "Man",
    age: 30
};

_.assign(object, {age: 31, comment: "hoge"});
// -> { id: '001', name: '一郎', sex: 'Man', age: 31, comment: 'hoge' }

_.assign(object, {age: 31}, {age: 40, sex: 'Woman'});
// -> { id: '001', name: '一郎', sex: 'Woman', age: 40 }

ネストしているプロパティは全体が上書きされる。
上書きしたくない場合はdefaultsDeepを使うこと。

let object = {
    id: "001",
    name: {
        ja: "一郎",
        en: "Ichiro"
    },
    sex: "Man",
    age: 30
};

_.assign(object, {age: 31, name: {ja: "イチロー"}})
// -> { id: '001', name: { ja: 'イチロー' }, sex: 'Man', age: 31 }

[defaults] オブジェクトのプロパティを上書き禁止で追加する

_.defaults(object, [sources])

項目
引数 Object
戻り Object
x
Immutable x
Chainable o

変数を第2引数移行にすることでImmutableを担保することも可能。

let object = {
    id: "001",
    name: "一郎",
    sex: "Man",
    age: 30
};

_.defaults(object, {age: 31, comment: "hoge"});
// -> { id: '001', name: '一郎', sex: 'Man', age: 30, comment: 'hoge' }

_.defaults(object, {age: 31}, {age: 40, sex: 'Woman'});
// -> { id: '001', name: '一郎', sex: 'Man', age: 30 }

ネストしているプロパティは動作しないので、defaultsDeepを使うこと。

let object = {
    id: "001",
    name: {
        ja: "一郎"
    },
    sex: "Man",
    age: 30
};

_.defaults(object, {name: {en: "Ichiro"}})
// -> { id: '001', name: { ja: '一郎' }, sex: 'Man', age: 30 }

[defaultsDeep] オブジェクトの階層化プロパティを上書き禁止で追加する

_.defaultsDeep(object, [sources])

項目
引数 Object
戻り Object
x
Immutable x
Chainable o

変数を第2引数移行にすることでImmutableを担保することも可能。

let object = {
    id: "001",
    name: {
        ja: "一郎"
    },
    sex: "Man",
    age: 30
};

_.defaultsDeep(object, {name: {en: "Ichiro"}})
// -> { id: '001', name: { ja: '一郎', en: 'Ichiro' }, sex: 'Man', age: 30 }

[debounce] 一定時間内に同じ関数が呼び出されなければ実行する関数を返却する

_.debounce(func, [wait=0], [options={}], [options.leading=false], [options.maxWait], [options.trailing=true])

項目
引数 Function
戻り Function
x
Immutable
Chainable o

_.throttleと似ている。

一定時間内の実行は最後の1回だけよい場合に使う。
例えば、高速入力完了まで表示したくないオートコンプリートの制御とか。

async function sleep(ms) {
    await new Promise(resolve => setTimeout(resolve, ms));
}

async function main() {
    // 500ms待って実行。500ms以内にもう一度呼び出されたら待ち時間リセット
    let f = _.debounce(x => console.log(`${new Date().toISOString()}: exec ${x}`), 500);
    let exec = msg => {
        console.log(`${new Date().toISOString()}: stanby ${msg}`);
        f(msg)
    };

    exec('event1');
    await sleep(200);
    exec('event2');
    await sleep(400);
    exec('event3');
    await sleep(600);
    exec('event4');
    await sleep(800);
    exec('event5');
    await sleep(1000);
    exec('event6');
    await sleep(1200);
}
main();
// -> 2016-04-17T04:23:10.142Z: stanby event1
//    2016-04-17T04:23:10.345Z: stanby event2   => 500ms以内に呼ばれたのでevent1は実行されない
//    2016-04-17T04:23:10.747Z: stanby event3   => 500ms以内に呼ばれたのでevent2は実行されない
//    2016-04-17T04:23:11.248Z: exec event3
//    2016-04-17T04:23:11.347Z: stanby event4
//    2016-04-17T04:23:11.848Z: exec event4
//    2016-04-17T04:23:12.149Z: stanby event5
//    2016-04-17T04:23:12.649Z: exec event5
//    2016-04-17T04:23:13.150Z: stanby event6
//    2016-04-17T04:23:13.650Z: exec event6

[throttle] 一定時間ごとの実行数を制限する関数を返却する

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

項目
引数 Function
戻り Function
x
Immutable
Chainable o

_.debounceと似ている。

大量のイベントを[呼び出し回数/一定間時間]で制御したい場合に使う。
例えば、高速入力中もチマチマ表示するオートコンプリートの制御とか。

一部想定通りに動かないケースがありますが詳細は不明です。。

async function sleep(ms) {
    await new Promise(resolve => setTimeout(resolve, ms));
}

async function main() {
    // 500ms以内に実行されていなければ即実行。そうでなければそれまで待機
    let f = _.throttle(x => console.log(`${new Date().toISOString()}: exec ${x}`), 500);
    let exec = msg => {
        console.log(`${new Date().toISOString()}: stanby ${msg}`);
        f(msg)
    };

    exec('event1');
    await sleep(100);
    exec('event2');
    await sleep(200);
    exec('event3');
    await sleep(300);
    exec('event4');
    await sleep(400);
    exec('event5');
    await sleep(500);
    exec('event6');
    await sleep(600);
}
main();
// -> 2016-04-17T04:45:09.446Z: stanby event1   => 前回のexec(empty?)から500ms以上経っているので即実行
//    2016-04-17T04:45:09.448Z: exec event1
//    2016-04-17T04:45:09.550Z: stanby event2   => 前回のexec(event1)から500ms未満(100ms)なので400ms後に実行予定
//    2016-04-17T04:45:09.751Z: stanby event3   => 前回のexec(event1)から500ms未満(300ms)なので200ms後に実行予定
//    2016-04-17T04:45:09.949Z: exec event3
//    2016-04-17T04:45:10.052Z: stanby event4   => 前回のexec(event3)から500ms未満(100ms)なので400ms後に実行予定
//    2016-04-17T04:45:10.452Z: stanby event5   => 前回のexec(event3)から500ms以上経っているので即実行
//    2016-04-17T04:45:10.452Z: exec event5
//    2016-04-17T04:45:10.953Z: stanby event6   => 前回のexec(event5)から500ms以上経っているので即実行
//    2016-04-17T04:45:10.953Z: exec event6

[round] 四捨五入する

_.round(number, [precision=0])

項目
引数 number
戻り number
x
Immutable o
Chainable x
_.round(1);
// -> 1
_.round(1.4);
// -> 1
_.round(1.5);
// -> 2

[random] ランダム値を生成する

_.random([lower=0], [upper=1], [floating])

項目
引数 number
戻り number
x
Immutable o
Chainable x

コレクションから取得する場合は_.shuffle

_.random(1, 10)
// -> ? (1~10の整数いずれか)
_.random(1, 10, true)
// -> ? (1~10の小数いずれか)

[has] オブジェクトの任意のパスが存在するかを判定する

_.has(object, path)

値がundefinedでもtrueになる。

項目
引数 Object
戻り boolean
x
Immutable o
Chainable x
let object = {
    name: "東京駅 丸の内口",
    ruby: "とうきょうえき まるのうちぐち",
    stations: [
        {
            id: 123,
            name: "東京"
        }
    ]
};

_.has(object, 'name');
// -> true
_.has(object, 'ruby');
// -> true
_.has(object, 'stations[0].id');
// -> true
_.has(object, ['stations', 0, 'id']);
// -> true
_.has(object, 'stations[0].ruby');
// -> false

[keys] オブジェクトのキー一覧を返却する

_.keys(object)

項目
引数 Object
戻り Array
x
Immutable o
Chainable o
let object = {
    id: "001",
    name: "一郎"
};

console.log(_.keys(object));
// -> [ 'id', 'name' ]

lodash無しでも可能

Object.keys(object);
// -> [ 'id', 'name' ]

[flow] 複数の関数を先頭からパイプラインのように処理する関数を作成する

_.flow([funcs])

項目
引数 …Function
戻り Function
flowRight
Immutable o
Chainable o
let plusOne = n => n + 1;
let square = n => n * n;

_.flow(plusOne, square)(4)
// => 25

以下と等価。

square(plusOne(4));
// -> 18

[memoize] メモ化した関数を作成する

_.memoize(func, [resolver])

項目
引数 Function
戻り Function
x
Immutable o
Chainable o

再帰関数を定義するときに_.memoizeで包むイメージ。

let f = n => {
    if(n == 0) return 1;
    if(n == 1) return 1;
    return f(n-1) + f(n-2);
};

let m = _.memoize(n => {
    if(n == 0) return 1;
    if(n == 1) return 1;
    return m(n-1) + m(n-2);
});

function main() {
    console.time('memo');
    console.log(m(40));
    console.timeEnd('memo');

    console.time('normal');
    console.log(f(40));
    console.timeEnd('normal');
}
main();
// -> 165580141
//    memo: 2.635ms
//    165580141
//    normal: 1560.732ms

あまり使わない

[chunk] 配列のサイズを任意のサイズで分割する

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

項目
引数 Array
戻り Array
x
Immutable o
Chainable o
_.chunk([1, 2, 3, 4, 5], 2)
// -> [ [ 1, 2 ], [ 3, 4 ], [ 5 ] ]

[compact] 配列からネガティブな値を削除する

_.compact(array)

項目
引数 Array
戻り Array
x
Immutable o
Chainable o
_.compact(
    [
        0, 1,
        true, false,
        "hoge", "",
        null, undefined, NaN
    ]
)
// -> [ 1, true, 'hoge' ]

削除対象の値は以下。

  • false
  • null
  • 0
  • “”
  • undefined
  • NaN

[drop] 配列の要素を先頭から任意の数だけ削除する

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

項目
引数 Array
戻り Array
dropRight
Immutable o
Chainable o
_.drop([1, 2, 3, 4, 5], 2)
// -> [3, 4, 5]

[dropRight] 配列の要素を末尾から任意の数だけ削除する

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

項目
引数 Array
戻り Array
drop
Immutable o
Chainable o
_.dropRight([1, 2, 3, 4, 5], 2)
// -> [1, 2, 3]

[fill] 配列の要素を任意の値で埋め尽くす

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

項目
引数 Array
戻り Array
x
Immutable o
Chainable o
_.fill(Array(5), 100, 2, 4)
// -> [ , , 100, 100,  ]

[findIndex] 配列の要素で条件を満たす最初のindexを返却する

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

項目
引数 Array
戻り number
findLastIndex
Immutable o
Chainable x
_.findIndex([10, 20, 30, 40, 50], x => x > 15)
// -> 1

_.findIndex([
    {"name": "taro", "age": 25, "country": "ja"},
    {"name": "jiro", "age": 20, "country": "en"},
    {"name": "goro", "age": 15, "country": "ja"}
], "country", "ja")
// -> 0

_.findIndex([
    {"name": "taro", "age": 25, "country": "ja"},
    {"name": "jiro", "age": 20, "country": "en"},
    {"name": "goro", "age": 15, "country": "ja"}
], {"age": 20, "country": "en"})
// -> 1

// 存在しない場合は-1
let r = _.findIndex([
    {"name": "taro", "age": 25, "country": "ja"},
    {"name": "jiro", "age": 20, "country": "en"},
    {"name": "goro", "age": 15, "country": "ja"}
], {"age": 20, "country": "fr"})
// -> -1

[findLastIndex] 配列の要素で条件を満たす最後のindexを返却する

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

項目
引数 Array
戻り number
findIndex
Immutable o
Chainable x
_.findLastIndex([10, 20, 30, 40, 50], x => x > 15)
// -> 4

// 存在しない場合は-1
let r = _.findLastIndex([10, 20, 30, 40, 50], x => x > 55)
// -> -1

[indexOf] 配列の要素で任意の値が出現する最初indexを返却する

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

項目
引数 Array
戻り number
lastIndexOf
Immutable o
Chainable x

fromIndexとそれより右側に検索し、初めに出現したindexを返却します。

_.indexOf([10, 20, 10, 20, 10], 10)
// -> 0

_.indexOf([10, 20, 10, 20, 10], 20)
// -> 1

_.indexOf([10, 20, 20, 20, 10], 10, 1)
// -> 4

[lastIndexOf] 配列の要素で任意の値が出現する最後のindexを返却する

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

項目
引数 Array
戻り number
indexOf
Immutable o
Chainable x

fromIndexとそれより左側に検索し、初めに出現したindexを返却します。

_.lastIndexOf([1, 2, 1, 2, 1], 1)
// -> 4

_.lastIndexOf([1, 2, 1, 2, 1], 2)
// -> 1

_.lastIndexOf([1, 2, 2, 2, 1], 1, 1)
// -> 0

[initial] 配列の要素から最後の値を削除する

_.initial(array)

項目
引数 Array
戻り Array
tail
Immutable o
Chainable o
_.initial([1, 2, 3, 4, 5])
// -> [1, 2, 3, 4]

[tail] 配列の要素から最初の値を削除する

_.tail(array)

項目
引数 Array
戻り Array
initial
Immutable o
Chainable o
_.tail([1, 2, 3, 4, 5])
// -> [2, 3, 4, 5]

[sortedIndex] 配列の要素を挿入すべきindexの最小値を求める

_.sortedIndex(array, value)

項目
引数 Array
戻り number
sortedLastIndex
Immutable o
Chainable o
_.sortedIndex([1, 2, 3, 3, 3, 4, 5], 3.7)
// -> 5
_.sortedIndex([1, 1, 2, 2], 2)
// -> 2

[sortedLastIndex] 配列の要素を挿入すべきindexの最大値を求める

_.sortedLastIndex(array, value)

項目
引数 Array
戻り number
sortedIndex
Immutable o
Chainable o
_.sortedLastIndex([1, 2, 3, 3, 3, 4, 5], 3.7)
// -> 5
_.sortedLastIndex([1, 1, 2, 2], 2)
// -> 4

[takeWhile] 配列の先頭から条件に一致する連続した要素を切り出す

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

項目
引数 Array
戻り Array
takeRightWhile
Immutable o
Chainable o

1度でも条件を満たさなければ、後の要素が条件を満たしていても処理は終了。

_.takeWhile([1, 2, 3, 4, 5, 4, 3, 2, 1], x => x < 3)
// -> [1, 2]

[takeRightWhile] 配列の末尾から条件に一致する連続した要素を切り出す

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

項目
引数 Array
戻り Array
takeWhile
Immutable o
Chainable o

1度でも条件を満たさなければ、後の要素が条件を満たしていても処理は終了。

_.takeRightWhile([1, 2, 3, 4, 5, 4, 3, 2, 1], x => x < 3)
// -> [2, 1]

[findLast] コレクションから条件に一致する最後の要素のみ返却する

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

項目
引数 Array / Object
戻り *
find
Immutable o
Chainable x
_.findLast([1, 2, 3], x => x > 1)
// -> 3
_.findLast({id: 1, name: "一郎", age: 10}, x => x > 0)
// -> 10
let array = [
    {id: 1, name: "一郎", age: 10},
    {id: 2, name: "二郎", age: 15},
    {id: 3, name: "三郎", age: 15}
];
_.findLast(array, {age: 15})
// -> { id: 3, name: '三郎', age: 15 }

[forEachRight] コレクションの各要素に対して末尾から処理を行う

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

項目
引数 Array / Object
戻り *
forEach
Immutable o
Chainable x
_.forEachRight([1, 2, 3, 4, 5], x => console.log(x))
// -> 5
//    4
//    3
//    2
//    1
//    [ 1, 2, 3, 4, 5 ]

[partition] コレクションの各要素を条件に一致するものと一致しないものに分ける

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

項目
引数 Array / Object
戻り Array
x
Immutable o
Chainable o
_.partition([1, 2, 3, 4, 5], x => x < 3)
// -> [ [ 1, 2 ], [ 3, 4, 5 ] ]

[findKey] 条件に一致する最初の要素のキーを取得する

_.findKey(object, [predicate=_.identity])

項目
引数 Object
戻り *
findLastKey
Immutable o
Chainable x
let object = {
    ichiro: {id: 1, name: "一郎", age: 10},
    jiro: {id: 2, name: "二郎", age: 15},
    saburo: {id: 3, name: "三郎", age: 15}
};

_.findKey(object, {age: 15});
// -> jiro

[findLastKey] 条件に一致する最後の要素のキーを取得する

_.findLastKey(object, [predicate=_.identity])

項目
引数 Object
戻り *
findKey
Immutable o
Chainable x
let object = {
    ichiro: {id: 1, name: "一郎", age: 10},
    jiro: {id: 2, name: "二郎", age: 15},
    saburo: {id: 3, name: "三郎", age: 15}
};

_.findLastKey(object, {age: 15});
// -> saburo

[after] 指定回数以上呼び出されないと実行されない関数を作成する

_.after(n, func)

項目
引数 Function
戻り Function
before
Immutable o
Chainable o
let f = _.after(2, x => x + 1);
f(1)
// -> undefined
f(1)
// -> 2
f(1)
// -> 2

[before] 指定回数以上呼び出されると最後の実行結果を返却し続ける関数を作成する

_.before(n, func)

項目
引数 Function
戻り Function
after
Immutable o
Chainable o

同じ閉鎖スコープ内でしか発動しない。
_.afterの例では期待通り動かないので注意。

let f = _.before(3, x => x + 1);
f(1)
// -> 2
f(2)
// -> 3
f(3)
// -> 3  (呼び出し3回以上なので、2回目の結果を返す)
f(4)
// -> 3  (呼び出し3回以上なので、2回目の結果を返す)

[unary] 関数の引数最大数を1にした関数を作成する

_.unary(func)

項目
引数 Function
戻り Function
x
Immutable o
Chainable o

引数が2つ以上あるメソッドをチェーンするときに使える

parseIntは第2引数で進数を指定する。

parseInt('7')
// -> 7
parseInt('111', 2)
// -> 7

以下のように書きたいが第2引数が邪魔で書けない。

_.map([1, 2, 3], parseInt);
// -> [1, NaN, NaN]

普通に書くと冗長になる。

_.map([1, 2, 3], x => parseInt(x));
// -> [1, 2, 3]

unaryでシンプルに書ける。

_.map([1, 2, 3], _.unary(parseInt))
// -> [1, 2, 3]

ただ、文字数は変わらない。。

[ary] 関数の引数最大数を変更した関数を作成する

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

項目
引数 Function
戻り Function
x
Immutable o
Chainable o

unaryの引数を指定できるバージョン。

※ 期待通り動かなかったので例は保留。。

[curry] 先頭からカリー化した関数を作成する

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

項目
引数 Function
戻り Function
curryRight
Immutable o
Chainable o

普通にカリー化っぽく書くとエラーになる。

let sum = (x, y, z) => x + y + z;
sum("1", "2", "3");
// -> 123
sum(1)(2)(3);
// -> エラー

curryでカリー化できる。

let curriedSum = _.curry(sum);
curriedSum("1", "2", "3");
// -> 123
curriedSum("1")("2")("3");
// -> 123
curriedSum("1", "2")("3");
// -> 123
curriedSum("1")("2", "3");
// -> 123

[curryRight] 末尾からカリー化した関数を作成する

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

項目
引数 Function
戻り Function
curry
Immutable o
Chainable o
let sum = (x, y, z) => x + y + z;

let curriedSum = _.curryRight(sum);
curriedSum("1", "2", "3");
// -> 123
curriedSum("1")("2")("3");
// -> 321
curriedSum("1", "2")("3");
// -> 312
curriedSum("1")("2", "3");
// -> 231

[delay] 関数の処理を遅延実行する

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

項目
引数 Function
戻り number
x
Immutable o
Chainable o

setTimeoutとの違いはよく分からない。

function main() {
    console.log('start')
    _.delay(() => console.log('event1'), 1000); // 3つのeventはほぼ同時実行
    _.delay(() => console.log('event2'), 1000); // 3つのeventはほぼ同時実行
    _.delay(() => console.log('event3'), 1000); // 3つのeventはほぼ同時実行
    console.log('end')
}
main();
// -> start
//    end
//    event1
//    event2
//    event3

[flowRight] 複数の関数を末尾からパイプラインのように処理する関数を作成する

_.flowRight([funcs])

項目
引数 …Function
戻り Function
flow
Immutable o
Chainable o
let plusOne = n => n + 1;
let square = n => n * n;

_.flowRight(plusOne, square)(4)
// => 17

以下と等価。

plusOne(square(4));
// -> 17

[negate] 真偽判定関数の結果を逆転させる関数を作成する

_.negate(predicate)

項目
引数 Function
戻り Function
x
Immutable o
Chainable o

間違えやすそうなのであまり使わない方がいいかも。

let isEven = n => n % 2 == 0;

_.filter([1, 2, 3, 4, 5, 6], isEven)
// -> [ 2, 4, 6 ]
_.filter([1, 2, 3, 4, 5, 6], _.negate(isEven))
// -> [ 1, 3, 5 ]
_.reject([1, 2, 3, 4, 5, 6], isEven)
// -> [ 1, 3, 5 ]
_.filter([1, 2, 3, 4, 5, 6], !isEven)
// -> []
_.filter([1, 2, 3, 4, 5, 6], x => !isEven(x))
// -> [ 1, 3, 5 ]

[once] 二回目以降呼び出しても一回目の結果を返し続ける関数を作成する

_.once(func)

項目
引数 Function
戻り Function
x
Immutable o
Chainable o

_.before(2, func)と同じ。

let isEven = n => n % 2 == 0;
let isEvenOnce = _.once(isEven);

isEvenOnce(1);
// -> false
isEvenOnce(2);
// -> false
isEvenOnce(3);
// -> false

onceを使わない場合は以下のようになる

let isEven = n => n % 2 == 0;

isEven(1);
// -> false
isEven(2);
// -> true
isEven(3);
// -> false

[partial] 先頭の引数から部分適合した関数を作成する

_.partial(func, [partials])

項目
引数 Function
戻り Function
partialRight
Immutable o
Chainable o
let f = (x, y, z) => x + y + z;
f("a", "b", "c");
// -> abc
(_.partial(f, "a", "b"))("c");
// -> abc

partialを使わないと以下のように書く必要がある。

(z => f("a", "b", z))("c");
// -> abc
(_.curry(f)("a")("b"))("c");
// -> abc

[partialRight] 先頭の引数から末尾寄せで部分適合した関数を作成する

_.partialRight(func, [partials])

項目
引数 Function
戻り Function
partial
Immutable o
Chainable o
let f = (x, y, z) => x + y + z;
f("a", "b", "c");
// -> abc
(_.partialRight(f, "a", "b"))("c");
// -> cab

[rearg] 引数の順序を並び替えた関数を作成する

_.rearg(func, indexes)

項目
引数 Function
戻り Function
x
Immutable o
Chainable o
let f = (x, y, z) => x + y + z;
_.rearg(f, 1, 0, 2)('a', 'b', 'c');
// -> bac

reargを使わないと以下のように書く必要がある。

((x, y, z) => f(y, x, z))('a', 'b', 'c')
// -> bac

[spread] 複数の引数を1つの配列引数に変換した関数を作成する

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

項目
引数 Function
戻り Function
x
Immutable o
Chainable o
let f = (x, y, z) => x + y + z;
let alphabets = ['a', 'b', 'c'];

_.spread(f)(alphabets);
// -> abc

ES2015からspread operatorが使えるのでf(...alphabets)と書くことを推奨

[invert] キーと値を反転させる

_.invert(object)

項目
引数 Object
戻り Object
x
Immutable o
Chainable o

反転した結果、キーが重複した場合は後に処理をした値で上書きされる。
上書きではなく複数返却したい場合はinvertByを使う。

let object = {
    id: "ichiro",
    name: "ichiro"
};

_.invert(object);
// -> { 'ichiro': 'name' }

[invertBy] キーと値を反転させた上で処理を加える

_.invertBy(object, [iteratee=_.identity])

項目
引数 Object
戻り Object
x
Immutable o
Chainable o

反転後の値は配列型になるので、キーが重複した場合も問題なし

let object = {
    id: "ichiro",
    name: "ichiro"
};

_.invertBy(object);
// -> { ichiro: [ 'id', 'name' ] }

_.invertBy(object, x => `<< ${x} >>`)
// -> { '<< ichiro >>': [ 'id', 'name' ] }

[invoke] パスを指定して処理を実行する

_.invoke(object, path, [args])

項目
引数 Object
戻り *
x
Immutable o
Chainable x

あえて使う必要は無さそう。

let spot = {
    name: "東京駅 丸の内口",
    ruby: "とうきょうえき まるのうちぐち",
    stations: [
        {
            id: 123,
            name: "東京"
        },
        {
            id: 234,
            name: "新宿"
        }
    ]
};

_.invoke(spot, 'stations.filter', x => x.id > 200);
// -> [ { id: 234, name: '新宿' } ]

// 以下と同じ
_.filter(spot.stations, x => x.id > 200);
// -> [ { id: 234, name: '新宿' } ]

[mapKeys] オブジェクトの値を固定したままキーのみを変換する

_.mapKeys(object, [iteratee=_.identity])

項目
引数 Object
戻り Object
mapValues
Immutable o
Chainable o
let object = {
    id: "001",
    name: "一郎"
};

_.mapKeys(object, (v, k) => `<< ${k} >>`)
// -> { '<< id >>': '001', '<< name >>': '一郎' }

理解できなかった

[bind]

[bindAll]

[bindKey]

[defer]

[wrap]

[create]

[assignWith]

[forOwn] (forEachでいいのでは?)

[forOwnRight] (forEachRightでいいのでは?)

[functions] (ES2015からは関係無いのでは)

[functionsIn] (ES2015からは関係無いのでは)

削除された

[pluck] コレクションから指定したキーの値のみを配列で返却する

_.mapを使いましょう。

[indexBy] コレクションの各要素を特定条件でインデクシングする

TODO: なんでだろう?

[sortByAll]

_.sortByを使いましょう。

[where] コレクションの要素が指定プロパティが一致するものを返却する

_.filterを使いましょうってことのはず

[rest] 配列の要素から最初の値を除外した配列を返却する

元々の定義は_tailに移行した。
今は別の動作するもの。

[findWhere]

[modArgs]

[restParam]

非推奨

公式が言っているものと、個人的にそう感じたものが混ざっています。

[pull] 配列から指定した要素を削除する

Immutableじゃないので_.withoutを使いましょう。

[pullAt] 配列から指定したindexの要素を抽出する

Immutableじゃないので_.atを使いましょう。

[remove] 配列から条件に一致する要素を削除する

Immutableじゃないので_.filterを使いましょう。

[assignIn]

prototypeを使用しなければ不要です。

[assignInWith]

prototypeを使用しなければ不要です。

[forIn]

prototypeを使用しなければ不要です。

[forInRight]

prototypeを使用しなければ不要です。

[hasIn]

prototypeを使用しなければ不要です。

[keysIn]

prototypeを使用しなければ不要です。

lodash4へのメジャーバージョンアップ時 要注意

  • pluckが廃止されたのでmapを使う
  • sumiterateeを指定できなくなったのでsumByを使う
  • filter, reject, findの条件指定に可変長引数を指定できなくなったので、Objectを指定する
    • そのままにしておくと期待通り動作せず、エラーも出ない
    • 1つ目の条件だけが考慮され、2つ目以降は無視されてしまうため