使用lodash在深路径处创建空对象

Question

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

这可以通过使用来实现。有，\。设置，然后设置。获取

let path = 'some.deep.path';

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

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

相反，我希望避免重复对象，路径（或者引入路径变量以避免重复路径值）

我想知道是否有一种不用额外函数/库就可以做到这一点的方法。

这包括处理数组/集合并接受的方法。属性iteratee/predicate速记，即当字符串作为参数提供时，它将传递给\。属性方法，该方法创建一个函数，该函数返回给定对象（由主函数给定的）路径上的值，例如\uuuu.map）。

数组

• v4。0.0 _.差分方式（数组，[值]，[迭代对象=uuu.identity]）
• v3。0.0 _.dropRightWhile（数组，[predicate=.[identity]）
• v3。0.0 _.dropWhile（数组，[predicate=.[identity]）
• v1。1.0 _.findIndex（数组，[predicate=.\identity]，[fromIndex=0]）
• v2。0.0 _.findLastIndex（数组，[predicate=u2;.identity]，[fromIndex=array.length-1]）
• v4。0.0 _.intersectionBy（[arrays]，[iteratee=uu.identity]）
• v4。0.0 _.sortedIndexBy（数组，值，[iteratee=uu2;.identity]）
• v4。0.0 _.sortedLastIndexBy（数组，值，[iteratee=..identity]）
• v3。0.0 _.takeRightWhile（数组，[谓词=\标识]）
• v3。0.0 _.takeWhile（数组，[predicate=.[identity]）
• v4。0.0 _.unionBy（[arrays]，[iteratee=_uu.identity]）
• v4。0.0 _.uniqBy（数组，[iteratee=..identity]）
• v4。0.0 _.xorBy（[arrays]，[iteratee=..identity]）
• v4。1.0 _.zipObjectDeep（[props=[]]，[values=[]]）

收集

• v0。5.0 _.countBy（集合，[iteratee=uu.identity]）

数学

• v4。0.0 _.maxBy（数组，[iteratee=uu.identity]）

对象

• v1。0.0 _.at（对象，[路径]）

乌提尔

• v4。0.0 _.迭代对象（[func=u.identity]）
• v3。2.0 _.匹配属性（路径、srcValue）
• v3。7.0 _.方法（路径，[args]）
• v3。7.0 _.methodOf（对象，[args]）
• v2。4.0 _.属性（路径）
• v3。0.0 _.属性（对象）
• v4。0.0 _.toPath（值）

序号

链式方法，即按顺序调用的方法，例如：

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

• v1.0.0_prototype.at

Answer 1

这个怎么样：

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

如果路径不存在，它将被创建，否则不会更改。但是仍然不确定如何避免get。。

Answer 2

这里有一个\uu。额外lodash深度库中的deepDefault方法，该方法检查属性路径处的值是否解析为未定义，如果是这种情况，则将其设置为默认值：

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

该库不再更新，因为Lodash现在以本机方式支持大部分功能，因此下面是一个作为Lodash mixin函数的实现：

function getOrSetDefault(object, path, defaultValue) {
    const descendant = _.get(object, path);
    if (descendant === undefined) {
        _.set(object, path, defaultValue);
    }
    return descendant;
}

_.mixin({ getOrSetDefault });

const a = _.getOrSetDefault(object, 'some.deep.path', 42);
const b = _.getOrSetDefault(object, 'some.other.deep.path', {});
b.c = 42;

使用新的可选链接运算符和逻辑空赋值，在这种特殊情况下无需使用lodash（如果可以使用默认值填充/定义some.deep.path），例如：

some?.deep?.path ??= {}
const { foo } = some.deep.path

不幸的是，可选的链接分配还不可用。看见https://stackoverflow.com/a/58882121/1949503

只有一个缺点，即需要重复属性访问器（some.deep.path）来检索值。但是在这种情况下，我们将使用Typescript/JSDoc实现自动完成，这与lodash函数的路径参数（字符串或数组）不同

如果只需要在path上获取值，那么vanillatry/cat就足够了：

let foo: Foo;
try {
  foo = some.deep.path.foo
} catch {}

Answer 3

您可以避免使用\ux。有与此相关：

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

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