如何从键和值获取javascript对象的路径

我有一个javascript对象宽度深度

我需要知道对象中该键的确切路径，例如：“obj1.obj2.data1”

我已经知道键是data1，值是123

我的javascript对象如下所示

{
    obj1: {
        obj2: {
            data1: 213,
            data2: "1231",
            obj3: {
                data: "milf"
            }
        }
    },
    obj4: {
        description: "toto"
    }
}

我怎样才能做到这一点

下面是一个JSFIDLE：

---

我正在尝试实现getPath。

我强烈建议您使用它来解决此问题

在他们的文件中

---

我认为递归函数可以帮助你（更新版本，检查值）

函数路径（c，name，v，currentPath，t）{
var currentPath=currentPath | |“根”；
用于（c中的变量i）{
如果（i==name&&c[i]==v）{
t=电流路径；
}
else if（c[i]=“对象”的类型）{
返回路径（c[i]，名称，v，currentPath+“+i）；
}
}
返回t+“+”名称；
};
log（路径（{1:2，s:5，2:{3:{2:{s:1，p:2}}}}，“s”，1））给你

function getPath(obj, value, path) {

    if(typeof obj !== 'object') {
        return;
    }

    for(var key in obj) {
        if(obj.hasOwnProperty(key)) {
            console.log(key);
            var t = path;
            var v = obj[key];
            if(!path) {
                path = key;
            }
            else {
                path = path + '.' + key;
            }
            if(v === value) {
                return path;
            }
            else if(typeof v !== 'object'){
                path = t;
            }
            var res = getPath(v, value, path);
            if(res) {
                return res;
            } 
        }
    }

}

getPath(yourObject, valueYouWantToFindPath);

如果找到，则重新运行路径，否则返回未定义。
我只使用对象测试过它&比较非常严格（即：使用
==
）

更新：
以key作为参数的更新版本

function getPath(obj, key, value, path) {

    if(typeof obj !== 'object') {
        return;
    }

    for(var k in obj) {
        if(obj.hasOwnProperty(k)) {
            console.log(k);
            var t = path;
            var v = obj[k];
            if(!path) {
                path = k;
            }
            else {
                path = path + '.' + k;
            }
            if(v === value) {
                if(key === k) {
                    return path;
                }
                else {
                    path = t;
                }
            }
            else if(typeof v !== 'object'){
                path = t;
            }
            var res = getPath(v, key, value, path);
            if(res) {
                return res;
            } 
        }
    }

}

getPath(yourObject, key, valueYouWantToFindPath);

JSON对象可以在JavaScript中作为关联数组处理

因此，您可以在某些变量中循环并存储“父对象”的索引

假设整个对象存储在名为obj的变量中

用于（obj中的变量p1）

{

}

希望答案是有帮助的。
我会做以下工作


Object.prototype.paths=函数（根=[]，结果={}）{
var ok=Object.keys（这个）；
返回ok.reduce（（res，key）=>{var path=root.concat（key）；
此[键]=“对象”的类型&&
此[键]！==null？此[键]。路径（路径，分辨率）
：res[this[key]==0 | | res[this[key]]？res[this[key]]。推送（路径）
：res[this[key]]=[path]；
返回res；
}，结果）；
};
var myObj={
obj1：{
obj2：{
数据1:213,，
数据2：“1231”，
obj3：{
数据：“米尔夫”
}
}
},
obj4：{
描述：“toto”，
美洲狮：“乔迪”，
类别：“米尔夫”
}
},
value=“milf”，
milfPath=myObj.paths（）[value]；//该值可以动态设置，如果存在，将列出其路径。
console.log（milfPath）以下命令可在任何级别的嵌套对象中查找路径。还有数组。
它返回找到的所有路径，如果您有同名的键，则需要这些路径

我喜欢这种方法，因为它可以与
lodash
方法
get
和
set
一起使用

function findPathsToKey(options) {
  let results = [];

  (function findKey({
    key,
    obj,
    pathToKey,
  }) {
    const oldPath = `${pathToKey ? pathToKey + "." : ""}`;
    if (obj.hasOwnProperty(key)) {
      results.push(`${oldPath}${key}`);
      return;
    }

    if (obj !== null && typeof obj === "object" && !Array.isArray(obj)) {
      for (const k in obj) {
        if (obj.hasOwnProperty(k)) {
          if (Array.isArray(obj[k])) {
            for (let j = 0; j < obj[k].length; j++) {
              findKey({
                obj: obj[k][j],
                key,
                pathToKey: `${oldPath}${k}[${j}]`,
              });
            }
          }

          if (obj[k] !== null && typeof obj[k] === "object") {
            findKey({
              obj: obj[k],
              key,
              pathToKey: `${oldPath}${k}`,
            });
          }
        }
      }
    }
  })(options);

  return results;
}

findPathsToKey({ obj: objWithDuplicates, key: "d" })
// ["parentKey.arr[0].c.d", "parentKey.arr[1].c.d", "parentKey.arr[2].c.d"]

函数findPathsToKey（选项）{
让结果=[]；
（函数findKey）({
钥匙
obj，
可怜的，
}) {
constoldpath=${pathToKey？pathToKey+”：“}”；
if（对象hasOwnProperty（键））{
push（`${oldPath}${key}`）；
返回；
}
if（obj！==null&&typeof obj===“object”&&&！Array.isArray（obj））{
用于（对象中的常数k）{
if（对象hasOwnProperty（k））{
if（Array.isArray（obj[k]））{
for（设j=0；j

在这里试试-

如果希望结果是单个键（第一次遇到），可以将
结果更改为字符串，如果已定义，则返回包含该结果的函数。
我最后使用了以下用于嵌套对象/数组的函数：


函数findPath（对象、名称、值、当前路径）{
currentPath=currentPath | |“”
让匹配路径
如果（！obj | | typeof obj！=“object”）返回
if（obj[name]==val）返回`${currentPath}['${name}']`
for（对象的常量键。键（obj））{
if（key==名称和对象[key]==值）{
匹配路径=当前路径
}否则{
matchingPath=findPath（obj[key]，name，val，`${currentPath}['${key}']`）
}
如果（匹配路径）中断
}
返回匹配路径
}
常数treeData=[{
id:1，
儿童：[{
身份证号码：2
}]
}, {
id:3，
儿童：[{
id:4，
儿童：[{
身份证号码：5
}]
}]
}]
console.log（findPath（treeData，'id'，5））
这样做的目的是什么？它是为了实现一个变更日志，如果我们能像现在这样做的话，它会变得更容易。它是为了mongodb更新吗？@TamilVendhan不是，它是为了从一个版本到另一个版本的json变更日志another@Prinzhorn我正在研究一个现有的系统，不需要重新实现所有逻辑。我不能实现一个新的库，这需要几个月的测试。请不要给我提供更多的替代解决方案，提琴只是为了展示我正在努力实现的目标。这不会返回我需要的路径。为什么您需要该路径？我需要保存原始门店位置的参考，但是，我的意思是，您想用它做什么？如果它是一个静态路径，你可以很容易地手动找到它，如果它是动态的，我看不出保存它的意义。它可以是动态的，我刚刚添加了一个JSFIDDLE谢谢，我在我的小提琴中尝试了你的fn，你在这个函数中缺少了一个参数，我们知道原始对象，我们知道我们是l的键
   for( var p2 in obj[ p1 ] )
   {
       for( var p3 in obj[ p1 ][ p2 ] )
       {
           // obj[ p1 ][ p2 ][ p3 ] is current node
           // so for Your example it is obj.obj1.obj2.data1
       }
   }

function findPathsToKey(options) {
  let results = [];

  (function findKey({
    key,
    obj,
    pathToKey,
  }) {
    const oldPath = `${pathToKey ? pathToKey + "." : ""}`;
    if (obj.hasOwnProperty(key)) {
      results.push(`${oldPath}${key}`);
      return;
    }

    if (obj !== null && typeof obj === "object" && !Array.isArray(obj)) {
      for (const k in obj) {
        if (obj.hasOwnProperty(k)) {
          if (Array.isArray(obj[k])) {
            for (let j = 0; j < obj[k].length; j++) {
              findKey({
                obj: obj[k][j],
                key,
                pathToKey: `${oldPath}${k}[${j}]`,
              });
            }
          }

          if (obj[k] !== null && typeof obj[k] === "object") {
            findKey({
              obj: obj[k],
              key,
              pathToKey: `${oldPath}${k}`,
            });
          }
        }
      }
    }
  })(options);

  return results;
}

findPathsToKey({ obj: objWithDuplicates, key: "d" })
// ["parentKey.arr[0].c.d", "parentKey.arr[1].c.d", "parentKey.arr[2].c.d"]