Question

在Javascript中如何只给出一个对象的字符串中的完整祖先层次结构？现在我甚至无法考虑如何提出这个问题...所以我甚至不能谷歌。这是一个例子：

var lvl1 = { one: "one", two: "two" };
lvl1.lvl2 = {flip:"flip", flam:"flam"};
lvl1.lvl2.lvl3 = {who:"who", what:"what"};

test(o) {
     alert( hierarchyToString(o) );
}

var tmp = lvl1.lvl2.lvl3;
test(tmp);

我想看看：

"lvl1.lvl2.lvl3"

可能？如果我传入最后一个叶子串怎么办：

test(lvl1.lvl2.lvl3.what);

可能？希望这些代码有意义......就在我的头顶......

谢谢！

Answer 1

由于没有parent引用，因此无法使用纯JavaScript对象。有关详细信息，请参阅此question。

不幸的是，从字符串表示到对象很容易，但不是相反。您必须在每个对象中显式编写父引用，并且每个叶节点都能够向上遍历。

Answer 2

您可以执行类似的操作，但无法识别根元素的名称。

var lvl1 = { one: "one", two: "two" };
lvl1.lvl2 = {flip:"flip", flam:"flam"};
lvl1.lvl2.lvl3 = {who:"who", what:"what"};

function test(o) {
     for (var item in o)
     {
         if (typeof( o[item] ) === 'object')
         {
             var next = test( o[item] );
             if (next != '')
                 return item + '.' + next
             else
                 return item ;
         }
     }
     return '';
}
alert( test( lvl1 ) );

而且它只能outer->inner而不是另一种方式......

要识别第一个元素，可以使用空父节点..

var root={};
root.lvl1 = { one: "one", two: "two" };
root.lvl1.lvl2 = {flip:"flip", flam:"flam"};
root.lvl1.lvl2.lvl3 = {who:"who", what:"what"};

并使用alert( test( root ) );

进行调用

Answer 3

对于仍然需要解决方案的任何人：

function getStringOutOfHierarchy(obj){
  let finalString=[];
  let lastString=[];
  let stringHierarachy = recHierarchy(obj, Object.keys(obj))[0];

  finalString.map(elem=>{
    if(elem.constructor===Array){
      elem.forEach(
        (subelem=>{
          lastString.push(subelem);
        })
      );
    }
  });
  return lastString;


  function recHierarchy(obj, initial){
    if(Object.keys(obj).length!=0){
      return Object.keys(obj).map((elem)=>{
        let basString= elem;
        switch (typeof obj[elem]) {
        case 'string':{

          return [`${elem.toString()}`];
        }
        default :{
          return [`${elem.toString()}`];
        }
        case 'object':{
          if(obj[elem].constructor === Array ){
            return  [`${elem.toString()}`];
          }
          let returnedValue = recHierarchy(obj[elem]);
          let value = returnedValue.map(
            (elem)=>{
              if(elem.constructor === Array){
                return elem.map(
                  (subelem)=>{
                    return `${basString}.${subelem.toString()}`;
                  }
                );
              }
              return `${basString}.${elem.toString()}`;
            }
          );
          (initial && initial.indexOf(elem)!==-1)?finalString=finalString.concat(value) :null;
          return value;
        }

        }
      });
    }else{
      return [''];
    }

  }
}

上面的代码将返回一个字符串列表，这些字符串代表参数中给出的obj的完整层次结构：

示例：

输入对象：

{
  itemOne:{
    subItemOneOne:{},
    subItemOneTwo:{
      SubSubItemOneTwoOne:'ZEZEZEZEZEZEZE',
      SubSubItemOneTwoTwo:"kkokokokok"
    },
    subItemOneThree:['erererer', 'ffdfdfdf']
  },
  itemTwo:{
    subItemTwoOne:["popopopo","éopopopo"]
  }
}

层次结构的输出数组：

[ 'itemOne.subItemOneOne.',
  'itemOne.subItemOneTwo.SubSubItemOneTwoOne',
  'itemOne.subItemOneTwo.SubSubItemOneTwoTwo',
  'itemOne.subItemOneThree',
  'itemTwo.subItemTwoOne' ]

注意：可以做一些小的修改，以增加将数组提取为0和1键的可能性，从而将itemOne.subItemOneThree.0和itemOne.subItemOneThree.1作为单独的分层字符串。

Javascript：将完整对象层次结构作为字符串

3 个答案: