Javascript 使用点符号（如字符串）动态创建对象

我试图动态创建一个JS对象，提供一个键和一个值。键是点表示法，因此如果提供了类似于

car.model.color

的字符串，则生成的对象将是：

{
  car: {
    model: {
      color: value;
    }
  }
}

如果提供的键是一个简单的属性，那么这个问题就有一个简单的解决方案，但是我正在努力使它适用于组合键

我的代码：

function (key, value) {
  var object = {};
  var arr = key.split('.');                                   
  for(var i = 0; i < arr.length; i++) {
    object = object[arr[i]] = {};
  }
  object[arr[arr.length-1]] = value;
  return object;
}

函数（键、值）{
var对象={}；
var arr=key.split（'.'）；
对于（变量i=0；i

使用名称空间模式，如Addy Osmani所示：

这是为方便起见粘贴的代码，所有代码都归Addy所有：

// top-level namespace being assigned an object literal
var myApp = myApp || {};
// a convenience function for parsing string namespaces and
// automatically generating nested namespaces
function extend( ns, ns_string ) {
    var parts = ns_string.split('.'),
        parent = ns,
        pl, i;
    if (parts[0] == "myApp") {
        parts = parts.slice(1);
    }
    pl = parts.length;
    for (i = 0; i < pl; i++) {
        //create a property if it doesnt exist
        if (typeof parent[parts[i]] == 'undefined') {
            parent[parts[i]] = {};
        }
        parent = parent[parts[i]];
    }
    return parent;
}
// sample usage:
// extend myApp with a deeply nested namespace
var mod = extend(myApp, 'myApp.modules.module2');

//正在为顶级命名空间分配对象文字
var myApp=myApp | |{}；
//用于解析字符串名称空间和
//自动生成嵌套名称空间
函数扩展（ns，ns\u字符串）{
var parts=ns_string.split（'.'），
父项=ns，
pl，i；
如果（部件[0]=“myApp”）{
零件=零件。切片（1）；
}
pl=零件长度；
对于（i=0；i

您稍微修改的代码

function f(key, value) {
  var result = object = {};
  var arr = key.split('.');                                   
  for(var i = 0; i < arr.length-1; i++) {
    object = object[arr[i]] = {};
  }
  object[arr[arr.length-1]] = value;
  return result;
}

函数f（键、值）{
var result=object={}；
var arr=key.split（'.'）；
对于（变量i=0；i

在循环中，除了最后一个道具外，你应该设置所有道具。 接下来设置最终属性和所有设置。

函数strtobj（str，val）{
function strToObj(str, val) {
var i, obj = {}, strarr = str.split(".");
var x = obj;
    for(i=0;i<strarr.length-1;i++) {
    x = x[strarr[i]] = {};
    }
x[strarr[i]] = val;
return obj;
}

变量i，obj={}，strarr=str.split（“.”）；
var x=obj；
对于（i=0；i我将使用递归方法


var createObject=函数（键，值）{
var obj={}；
var parts=键。拆分（'.'）；
如果（parts.length==1）{
obj[零件[0]]=值；
}否则如果（零件长度>1）{
//除了钥匙的第一部分外，其他都没有
var remainingParts=parts.slice（1，parts.length）.join（'.'）；
obj[parts[0]]=createObject（剩余部分，值）；
}
返回obj；
};
var simple=createObject（'simple'，'value1'）；
var complex=createObject（'more.complex.test'，'value2'）；
console.log（简单）；
console.log（复杂）；
如果您正在使用


const obj={}
_.set（obj，“汽车.车型.颜色”，“我的价值”）
console.log（obj）
你所说的更复杂的字符串到底是什么意思？你能分享一下你所尝试过的吗？简单的：“属性”，复杂的：“属性1.property2.property3”。如果我没有说清楚，很抱歉。除了递归性之外，这段代码还有哪些优点？每次迭代都必须拆分和连接其余部分，这会影响性能吗？如果有人想知道，线性时间增加会比接受的答案大。这有一个警告，可能会替换名为
object的变量
在函数的作用域之外。函数中的第一行相当于将
{}
赋值给
对象
和
结果
，而无需像使用
结果
那样首先将其初始化为作用域内的变量（很可能导致
对象
最终进入全局作用域）。