Question

尝试在递归时将管道弄脏。任何人都可以帮我一把吗？

我有一个JavaScript对象，其值包含其他键的数组。使用JavaScript我试图规范化列表，以便我可以看到哪些键属于相关键的依赖项。让我直观地解释一下：

这是对象（itemDepsMap）：

{
  "zero" : '',
  "one"  : ['zero'],
  "two"  : ['one'],
  "three": ['one', 'two'],
  "four" : ['three']
}

所以关键四取决于三，这取决于一个和两个，这取决于< strong>一个和零

我需要一个名为checkDeps（id）的函数，它将返回如下“

checkDeps（'four'）=＆gt; [三，二，一，零] checkDeps（'two'）=＆gt; [一，零]

我相信这被称为封闭。我也相信这是递归完成的。

这就是我所拥有的：

  this.checkDeps = function(id) {
    var closure = [];
    if(this.itemDepsMap[id] !== ''){
      for(var dep in this.itemDepsMap[id]) {
        console.log(this.itemDepsMap[id][dep]);
        closure = this.checkDeps(this.itemDepsMap[id][dep]);
      }
    }
    return closure;
  }

我真的很感激这里的一些帮助！重复项并不重要，但如果解决方案不添加重复项（优雅地......）

，则奖励积分

Answer 1

我做了一个非常简单的方法。您可以将其作为参考。它将返回一个唯一的数组

var itemDepsMap =
{
  "zero" : '',
  "one"  : ['zero'],
  "two"  : ['one'],
  "three": ['one', 'two'],
  "four" : ['three']
};

function makeUnique(value, index, self) { 
    return self.indexOf(value) === index;
}

var closure = [];
var checkDeps = function(id) {
    if(itemDepsMap[id] !== ''){
      for(var dep in itemDepsMap[id]) {
        console.log(itemDepsMap[id][dep]);
        closure.push(itemDepsMap[id][dep]);
        checkDeps(itemDepsMap[id][dep]);
      }
    }
    closure = closure.filter( makeUnique );
};

checkDeps('four');
console.log(closure);

Answer 2

你可以在这里使用两个函数是我的代码

y = x.map(function(e)
{
    var obj = {c: []};
    for(var prop in e){
        obj.c.push({v:e[prop]})
    }
    return obj;
});

用于测试的功能测试

Answer 3

另一种没有要求的方式：

function f(id, obj) {
  if (obj[id] == '') return [];//if not dependencies return at once

  var path = obj[id],//save dependecies to check
    p = {},//result dependencies
    cur;//pointer to current 
  while (path.length) {
    do {
      cur = path.shift();//get first dependency that not checked
    } while (cur && p[cur]);

    if (!cur) break;//if nothing current break loop

    p[cur] = true; //mark dependency as checked
    if (obj[cur] != '') {//if current field have dependency
      path = path.concat(obj[cur]);//add to saved dependecies
    }
  }

  return Object.keys(p);
}

＆＃13;

function f(id, obj) {
  if (obj[id] == '') return [];

  var path = obj[id],
    p = {},
    cur;
  while (path.length) {
    do {
      cur = path.shift();
    } while (cur && p[cur]);

    if (!cur) break;
    p[cur] = true;
    if (obj[cur] != '') {
      path = path.concat(obj[cur]);
    }
  }

  return Object.keys(p);
}

t={
  "zero" : '',
  "one"  : ['zero'],
  "two"  : ['one'],
  "three": ['one', 'two'],
  "four" : ['three']
};

document.getElementById('r').innerHTML = JSON.stringify(t)
+ '<br /><br />' + JSON.stringify(f('four',t))
+ '<br />' + JSON.stringify(f('two',t));

＆＃13;

<div id="r"></div>

＆＃13;

Answer 4

只是简单的递归，只使用一个完全独立的函数：

var omap = {
  "zero" : '',
  "one"  : ['zero'],
  "two"  : ['one'],
  "three": ['one', 'two'],
  "four" : ['three']
};

function tracer(key, logger) {
  obj = omap[key] ? omap[key] : obj[key];
  if (!obj || obj == 'undefined') { return logger; }
  obj.forEach(function(elem) { 
    if (logger.indexOf(elem) < 0) { 
      tracer(elem, logger); logger.unshift(elem);        	
    }
  });
  return logger;
}

snippet.log('four - ' + tracer('four', [])); 
snippet.log('three - ' + tracer('three', [])); 
snippet.log('two - ' + tracer('two', []));

<script src="//tjcrowder.github.io/simple-snippets-console/snippet.js"></script>

只需使用密钥和空数组调用tracer。

e.g。 tracer('four', [])在密钥four上运行跟踪。

通过JavaScript对象递归

4 个答案: