动态设置嵌套对象的属性


84

我有一个对象,它可以是任意多个级别的深度,并且可以具有任何现有属性。例如:

var obj = {
    db: {
        mongodb: {
            host: 'localhost'
        }
    }
};

在此我想设置(或覆盖)属性,如下所示:

set('db.mongodb.user', 'root');
// or:
set('foo.bar', 'baz');

属性字符串可以具有任何深度,并且值可以是任何类型/事物。
如果属性键已经存在,则不需要合并对象和数组作为值。

前面的示例将产生以下对象:

var obj = {
    db: {
        mongodb: {
            host: 'localhost',
            user: 'root'
        }
    },
    foo: {
        bar: baz
    }
};

如何实现这种功能?


应该是什么结果set('foo', 'bar'); set('foo.baz', 'qux');,其中foo第一持有String就变成一个Object?发生什么事了'bar'
乔纳森·洛诺夫斯基


:可能更多钞票此帮助stackoverflow.com/questions/695050/...
勒内·M.

1
如果您删除该set()方法,只是obj.db.mongodb.user = 'root';您确实拥有了您想要的东西?
2013年

@JonathanLonowski Lonowskibar被覆盖Object。@adeneo和@rmertins的确是:)但是不幸的是,我不得不包装其他一些逻辑。@Robert Levy我找到了一个,并且可以访问,但是设置起来似乎要复杂得多……
John B.

Answers:


92

此函数使用您指定的参数应添加/更新obj容器中的数据。请注意,您需要跟踪obj架构中的哪些元素是容器以及哪些是值(字符串,整数等),否则您将开始引发异常。

obj = {};  // global object

function set(path, value) {
    var schema = obj;  // a moving reference to internal objects within obj
    var pList = path.split('.');
    var len = pList.length;
    for(var i = 0; i < len-1; i++) {
        var elem = pList[i];
        if( !schema[elem] ) schema[elem] = {}
        schema = schema[elem];
    }

    schema[pList[len-1]] = value;
}

set('mongo.db.user', 'root');

2
@ bpmason1您能解释为什么使用var schema = obj而不是obj到处使用吗?
sman591

3
@ sman591schema是一个指针,使用向下移动schema = schema[elem]。因此,在for循环之后,schema[pList[len - 1]]指向中的mongo.db.user obj
webjay

解决了我的问题,谢谢,在MDN文档中找不到此内容。但是我还有一个疑问,如果赋值运算符给出了对内部对象的引用,那么如何从object1中分离出一个object2,以便对object2所做的更改不会反映在object1上。
Onix

@Onix您可以cloneDeep为此使用lodash函数。
Aakash Thakur

@Onix const clone = JSON.parse(JSON.stringify(obj))
Mike Makuch


19

有点晚了,但这是一个非图书馆的,更简单的答案:

/**
 * Dynamically sets a deeply nested value in an object.
 * Optionally "bores" a path to it if its undefined.
 * @function
 * @param {!object} obj  - The object which contains the value you want to change/set.
 * @param {!array} path  - The array representation of path to the value you want to change/set.
 * @param {!mixed} value - The value you want to set it to.
 * @param {boolean} setrecursively - If true, will set value of non-existing path as well.
 */
function setDeep(obj, path, value, setrecursively = false) {
    path.reduce((a, b, level) => {
        if (setrecursively && typeof a[b] === "undefined" && level !== path.length){
            a[b] = {};
            return a[b];
        }

        if (level === path.length){
            a[b] = value;
            return value;
        } 
        return a[b];
    }, obj);
}

我做的这个功能可以完全满足您的需求。

假设我们要更改深嵌套在此对象中的目标值:

let myObj = {
    level1: {
        level2: {
           target: 1
       }
    }
}

因此,我们将这样调用函数:

setDeep(myObj, ["level1", "level2", "target1"], 3);

将导致:

myObj = {级别1:{级别2:{目标:3}}}

将set递归设置为true将设置对象(如果不存在)。

setDeep(myObj, ["new", "path", "target"], 3, true);

将导致:

obj = myObj = {
    new: {
         path: {
             target: 3
         }
    },
    level1: {
        level2: {
           target: 3
       }
    }
}

1
使用此代码,干净简单。level我不使用计算,而是使用reduce的第三个参数。
Juan Lanus

我认为该值level应该为+1或path.length-1
ThomasReggi

12

我们可以使用递归函数:

/**
 * Sets a value of nested key string descriptor inside a Object.
 * It changes the passed object.
 * Ex:
 *    let obj = {a: {b:{c:'initial'}}}
 *    setNestedKey(obj, ['a', 'b', 'c'], 'changed-value')
 *    assert(obj === {a: {b:{c:'changed-value'}}})
 *
 * @param {[Object]} obj   Object to set the nested key
 * @param {[Array]} path  An array to describe the path(Ex: ['a', 'b', 'c'])
 * @param {[Object]} value Any value
 */
export const setNestedKey = (obj, path, value) => {
  if (path.length === 1) {
    obj[path] = value
    return
  }
  return setNestedKey(obj[path[0]], path.slice(1), value)
}

更简单!


3
看起来挺好的!只需检查obj参数以确保其不为假,如果链中的任何道具都不存在,则会抛出错误。
C史密斯

2
您可以只使用path.slice(1);
马科斯·佩雷拉

1
出色的答案,一个简洁的解决方案。
chim

我相信if语句应该是obj[path[0]] = value;因为path始终为type string[],即使只剩下1个字符串也是如此。
瓦拉拉德

Javascript对象应使用obj[['a']] = 'new value'。检查代码:jsfiddle.net/upsdne03
HEMA维达尔

11

我只是使用ES6 +递归编写了一个小函数来实现目标。

updateObjProp = (obj, value, propPath) => {
    const [head, ...rest] = propPath.split('.');

    !rest.length
        ? obj[head] = value
        : this.updateObjProp(obj[head], value, rest.join('.'));
}

const user = {profile: {name: 'foo'}};
updateObjProp(user, 'fooChanged', 'profile.name');

我在更新状态时经常使用它,对我来说效果很好。


1
这很方便,我不得不在proPath上放置一个toString()使其与嵌套属性一起使用,但此后效果很好。const [head,... rest] = propPath.toString()。split('。');
WizardsOfWor

1
@ user738048 @ Bruno-Joaquim行this.updateStateProp(obj[head], value, rest);应该是this.updateStateProp(obj[head], value, rest.join());
ma.mehralian19年

8

ES6也有一个很酷的方法,即使用计算属性名Rest参数来执行此操作

const obj = {
  levelOne: {
    levelTwo: {
      levelThree: "Set this one!"
    }
  }
}

const updatedObj = {
  ...obj,
  levelOne: {
    ...obj.levelOne,
    levelTwo: {
      ...obj.levelOne.levelTwo,
      levelThree: "I am now updated!"
    }
  }
}

如果levelThree是动态属性,即要在中设置任何属性levelTwo,则可以使用[propertyName]: "I am now updated!"where来propertyName保存属性的名称levelTwo


7

Lodash有一种叫做update的方法可以完全满足您的需求。

此方法接收以下参数:

  1. 要更新的对象
  2. 要更新的属性的路径(该属性可以深度嵌套)
  3. 该函数返回要更新的值(将原始值作为参数)

在您的示例中,它看起来像这样:

_.update(obj, 'db.mongodb.user', function(originalValue) {
  return 'root'
})

7

受@ bpmason1的答案启发:

function leaf(obj, path, value) {
  const pList = path.split('.');
  const key = pList.pop();
  const pointer = pList.reduce((accumulator, currentValue) => {
    if (accumulator[currentValue] === undefined) accumulator[currentValue] = {};
    return accumulator[currentValue];
  }, obj);
  pointer[key] = value;
  return obj;
}

例:

const obj = {
  boats: {
    m1: 'lady blue'
  }
};
leaf(obj, 'boats.m1', 'lady blue II');
leaf(obj, 'boats.m2', 'lady bird');
console.log(obj); // { boats: { m1: 'lady blue II', m2: 'lady bird' } }

2

我创建了用于根据正确答案通过字符串设置和获取obj值的要点。您可以下载它或将其作为npm / yarn软件包使用。

// yarn add gist:5ceba1081bbf0162b98860b34a511a92
// npm install gist:5ceba1081bbf0162b98860b34a511a92
export const DeepObject = {
  set: setDeep,
  get: getDeep
};

// https://stackoverflow.com/a/6491621
function getDeep(obj: Object, path: string) {
  path = path.replace(/\[(\w+)\]/g, '.$1'); // convert indexes to properties
  path = path.replace(/^\./, '');           // strip a leading dot
  const a = path.split('.');
  for (let i = 0, l = a.length; i < l; ++i) {
    const n = a[i];
    if (n in obj) {
      obj = obj[n];
    } else {
      return;
    }
  }

  return obj;
}

// https://stackoverflow.com/a/18937118
function setDeep(obj: Object, path: string, value: any) {
  let schema = obj;  // a moving reference to internal objects within obj
  const pList = path.split('.');
  const len = pList.length;
  for (let i = 0; i < len - 1; i++) {
    const elem = pList[i];
    if (!schema[elem]) {
      schema[elem] = {};
    }
    schema = schema[elem];
  }

  schema[pList[len - 1]] = value;
}

// Usage
// import {DeepObject} from 'somePath'
//
// const obj = {
//   a: 4,
//   b: {
//     c: {
//       d: 2
//     }
//   }
// };
//
// DeepObject.set(obj, 'b.c.d', 10); // sets obj.b.c.d to 10
// console.log(DeepObject.get(obj, 'b.c.d')); // returns 10

1

如果只需要更改更深层的嵌套对象,则另一种方法可以是引用该对象。由于JS对象由其引用处理,因此您可以创建对您具有字符串键访问权限的对象的引用。

例:

// The object we want to modify:
var obj = {
    db: {
        mongodb: {
            host: 'localhost',
            user: 'root'
        }
    },
    foo: {
        bar: baz
    }
};

var key1 = 'mongodb';
var key2 = 'host';

var myRef = obj.db[key1]; //this creates a reference to obj.db['mongodb']

myRef[key2] = 'my new string';

// The object now looks like:
var obj = {
    db: {
        mongodb: {
            host: 'my new string',
            user: 'root'
        }
    },
    foo: {
        bar: baz
    }
};

1

另一种方法是使用递归来挖掘对象:

(function(root){

  function NestedSetterAndGetter(){
    function setValueByArray(obj, parts, value){

      if(!parts){
        throw 'No parts array passed in';
      }

      if(parts.length === 0){
        throw 'parts should never have a length of 0';
      }

      if(parts.length === 1){
        obj[parts[0]] = value;
      } else {
        var next = parts.shift();

        if(!obj[next]){
          obj[next] = {};
        }
        setValueByArray(obj[next], parts, value);
      }
    }

    function getValueByArray(obj, parts, value){

      if(!parts) {
        return null;
      }

      if(parts.length === 1){
        return obj[parts[0]];
      } else {
        var next = parts.shift();

        if(!obj[next]){
          return null;
        }
        return getValueByArray(obj[next], parts, value);
      }
    }

    this.set = function(obj, path, value) {
      setValueByArray(obj, path.split('.'), value);
    };

    this.get = function(obj, path){
      return getValueByArray(obj, path.split('.'));
    };

  }
  root.NestedSetterAndGetter = NestedSetterAndGetter;

})(this);

var setter = new this.NestedSetterAndGetter();

var o = {};
setter.set(o, 'a.b.c', 'apple');
console.log(o); //=> { a: { b: { c: 'apple'}}}

var z = { a: { b: { c: { d: 'test' } } } };
setter.set(z, 'a.b.c', {dd: 'zzz'}); 

console.log(JSON.stringify(z)); //=> {"a":{"b":{"c":{"dd":"zzz"}}}}
console.log(JSON.stringify(setter.get(z, 'a.b.c'))); //=> {"dd":"zzz"}
console.log(JSON.stringify(setter.get(z, 'a.b'))); //=> {"c":{"dd":"zzz"}}

1

我需要完成同样的事情,但是在Node.js中...因此,我找到了一个不错的模块:https : //www.npmjs.com/package/nested-property

例:

var mod = require("nested-property");
var obj = {
  a: {
    b: {
      c: {
        d: 5
      }
    }
  }
};
console.log(mod.get(obj, "a.b.c.d"));
mod.set(obj, "a.b.c.d", 6);
console.log(mod.get(obj, "a.b.c.d"));

如何解决复杂的嵌套对象。```const x = {'一个':1,'两个':2,'三个':{'一个':1,'两个':2,'三个':[{'一个':1},{ 'one':'ONE'},{'one':'I'}]},'four':[0,1,2]}; console.log(np.get(x,'three.three [0] .one'))); ```
Sumukha HS

1

我想出了自己的解决方案,使用的是纯es6和不会改变原始对象的递归。

const setNestedProp = (obj = {}, [first, ...rest] , value) => ({
  ...obj,
  [first]: rest.length
    ? setNestedProp(obj[first], rest, value)
    : value
});

const result = setNestedProp({}, ["first", "second", "a"], 
"foo");
const result2 = setNestedProp(result, ["first", "second", "b"], "bar");

console.log(result);
console.log(result2);


您可以通过使用默认值setNestedProp =(obj = {},keys,value)=> {声明“ obj”来消除第一个if块
Chigchicken

1
很好 往回看也可以原位分解key参数并保存另一行代码
Henry Ing-Simmons

现在基本上是一个班轮liner
亨利·英

0

如果您想要一个需要先验属性存在的函数,则可以使用类似的方法,它还会返回一个标志,说明它是否设法找到并设置了嵌套属性。

function set(obj, path, value) {
    var parts = (path || '').split('.');
    // using 'every' so we can return a flag stating whether we managed to set the value.
    return parts.every((p, i) => {
        if (!obj) return false; // cancel early as we havent found a nested prop.
        if (i === parts.length - 1){ // we're at the final part of the path.
            obj[parts[i]] = value;          
        }else{
            obj = obj[parts[i]]; // overwrite the functions reference of the object with the nested one.            
        }   
        return true;        
    });
}

0

受ClojureScript assoc-inhttps://github.com/clojure/clojurescript/blob/master/src/main/cljs/cljs/core.cljs#L5280)启发,使用递归:

/**
 * Associate value (v) in object/array (m) at key/index (k).
 * If m is falsy, use new object.
 * Returns the updated object/array.
 */
function assoc(m, k, v) {
    m = (m || {});
    m[k] = v;
    return m;
}

/**
 * Associate value (v) in nested object/array (m) using sequence of keys (ks)
 * to identify the path to the nested key/index.
 * If one of the values in the nested object/array doesn't exist, it adds
 * a new object.
 */
function assoc_in(m={}, [k, ...ks], v) {
    return ks.length ? assoc(m, k, assoc_in(m[k], ks, v)) : assoc(m, k, v);
}

/**
 * Associate value (v) in nested object/array (m) using key string notation (s)
 * (e.g. "k1.k2").
 */
function set(m, s, v) {
    ks = s.split(".");
    return assoc_in(m, ks, v);
}

注意:

通过提供的实现,

assoc_in({"a": 1}, ["a", "b"], 2) 

退货

{"a": 1}

我希望它在这种情况下会引发错误。如果需要,您可以添加签入assoc以验证m是对象还是数组,否则抛出错误。


0

我试图简短地编写此set方法,它可能会对某人有所帮助!

function set(obj, key, value) {
 let keys = key.split('.');
 if(keys.length<2){ obj[key] = value; return obj; }

 let lastKey = keys.pop();

 let fun = `obj.${keys.join('.')} = {${lastKey}: '${value}'};`;
 return new Function(fun)();
}

var obj = {
"hello": {
    "world": "test"
}
};

set(obj, "hello.world", 'test updated'); 
console.log(obj);

set(obj, "hello.world.again", 'hello again'); 
console.log(obj);

set(obj, "hello.world.again.onece_again", 'hello once again');
console.log(obj);


By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.