Lines Matching defs:result
92 /** `Object#toString` result references. */
483 * @returns {*} Returns the result of `func`.
592 result = [];
597 result[resIndex++] = value;
600 return result;
650 result = Array(length);
653 result[index] = iteratee(array[index], index, array);
655 return result;
790 var result;
793 result = key;
797 return result;
963 var result,
970 result = result === undefined ? current : (result + current);
973 return result;
987 result = Array(n);
990 result[index] = iteratee(index);
992 return result;
1107 result = 0;
1111 ++result;
1114 return result;
1190 result = [];
1193 result.push(data.value);
1195 return result;
1207 result = Array(map.size);
1210 result[++index] = [key, value];
1212 return result;
1242 result = [];
1248 result[resIndex++] = index;
1251 return result;
1263 result = Array(set.size);
1266 result[++index] = value;
1268 return result;
1280 result = Array(set.size);
1283 result[++index] = [value, value];
1285 return result;
1388 var result = reUnicode.lastIndex = 0;
1390 ++result;
1392 return result;
1655 * `repeat`, `result`, `round`, `runInContext`, `sample`, `shift`, `size`,
1720 var result = new object;
1722 return result;
1846 var result = new LazyWrapper(this.__wrapped__);
1847 result.__actions__ = copyArray(this.__actions__);
1848 result.__dir__ = this.__dir__;
1849 result.__filtered__ = this.__filtered__;
1850 result.__iteratees__ = copyArray(this.__iteratees__);
1851 result.__takeCount__ = this.__takeCount__;
1852 result.__views__ = copyArray(this.__views__);
1853 return result;
1866 var result = new LazyWrapper(this);
1867 result.__dir__ = -1;
1868 result.__filtered__ = true;
1870 result = this.clone();
1871 result.__dir__ *= -1;
1873 return result;
1903 var result = [];
1928 result[resIndex++] = value;
1930 return result;
1980 var result = this.has(key) && delete this.__data__[key];
1981 this.size -= result ? 1 : 0;
1982 return result;
1997 var result = data[key];
1998 return result === HASH_UNDEFINED ? undefined : result;
2204 var result = getMapData(this, key)['delete'](key);
2205 this.size -= result ? 1 : 0;
2206 return result;
2350 result = data['delete'](key);
2353 return result;
2431 result = skipIndexes ? baseTimes(value.length, String) : [],
2432 length = result.length;
2446 result.push(key);
2449 return result;
2616 result = Array(length),
2620 result[index] = skip ? undefined : get(object, paths[index]);
2622 return result;
2663 var result,
2669 result = object ? customizer(value, key, object, stack) : customizer(value);
2671 if (result !== undefined) {
2672 return result;
2679 result = initCloneArray(value);
2681 return copyArray(value, result);
2691 result = (isFlat || isFunc) ? {} : initCloneObject(value);
2694 ? copySymbolsIn(value, baseAssignIn(result, value))
2695 : copySymbols(value, baseAssign(result, value));
2701 result = initCloneByTag(value, tag, isDeep);
2710 stack.set(value, result);
2714 result.add(baseClone(subValue, bitmask, customizer, subValue, value, stack));
2718 result.set(key, baseClone(subValue, bitmask, customizer, key, value, stack));
2733 assignValue(result, key, baseClone(subValue, bitmask, customizer, key, value, stack));
2735 return result;
2811 result = [],
2815 return result;
2842 result.push(value);
2845 result.push(value);
2848 return result;
2881 var result = true;
2883 result = !!predicate(value, index, collection);
2884 return result;
2886 return result;
2912 result = value;
2915 return result;
2955 var result = [];
2958 result.push(value);
2961 return result;
2972 * @param {Array} [result=[]] The initial result value.
2975 function baseFlatten(array, depth, predicate, isStrict, result) {
2980 result || (result = []);
2987 baseFlatten(value, depth - 1, predicate, isStrict, result);
2989 arrayPush(result, value);
2992 result[result.length] = value;
2995 return result;
3094 var result = keysFunc(object);
3095 return isArray(object) ? result : arrayPush(result, symbolsFunc(object));
3181 result = [];
3199 while (++index < length && result.length < maxLength) {
3206 : includes(result, computed, comparator)
3221 result.push(value);
3224 return result;
3253 * @returns {*} Returns the result of the invoked method.
3430 var result = customizer(objValue, srcValue, key, object, source, stack);
3432 if (!(result === undefined
3434 : result
3501 // Don't store the `typeof` result in a variable to avoid a JIT bug in Safari 9.
3528 var result = [];
3531 result.push(key);
3534 return result;
3549 result = [];
3553 result.push(key);
3556 return result;
3582 result = isArrayLike(collection) ? Array(collection.length) : [];
3585 result[++index] = iteratee(value, key, collection);
3587 return result;
3780 var result = baseMap(collection, function(value, key, collection) {
3787 return baseSortBy(result, function(object, other) {
3819 result = {};
3826 baseSet(result, castPath(path, object), value);
3829 return result;
3937 result = Array(length);
3940 result[fromRight ? length : ++index] = start;
3943 return result;
3955 var result = '';
3957 return result;
3963 result += string;
3971 return result;
4072 * @param {Function} string The `toString` result.
4118 var result = Array(length);
4120 result[index] = array[index + start];
4122 return result;
4135 var result;
4138 result = predicate(value, index, collection);
4139 return !result;
4141 return !!result;
4246 result = [];
4254 result[resIndex++] = value === 0 ? 0 : value;
4257 return result;
4298 var result = (value + '');
4299 return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;
4316 result = [],
4317 seen = result;
4333 seen = iteratee ? [] : result;
4351 result.push(value);
4354 if (seen !== result) {
4357 result.push(value);
4360 return result;
4415 * The base implementation of `wrapperValue` which returns the result of
4425 var result = value;
4426 if (result instanceof LazyWrapper) {
4427 result = result.value();
4429 return arrayReduce(actions, function(result, action) {
4430 return action.func.apply(action.thisArg, arrayPush([result], action.args));
4431 }, result);
4450 result = Array(length);
4458 result[index] = baseDifference(result[index] || array, arrays[othIndex], iteratee, comparator);
4462 return baseUniq(baseFlatten(result, 1), iteratee, comparator);
4478 result = {};
4482 assignFunc(result, props[index], value);
4484 return result;
4573 result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);
4575 buffer.copy(result);
4576 return result;
4587 var result = new arrayBuffer.constructor(arrayBuffer.byteLength);
4588 new Uint8Array(result).set(new Uint8Array(arrayBuffer));
4589 return result;
4613 var result = new regexp.constructor(regexp.source, reFlags.exec(regexp));
4614 result.lastIndex = regexp.lastIndex;
4615 return result;
4702 var result = compareAscending(objCriteria[index], othCriteria[index]);
4703 if (result) {
4705 return result;
4708 return result * (order == 'desc' ? -1 : 1);
4739 result = Array(leftLength + rangeLength),
4743 result[leftIndex] = partials[leftIndex];
4747 result[holders[argsIndex]] = args[argsIndex];
4751 result[leftIndex++] = args[argsIndex++];
4753 return result;
4775 result = Array(rangeLength + rightLength),
4779 result[argsIndex] = args[argsIndex];
4783 result[offset + rightIndex] = partials[rightIndex];
4787 result[offset + holders[holdersIndex]] = args[argsIndex++];
4790 return result;
5061 result = Ctor.apply(thisBinding, args);
5065 return isObject(result) ? result : thisBinding;
5177 result = length ? funcs[index].apply(this, args) : value;
5180 result = funcs[index].call(this, result);
5182 return result;
5284 var result;
5289 result = value;
5292 if (result === undefined) {
5302 result = operator(value, other);
5304 return result;
5343 var result = baseRepeat(chars, nativeCeil(length / stringSize(chars)));
5345 ? castSlice(stringToArray(result), 0, length).join('')
5346 : result.slice(0, length);
5461 var result = wrapFunc.apply(undefined, newData);
5463 setData(result, newData);
5465 result.placeholder = placeholder;
5466 return setWrapToString(result, func, bitmask);
5593 var result = createBind(func, bitmask, thisArg);
5595 result = createCurry(func, bitmask, arity);
5597 result = createPartial(func, bitmask, thisArg, partials);
5599 result = createHybrid.apply(undefined, newData);
5602 return setWrapToString(setter(result, newData), func, bitmask);
5690 result = true,
5710 result = false;
5721 result = false;
5728 result = false;
5734 return result;
5807 var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack);
5809 return result;
5855 var result = true;
5875 result = false;
5880 if (result && !skipCtor) {
5889 result = false;
5894 return result;
5950 var result = (func.name + ''),
5951 array = realNames[result],
5952 length = hasOwnProperty.call(realNames, result) ? array.length : 0;
5961 return result;
5980 * its result is returned.
5985 * @returns {Function} Returns the chosen function or its result.
5988 var result = lodash.iteratee || iteratee;
5989 result = result === iteratee ? baseIteratee : result;
5990 return arguments.length ? result(arguments[0], arguments[1]) : result;
6016 var result = keys(object),
6017 length = result.length;
6020 var key = result[length],
6023 result[length] = [key, value, isStrictComparable(value)];
6025 return result;
6057 var result = nativeObjectToString.call(value);
6065 return result;
6093 var result = [];
6095 arrayPush(result, getSymbols(object));
6098 return result;
6117 var result = baseGetTag(value),
6118 Ctor = result == objectTag ? value.constructor : undefined,
6130 return result;
6188 result = false;
6192 if (!(result = object != null && hasFunc(object, key))) {
6197 if (result || ++index != length) {
6198 return result;
6214 result = new array.constructor(length);
6218 result.index = array.index;
6219 result.input = array.input;
6221 return result;
6489 var result = memoize(func, function(key) {
6496 var cache = result.cache;
6497 return result;
6581 var result = [];
6584 result.push(key);
6587 return result;
6718 * @param {Function} string The `toString` result.
6800 var result = [];
6802 result.push('');
6805 result.push(quote ? subString.replace(reEscapeChar, '$1') : (number || match));
6807 return result;
6821 var result = (value + '');
6822 return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;
6873 var result = new LodashWrapper(wrapper.__wrapped__, wrapper.__chain__);
6874 result.__actions__ = copyArray(wrapper.__actions__);
6875 result.__index__ = wrapper.__index__;
6876 result.__values__ = wrapper.__values__;
6877 return result;
6915 result = Array(nativeCeil(length / size));
6918 result[resIndex++] = baseSlice(array, index, (index += size));
6920 return result;
6942 result = [];
6947 result[resIndex++] = value;
6950 return result;
6993 * for equality comparisons. The order and references of result values are
7020 * by which they're compared. The order and references of result values are
7056 * references of result values are determined by the first array. The comparator
7460 result = {};
7464 result[pair[0]] = pair[1];
7466 return result;
7548 * for equality comparisons. The order and references of result values are
7572 * by which they're compared. The order and references of result values are
7609 * of result values are determined by the first array. The comparator is
7874 result = baseAt(array, indexes);
7880 return result;
7912 var result = [];
7914 return result;
7924 result.push(value);
7929 return result;
8440 * is kept. The order of result values is determined by the order they occur
8461 * uniqueness is computed. The order of result values is determined by the
8487 * is invoked to compare elements of `array`. The order of result values is
8570 var result = unzip(array);
8572 return result;
8574 return arrayMap(result, function(group) {
8608 * of the given arrays. The order of result values is determined by the order
8630 * which by which they're compared. The order of result values is determined
8660 * invoked to compare elements of `arrays`. The order of result values is
8774 * chain sequences enabled. The result of such sequences must be unwrapped
8802 var result = lodash(value);
8803 result.__chain__ = true;
8804 return result;
8836 * This method is like `_.tap` except that it returns the result of `interceptor`.
8846 * @returns {*} Returns the result of `interceptor`.
8934 * Executes the chain sequence and returns the wrapped result.
9042 var result,
9049 if (result) {
9052 result = clone;
9058 return result;
9141 var countBy = createAggregator(function(result, value, key) {
9142 if (hasOwnProperty.call(result, key)) {
9143 ++result[key];
9145 baseAssignValue(result, key, 1);
9461 var groupBy = createAggregator(function(result, value, key) {
9462 if (hasOwnProperty.call(result, key)) {
9463 result[key].push(value);
9465 baseAssignValue(result, key, [value]);
9538 result = isArrayLike(collection) ? Array(collection.length) : [];
9541 result[++index] = isFunc ? apply(path, value, args) : baseInvoke(value, path, args);
9543 return result;
9574 var keyBy = createAggregator(function(result, value, key) {
9575 baseAssignValue(result, key, value);
9704 var partition = createAggregator(function(result, value, key) {
9705 result[key ? 0 : 1].push(value);
9709 * Reduces `collection` to a value which is the accumulated result of running
9739 * _.reduce({ 'a': 1, 'b': 2, 'c': 1 }, function(result, value, key) {
9740 * (result[value] || (result[value] = [])).push(key);
9741 * return result;
10096 * calls to the created function return the result of the last `func` invocation.
10111 var result;
10118 result = func.apply(this, arguments);
10123 return result;
10227 * `func` returning its result, if at least `arity` number of arguments have
10268 var result = createWrap(func, WRAP_CURRY_FLAG, undefined, undefined, undefined, undefined, undefined, arity);
10269 result.placeholder = curry.placeholder;
10270 return result;
10313 var result = createWrap(func, WRAP_CURRY_RIGHT_FLAG, undefined, undefined, undefined, undefined, undefined, arity);
10314 result.placeholder = curryRight.placeholder;
10315 return result;
10326 * calls to the debounced function return the result of the last `func`
10376 result,
10401 result = func.apply(thisArg, args);
10402 return result;
10411 return leading ? invokeFunc(time) : result;
10453 return result;
10465 return timerId === undefined ? result : trailingEdge(now());
10490 return result;
10565 * Creates a function that memoizes the result of `func`. If `resolver` is
10566 * provided, it determines the cache key for storing the result based on the
10600 * // Modify the result cache.
10620 var result = func.apply(this, args);
10621 memoized.cache = cache.set(key, result) || cache;
10622 return result;
10632 * Creates a function that negates the result of the predicate `func`. The
10929 * result of the last `func` invocation.
11637 var result = customizer ? customizer(value, other) : undefined;
11638 return result === undefined ? baseIsEqual(value, other, undefined, customizer) : !!result;
11818 * and has a `typeof` result of "object".
11973 * attempt to fix the detection will be obstructed. As a result, we're left
12138 * double precision number which isn't the result of a rounded unsafe integer.
12465 var result = toFinite(value),
12466 remainder = result % 1;
12468 return result === result ? (remainder ? result - remainder : result) : 0;
12829 var result = baseCreate(prototype);
12830 return properties == null ? result : baseAssign(result, properties);
13195 var result = object == null ? undefined : baseGet(object, path);
13196 return result === undefined ? defaultValue : result;
13278 var invert = createInverter(function(result, value, key) {
13284 result[value] = key;
13313 var invertBy = createInverter(function(result, value, key) {
13319 if (hasOwnProperty.call(result, value)) {
13320 result[value].push(key);
13322 result[value] = [key];
13336 * @returns {*} Returns the result of the invoked method.
13427 var result = {};
13431 baseAssignValue(result, iteratee(value, key, object), value);
13433 return result;
13465 var result = {};
13469 baseAssignValue(result, key, iteratee(value, key, object));
13471 return result;
13565 var result = {};
13567 return result;
13575 copyObject(object, getAllKeysIn(object), result);
13577 result = baseClone(result, CLONE_DEEP_FLAG | CLONE_FLAT_FLAG | CLONE_SYMBOLS_FLAG, customOmitClone);
13581 baseUnset(result, paths[length]);
13583 return result;
13665 * its result is returned.
13679 * _.result(object, 'a[0].b.c1');
13682 * _.result(object, 'a[0].b.c2');
13685 * _.result(object, 'a[0].b.c3', 'default');
13688 * _.result(object, 'a[0].b.c3', _.constant('default'));
13691 function result(object, path, defaultValue) {
13828 * `accumulator` object which is the result of running each of its own
13845 * _.transform([2, 3, 4], function(result, n) {
13846 * result.push(n *= n);
13851 * _.transform({ 'a': 1, 'b': 2, 'c': 1 }, function(result, value, key) {
13852 * (result[value] || (result[value] = [])).push(key);
14207 var camelCase = createCompounder(function(result, word, index) {
14209 return result + (index ? capitalize(word) : word);
14369 var kebabCase = createCompounder(function(result, word, index) {
14370 return result + (index ? '-' : '') + word.toLowerCase();
14393 var lowerCase = createCompounder(function(result, word, index) {
14394 return result + (index ? ' ' : '') + word.toLowerCase();
14632 var snakeCase = createCompounder(function(result, word, index) {
14633 return result + (index ? '_' : '') + word.toLowerCase();
14697 var startCase = createCompounder(function(result, word, index) {
14698 return result + (index ? ' ' : '') + upperFirst(word);
14941 var result = attempt(function() {
14948 result.source = source;
14949 if (isError(result)) {
14950 throw result;
14952 return result;
15169 var result = strSymbols
15174 return result + omission;
15177 end += (result.length - end);
15182 substring = result;
15191 result = result.slice(0, newEnd === undefined ? end : newEnd);
15194 var index = result.lastIndexOf(separator);
15196 result = result.slice(0, index);
15199 return result + omission;
15248 var upperCase = createCompounder(function(result, word, index) {
15249 return result + (index ? ' ' : '') + word.toUpperCase();
15303 * Attempts to invoke `func`, returning either the result or the caught error
15312 * @returns {*} Returns the `func` result or error object.
15495 * Creates a function that returns the result of invoking the given functions
15799 var result = object(this.__wrapped__),
15800 actions = result.__actions__ = copyArray(this.__actions__);
15803 result.__chain__ = chainAll;
15804 return result;
16219 var result = baseTimes(length, iteratee);
16223 return result;
16897 lodash.result = result;
16970 var result = (this.__filtered__ && !index)
16974 if (result.__filtered__) {
16975 result.__takeCount__ = nativeMin(n, result.__takeCount__);
16977 result.__views__.push({
16979 'type': methodName + (result.__dir__ < 0 ? 'Right' : '')
16982 return result;
16996 var result = this.clone();
16997 result.__iteratees__.push({
17001 result.__filtered__ = result.__filtered__ || isFilter;
17002 return result;
17052 var result = this;
17053 if (result.__filtered__ && (start > 0 || end < 0)) {
17054 return new LazyWrapper(result);
17057 result = result.takeRight(-start);
17059 result = result.drop(start);
17063 result = end < 0 ? result.dropRight(-end) : result.take(end - start);
17065 return result;
17094 var result = lodashFunc.apply(lodash, arrayPush([value], args));
17095 return (isTaker && chainAll) ? result[0] : result;
17109 var result = func.apply(value, args);
17110 result.__actions__.push({ 'func': thru, 'args': [interceptor], 'thisArg': undefined });
17111 return new LodashWrapper(result, chainAll);
17116 result = this.thru(interceptor);
17117 return isUnwrapped ? (isTaker ? result.value()[0] : result.value()) : result;