From d01a1e4ef34afa3dcd23e0dbddd5a0eb634ba62a Mon Sep 17 00:00:00 2001 From: jdalton Date: Sat, 28 Feb 2015 22:12:58 -0800 Subject: [PATCH] Bump to v3.4.0. --- LICENSE.txt | 2 +- README.md | 4 +- array/difference.js | 9 +-- array/dropRightWhile.js | 2 +- array/findLastIndex.js | 2 +- array/flatten.js | 2 +- array/flattenDeep.js | 2 +- array/indexOf.js | 4 +- array/intersection.js | 4 +- array/pull.js | 8 ++- array/union.js | 2 +- chain/lodash.js | 22 +++---- collection.js | 8 ++- collection/max.js | 53 +--------------- collection/min.js | 53 +--------------- collection/partition.js | 2 +- collection/size.js | 4 +- collection/sortBy.js | 5 +- collection/sortByAll.js | 30 +++------ collection/sortByOrder.js | 47 ++++++++++++++ collection/sum.js | 2 + function/flow.js | 33 +--------- function/flowRight.js | 33 +--------- function/memoize.js | 7 ++- internal/baseDifference.js | 2 +- internal/baseFlatten.js | 10 +-- internal/baseIndexOf.js | 4 +- internal/baseSortBy.js | 4 +- internal/baseSortByOrder.js | 35 +++++++++++ internal/baseUniq.js | 2 +- ...ultipleAscending.js => compareMultiple.js} | 22 +++++-- internal/createAssigner.js | 27 +++++--- internal/createComposer.js | 39 ++++++++++++ internal/indexOfNaN.js | 4 +- internal/lazyValue.js | 19 ++++-- internal/root.js | 24 +++---- lang/isEmpty.js | 2 +- lodash.js | 63 ++++++++++--------- math.js | 11 ++++ math/add.js | 19 ++++++ math/max.js | 53 ++++++++++++++++ math/min.js | 53 ++++++++++++++++ math/sum.js | 33 ++++++++++ number/inRange.js | 2 +- object/defaults.js | 2 +- package.json | 2 +- string/escape.js | 2 +- string/words.js | 2 +- utility/attempt.js | 12 ++-- utility/range.js | 6 +- 50 files changed, 477 insertions(+), 317 deletions(-) create mode 100644 collection/sortByOrder.js create mode 100644 collection/sum.js create mode 100644 internal/baseSortByOrder.js rename internal/{compareMultipleAscending.js => compareMultiple.js} (57%) create mode 100644 internal/createComposer.js create mode 100644 math.js create mode 100644 math/add.js create mode 100644 math/max.js create mode 100644 math/min.js create mode 100644 math/sum.js diff --git a/LICENSE.txt b/LICENSE.txt index 17764328c..9cd87e5dc 100644 --- a/LICENSE.txt +++ b/LICENSE.txt @@ -1,5 +1,5 @@ Copyright 2012-2015 The Dojo Foundation -Based on Underscore.js 1.7.0, copyright 2009-2015 Jeremy Ashkenas, +Based on Underscore.js, copyright 2009-2015 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors Permission is hereby granted, free of charge, to any person obtaining diff --git a/README.md b/README.md index 29fa3b35e..5a4b3c627 100644 --- a/README.md +++ b/README.md @@ -1,4 +1,4 @@ -# lodash-es v3.3.1 +# lodash-es v3.4.0 The [modern build](https://github.com/lodash/lodash/wiki/Build-Differences) of [lodash](https://lodash.com/) exported as [ES](https://people.mozilla.org/~jorendorff/es6-draft.html) modules. @@ -7,4 +7,4 @@ Generated using [lodash-cli](https://www.npmjs.com/package/lodash-cli): $ lodash modularize modern exports=es -o ./ ``` -See the [package source](https://github.com/lodash/lodash/tree/3.3.1-es) for more details. +See the [package source](https://github.com/lodash/lodash/tree/3.4.0-es) for more details. diff --git a/array/difference.js b/array/difference.js index 085893756..627919db3 100644 --- a/array/difference.js +++ b/array/difference.js @@ -24,16 +24,17 @@ import isArray from '../lang/isArray'; * // => [1, 3] */ function difference() { - var index = -1, - length = arguments.length; + var args = arguments, + index = -1, + length = args.length; while (++index < length) { - var value = arguments[index]; + var value = args[index]; if (isArray(value) || isArguments(value)) { break; } } - return baseDifference(value, baseFlatten(arguments, false, true, ++index)); + return baseDifference(value, baseFlatten(args, false, true, ++index)); } export default difference; diff --git a/array/dropRightWhile.js b/array/dropRightWhile.js index 7c2a13f94..91c94728e 100644 --- a/array/dropRightWhile.js +++ b/array/dropRightWhile.js @@ -39,7 +39,7 @@ import baseSlice from '../internal/baseSlice'; * ]; * * // using the `_.matches` callback shorthand - * _.pluck(_.dropRightWhile(users, { 'user': pebbles, 'active': false }), 'user'); + * _.pluck(_.dropRightWhile(users, { 'user': 'pebbles', 'active': false }), 'user'); * // => ['barney', 'fred'] * * // using the `_.matchesProperty` callback shorthand diff --git a/array/findLastIndex.js b/array/findLastIndex.js index 1606833e9..ce91f93b9 100644 --- a/array/findLastIndex.js +++ b/array/findLastIndex.js @@ -42,7 +42,7 @@ import baseCallback from '../internal/baseCallback'; * * // using the `_.matchesProperty` callback shorthand * _.findLastIndex(users, 'active', false); - * // => 1 + * // => 2 * * // using the `_.property` callback shorthand * _.findLastIndex(users, 'active'); diff --git a/array/flatten.js b/array/flatten.js index f50aee565..b22b17ee5 100644 --- a/array/flatten.js +++ b/array/flatten.js @@ -26,7 +26,7 @@ function flatten(array, isDeep, guard) { if (guard && isIterateeCall(array, isDeep, guard)) { isDeep = false; } - return length ? baseFlatten(array, isDeep) : []; + return length ? baseFlatten(array, isDeep, false, 0) : []; } export default flatten; diff --git a/array/flattenDeep.js b/array/flattenDeep.js index 383ed3710..0bbd95cdb 100644 --- a/array/flattenDeep.js +++ b/array/flattenDeep.js @@ -15,7 +15,7 @@ import baseFlatten from '../internal/baseFlatten'; */ function flattenDeep(array) { var length = array ? array.length : 0; - return length ? baseFlatten(array, true) : []; + return length ? baseFlatten(array, true, false, 0) : []; } export default flattenDeep; diff --git a/array/indexOf.js b/array/indexOf.js index d08de53db..a92895fb4 100644 --- a/array/indexOf.js +++ b/array/indexOf.js @@ -42,14 +42,14 @@ function indexOf(array, value, fromIndex) { return -1; } if (typeof fromIndex == 'number') { - fromIndex = fromIndex < 0 ? nativeMax(length + fromIndex, 0) : (fromIndex || 0); + fromIndex = fromIndex < 0 ? nativeMax(length + fromIndex, 0) : fromIndex; } else if (fromIndex) { var index = binaryIndex(array, value), other = array[index]; return (value === value ? value === other : other !== other) ? index : -1; } - return baseIndexOf(array, value, fromIndex); + return baseIndexOf(array, value, fromIndex || 0); } export default indexOf; diff --git a/array/intersection.js b/array/intersection.js index 4b115a5bb..e204f130a 100644 --- a/array/intersection.js +++ b/array/intersection.js @@ -47,11 +47,11 @@ function intersection() { outer: while (++index < length) { value = array[index]; - if ((seen ? cacheIndexOf(seen, value) : indexOf(result, value)) < 0) { + if ((seen ? cacheIndexOf(seen, value) : indexOf(result, value, 0)) < 0) { argsIndex = argsLength; while (--argsIndex) { var cache = caches[argsIndex]; - if ((cache ? cacheIndexOf(cache, value) : indexOf(args[argsIndex], value)) < 0) { + if ((cache ? cacheIndexOf(cache, value) : indexOf(args[argsIndex], value, 0)) < 0) { continue outer; } } diff --git a/array/pull.js b/array/pull.js index bab5eb17e..d911ba079 100644 --- a/array/pull.js +++ b/array/pull.js @@ -31,17 +31,19 @@ var splice = arrayProto.splice; * // => [1, 1] */ function pull() { - var array = arguments[0]; + var args = arguments, + array = args[0]; + if (!(array && array.length)) { return array; } var index = 0, indexOf = baseIndexOf, - length = arguments.length; + length = args.length; while (++index < length) { var fromIndex = 0, - value = arguments[index]; + value = args[index]; while ((fromIndex = indexOf(array, value, fromIndex)) > -1) { splice.call(array, fromIndex, 1); diff --git a/array/union.js b/array/union.js index 43b2d69b8..4eeeff37e 100644 --- a/array/union.js +++ b/array/union.js @@ -21,7 +21,7 @@ import baseUniq from '../internal/baseUniq'; * // => [1, 2, 4] */ function union() { - return baseUniq(baseFlatten(arguments, false, true)); + return baseUniq(baseFlatten(arguments, false, true, 0)); } export default union; diff --git a/chain/lodash.js b/chain/lodash.js index c94be2104..31ccb31eb 100644 --- a/chain/lodash.js +++ b/chain/lodash.js @@ -49,26 +49,26 @@ var hasOwnProperty = objectProto.hasOwnProperty; * `mixin`, `negate`, `noop`, `omit`, `once`, `pairs`, `partial`, `partialRight`, * `partition`, `pick`, `plant`, `pluck`, `property`, `propertyOf`, `pull`, * `pullAt`, `push`, `range`, `rearg`, `reject`, `remove`, `rest`, `reverse`, - * `shuffle`, `slice`, `sort`, `sortBy`, `sortByAll`, `splice`, `spread`, - * `take`, `takeRight`, `takeRightWhile`, `takeWhile`, `tap`, `throttle`, - * `thru`, `times`, `toArray`, `toPlainObject`, `transform`, `union`, `uniq`, - * `unshift`, `unzip`, `values`, `valuesIn`, `where`, `without`, `wrap`, `xor`, - * `zip`, and `zipObject` + * `shuffle`, `slice`, `sort`, `sortBy`, `sortByAll`, `sortByOrder`, `splice`, + * `spread`, `take`, `takeRight`, `takeRightWhile`, `takeWhile`, `tap`, + * `throttle`, `thru`, `times`, `toArray`, `toPlainObject`, `transform`, + * `union`, `uniq`, `unshift`, `unzip`, `values`, `valuesIn`, `where`, + * `without`, `wrap`, `xor`, `zip`, and `zipObject` * * The wrapper methods that are **not** chainable by default are: - * `attempt`, `camelCase`, `capitalize`, `clone`, `cloneDeep`, `deburr`, + * `add`, `attempt`, `camelCase`, `capitalize`, `clone`, `cloneDeep`, `deburr`, * `endsWith`, `escape`, `escapeRegExp`, `every`, `find`, `findIndex`, `findKey`, * `findLast`, `findLastIndex`, `findLastKey`, `findWhere`, `first`, `has`, - * `identity`, `includes`, `indexOf`, `isArguments`, `isArray`, `isBoolean`, - * `isDate`, `isElement`, `isEmpty`, `isEqual`, `isError`, `isFinite`, - * `isFunction`, `isMatch`, `isNative`, `isNaN`, `isNull`, `isNumber`, + * `identity`, `includes`, `indexOf`, `inRange`, `isArguments`, `isArray`, + * `isBoolean`, `isDate`, `isElement`, `isEmpty`, `isEqual`, `isError`, + * `isFinite`,`isFunction`, `isMatch`, `isNative`, `isNaN`, `isNull`, `isNumber`, * `isObject`, `isPlainObject`, `isRegExp`, `isString`, `isUndefined`, * `isTypedArray`, `join`, `kebabCase`, `last`, `lastIndexOf`, `max`, `min`, * `noConflict`, `now`, `pad`, `padLeft`, `padRight`, `parseInt`, `pop`, * `random`, `reduce`, `reduceRight`, `repeat`, `result`, `runInContext`, * `shift`, `size`, `snakeCase`, `some`, `sortedIndex`, `sortedLastIndex`, - * `startCase`, `startsWith`, `template`, `trim`, `trimLeft`, `trimRight`, - * `trunc`, `unescape`, `uniqueId`, `value`, and `words` + * `startCase`, `startsWith`, `sum`, `template`, `trim`, `trimLeft`, + * `trimRight`, `trunc`, `unescape`, `uniqueId`, `value`, and `words` * * The wrapper method `sample` will return a wrapped value when `n` is provided, * otherwise an unwrapped value is returned. diff --git a/collection.js b/collection.js index 351c74573..d1a94a5cb 100644 --- a/collection.js +++ b/collection.js @@ -23,8 +23,8 @@ import indexBy from './collection/indexBy'; import inject from './collection/inject'; import invoke from './collection/invoke'; import map from './collection/map'; -import max from './collection/max'; -import min from './collection/min'; +import max from './math/max'; +import min from './math/min'; import partition from './collection/partition'; import pluck from './collection/pluck'; import reduce from './collection/reduce'; @@ -37,6 +37,8 @@ import size from './collection/size'; import some from './collection/some'; import sortBy from './collection/sortBy'; import sortByAll from './collection/sortByAll'; +import sortByOrder from './collection/sortByOrder'; +import sum from './math/sum'; import where from './collection/where'; export default { @@ -79,5 +81,7 @@ export default { 'some': some, 'sortBy': sortBy, 'sortByAll': sortByAll, + 'sortByOrder': sortByOrder, + 'sum': sum, 'where': where }; diff --git a/collection/max.js b/collection/max.js index 923d4bd42..29b9656bb 100644 --- a/collection/max.js +++ b/collection/max.js @@ -1,53 +1,2 @@ -import arrayMax from '../internal/arrayMax'; -import createExtremum from '../internal/createExtremum'; - -/** - * Gets the maximum value of `collection`. If `collection` is empty or falsey - * `-Infinity` is returned. If an iteratee function is provided it is invoked - * for each value in `collection` to generate the criterion by which the value - * is ranked. The `iteratee` is bound to `thisArg` and invoked with three - * arguments; (value, index, collection). - * - * If a property name is provided for `predicate` the created `_.property` - * style callback returns the property value of the given element. - * - * If a value is also provided for `thisArg` the created `_.matchesProperty` - * style callback returns `true` for elements that have a matching property - * value, else `false`. - * - * If an object is provided for `predicate` the created `_.matches` style - * callback returns `true` for elements that have the properties of the given - * object, else `false`. - * - * @static - * @memberOf _ - * @category Collection - * @param {Array|Object|string} collection The collection to iterate over. - * @param {Function|Object|string} [iteratee] The function invoked per iteration. - * @param {*} [thisArg] The `this` binding of `iteratee`. - * @returns {*} Returns the maximum value. - * @example - * - * _.max([4, 2, 8, 6]); - * // => 8 - * - * _.max([]); - * // => -Infinity - * - * var users = [ - * { 'user': 'barney', 'age': 36 }, - * { 'user': 'fred', 'age': 40 } - * ]; - * - * _.max(users, function(chr) { - * return chr.age; - * }); - * // => { 'user': 'fred', 'age': 40 }; - * - * // using the `_.property` callback shorthand - * _.max(users, 'age'); - * // => { 'user': 'fred', 'age': 40 }; - */ -var max = createExtremum(arrayMax); - +import max from '../math/max' export default max; diff --git a/collection/min.js b/collection/min.js index a730ccb05..9c8a91efd 100644 --- a/collection/min.js +++ b/collection/min.js @@ -1,53 +1,2 @@ -import arrayMin from '../internal/arrayMin'; -import createExtremum from '../internal/createExtremum'; - -/** - * Gets the minimum value of `collection`. If `collection` is empty or falsey - * `Infinity` is returned. If an iteratee function is provided it is invoked - * for each value in `collection` to generate the criterion by which the value - * is ranked. The `iteratee` is bound to `thisArg` and invoked with three - * arguments; (value, index, collection). - * - * If a property name is provided for `predicate` the created `_.property` - * style callback returns the property value of the given element. - * - * If a value is also provided for `thisArg` the created `_.matchesProperty` - * style callback returns `true` for elements that have a matching property - * value, else `false`. - * - * If an object is provided for `predicate` the created `_.matches` style - * callback returns `true` for elements that have the properties of the given - * object, else `false`. - * - * @static - * @memberOf _ - * @category Collection - * @param {Array|Object|string} collection The collection to iterate over. - * @param {Function|Object|string} [iteratee] The function invoked per iteration. - * @param {*} [thisArg] The `this` binding of `iteratee`. - * @returns {*} Returns the minimum value. - * @example - * - * _.min([4, 2, 8, 6]); - * // => 2 - * - * _.min([]); - * // => Infinity - * - * var users = [ - * { 'user': 'barney', 'age': 36 }, - * { 'user': 'fred', 'age': 40 } - * ]; - * - * _.min(users, function(chr) { - * return chr.age; - * }); - * // => { 'user': 'barney', 'age': 36 }; - * - * // using the `_.property` callback shorthand - * _.min(users, 'age'); - * // => { 'user': 'barney', 'age': 36 }; - */ -var min = createExtremum(arrayMin, true); - +import min from '../math/min' export default min; diff --git a/collection/partition.js b/collection/partition.js index ddd3b5124..5394bcab8 100644 --- a/collection/partition.js +++ b/collection/partition.js @@ -35,7 +35,7 @@ import createAggregator from '../internal/createAggregator'; * _.partition([1.2, 2.3, 3.4], function(n) { * return this.floor(n) % 2; * }, Math); - * // => [[1, 3], [2]] + * // => [[1.2, 3.4], [2.3]] * * var users = [ * { 'user': 'barney', 'age': 36, 'active': false }, diff --git a/collection/size.js b/collection/size.js index 0e47254bd..60816e9f9 100644 --- a/collection/size.js +++ b/collection/size.js @@ -2,8 +2,8 @@ import isLength from '../internal/isLength'; import keys from '../object/keys'; /** - * Gets the size of `collection` by returning `collection.length` for - * array-like values or the number of own enumerable properties for objects. + * Gets the size of `collection` by returning its length for array-like + * values or the number of own enumerable properties for objects. * * @static * @memberOf _ diff --git a/collection/sortBy.js b/collection/sortBy.js index 6cc525a2f..28744a43e 100644 --- a/collection/sortBy.js +++ b/collection/sortBy.js @@ -55,8 +55,11 @@ import isLength from '../internal/isLength'; * // => ['barney', 'fred', 'pebbles'] */ function sortBy(collection, iteratee, thisArg) { + if (collection == null) { + return []; + } var index = -1, - length = collection ? collection.length : 0, + length = collection.length, result = isLength(length) ? Array(length) : []; if (thisArg && isIterateeCall(collection, iteratee, thisArg)) { diff --git a/collection/sortByAll.js b/collection/sortByAll.js index 51d2be63f..075a165cb 100644 --- a/collection/sortByAll.js +++ b/collection/sortByAll.js @@ -1,9 +1,6 @@ -import baseEach from '../internal/baseEach'; import baseFlatten from '../internal/baseFlatten'; -import baseSortBy from '../internal/baseSortBy'; -import compareMultipleAscending from '../internal/compareMultipleAscending'; +import baseSortByOrder from '../internal/baseSortByOrder'; import isIterateeCall from '../internal/isIterateeCall'; -import isLength from '../internal/isLength'; /** * This method is like `_.sortBy` except that it sorts by property names @@ -29,25 +26,16 @@ import isLength from '../internal/isLength'; * // => [['barney', 26], ['barney', 36], ['fred', 30], ['fred', 40]] */ function sortByAll(collection) { - var args = arguments; - if (args.length > 3 && isIterateeCall(args[1], args[2], args[3])) { + if (collection == null) { + return []; + } + var args = arguments, + guard = args[3]; + + if (guard && isIterateeCall(args[1], args[2], guard)) { args = [collection, args[1]]; } - var index = -1, - length = collection ? collection.length : 0, - props = baseFlatten(args, false, false, 1), - result = isLength(length) ? Array(length) : []; - - baseEach(collection, function(value) { - var length = props.length, - criteria = Array(length); - - while (length--) { - criteria[length] = value == null ? undefined : value[props[length]]; - } - result[++index] = { 'criteria': criteria, 'index': index, 'value': value }; - }); - return baseSortBy(result, compareMultipleAscending); + return baseSortByOrder(collection, baseFlatten(args, false, false, 1), []); } export default sortByAll; diff --git a/collection/sortByOrder.js b/collection/sortByOrder.js new file mode 100644 index 000000000..b226e1933 --- /dev/null +++ b/collection/sortByOrder.js @@ -0,0 +1,47 @@ +import baseSortByOrder from '../internal/baseSortByOrder'; +import isArray from '../lang/isArray'; +import isIterateeCall from '../internal/isIterateeCall'; + +/** + * This method is like `_.sortByAll` except that it allows specifying the + * sort orders of the property names to sort by. A truthy value in `orders` + * will sort the corresponding property name in ascending order while a + * falsey value will sort it in descending order. + * + * @static + * @memberOf _ + * @category Collection + * @param {Array|Object|string} collection The collection to iterate over. + * @param {string[]} props The property names to sort by. + * @param {boolean[]} orders The sort orders of `props`. + * @returns {Array} Returns the new sorted array. + * @example + * + * var users = [ + * { 'user': 'barney', 'age': 36 }, + * { 'user': 'fred', 'age': 40 }, + * { 'user': 'barney', 'age': 26 }, + * { 'user': 'fred', 'age': 30 } + * ]; + * + * // sort by `user` in ascending order and by `age` in descending order + * _.map(_.sortByOrder(users, ['user', 'age'], [true, false]), _.values); + * // => [['barney', 36], ['barney', 26], ['fred', 40], ['fred', 30]] + */ +function sortByOrder(collection, props, orders, guard) { + if (collection == null) { + return []; + } + if (guard && isIterateeCall(props, orders, guard)) { + orders = null; + } + if (!isArray(props)) { + props = props == null ? [] : [props]; + } + if (!isArray(orders)) { + orders = orders == null ? [] : [orders]; + } + return baseSortByOrder(collection, props, orders); +} + +export default sortByOrder; diff --git a/collection/sum.js b/collection/sum.js new file mode 100644 index 000000000..f4ad00270 --- /dev/null +++ b/collection/sum.js @@ -0,0 +1,2 @@ +import sum from '../math/sum' +export default sum; diff --git a/function/flow.js b/function/flow.js index 072ab3635..a6da82918 100644 --- a/function/flow.js +++ b/function/flow.js @@ -1,8 +1,4 @@ -import arrayEvery from '../internal/arrayEvery'; -import baseIsFunction from '../internal/baseIsFunction'; - -/** Used as the `TypeError` message for "Functions" methods. */ -var FUNC_ERROR_TEXT = 'Expected a function'; +import createComposer from '../internal/createComposer'; /** * Creates a function that returns the result of invoking the provided @@ -16,37 +12,14 @@ var FUNC_ERROR_TEXT = 'Expected a function'; * @returns {Function} Returns the new function. * @example * - * function add(x, y) { - * return x + y; - * } - * * function square(n) { * return n * n; * } * - * var addSquare = _.flow(add, square); + * var addSquare = _.flow(_.add, square); * addSquare(1, 2); * // => 9 */ -function flow() { - var funcs = arguments, - length = funcs.length; - - if (!length) { - return function() { return arguments[0]; }; - } - if (!arrayEvery(funcs, baseIsFunction)) { - throw new TypeError(FUNC_ERROR_TEXT); - } - return function() { - var index = 0, - result = funcs[index].apply(this, arguments); - - while (++index < length) { - result = funcs[index].call(this, result); - } - return result; - }; -} +var flow = createComposer(); export default flow; diff --git a/function/flowRight.js b/function/flowRight.js index 1425d2cbd..a1a8fc128 100644 --- a/function/flowRight.js +++ b/function/flowRight.js @@ -1,8 +1,4 @@ -import arrayEvery from '../internal/arrayEvery'; -import baseIsFunction from '../internal/baseIsFunction'; - -/** Used as the `TypeError` message for "Functions" methods. */ -var FUNC_ERROR_TEXT = 'Expected a function'; +import createComposer from '../internal/createComposer'; /** * This method is like `_.flow` except that it creates a function that @@ -16,37 +12,14 @@ var FUNC_ERROR_TEXT = 'Expected a function'; * @returns {Function} Returns the new function. * @example * - * function add(x, y) { - * return x + y; - * } - * * function square(n) { * return n * n; * } * - * var addSquare = _.flowRight(square, add); + * var addSquare = _.flowRight(square, _.add); * addSquare(1, 2); * // => 9 */ -function flowRight() { - var funcs = arguments, - fromIndex = funcs.length - 1; - - if (fromIndex < 0) { - return function() { return arguments[0]; }; - } - if (!arrayEvery(funcs, baseIsFunction)) { - throw new TypeError(FUNC_ERROR_TEXT); - } - return function() { - var index = fromIndex, - result = funcs[index].apply(this, arguments); - - while (index--) { - result = funcs[index].call(this, result); - } - return result; - }; -} +var flowRight = createComposer(true); export default flowRight; diff --git a/function/memoize.js b/function/memoize.js index 5d90cb8ad..5b0e89fe8 100644 --- a/function/memoize.js +++ b/function/memoize.js @@ -61,13 +61,14 @@ function memoize(func, resolver) { throw new TypeError(FUNC_ERROR_TEXT); } var memoized = function() { - var cache = memoized.cache, - key = resolver ? resolver.apply(this, arguments) : arguments[0]; + var args = arguments, + cache = memoized.cache, + key = resolver ? resolver.apply(this, args) : args[0]; if (cache.has(key)) { return cache.get(key); } - var result = func.apply(this, arguments); + var result = func.apply(this, args); cache.set(key, result); return result; }; diff --git a/internal/baseDifference.js b/internal/baseDifference.js index 9aae88ea2..58028e7b9 100644 --- a/internal/baseDifference.js +++ b/internal/baseDifference.js @@ -42,7 +42,7 @@ function baseDifference(array, values) { } result.push(value); } - else if (indexOf(values, value) < 0) { + else if (indexOf(values, value, 0) < 0) { result.push(value); } } diff --git a/internal/baseFlatten.js b/internal/baseFlatten.js index 6dc272b71..ff0a993e1 100644 --- a/internal/baseFlatten.js +++ b/internal/baseFlatten.js @@ -9,13 +9,13 @@ import isObjectLike from './isObjectLike'; * * @private * @param {Array} array The array to flatten. - * @param {boolean} [isDeep] Specify a deep flatten. - * @param {boolean} [isStrict] Restrict flattening to arrays and `arguments` objects. - * @param {number} [fromIndex=0] The index to start from. + * @param {boolean} isDeep Specify a deep flatten. + * @param {boolean} isStrict Restrict flattening to arrays and `arguments` objects. + * @param {number} fromIndex The index to start from. * @returns {Array} Returns the new flattened array. */ function baseFlatten(array, isDeep, isStrict, fromIndex) { - var index = (fromIndex || 0) - 1, + var index = fromIndex - 1, length = array.length, resIndex = -1, result = []; @@ -26,7 +26,7 @@ function baseFlatten(array, isDeep, isStrict, fromIndex) { if (isObjectLike(value) && isLength(value.length) && (isArray(value) || isArguments(value))) { if (isDeep) { // Recursively flatten arrays (susceptible to call stack limits). - value = baseFlatten(value, isDeep, isStrict); + value = baseFlatten(value, isDeep, isStrict, 0); } var valIndex = -1, valLength = value.length; diff --git a/internal/baseIndexOf.js b/internal/baseIndexOf.js index d7fe970f5..3e14bfefb 100644 --- a/internal/baseIndexOf.js +++ b/internal/baseIndexOf.js @@ -6,14 +6,14 @@ import indexOfNaN from './indexOfNaN'; * @private * @param {Array} array The array to search. * @param {*} value The value to search for. - * @param {number} [fromIndex=0] The index to search from. + * @param {number} fromIndex The index to search from. * @returns {number} Returns the index of the matched value, else `-1`. */ function baseIndexOf(array, value, fromIndex) { if (value !== value) { return indexOfNaN(array, fromIndex); } - var index = (fromIndex || 0) - 1, + var index = fromIndex - 1, length = array.length; while (++index < length) { diff --git a/internal/baseSortBy.js b/internal/baseSortBy.js index 26df3cdc9..aeb74542f 100644 --- a/internal/baseSortBy.js +++ b/internal/baseSortBy.js @@ -1,6 +1,6 @@ /** - * The base implementation of `_.sortBy` and `_.sortByAll` which uses `comparer` - * to define the sort order of `array` and replaces criteria objects with their + * The base implementation of `_.sortBy` which uses `comparer` to define + * the sort order of `array` and replaces criteria objects with their * corresponding values. * * @private diff --git a/internal/baseSortByOrder.js b/internal/baseSortByOrder.js new file mode 100644 index 000000000..41703ee96 --- /dev/null +++ b/internal/baseSortByOrder.js @@ -0,0 +1,35 @@ +import baseEach from './baseEach'; +import baseSortBy from './baseSortBy'; +import compareMultiple from './compareMultiple'; +import isLength from './isLength'; + +/** + * The base implementation of `_.sortByOrder` without param guards. + * + * @private + * @param {Array|Object|string} collection The collection to iterate over. + * @param {string[]} props The property names to sort by. + * @param {boolean[]} orders The sort orders of `props`. + * @returns {Array} Returns the new sorted array. + */ +function baseSortByOrder(collection, props, orders) { + var index = -1, + length = collection.length, + result = isLength(length) ? Array(length) : []; + + baseEach(collection, function(value) { + var length = props.length, + criteria = Array(length); + + while (length--) { + criteria[length] = value == null ? undefined : value[props[length]]; + } + result[++index] = { 'criteria': criteria, 'index': index, 'value': value }; + }); + + return baseSortBy(result, function(object, other) { + return compareMultiple(object, other, orders); + }); +} + +export default baseSortByOrder; diff --git a/internal/baseUniq.js b/internal/baseUniq.js index c5894a2d2..836ee68f0 100644 --- a/internal/baseUniq.js +++ b/internal/baseUniq.js @@ -44,7 +44,7 @@ function baseUniq(array, iteratee) { } result.push(value); } - else if (indexOf(seen, computed) < 0) { + else if (indexOf(seen, computed, 0) < 0) { if (iteratee || isLarge) { seen.push(computed); } diff --git a/internal/compareMultipleAscending.js b/internal/compareMultiple.js similarity index 57% rename from internal/compareMultipleAscending.js rename to internal/compareMultiple.js index eb24af85c..91020a8ae 100644 --- a/internal/compareMultipleAscending.js +++ b/internal/compareMultiple.js @@ -1,24 +1,34 @@ import baseCompareAscending from './baseCompareAscending'; /** - * Used by `_.sortByAll` to compare multiple properties of each element - * in a collection and stable sort them in ascending order. + * Used by `_.sortByOrder` to compare multiple properties of each element + * in a collection and stable sort them in the following order: + * + * If orders is unspecified, sort in ascending order for all properties. + * Otherwise, for each property, sort in ascending order if its corresponding value in + * orders is true, and descending order if false. * * @private * @param {Object} object The object to compare to `other`. * @param {Object} other The object to compare to `object`. + * @param {boolean[]} orders The order to sort by for each property. * @returns {number} Returns the sort order indicator for `object`. */ -function compareMultipleAscending(object, other) { +function compareMultiple(object, other, orders) { var index = -1, objCriteria = object.criteria, othCriteria = other.criteria, - length = objCriteria.length; + length = objCriteria.length, + ordersLength = orders.length; while (++index < length) { var result = baseCompareAscending(objCriteria[index], othCriteria[index]); if (result) { - return result; + if (index >= ordersLength) { + return result; + } else { + return orders[index] ? result : result * -1; + } } } // Fixes an `Array#sort` bug in the JS engine embedded in Adobe applications @@ -31,4 +41,4 @@ function compareMultipleAscending(object, other) { return object.index - other.index; } -export default compareMultipleAscending; +export default compareMultiple; diff --git a/internal/createAssigner.js b/internal/createAssigner.js index 46d3a03e1..480907b1b 100644 --- a/internal/createAssigner.js +++ b/internal/createAssigner.js @@ -11,24 +11,31 @@ import isIterateeCall from './isIterateeCall'; */ function createAssigner(assigner) { return function() { - var length = arguments.length, - object = arguments[0]; + var args = arguments, + length = args.length, + object = args[0]; if (length < 2 || object == null) { return object; } - if (length > 3 && isIterateeCall(arguments[1], arguments[2], arguments[3])) { - length = 2; + var customizer = args[length - 2], + thisArg = args[length - 1], + guard = args[3]; + + if (length > 3 && typeof customizer == 'function') { + customizer = bindCallback(customizer, thisArg, 5); + length -= 2; + } else { + customizer = (length > 2 && typeof thisArg == 'function') ? thisArg : null; + length -= (customizer ? 1 : 0); } - // Juggle arguments. - if (length > 3 && typeof arguments[length - 2] == 'function') { - var customizer = bindCallback(arguments[--length - 1], arguments[length--], 5); - } else if (length > 2 && typeof arguments[length - 1] == 'function') { - customizer = arguments[--length]; + if (guard && isIterateeCall(args[1], args[2], guard)) { + customizer = length == 3 ? null : customizer; + length = 2; } var index = 0; while (++index < length) { - var source = arguments[index]; + var source = args[index]; if (source) { assigner(object, source, customizer); } diff --git a/internal/createComposer.js b/internal/createComposer.js new file mode 100644 index 000000000..f0be26990 --- /dev/null +++ b/internal/createComposer.js @@ -0,0 +1,39 @@ +/** Used as the `TypeError` message for "Functions" methods. */ +var FUNC_ERROR_TEXT = 'Expected a function'; + +/** + * Creates a function to compose other functions into a single function. + * + * @private + * @param {boolean} [fromRight] Specify iterating from right to left. + * @returns {Function} Returns the new composer function. + */ +function createComposer(fromRight) { + return function() { + var length = arguments.length, + index = length, + fromIndex = fromRight ? length - 1 : 0; + + if (!length) { + return function() { return arguments[0]; }; + } + var funcs = Array(length); + while (index--) { + funcs[index] = arguments[index]; + if (typeof funcs[index] != 'function') { + throw new TypeError(FUNC_ERROR_TEXT); + } + } + return function() { + var index = fromIndex, + result = funcs[index].apply(this, arguments); + + while ((fromRight ? index-- : ++index < length)) { + result = funcs[index].call(this, result); + } + return result; + }; + }; +} + +export default createComposer; diff --git a/internal/indexOfNaN.js b/internal/indexOfNaN.js index f6472d996..18c2af405 100644 --- a/internal/indexOfNaN.js +++ b/internal/indexOfNaN.js @@ -4,13 +4,13 @@ * * @private * @param {Array} array The array to search. - * @param {number} [fromIndex] The index to search from. + * @param {number} fromIndex The index to search from. * @param {boolean} [fromRight] Specify iterating from right to left. * @returns {number} Returns the index of the matched `NaN`, else `-1`. */ function indexOfNaN(array, fromIndex, fromRight) { var length = array.length, - index = fromRight ? (fromIndex || length) : ((fromIndex || 0) - 1); + index = fromIndex + (fromRight ? 0 : -1); while ((fromRight ? index-- : ++index < length)) { var other = array[index]; diff --git a/internal/lazyValue.js b/internal/lazyValue.js index 2f1a01b96..f128f85f6 100644 --- a/internal/lazyValue.js +++ b/internal/lazyValue.js @@ -3,8 +3,9 @@ import getView from './getView'; import isArray from '../lang/isArray'; /** Used to indicate the type of lazy iteratees. */ -var LAZY_FILTER_FLAG = 0, - LAZY_MAP_FLAG = 1; +var LAZY_DROP_WHILE_FLAG = 0, + LAZY_MAP_FLAG = 2, + LAZY_TAKE_WHILE_FLAG = 3; /* Native method references for those with the same name as other `lodash` methods. */ var nativeMin = Math.min; @@ -46,16 +47,22 @@ function lazyValue() { while (++iterIndex < iterLength) { var data = iteratees[iterIndex], iteratee = data.iteratee, - computed = iteratee(value, index, array), type = data.type; + if (type != LAZY_DROP_WHILE_FLAG) { + var computed = iteratee(value); + } else { + data.done = data.done && (isRight ? index < data.index : index > data.index); + data.index = index; + computed = data.done || (data.done = !iteratee(value)); + } if (type == LAZY_MAP_FLAG) { value = computed; } else if (!computed) { - if (type == LAZY_FILTER_FLAG) { - continue outer; - } else { + if (type == LAZY_TAKE_WHILE_FLAG) { break outer; + } else { + continue outer; } } } diff --git a/internal/root.js b/internal/root.js index c326966a8..2809c72e3 100644 --- a/internal/root.js +++ b/internal/root.js @@ -4,24 +4,24 @@ var objectTypes = { 'object': true }; -/** - * Used as a reference to the global object. - * - * The `this` value is used if it is the global object to avoid Greasemonkey's - * restricted `window` object, otherwise the `window` object is used. - */ -var root = (objectTypes[typeof window] && window !== (this && this.window)) ? window : this; - /** Detect free variable `exports`. */ var freeExports = objectTypes[typeof exports] && exports && !exports.nodeType && exports; /** Detect free variable `module`. */ var freeModule = objectTypes[typeof module] && module && !module.nodeType && module; -/** Detect free variable `global` from Node.js or Browserified code and use it as `root`. */ +/** Detect free variable `global` from Node.js. */ var freeGlobal = freeExports && freeModule && typeof global == 'object' && global; -if (freeGlobal && (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal || freeGlobal.self === freeGlobal)) { - root = freeGlobal; -} + +/** Detect free variable `window`. */ +var freeWindow = objectTypes[typeof window] && window; + +/** + * Used as a reference to the global object. + * + * The `this` value is used if it is the global object to avoid Greasemonkey's + * restricted `window` object, otherwise the `window` object is used. + */ +var root = freeGlobal || ((freeWindow !== (this && this.window)) && freeWindow) || this; export default root; diff --git a/lang/isEmpty.js b/lang/isEmpty.js index 8a6adffa4..11e5fb898 100644 --- a/lang/isEmpty.js +++ b/lang/isEmpty.js @@ -7,7 +7,7 @@ import isString from './isString'; import keys from '../object/keys'; /** - * Checks if a value is empty. A value is considered empty unless it is an + * Checks if `value` is empty. A value is considered empty unless it is an * `arguments` object, array, string, or jQuery-like collection with a length * greater than `0` or an object with own enumerable properties. * diff --git a/lodash.js b/lodash.js index b6e93355c..a49d964f7 100644 --- a/lodash.js +++ b/lodash.js @@ -1,6 +1,6 @@ /** * @license - * lodash 3.3.1 (Custom Build) + * lodash 3.4.0 (Custom Build) * Build: `lodash modularize modern exports="es" -o ./` * Copyright 2012-2015 The Dojo Foundation * Based on Underscore.js 1.8.2 @@ -13,6 +13,7 @@ import collection from './collection'; import date from './date'; import func from './function'; import lang from './lang'; +import math from './math'; import number from './number'; import object from './object'; import string from './string'; @@ -38,11 +39,11 @@ import support from './support'; import thru from './chain/thru'; /** Used as the semantic version number. */ -var VERSION = '3.3.1'; +var VERSION = '3.4.0'; /** Used to indicate the type of lazy iteratees. */ -var LAZY_FILTER_FLAG = 0, - LAZY_WHILE_FLAG = 2; +var LAZY_DROP_WHILE_FLAG = 0, + LAZY_MAP_FLAG = 2; /** Used for native method references. */ var arrayProto = Array.prototype; @@ -150,6 +151,7 @@ lodash.shuffle = collection.shuffle; lodash.slice = array.slice; lodash.sortBy = collection.sortBy; lodash.sortByAll = collection.sortByAll; +lodash.sortByOrder = collection.sortByOrder; lodash.spread = func.spread; lodash.take = array.take; lodash.takeRight = array.takeRight; @@ -192,6 +194,7 @@ lodash.unique = array.uniq; mixin(lodash, lodash); // Add functions that return unwrapped values when chaining. +lodash.add = math.add; lodash.attempt = utility.attempt; lodash.camelCase = string.camelCase; lodash.capitalize = string.capitalize; @@ -239,8 +242,8 @@ lodash.isUndefined = lang.isUndefined; lodash.kebabCase = string.kebabCase; lodash.last = array.last; lodash.lastIndexOf = array.lastIndexOf; -lodash.max = collection.max; -lodash.min = collection.min; +lodash.max = math.max; +lodash.min = math.min; lodash.noop = utility.noop; lodash.now = date.now; lodash.pad = string.pad; @@ -259,6 +262,7 @@ lodash.sortedIndex = array.sortedIndex; lodash.sortedLastIndex = array.sortedLastIndex; lodash.startCase = string.startCase; lodash.startsWith = string.startsWith; +lodash.sum = math.sum; lodash.template = string.template; lodash.trim = string.trim; lodash.trimLeft = string.trimLeft; @@ -319,15 +323,17 @@ arrayEach(['bind', 'bindKey', 'curry', 'curryRight', 'partial', 'partialRight'], }); // Add `LazyWrapper` methods that accept an `iteratee` value. -arrayEach(['filter', 'map', 'takeWhile'], function(methodName, index) { - var isFilter = index == LAZY_FILTER_FLAG || index == LAZY_WHILE_FLAG; +arrayEach(['dropWhile', 'filter', 'map', 'takeWhile'], function(methodName, type) { + var isFilter = type != LAZY_MAP_FLAG, + isDropWhile = type == LAZY_DROP_WHILE_FLAG; LazyWrapper.prototype[methodName] = function(iteratee, thisArg) { - var result = this.clone(), + var filtered = this.__filtered__, + result = (filtered && isDropWhile) ? new LazyWrapper(this) : this.clone(), iteratees = result.__iteratees__ || (result.__iteratees__ = []); - result.__filtered__ = result.__filtered__ || isFilter; - iteratees.push({ 'iteratee': baseCallback(iteratee, thisArg, 3), 'type': index }); + result.__filtered__ = filtered || isFilter; + iteratees.push({ 'done': false, 'index': 0, 'iteratee': baseCallback(iteratee, thisArg, 1), 'type': type }); return result; }; }); @@ -392,23 +398,10 @@ LazyWrapper.prototype.compact = function() { return this.filter(identity); }; -LazyWrapper.prototype.dropWhile = function(predicate, thisArg) { - var done, - lastIndex, - isRight = this.__dir__ < 0; - - predicate = baseCallback(predicate, thisArg, 3); - return this.filter(function(value, index, array) { - done = done && (isRight ? index < lastIndex : index > lastIndex); - lastIndex = index; - return done || (done = !predicate(value, index, array)); - }); -}; - LazyWrapper.prototype.reject = function(predicate, thisArg) { - predicate = baseCallback(predicate, thisArg, 3); - return this.filter(function(value, index, array) { - return !predicate(value, index, array); + predicate = baseCallback(predicate, thisArg, 1); + return this.filter(function(value) { + return !predicate(value); }); }; @@ -430,16 +423,24 @@ LazyWrapper.prototype.toArray = function() { // Add `LazyWrapper` methods to `lodash.prototype`. baseForOwn(LazyWrapper.prototype, function(func, methodName) { var lodashFunc = lodash[methodName], + checkIteratee = /^(?:filter|map|reject)|While$/.test(methodName), retUnwrapped = /^(?:first|last)$/.test(methodName); lodash.prototype[methodName] = function() { - var value = this.__wrapped__, - args = arguments, + var args = arguments, + length = args.length, chainAll = this.__chain__, + value = this.__wrapped__, isHybrid = !!this.__actions__.length, isLazy = value instanceof LazyWrapper, - onlyLazy = isLazy && !isHybrid; + iteratee = args[0], + useLazy = isLazy || isArray(value); + if (useLazy && checkIteratee && typeof iteratee == 'function' && iteratee.length != 1) { + // avoid lazy use if the iteratee has a `length` other than `1` + isLazy = useLazy = false; + } + var onlyLazy = isLazy && !isHybrid; if (retUnwrapped && !chainAll) { return onlyLazy ? func.call(value) @@ -450,7 +451,7 @@ baseForOwn(LazyWrapper.prototype, function(func, methodName) { push.apply(otherArgs, args); return lodashFunc.apply(lodash, otherArgs); }; - if (isLazy || isArray(value)) { + if (useLazy) { var wrapper = onlyLazy ? value : new LazyWrapper(this), result = func.apply(wrapper, args); diff --git a/math.js b/math.js new file mode 100644 index 000000000..b91229c03 --- /dev/null +++ b/math.js @@ -0,0 +1,11 @@ +import add from './math/add'; +import max from './math/max'; +import min from './math/min'; +import sum from './math/sum'; + +export default { + 'add': add, + 'max': max, + 'min': min, + 'sum': sum +}; diff --git a/math/add.js b/math/add.js new file mode 100644 index 000000000..39b53553c --- /dev/null +++ b/math/add.js @@ -0,0 +1,19 @@ +/** + * Adds two numbers. + * + * @static + * @memberOf _ + * @category Math + * @param {number} augend The first number to add. + * @param {number} addend The second number to add. + * @returns {number} Returns the sum. + * @example + * + * _.add(6, 4); + * // => 10 + */ +function add(augend, addend) { + return augend + addend; +} + +export default add; diff --git a/math/max.js b/math/max.js new file mode 100644 index 000000000..10dd13464 --- /dev/null +++ b/math/max.js @@ -0,0 +1,53 @@ +import arrayMax from '../internal/arrayMax'; +import createExtremum from '../internal/createExtremum'; + +/** + * Gets the maximum value of `collection`. If `collection` is empty or falsey + * `-Infinity` is returned. If an iteratee function is provided it is invoked + * for each value in `collection` to generate the criterion by which the value + * is ranked. The `iteratee` is bound to `thisArg` and invoked with three + * arguments; (value, index, collection). + * + * If a property name is provided for `predicate` the created `_.property` + * style callback returns the property value of the given element. + * + * If a value is also provided for `thisArg` the created `_.matchesProperty` + * style callback returns `true` for elements that have a matching property + * value, else `false`. + * + * If an object is provided for `predicate` the created `_.matches` style + * callback returns `true` for elements that have the properties of the given + * object, else `false`. + * + * @static + * @memberOf _ + * @category Math + * @param {Array|Object|string} collection The collection to iterate over. + * @param {Function|Object|string} [iteratee] The function invoked per iteration. + * @param {*} [thisArg] The `this` binding of `iteratee`. + * @returns {*} Returns the maximum value. + * @example + * + * _.max([4, 2, 8, 6]); + * // => 8 + * + * _.max([]); + * // => -Infinity + * + * var users = [ + * { 'user': 'barney', 'age': 36 }, + * { 'user': 'fred', 'age': 40 } + * ]; + * + * _.max(users, function(chr) { + * return chr.age; + * }); + * // => { 'user': 'fred', 'age': 40 }; + * + * // using the `_.property` callback shorthand + * _.max(users, 'age'); + * // => { 'user': 'fred', 'age': 40 }; + */ +var max = createExtremum(arrayMax); + +export default max; diff --git a/math/min.js b/math/min.js new file mode 100644 index 000000000..dd3a2d5a3 --- /dev/null +++ b/math/min.js @@ -0,0 +1,53 @@ +import arrayMin from '../internal/arrayMin'; +import createExtremum from '../internal/createExtremum'; + +/** + * Gets the minimum value of `collection`. If `collection` is empty or falsey + * `Infinity` is returned. If an iteratee function is provided it is invoked + * for each value in `collection` to generate the criterion by which the value + * is ranked. The `iteratee` is bound to `thisArg` and invoked with three + * arguments; (value, index, collection). + * + * If a property name is provided for `predicate` the created `_.property` + * style callback returns the property value of the given element. + * + * If a value is also provided for `thisArg` the created `_.matchesProperty` + * style callback returns `true` for elements that have a matching property + * value, else `false`. + * + * If an object is provided for `predicate` the created `_.matches` style + * callback returns `true` for elements that have the properties of the given + * object, else `false`. + * + * @static + * @memberOf _ + * @category Math + * @param {Array|Object|string} collection The collection to iterate over. + * @param {Function|Object|string} [iteratee] The function invoked per iteration. + * @param {*} [thisArg] The `this` binding of `iteratee`. + * @returns {*} Returns the minimum value. + * @example + * + * _.min([4, 2, 8, 6]); + * // => 2 + * + * _.min([]); + * // => Infinity + * + * var users = [ + * { 'user': 'barney', 'age': 36 }, + * { 'user': 'fred', 'age': 40 } + * ]; + * + * _.min(users, function(chr) { + * return chr.age; + * }); + * // => { 'user': 'barney', 'age': 36 }; + * + * // using the `_.property` callback shorthand + * _.min(users, 'age'); + * // => { 'user': 'barney', 'age': 36 }; + */ +var min = createExtremum(arrayMin, true); + +export default min; diff --git a/math/sum.js b/math/sum.js new file mode 100644 index 000000000..b0ef03ece --- /dev/null +++ b/math/sum.js @@ -0,0 +1,33 @@ +import isArray from '../lang/isArray'; +import toIterable from '../internal/toIterable'; + +/** + * Gets the sum of the values in `collection`. + * + * @static + * @memberOf _ + * @category Math + * @param {Array|Object|string} collection The collection to iterate over. + * @returns {number} Returns the sum. + * @example + * + * _.sum([4, 6, 2]); + * // => 12 + * + * _.sum({ 'a': 4, 'b': 6, 'c': 2 }); + * // => 12 + */ +function sum(collection) { + if (!isArray(collection)) { + collection = toIterable(collection); + } + var length = collection.length, + result = 0; + + while (length--) { + result += +collection[length] || 0; + } + return result; +} + +export default sum; diff --git a/number/inRange.js b/number/inRange.js index 75c9e41d4..a4f328f0d 100644 --- a/number/inRange.js +++ b/number/inRange.js @@ -1,6 +1,6 @@ /** * Checks if `n` is between `start` and up to but not including, `end`. If - * `end` is not specified it defaults to `start` with `start` becoming `0`. + * `end` is not specified it is set to `start` with `start` then set to `0`. * * @static * @memberOf _ diff --git a/object/defaults.js b/object/defaults.js index 5c5fe4815..759c6d89b 100644 --- a/object/defaults.js +++ b/object/defaults.js @@ -5,7 +5,7 @@ import assignDefaults from '../internal/assignDefaults'; /** * Assigns own enumerable properties of source object(s) to the destination * object for all destination properties that resolve to `undefined`. Once a - * property is set, additional defaults of the same property are ignored. + * property is set, additional values of the same property are ignored. * * @static * @memberOf _ diff --git a/package.json b/package.json index 376625a00..364370f75 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "lodash-es", - "version": "3.3.1", + "version": "3.4.0", "description": "The modern build of lodash exported as ES modules.", "homepage": "https://lodash.com/custom-builds", "license": "MIT", diff --git a/string/escape.js b/string/escape.js index f497cd836..341b07429 100644 --- a/string/escape.js +++ b/string/escape.js @@ -6,7 +6,7 @@ var reUnescapedHtml = /[&<>"'`]/g, reHasUnescapedHtml = RegExp(reUnescapedHtml.source); /** - * Converts the characters "&", "<", ">", '"', "'", and '`', in `string` to + * Converts the characters "&", "<", ">", '"', "'", and "\`", in `string` to * their corresponding HTML entities. * * **Note:** No other characters are escaped. To escape additional characters diff --git a/string/words.js b/string/words.js index 2d3389f88..be3fba9ce 100644 --- a/string/words.js +++ b/string/words.js @@ -6,7 +6,7 @@ var reWords = (function() { var upper = '[A-Z\\xc0-\\xd6\\xd8-\\xde]', lower = '[a-z\\xdf-\\xf6\\xf8-\\xff]+'; - return RegExp(upper + '{2,}(?=' + upper + lower + ')|' + upper + '?' + lower + '|' + upper + '+|[0-9]+', 'g'); + return RegExp(upper + '+(?=' + upper + lower + ')|' + upper + '?' + lower + '|' + upper + '+|[0-9]+', 'g'); }()); /** diff --git a/utility/attempt.js b/utility/attempt.js index baa49683a..b6e26caa9 100644 --- a/utility/attempt.js +++ b/utility/attempt.js @@ -21,14 +21,14 @@ import isError from '../lang/isError'; * } */ function attempt() { - var length = arguments.length, - func = arguments[0]; + var func = arguments[0], + length = arguments.length, + args = Array(length ? length - 1 : 0); + while (--length > 0) { + args[length - 1] = arguments[length]; + } try { - var args = Array(length ? length - 1 : 0); - while (--length > 0) { - args[length - 1] = arguments[length]; - } return func.apply(undefined, args); } catch(e) { return isError(e) ? e : new Error(e); diff --git a/utility/range.js b/utility/range.js index 85c1d7675..dedcdbc04 100644 --- a/utility/range.js +++ b/utility/range.js @@ -8,9 +8,9 @@ var nativeMax = Math.max; /** * Creates an array of numbers (positive and/or negative) progressing from - * `start` up to, but not including, `end`. If `end` is not specified it - * defaults to `start` with `start` becoming `0`. If `start` is less than - * `end` a zero-length range is created unless a negative `step` is specified. + * `start` up to, but not including, `end`. If `end` is not specified it is + * set to `start` with `start` then set to `0`. If `start` is less than `end` + * a zero-length range is created unless a negative `step` is specified. * * @static * @memberOf _