Javascript 我知道那里'；这是一个更好的方法，但我不'；我看不出来。解析出子URL

有没有关于如何打开这个列表的想法

// How to get from this urls
[
     '/this',
     '/should/not',
     '/should/close',
     '/should',
     '/not/be/that',
     '/this/is'
]

进入这个结构

// To this in a smart way
[
    {
        url: 'this',
        sub: [{
            url: 'is'
        }]
    },
    {
        url: 'should',
        sub: [{
            url: 'not'
        },{
            url: 'close'
        }]
    },
    {
        url: 'not',
        sub: [{
            url: 'be',
            sub: [{
                url: 'hard'
            }]
        }]
    }
]

我不是在要求速度，我已经有了一个正在运行的解决方案（在第一个级别上使用for循环迭代一次，然后在下一个级别上使用for循环迭代一次，等等，并建立结果），但我一直认为应该可以用几行代码来实现这一点

是吗

Larsi

我有这个“解决方案”，以防您使用不同的格式：

var a = [
     '/this',
     '/should/not',
     '/should',
     '/not/be/that',
     '/this/is'
],
b = {};

for(var i = 0; i < a.length; i++){
    var items = a[i].replace('/','').split('/');
    var temp = {};
    b[items[0]] = temp;
    for(var j = 1; j < items.length; j++){
        temp[items[j]] = {};
        temp = temp[items[j]];
    }
}

---

我同意CERBURS的观点，即提议的结构是可怕的，但这里有一个尝试：

    var dir = [
         '/this',
         '/should/not',
         '/should',
         '/not/be/that',
         '/this/is'
    ];

    var res = [];

    function subify(s) {
        if (s == "") return {url: ""};
        if (s[0] == "/") s = s.substr(1);

        var i = s.indexOf("/", 0);

        if (i < 0) return {url: s}
        return {url: s.substr(0, i), sub: subify(s.substr(i + 1))};            
    }

    for (var i = 0; i < dir.length; i++) {
        var s = subify(dir[i]);            // create object
        if ("sub" in s) res.push(s);       // filter out non-subs
    }

var-dir=[
“/这个”，
“/应该/不”，
“/应该”，
“/不是/是/那”，
“/这/是”
];
var-res=[]；
功能子化（s）{
如果（s==“”）返回{url:“”；
如果（s[0]==“/”）s=s.substr（1）；
var i=s.indexOf（“/”，0）；
if（i<0）返回{url:s}
返回{url:s.substr（0，i），sub:subify（s.substr（i+1））}；
}
对于（变量i=0；i

---

您可能会更接近使用某种奇特的正则表达式替换的单行程序。这段代码将在类似于您的路径上工作，但如果有后面的斜杠，则不会工作。它也不会强制要求在开头有一条斜线；该信息将丢失。

您可以尝试一些递归映射算法：

function mapurl (a){
  var aa = a.replace(/^\//,'').split('/'), obj = {url: aa[0]};
  if (aa.length>1) { 
    var x= [];  
    mapurl.call(x, aa.slice(1).join('/')); 
    obj.sub = x; 
  }
  this.push( obj );
  return a;
}
var urls2objs = [];
[
 '/this',
 '/should/not',
 '/should/close',
 '/should',
 '/not/be/that',
 '/this/is'
].map(mapurl, urls2objs);
//=> now urls2objs contains an array of objects 
     ( [{url: ...,  sub: [{url:..., sub:...}] }

---

有比我女儿更漂亮的孩子吗？你不能说，因为你没见过我女儿。还有，这是离题的。你真的必须有这样的结构吗？结果元素中的数组确实使格式化变得困难。是的，请同意这是一种困难的格式。但必须是这样。根据投票结果，没有人发布聪明的一行代码，我想我会让代码保持原样，忘记这个问题：-）Ai。。。！我很抱歉，瑟布鲁斯。sub是一个数组，我的示例没有指出这一点。我会更新ItaaArgh！这比我担心的还要糟糕xD你能详细解释一下为什么格式不能更改吗？谢谢你的尝试！不幸的是，格式无法更改。我只从您的代码中获得了

{url:“this”，sub:{url:“is”}

。谢谢您的建议。我在编写示例时犯了一个小错误，因此您的代码不正确。很抱歉浪费您的时间：-（@Cerbrus:Hmm，当我打印到控制台时，我得到三个带有多个斜杠的条目。但是我的代码无法处理新的（已编辑）不管怎样，我还是要保留它。@Larsi：我明白了；更新后的数据结构比以前更难看。既然你似乎已经有了解决方案，我就保留它。只是这会为

“应该”

和

“这个”创建重复的条目

@Cerbrus:真的吗？是的，真的。当你，或者也一样的时候，它更可见。好吧，它只是映射它在数组中遇到的东西，答案只是为了给出一个方向。也许

reduce

可能是组合URL的下一步。

function mapurl (a){
  var aa = a.replace(/^\//,'').split('/'), obj = {url: aa[0]};
  if (aa.length>1) { 
    var x= [];  
    mapurl.call(x, aa.slice(1).join('/')); 
    obj.sub = x; 
  }
  this.push( obj );
  return a;
}
var urls2objs = [];
[
 '/this',
 '/should/not',
 '/should/close',
 '/should',
 '/not/be/that',
 '/this/is'
].map(mapurl, urls2objs);
//=> now urls2objs contains an array of objects 
     ( [{url: ...,  sub: [{url:..., sub:...}] }