Javascript 逐行显示递归

我正在尝试用javascript创建一个函数，该函数将使用破折号展开/拆分字符串，并使用递归（逐行）显示流程

例如，字符串“anna”将变成：

expand("anna") = expand("an")+"---"+expand("na") ->
                 "a"+"---"+"n"+"---"+"n"+"---"+"a"

期望的输出是：

anna
an---na
a---n---n---a

到目前为止，我已经完成了以下工作（我知道这可能不是我正在寻找的解决方案）：

我得到的结果是：

an---n---a

我似乎无法连接头部来执行第一个示例

我的扩展javascript函数如下：

function expand(word) {
    if (word.length<=1) {
        return word;
    } else {
        mid = word.length/2;
        return word.substr(0,mid) + "  " + expand(word.substr(mid,word.length));
    }
}

document.write(expand("anna"));

函数展开（word）{
如果（word.length希望问题出现在你的第一部分。根据你的算法，你把你的字符串anna分成两部分

安纳

因此，您需要展开两个零件，直到零件长度小于或等于1。因此，您需要的函数是下面的函数

function expand(word) {
    if (word.length<=1) {
        return word;
    } else {
        mid = word.length/2;
        return expand(word.substr(0,mid)) + " --- " + expand(word.substr(mid,word.length));
    }
}

document.write(expand("anna"));

函数展开（word）{
如果（word.length希望问题出现在你的第一部分。根据你的算法，你把你的字符串anna分成两部分

安纳

因此，您需要展开两个零件，直到零件长度小于或等于1。因此，您需要的函数是下面的函数

function expand(word) {
    if (word.length<=1) {
        return word;
    } else {
        mid = word.length/2;
        return expand(word.substr(0,mid)) + " --- " + expand(word.substr(mid,word.length));
    }
}

document.write(expand("anna"));

函数展开（word）{
如果（word.length希望问题出现在你的第一部分。根据你的算法，你把你的字符串anna分成两部分

安纳

因此，您需要展开两个零件，直到零件长度小于或等于1。因此，您需要的函数是下面的函数

function expand(word) {
    if (word.length<=1) {
        return word;
    } else {
        mid = word.length/2;
        return expand(word.substr(0,mid)) + " --- " + expand(word.substr(mid,word.length));
    }
}

document.write(expand("anna"));

函数展开（word）{
如果（word.length希望问题出现在你的第一部分。根据你的算法，你把你的字符串anna分成两部分

安纳

因此，您需要展开两个零件，直到零件长度小于或等于1。因此，您需要的函数是下面的函数

function expand(word) {
    if (word.length<=1) {
        return word;
    } else {
        mid = word.length/2;
        return expand(word.substr(0,mid)) + " --- " + expand(word.substr(mid,word.length));
    }
}

document.write(expand("anna"));

函数展开（word）{
如果（word.length，则必须返回字符串的两部分：

function expand(word) {
output="";
if (word.length<=1) {
    output+=word;
    return output;
} else 
{
    var mid = word.length/2;
    output+=word.substr(0,mid)+"---"+word.substr(mid)+" \n";//this line will show the steps.
    output+=expand(word.substr(0,mid))+"---"+expand(word.substr(mid,word.length-1))+" \n";
    return output;
}
}
console.log(expand("anna"));

函数展开（word）{
输出=”；
如果（word.length，则必须返回字符串的两部分：

function expand(word) {
output="";
if (word.length<=1) {
    output+=word;
    return output;
} else 
{
    var mid = word.length/2;
    output+=word.substr(0,mid)+"---"+word.substr(mid)+" \n";//this line will show the steps.
    output+=expand(word.substr(0,mid))+"---"+expand(word.substr(mid,word.length-1))+" \n";
    return output;
}
}
console.log(expand("anna"));

函数展开（word）{
输出=”；
如果（word.length，则必须返回字符串的两部分：

function expand(word) {
output="";
if (word.length<=1) {
    output+=word;
    return output;
} else 
{
    var mid = word.length/2;
    output+=word.substr(0,mid)+"---"+word.substr(mid)+" \n";//this line will show the steps.
    output+=expand(word.substr(0,mid))+"---"+expand(word.substr(mid,word.length-1))+" \n";
    return output;
}
}
console.log(expand("anna"));

函数展开（word）{
输出=”；
如果（word.length，则必须返回字符串的两部分：

function expand(word) {
output="";
if (word.length<=1) {
    output+=word;
    return output;
} else 
{
    var mid = word.length/2;
    output+=word.substr(0,mid)+"---"+word.substr(mid)+" \n";//this line will show the steps.
    output+=expand(word.substr(0,mid))+"---"+expand(word.substr(mid,word.length-1))+" \n";
    return output;
}
}
console.log(expand("anna"));

函数展开（word）{
输出=”；
如果（word.length如我所说，在使用递归时不可能显示递归的“过程”步骤，那么这里有一个解决方法，可以输出所需的步骤：

var levels = [];

function expand(word, level) {
  if (typeof level === 'undefined') {
    level = 0;
  }
  if (!levels[level]) {
    levels[level] = [];
  }
  levels[level].push(word);
  if (word.length <= 1) {
    return word;
  } else {
    var mid = Math.ceil(word.length/2);
    return expand(word.substr(0, mid), level+1) + '---' + expand(word.substr(mid), level+1);
  }
}

expand('anna');

for (var i = 0; i < levels.length; i++) {
  console.log(levels[i].join('---'));
}

var级别=[]；
功能扩展（字、级）{
如果（级别的类型==‘未定义’）{
级别=0；
}
如果（！级别[级别]）{
级别[级别]=[]；
}
级别[级别]。推送（word）；
如果（word.length如我所说，在使用递归时不可能显示递归的“过程”步骤，那么这里有一个解决方法，可以输出所需的步骤：

var levels = [];

function expand(word, level) {
  if (typeof level === 'undefined') {
    level = 0;
  }
  if (!levels[level]) {
    levels[level] = [];
  }
  levels[level].push(word);
  if (word.length <= 1) {
    return word;
  } else {
    var mid = Math.ceil(word.length/2);
    return expand(word.substr(0, mid), level+1) + '---' + expand(word.substr(mid), level+1);
  }
}

expand('anna');

for (var i = 0; i < levels.length; i++) {
  console.log(levels[i].join('---'));
}

var级别=[]；
功能扩展（字、级）{
如果（级别的类型==‘未定义’）{
级别=0；
}
如果（！级别[级别]）{
级别[级别]=[]；
}
级别[级别]。推送（word）；
如果（word.length如我所说，在使用递归时不可能显示递归的“过程”步骤，那么这里有一个解决方法，可以输出所需的步骤：

var levels = [];

function expand(word, level) {
  if (typeof level === 'undefined') {
    level = 0;
  }
  if (!levels[level]) {
    levels[level] = [];
  }
  levels[level].push(word);
  if (word.length <= 1) {
    return word;
  } else {
    var mid = Math.ceil(word.length/2);
    return expand(word.substr(0, mid), level+1) + '---' + expand(word.substr(mid), level+1);
  }
}

expand('anna');

for (var i = 0; i < levels.length; i++) {
  console.log(levels[i].join('---'));
}

var级别=[]；
功能扩展（字、级）{
如果（级别的类型==‘未定义’）{
级别=0；
}
如果（！级别[级别]）{
级别[级别]=[]；
}
级别[级别]。推送（word）；
如果（word.length如我所说，在使用递归时不可能显示递归的“过程”步骤，那么这里有一个解决方法，可以输出所需的步骤：

var levels = [];

function expand(word, level) {
  if (typeof level === 'undefined') {
    level = 0;
  }
  if (!levels[level]) {
    levels[level] = [];
  }
  levels[level].push(word);
  if (word.length <= 1) {
    return word;
  } else {
    var mid = Math.ceil(word.length/2);
    return expand(word.substr(0, mid), level+1) + '---' + expand(word.substr(mid), level+1);
  }
}

expand('anna');

for (var i = 0; i < levels.length; i++) {
  console.log(levels[i].join('---'));
}

var级别=[]；
功能扩展（字、级）{
如果（级别的类型==‘未定义’）{
级别=0；
}
如果（！级别[级别]）{
级别[级别]=[]；
}
级别[级别]。推送（word）；
如果（word.length这就是你需要的

expand = function(word) {
    return [].map.call(word, function(x) {return x+'---'}).join('')
};

函数式编程的乐趣

并添加了处理最后一个字符的代码：

function expand(word) {
    return [].map.call(word, function(x, idx) {
        if (idx < word.length - 1)
            return x+'---';
        else return x
     }).join('')
}

函数展开（word）{
return[].map.call（字、函数（x、idx）{
if（idx
这就是您需要的

expand = function(word) {
    return [].map.call(word, function(x) {return x+'---'}).join('')
};

函数式编程的乐趣

并添加了处理最后一个字符的代码：

function expand(word) {
    return [].map.call(word, function(x, idx) {
        if (idx < word.length - 1)
            return x+'---';
        else return x
     }).join('')
}

函数展开（word）{
return[].map.call（字、函数（x、idx）{
if（idx
这就是您需要的

expand = function(word) {
    return [].map.call(word, function(x) {return x+'---'}).join('')
};

函数式编程的乐趣

并添加了处理最后一个字符的代码：

function expand(word) {
    return [].map.call(word, function(x, idx) {
        if (idx < word.length - 1)
            return x+'---';
        else return x
     }).join('')
}

函数展开（word）{
return[].map.call（字、函数（x、idx）{
if（idx
这就是您需要的

expand = function(word) {
    return [].map.call(word, function(x) {return x+'---'}).join('')
};

函数式编程的乐趣

并添加了处理最后一个字符的代码：

function expand(word) {
    return [].map.call(word, function(x, idx) {
        if (idx < word.length - 1)
            return x+'---';
        else return x
     }).join('')
}

函数展开（word）{
return[].map.call（字、函数（x、idx）{
if（idx
要查看所有步骤，我最好做的是：

function expand(word) {
    if (word.length<=1) {
        return word;
    } else {
        var mid = word.length/2;
        var str1 = word.substr(0,mid);
        var str2 = word.substr(mid,word.length);
        document.write(str1 + "---" + str2 + "<br></br>");
        return expand(str1) + "---" + expand(str2);
    }
}

document.write(expand("anna"));

函数展开（word）{
如果（word.length要查看所有步骤，我最好做的是：

function expand(word) {
    if (word.length<=1) {
        return word;
    } else {
        var mid = word.length/2;
        var str1 = word.substr(0,mid);
        var str2 = word.substr(mid,word.length);
        document.write(str1 + "---" + str2 + "<br></br>");
        return expand(str1) + "---" + expand(str2);
    }
}

document.write(expand("anna"));

函数展开（word）{
如果（word.length要查看所有步骤，我最好做的是：

function expand(word) {
    if (word.length<=1) {
        return word;
    } else {
        var mid = word.length/2;
        var str1 = word.substr(0,mid);
        var str2 = word.substr(mid,word.length);
        document.write(str1 + "---" + str2 + "<br></br>");
        return expand(str1) + "---" + expand(str2);
    }
}

document.write(expand("anna"));

函数展开（word）{
如果（word.length要查看所有步骤，我最好做的是：

function expand(word) {
    if (word.length<=1) {
        return word;
    } else {
        var mid = word.length/2;
        var str1 = word.substr(0,mid);
        var str2 = word.substr(mid,word.length);
        document.write(str1 + "---" + str2 + "<br></br>");
        return expand(str1) + "---" + expand(str2);
    }
}

document.write(expand("anna"));

函数展开（word）{
如果（单词长度这是我疯狂的尝试

var Word = function(str) {                
    this.isSplitable = function() {
        return str.length > 1;                    
    }
    this.split = function() {
        var p = Math.floor(str.length / 2);
        return [
            new Word(str.substr(0,p)),                        
            new Word(str.substr(p,p+1))
        ];
    }        
    this.toString = function() {
        return str;
    }
}

var expand = function(words) {
    var nwords = [];
    var do_recur = false;

    words.forEach(function(word){  
        if(word.isSplitable()) {
            var splitted = word.split();
            nwords.push(splitted[0]);                                                
            nwords.push(splitted[1]);                                                
            do_recur = true;
        }else{
            nwords.push(word);
        }                 
    });

    var result = [];
    nwords.forEach(function(word){
        result.push( word.toString() );
    });

    var result = result.join("--") + "<br/>";

    if(do_recur) {
        return result + expand(nwords);
    }else{
        return "";
    }                
}

document.write( expand([new Word("anna")]) );

var Word=function（str）{
this.isSplitable=函数（）{
返回str.length>1；
}
this.split=函数（）{
var p=数学楼层（str.length/2）；
返回[
新词（str.substr（0，p）），
新词（str.substr（p，p+1））
];
}        
this.toString=函数（）{
返回str；
}
}
变量扩展=函数（字