遍历嵌套的JavaScript对象

我试图遍历嵌套对象，以检索由字符串标识的特定对象。在下面的示例对象中，标识符字符串是“label”属性。我不知道如何通过遍历树来返回适当的对象。如有任何帮助或建议，将不胜感激

var cars = {
  label: 'Autos',
  subs: [
    {
      label: 'SUVs',
      subs: []
    },
    {
      label: 'Trucks',
      subs: [
        {
          label: '2 Wheel Drive',
          subs: []
        },
        {
          label: '4 Wheel Drive',
          subs: [
            {
              label: 'Ford',
              subs: []
            },
            {
              label: 'Chevrolet',
              subs: []
            }
          ]
        }
      ]
    },
    {
      label: 'Sedan',
      subs: []
    }
  ]
}

---

以下代码假定没有循环引用，并且假定

subs

始终是一个数组（在叶节点中不为null）：

函数查找（草堆、针）{
如果（haystack.label==针）返回haystack；
对于（var i=0；i

您可以创建这样的递归函数，对

cars

对象进行深度优先遍历

var findObjectByLabel = function(obj, label) {
    if(obj.label === label) { return obj; }
    for(var i in obj) {
        if(obj.hasOwnProperty(i)){
            var foundLabel = findObjectByLabel(obj[i], label);
            if(foundLabel) { return foundLabel; }
        }
    }
    return null;
};

可以这样称呼

findObjectByLabel(car, "Chevrolet");

---

为了进一步提高树操作的性能，最好将树视图转换为行集合视图，如[obj1、obj2、obj3]。您可以存储父子对象关系，以便轻松导航到父/子范围

---

在集合中搜索元素比在树中查找元素更有效（递归、添加动态函数创建、闭包）。

修改自Peter Olson的答案：

可以避免字符串值

！obj | |（obj的类型=='string'

您可以自定义您的密钥

---

---

下面的代码段将迭代嵌套对象。对象中的对象。请随意更改以满足您的要求。例如，如果要添加数组支持，请使用make if else并生成一个循环数组的函数

var p={
“p1”：“值1”，
“p2”：“值2”，
“p3”：“value3”，
“p4”：{
“p4”：“值4”
}
};
/**
*打印嵌套的javascript对象
*/
功能jsonPrinter（obj）{
用于（输入obj）{
//检查它是否嵌套
if（对象hasOwnProperty（键）&（对象的类型[键]=“对象”））{
jsonPrinter（obj[键]）
}否则{
//打印平面属性
console.log（key+“->”+obj[key]）；
}
}
}
jsonPrinter（p）；

您可以遍历列表中的每个对象并获得所需的值。只需将对象作为函数调用中的第一个参数传递，并将对象属性作为第二个参数传递。使用对象更改对象

const treeData=[{
“jssType”：“字段集”，
“jssSelectLabel”：“字段集（带图例）”，
“jssSelectGroup”：“jssItem”，
“jsName”：“fieldset-715”，
“jssLabel”：“图例”，
“jssIcon”：“typcn typcn文件夹”，
“扩展”：是的，
“儿童”：[{
“jssType”：“列表ol”，
“jssSelectLabel”：“列表-ol”，
“jssSelectGroup”：“jssItem”，
“jsName”：“list-ol-147”，
“jssLabel”：“，
“jssIcon”：“dashicons dashicons编辑器ol”，
“没有孩子”：错，
“扩展”：是的，
“儿童”：[{
“jssType”：“列表li”，
“jssSelectLabel”：“列表项-li”，
“jssSelectGroup”：“jssItem”，
“jsName”：“list-li-752”，
“jssLabel”：“，
“jssIcon”：“dashicons dashicons编辑器ul”，
“没有孩子”：错，
“扩展”：是的，
“儿童”：[{
“jssType”：“文本”，
“jssSelectLabel”：“文本（短文本）”，
“jssSelectGroup”：“jsTag”，
“jsName”：“text-422”，
“jssLabel”：“您的姓名（必填）”，
“jsRequired”：正确，
“jsTagOptions”：[{
“jsOption”：“，
“optionLabel”：“默认值”，
“optionType”：“输入”
},
{
“jsOption”：“占位符”，
“isChecked”：错误，
“optionLabel”：“使用此文本作为字段的占位符”，
“optionType”：“复选框”
},
{
“jsOption”：“akismet_作者_电子邮件”，
“isChecked”：错误，
“optionLabel”：“Akismet-此字段需要作者的电子邮件地址”，
“optionType”：“复选框”
}
],
“jsValues”：“，
“占位符”：false，
“jsAkismetAuthor”：错，
“jsIdAttribute”：“，
“jsClassAttribute”：“”，
“jssIcon”：“按字母顺序排序的类型”，
“没有孩子”：真的吗
}]
},
{
“jssType”：“列表li”，
“jssSelectLabel”：“列表项-li”，
“jssSelectGroup”：“jssItem”，
“jsName”：“list-li-538”，
“jssLabel”：“，
“jssIcon”：“dashicons dashicons编辑器ul”，
“没有孩子”：错，
“扩展”：是的，
“儿童”：[{
“jssType”：“电子邮件”，
“jssSelectLabel”：“电子邮件”，
“jssSelectGroup”：“jsTag”，
“jsName”：“email-842”，
findObjectByLabel(car, "Chevrolet");

var findObjectByKeyVal= function (obj, key, val) {
  if (!obj || (typeof obj === 'string')) {
    return null
  }
  if (obj[key] === val) {
    return obj
  }

  for (var i in obj) {
    if (obj.hasOwnProperty(i)) {
      var found = findObjectByKeyVal(obj[i], key, val)
      if (found) {
        return found
      }
    }
  }
  return null
}

let car = { name: 'BMW', meta: { model: 2018, color: 'white'};
pick(car,['name','model']) // Output will be {name: 'BMW', model: 2018}

const pick = (object, props) => {
  let newObject = {};
  if (isObjectEmpty(object)) return {}; // Object.keys(object).length <= 0;

  for (let i = 0; i < props.length; i++) {
    Object.keys(object).forEach(key => {
      if (key === props[i] && object.hasOwnProperty(props[i])) {
        newObject[key] = object[key];
      } else if (typeof object[key] === "object") {
        Object.assign(newObject, pick(object[key], [props[i]]));
      }
    });
  }
  return newObject;
};

function isObjectEmpty(obj) {
  for (let key in obj) {
    if (obj.hasOwnProperty(key)) return false;
  }
  return true;
}
export default pick;

const iterate = (obj) => {
    Object.keys(obj).forEach(key => {

    console.log(`key: ${key}, value: ${obj[key]}`)

    if (typeof obj[key] === 'object') {
            iterate(obj[key])
        }
    })
}

const findCar = function(car) {
    const carSearch = [cars];

      while(carSearch.length) {
          let item = carSearch.shift();
          if (item.label === car) return true;
          carSearch.push(...item.subs);
      }

      return false;
}

var findObjectByLabel = function(objs, label) {
  if(objs.label === label) { 
    return objs; 
    }
  else{
    if(objs.subs){
      for(var i in objs.subs){
        let found = findObjectByLabel(objs.subs[i],label)
        if(found) return found
      }
    }
  }
};

findObjectByLabel(cars, "Ford");

var findObjectByLabel = function(obj, label) 
{
  var foundLabel=null;
  if(obj.label === label)
  { 
    return obj; 
  }

for(var i in obj) 
{
    if(Array.isArray(obj[i])==true)
    {
        for(var j=0;j<obj[i].length;j++)
        {
            foundLabel = findObjectByLabel(obj[i], label);
        }
    }
    else if(typeof(obj[i])  == 'object')
    {
        if(obj.hasOwnProperty(i))
        {           
            foundLabel = findObjectByLabel(obj[i], label);     
        }       
    }

    if(foundLabel) 
    { 
        return foundLabel; 
    }

}

return null;
};

var x = findObjectByLabel(cars, "Sedan");
alert(JSON.stringify(x));

export interface INestedIterator<T> {
    getChildren(): T[];
}

export class NestedIterator {
    private static forEach<T extends INestedIterator<T>>(obj: T, fn: ((obj: T) => void)): void {      
        fn(obj);    
        if (obj.getChildren().length) {
            for (const item of obj.getChildren()) {
                NestedIterator.forEach(item, fn);            
            };
        }
    }
}

class SomeNestedClass implements INestedIterator<SomeNestedClass>{
    items: SomeNestedClass[];
    getChildren() {
        return this.items;
    }
}

NestedIterator.forEach(someNesteObject, (item) => {
    console.log(item);
})

export class NestedIterator {
    private static forEach(obj: any, fn: ((obj: any) => void)): void {      
        fn(obj);    
        if (obj.items && obj.items.length) {
            for (const item of obj.items) {
                NestedIterator.forEach(item, fn);            
            };
        }
    }
}