Lines Matching refs:object
879 return function(object) { argument
880 return object == null ? undefined : object[key];
891 function basePropertyOf(object) { argument
893 return object == null ? undefined : object[key];
990 function baseToPairs(object, props) { argument
992 return [key, object[key]];
1019 function baseValues(object, props) { argument
1021 return object[key];
1128 function getValue(object, key) { argument
1129 return object == null ? undefined : object[key];
1669 function object() {} function
1677 object.prototype = proto; class
1678 var result = new object;
1679 object.prototype = undefined;
2454 function assignMergeValue(object, key, value) { argument
2455 if ((value !== undefined && !eq(object[key], value)) ||
2456 (value === undefined && !(key in object))) {
2457 baseAssignValue(object, key, value);
2471 function assignValue(object, key, value) { argument
2472 var objValue = object[key];
2473 if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) ||
2474 (value === undefined && !(key in object))) {
2475 baseAssignValue(object, key, value);
2524 function baseAssign(object, source) { argument
2525 return object && copyObject(source, keys(source), object);
2537 function baseAssignIn(object, source) { argument
2538 return object && copyObject(source, keysIn(source), object);
2550 function baseAssignValue(object, key, value) { argument
2552 defineProperty(object, key, {
2559 object[key] = value;
2571 function baseAt(object, paths) { argument
2575 skip = object == null;
2578 result[index] = skip ? undefined : get(object, paths[index]);
2620 function baseClone(value, bitmask, customizer, key, object, stack) { argument
2627 result = object ? customizer(value, key, object, stack) : customizer(value);
2648 if (tag == objectTag || tag == argsTag || (isFunc && !object)) {
2657 return object ? value : {};
2705 return function(object) { argument
2706 return baseConformsTo(object, source, props);
2718 function baseConformsTo(object, source, props) { argument
2720 if (object == null) {
2723 object = Object(object);
2727 value = object[key];
2729 if ((value === undefined && !(key in object)) || !predicate(value)) {
2989 function baseForOwn(object, iteratee) { argument
2990 return object && baseFor(object, iteratee, keys);
3001 function baseForOwnRight(object, iteratee) { argument
3002 return object && baseForRight(object, iteratee, keys);
3014 function baseFunctions(object, props) { argument
3016 return isFunction(object[key]);
3028 function baseGet(object, path) { argument
3029 path = castPath(path, object);
3034 while (object != null && index < length) {
3035 object = object[toKey(path[index++])];
3037 return (index && index == length) ? object : undefined;
3051 function baseGetAllKeys(object, keysFunc, symbolsFunc) { argument
3052 var result = keysFunc(object);
3053 return isArray(object) ? result : arrayPush(result, symbolsFunc(object));
3093 function baseHas(object, key) { argument
3094 return object != null && hasOwnProperty.call(object, key);
3105 function baseHasIn(object, key) { argument
3106 return object != null && key in Object(object);
3196 function baseInverter(object, setter, iteratee, accumulator) { argument
3197 baseForOwn(object, function(value, key, object) { argument
3198 setter(accumulator, iteratee(value), key, object);
3213 function baseInvoke(object, path, args) { argument
3214 path = castPath(path, object);
3215 object = parent(object, path);
3216 var func = object == null ? object : object[toKey(last(path))];
3217 return func == null ? undefined : apply(func, object, args);
3291 function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) { argument
3292 var objIsArr = isArray(object),
3294 objTag = objIsArr ? arrayTag : getTag(object),
3304 if (isSameTag && isBuffer(object)) {
3313 return (objIsArr || isTypedArray(object))
3314 ? equalArrays(object, other, bitmask, customizer, equalFunc, stack)
3315 : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);
3318 var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'),
3322 var objUnwrapped = objIsWrapped ? object.value() : object,
3333 return equalObjects(object, other, bitmask, customizer, equalFunc, stack);
3357 function baseIsMatch(object, source, matchData, customizer) { argument
3362 if (object == null) {
3365 object = Object(object);
3369 ? data[1] !== object[data[0]]
3370 : !(data[0] in object)
3378 objValue = object[key],
3382 if (objValue === undefined && !(key in object)) {
3388 var result = customizer(objValue, srcValue, key, object, source, stack);
3482 function baseKeys(object) { argument
3483 if (!isPrototype(object)) {
3484 return nativeKeys(object);
3487 for (var key in Object(object)) {
3488 if (hasOwnProperty.call(object, key) && key != 'constructor') {
3502 function baseKeysIn(object) { argument
3503 if (!isObject(object)) {
3504 return nativeKeysIn(object);
3506 var isProto = isPrototype(object),
3509 for (var key in object) {
3510 if (!(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) {
3560 return function(object) { argument
3561 return object === source || baseIsMatch(object, source, matchData);
3577 return function(object) { argument
3578 var objValue = get(object, path);
3580 ? hasIn(object, path)
3596 function baseMerge(object, source, srcIndex, customizer, stack) { argument
3597 if (object === source) {
3603 baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack);
3607 ? customizer(safeGet(object, key), srcValue, (key + ''), object, source, stack)
3613 assignMergeValue(object, key, newValue);
3633 function baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) { argument
3634 var objValue = safeGet(object, key),
3639 assignMergeValue(object, key, stacked);
3643 ? customizer(objValue, srcValue, (key + ''), object, source, stack)
3692 assignMergeValue(object, key, newValue);
3732 return baseSortBy(result, function(object, other) { argument
3733 return compareMultiple(object, other, orders);
3746 function basePick(object, paths) { argument
3747 return basePickBy(object, paths, function(value, path) {
3748 return hasIn(object, path);
3761 function basePickBy(object, paths, predicate) { argument
3768 value = baseGet(object, path);
3771 baseSet(result, castPath(path, object), value);
3785 return function(object) { argument
3786 return baseGet(object, path);
3965 function baseSet(object, path, value, customizer) { argument
3966 if (!isObject(object)) {
3967 return object;
3969 path = castPath(path, object);
3974 nested = object;
3992 return object;
4309 function baseUnset(object, path) { argument
4310 path = castPath(path, object);
4311 object = parent(object, path);
4312 return object == null || delete object[toKey(last(path))];
4325 function baseUpdate(object, path, updater, customizer) { argument
4326 return baseSet(object, path, updater(baseGet(object, path)), customizer);
4455 function castPath(value, object) { argument
4459 return isKey(value, object) ? [value] : stringToPath(toString(value));
4632 function compareMultiple(object, other, orders) { argument
4634 objCriteria = object.criteria,
4656 return object.index - other.index;
4760 function copyObject(source, props, object, customizer) { argument
4761 var isNew = !object;
4762 object || (object = {});
4771 ? customizer(object[key], source[key], key, object, source)
4778 baseAssignValue(object, key, newValue);
4780 assignValue(object, key, newValue);
4783 return object;
4794 function copySymbols(source, object) { argument
4795 return copyObject(source, getSymbols(source), object);
4806 function copySymbolsIn(source, object) { argument
4807 return copyObject(source, getSymbolsIn(source), object);
4835 return baseRest(function(object, sources) { argument
4849 object = Object(object);
4853 assigner(object, source, index, customizer);
4856 return object;
4897 return function(object, iteratee, keysFunc) { argument
4899 iterable = Object(object),
4900 props = keysFunc(object),
4909 return object;
5207 return function(object, iteratee) { argument
5208 return baseInverter(object, setter, toIteratee(iteratee), {});
5451 return function(object) { argument
5452 var tag = getTag(object);
5454 return mapToArray(object);
5457 return setToPairs(object);
5459 return baseToPairs(object, keysFunc(object));
5555 function customDefaultsAssignIn(objValue, srcValue, key, object) { argument
5557 (eq(objValue, objectProto[key]) && !hasOwnProperty.call(object, key))) {
5577 function customDefaultsMerge(objValue, srcValue, key, object, source, stack) { argument
5691 function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) { argument
5694 if ((object.byteLength != other.byteLength) ||
5695 (object.byteOffset != other.byteOffset)) {
5698 object = object.buffer;
5702 if ((object.byteLength != other.byteLength) ||
5703 !equalFunc(new Uint8Array(object), new Uint8Array(other))) {
5713 return eq(+object, +other);
5716 return object.name == other.name && object.message == other.message;
5723 return object == (other + '');
5732 if (object.size != other.size && !isPartial) {
5736 var stacked = stack.get(object);
5743 stack.set(object, other);
5744 … var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack);
5745 stack['delete'](object);
5750 return symbolValueOf.call(object) == symbolValueOf.call(other);
5769 function equalObjects(object, other, bitmask, customizer, equalFunc, stack) { argument
5771 objProps = getAllKeys(object),
5787 var stacked = stack.get(object);
5792 stack.set(object, other);
5793 stack.set(other, object);
5798 var objValue = object[key],
5803 ? customizer(othValue, objValue, key, other, object, stack)
5804 : customizer(objValue, othValue, key, object, other, stack);
5817 var objCtor = object.constructor,
5822 ('constructor' in object && 'constructor' in other) &&
5828 stack['delete'](object);
5851 function getAllKeys(object) { argument
5852 return baseGetAllKeys(object, keys, getSymbols);
5863 function getAllKeysIn(object) { argument
5864 return baseGetAllKeys(object, keysIn, getSymbolsIn);
5908 var object = hasOwnProperty.call(lodash, 'placeholder') ? lodash : func;
5909 return object.placeholder;
5951 function getMatchData(object) { argument
5952 var result = keys(object),
5957 value = object[key];
5972 function getNative(object, key) { argument
5973 var value = getValue(object, key);
6011 var getSymbols = !nativeGetSymbols ? stubArray : function(object) {
6012 if (object == null) {
6015 object = Object(object);
6016 return arrayFilter(nativeGetSymbols(object), function(symbol) {
6017 return propertyIsEnumerable.call(object, symbol);
6028 var getSymbolsIn = !nativeGetSymbols ? stubArray : function(object) {
6030 while (object) {
6031 arrayPush(result, getSymbols(object));
6032 object = getPrototype(object);
6119 function hasPath(object, path, hasFunc) { argument
6120 path = castPath(path, object);
6128 if (!(result = object != null && hasFunc(object, key))) {
6131 object = object[key];
6136 length = object == null ? 0 : object.length;
6138 (isArray(object) || isArguments(object));
6167 function initCloneObject(object) {
6168 return (typeof object.constructor == 'function' && !isPrototype(object))
6169 ? baseCreate(getPrototype(object))
6185 function initCloneByTag(object, tag, isDeep) {
6186 var Ctor = object.constructor;
6189 return cloneArrayBuffer(object);
6193 return new Ctor(+object);
6196 return cloneDataView(object, isDeep);
6201 return cloneTypedArray(object, isDeep);
6208 return new Ctor(object);
6211 return cloneRegExp(object);
6217 return cloneSymbol(object);
6280 function isIterateeCall(value, index, object) {
6281 if (!isObject(object)) {
6286 ? (isArrayLike(object) && isIndex(index, object.length))
6287 : (type == 'string' && index in object)
6289 return eq(object[index], value);
6302 function isKey(value, object) {
6312 (object != null && value in Object(object));
6407 return function(object) {
6408 if (object == null) {
6411 return object[key] === srcValue &&
6412 (srcValue !== undefined || (key in Object(object)));
6516 function nativeKeysIn(object) {
6518 if (object != null) {
6519 for (var key in Object(object)) {
6575 function parent(object, path) {
6576 return path.length < 2 ? object : baseGet(object, baseSlice(path, 0, -1));
6609 function safeGet(object, key) {
6610 if (key === 'constructor' && typeof object[key] === 'function') {
6618 return object[key];
8818 interceptor = function(object) { return baseAt(object, paths); };
10148 var bindKey = baseRest(function(object, key, partials) {
10154 return createWrap(key, bitmask, object, partials, holders);
11148 function conformsTo(object, source) {
11149 return source == null || baseConformsTo(object, source, keys(source));
11823 function isMatch(object, source) {
11824 return object === source || baseIsMatch(object, source, getMatchData(source));
11859 function isMatchWith(object, source, customizer) {
11861 return baseIsMatch(object, source, getMatchData(source), customizer);
12595 var assign = createAssigner(function(object, source) {
12597 copyObject(source, keys(source), object);
12602 assignValue(object, key, source[key]);
12638 var assignIn = createAssigner(function(object, source) {
12639 copyObject(source, keysIn(source), object);
12671 var assignInWith = createAssigner(function(object, source, srcIndex, customizer) {
12672 copyObject(source, keysIn(source), object, customizer);
12703 var assignWith = createAssigner(function(object, source, srcIndex, customizer) {
12704 copyObject(source, keys(source), object, customizer);
12786 var defaults = baseRest(function(object, sources) {
12787 object = Object(object);
12805 var value = object[key];
12808 (eq(value, objectProto[key]) && !hasOwnProperty.call(object, key))) {
12809 object[key] = source[key];
12814 return object;
12876 function findKey(object, predicate) {
12877 return baseFindKey(object, getIteratee(predicate, 3), baseForOwn);
12915 function findLastKey(object, predicate) {
12916 return baseFindKey(object, getIteratee(predicate, 3), baseForOwnRight);
12947 function forIn(object, iteratee) {
12948 return object == null
12949 ? object
12950 : baseFor(object, getIteratee(iteratee, 3), keysIn);
12979 function forInRight(object, iteratee) {
12980 return object == null
12981 ? object
12982 : baseForRight(object, getIteratee(iteratee, 3), keysIn);
13013 function forOwn(object, iteratee) {
13014 return object && baseForOwn(object, getIteratee(iteratee, 3));
13043 function forOwnRight(object, iteratee) {
13044 return object && baseForOwnRight(object, getIteratee(iteratee, 3));
13070 function functions(object) {
13071 return object == null ? [] : baseFunctions(object, keys(object));
13097 function functionsIn(object) {
13098 return object == null ? [] : baseFunctions(object, keysIn(object));
13126 function get(object, path, defaultValue) {
13127 var result = object == null ? undefined : baseGet(object, path);
13158 function has(object, path) {
13159 return object != null && hasPath(object, path, baseHas);
13188 function hasIn(object, path) {
13189 return object != null && hasPath(object, path, baseHasIn);
13306 function keys(object) {
13307 return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);
13333 function keysIn(object) {
13334 return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);
13358 function mapKeys(object, iteratee) {
13362 baseForOwn(object, function(value, key, object) {
13363 baseAssignValue(result, iteratee(value, key, object), value);
13396 function mapValues(object, iteratee) {
13400 baseForOwn(object, function(value, key, object) {
13401 baseAssignValue(result, key, iteratee(value, key, object));
13437 var merge = createAssigner(function(object, source, srcIndex) {
13438 baseMerge(object, source, srcIndex);
13472 var mergeWith = createAssigner(function(object, source, srcIndex, customizer) {
13473 baseMerge(object, source, srcIndex, customizer);
13496 var omit = flatRest(function(object, paths) {
13498 if (object == null) {
13503 path = castPath(path, object);
13507 copyObject(object, getAllKeysIn(object), result);
13538 function omitBy(object, predicate) {
13539 return pickBy(object, negate(getIteratee(predicate)));
13559 var pick = flatRest(function(object, paths) {
13560 return object == null ? {} : basePick(object, paths);
13581 function pickBy(object, predicate) {
13582 if (object == null) {
13585 var props = arrayMap(getAllKeysIn(object), function(prop) {
13589 return basePickBy(object, props, function(value, path) {
13623 function result(object, path, defaultValue) {
13624 path = castPath(path, object);
13632 object = undefined;
13635 var value = object == null ? undefined : object[toKey(path[index])];
13640 object = isFunction(value) ? value.call(object) : value;
13642 return object;
13673 function set(object, path, value) {
13674 return object == null ? object : baseSet(object, path, value);
13701 function setWith(object, path, value, customizer) {
13703 return object == null ? object : baseSet(object, path, value, customizer);
13788 function transform(object, iteratee, accumulator) {
13789 var isArr = isArray(object),
13790 isArrLike = isArr || isBuffer(object) || isTypedArray(object);
13794 var Ctor = object && object.constructor;
13798 else if (isObject(object)) {
13799 accumulator = isFunction(Ctor) ? baseCreate(getPrototype(object)) : {};
13805 (isArrLike ? arrayEach : baseForOwn)(object, function(value, index, object) {
13806 return iteratee(accumulator, value, index, object);
13838 function unset(object, path) {
13839 return object == null ? true : baseUnset(object, path);
13869 function update(object, path, updater) {
13870 return object == null ? object : baseUpdate(object, path, castFunction(updater));
13897 function updateWith(object, path, updater, customizer) {
13899 return object == null ? object : baseUpdate(object, path, castFunction(updater), customizer);
13928 function values(object) {
13929 return object == null ? [] : baseValues(object, keys(object));
13956 function valuesIn(object) {
13957 return object == null ? [] : baseValues(object, keysIn(object));
15286 var bindAll = flatRest(function(object, methodNames) {
15289 baseAssignValue(object, key, bind(object[key], object));
15291 return object;
15622 return function(object) {
15623 return baseInvoke(object, path, args);
15650 var methodOf = baseRest(function(object, args) {
15652 return baseInvoke(object, path, args);
15692 function mixin(object, source, options) {
15699 source = object;
15700 object = this;
15704 isFunc = isFunction(object);
15708 object[methodName] = func;
15710 object.prototype[methodName] = function() {
15713 var result = object(this.__wrapped__),
15716 actions.push({ 'func': func, 'args': arguments, 'thisArg': object });
15720 return func.apply(object, arrayPush([this.value()], arguments));
15725 return object;
15910 function propertyOf(object) {
15912 return object == null ? undefined : baseGet(object, path);