Question

我需要在深层路径上创建一个空对象，但前提是它不存在并返回对该对象的引用。

可以使用_.has，_.set然后_.get

来完成此操作

let path = 'some.deep.path';

if (!_.has(object, path)) {
    _.set(object, path, {});
}

let descendant = _.get(object, path);

我想要的是避免重复object，path（或引入path变量以避免重复path值）

我想知道如果没有额外的功能/库，是否有办法做到这一点。

接受或处理路径的lodash方法列表。按字母顺序

这包括处理数组/集合并接受_.property iteratee / predicate简写的方法，即当一个字符串作为参数提供时，它会被传递给_.property方法，该方法创建一个函数，它返回给定对象的路径上的值（由main函数给出，例如_.map）。

阵列

v4.0.0 _.differenceBy（数组，[值]，[iteratee = _。identity]）
v3.0.0 _.dropRightWhile（数组，[谓词= _。身份]）
v3.0.0 _.dropWhile（数组，[谓词= _。身份]）
v1.1.0 _.findIndex（数组，[谓词= _。身份]，[fromIndex = 0]）
v2.0.0 _.findLastIndex（数组，[谓词= _。身份]，[fromIndex = array.length-1]）
v4.0.0 _.intersectionBy（[数组]，[iteratee = _。identity]）
v4.0.0 _.sortedIndexBy（数组，值，[iteratee = _。identity]）
v4.0.0 _.sortedLastIndexBy（数组，值，[iteratee = _。identity]）
v3.0.0 _.takeRightWhile（数组，[谓词= _。身份]）
v3.0.0 _.takeWhile（数组，[谓词= _。身份]）
v4.0.0 _.unionBy（[数组]，[iteratee = _。identity]）
v4.0.0 _.uniqBy（数组，[iteratee = _。identity]）
v4.0.0 _.xorBy（[数组]，[iteratee = _。identity]）
v4.1.0 _.zipObjectDeep（[props = []]，[values = []]）

集合

v0.5.0 _.countBy（集合，[iteratee = _。identity]）
v0.1.0 _.every（集合，[谓词= _。身份]）
v0.1.0 _.filter（集合，[谓词= _。身份]）
v0.1.0 _.find（集合，[谓词= _。身份]）
v0.1.0 _.groupBy（集合，[iteratee = _ .identity]）
v4.0.0 _.invokeMap（collection，path，[args]）
v0.1.0 _.map（集合，[iteratee = _ .identity]）
v3.0.0 _.partition（集合，[谓词= _。身份]）
v0.1.0 _.reject（集合，[iteratee = _ .identity]）
v0.1.0 _.some（集合，[iteratee = _ .identity]）

数学

v4.0.0 _.maxBy（数组，[iteratee = _。identity]）
v4.7.0 _.meanBy（数组，[iteratee = _。identity]）
v4.0.0 _.minBy（数组，[iteratee = _。identity]）
v4.0.0 _.sumBy（数组，[iteratee = _。identity]）

对象

v1.0.0 _.at（对象，[路径]）
v1.1.0 _.findKey（对象，[谓词= _。身份]）
v2.0.0 _.findLastKey（对象，[谓词= _。身份]）
v3.7.0 _.get（对象，路径，[defaultValue]）
v0.1.0 _.has（对象，路径）
v4.0.0 _.hasIn（对象，路径）
v4.0.0 _.invoke（对象，路径，[args]）
v2.4.0 _.mapValues（对象，[iteratee = _。identity]）
v0.1.0 _.omit（对象，[路径]）
v0.1.0 _.pick（对象，[路径]）
v0.1.0 _.result（object，path，[defaultValue]）
v3.7.0 _.set（对象，路径，值）
v4.0.0 _.setWith（对象，路径，值，[自定义程序]）
v4.0.0 _.unset（对象，路径）
v4.6.0 _.update（对象，路径，更新程序）
v4.6.0 _.updateWith（对象，路径，更新程序，[自定义程序]）

的Util

v4.0.0 _.iteratee（[func = _。identity]）
v3.2.0 _.matchesProperty（路径，srcValue）
v3.7.0 _.method（路径，[args]）
v3.7.0 _.methodOf（对象，[args]）
v2.4.0 _.property（路径）
v3.0.0 _.propertyOf（对象）
v4.0.0 _.toPath（价值）

SEQ

链式方法，即在 seq 中调用的方法，例如：

_(value).chained().method().value();

v1.0.0 _.prototype.at（[路径]）

Answer 1

你可以避免使用_.has：

var path = 'some.deep.path',
descendant = _.get(object, path);
if (!descendant) {
    descendant = {};
    _.set(object, path, descendant);
}

因此只遍历路径2次，而不是3次。

Answer 2

在额外的lodash-deep库中有一个很好的_.deepDefault方法，它返回一个引用：

var descendant = _.deepDefault(object, 'some.deep.path', {});

添加自定义lodash mixin功能：

function getDefault(object, path, defaultValue) {
    var descendant = _.get(object, path);
    if (typeof descendant === 'undefined') {
        _.set(object, path, defaultValue);
    }
    return descendant;
}

_.mixin({ 'getDefault': getDefault });

_.getDefault(object, '.some.deep.path', {});

Answer 3

这个怎么样：

function getDefault(obj, path, defaultValue) {
  _.update(obj, path, d => d ? d : {})
  return _.get(obj, path);
}

如果路径不存在则会创建，否则不会更改。仍然不确定如何避免get虽然..

Answer 4

现在您可以使用_.setWith

setWith({}, "some.deep.path", value, Object);

返回

{some:{deep:{path:4}}

使用lodash

接受或处理路径的lodash方法列表。按字母顺序

4 个答案: