Javascript 其中'；对于'；以下排列的循环？

我试图用for循环得到这些排列

• 2个元素{a，b}结果：
  a、 b，ab

• 3个元素{a，b，c}结果：
  a、 b、c、ab、ac、bc、abc

• 4个元素{a，b，c，d}结果：
  a、 b、c、d、ab、ac、ad、bc、bd、cd、abc、abd、acd、bcd、abcd

• 5个元素{a，b，c，d，e}结果：
  a、 b，c，d，e，ab，ac，ad，ae，bc，bd，be，cd，ce，de，abc，abd，abe， acd、ace、ade、bcd、bce、bde、cde、abcd、abce、abde、acde、bcde、， abcde

等等

我在中完成了这项工作，为一个接一个的循环制定了

，以捕获系统结构：

var a, b, c;

a = ['a', 'b', 'c', 'd', 'e', 'f'];
b = [];

for(i=0; i < a.length; i++){
  b[b.length] = a[i];
}
for(i=1; i < a.length; i++){
  b[b.length] = b[0]+b[i];
}
for(i=2; i < a.length; i++){
  b[b.length] = b[1]+b[i];
}
for(i=3; i < a.length; i++){
  b[b.length] = b[2]+b[i];
}
for(i=4; i < a.length; i++){
  b[b.length] = b[3]+b[i];
}
for(i=2; i < a.length; i++){
  b[b.length] = b[5]+b[i];
}
for(i=3; i < a.length; i++){
  b[b.length] = b[6]+b[i];
}
for(i=4; i < a.length; i++){
  b[b.length] = b[7]+b[i];
}
for(i=3; i < a.length; i++){
  b[b.length] = b[9]+b[i];
}
for(i=4; i < a.length; i++){
  b[b.length] = b[10]+b[i];
}
for(i=4; i < a.length; i++){
  b[b.length] = b[12]+b[i];
}
for(i=3; i < a.length; i++){
  b[b.length] = b[15]+b[i];
}
for(i=4; i < a.length; i++){
  b[b.length] = b[16]+b[i];
}
for(i=4; i < a.length; i++){
  b[b.length] = b[18]+b[i];
}
for(i=4; i < a.length; i++){
  b[b.length] = b[21]+b[i];
}
for(i=4; i < a.length; i++){
  b[b.length] = b[25]+b[i];
}

var a、b、c；
a=['a'，'b'，'c'，'d'，'e'，'f']；
b=[]；
对于（i=0；i
试试这个解决方案


var x=['a'，'b'，'c'，'d']，
可能项置换=[]；
x、 forEach（函数（elmt）{
可能置换推送（elmt）
var-rest=x.slice（x.indexOf（elmt）+1）；
myPermutationGeneration（elmt，rest）
})
函数myPermutationGeneration（当前，剩余）{
rest.forEach（函数（restEle）{
可能的置换推送（当前+重新删除）
var rest2=x.slice（x.indexOf（restEle）+1）；
myPermutationGeneration（当前+restEle，rest2）
})
}
console.log（可能的术语置换）
尝试此解决方案


var x=['a'，'b'，'c'，'d']，
可能项置换=[]；
x、 forEach（函数（elmt）{
可能置换推送（elmt）
var-rest=x.slice（x.indexOf（elmt）+1）；
myPermutationGeneration（elmt，rest）
})
函数myPermutationGeneration（当前，剩余）{
rest.forEach（函数（restEle）{
可能的置换推送（当前+重新删除）
var rest2=x.slice（x.indexOf（restEle）+1）；
myPermutationGeneration（当前+restEle，rest2）
})
}
log（可能是permutate）
这是另一个可能有效的方法


var getcombines=函数（arr，originalLength）{
if（originalLength==0）返回arr；
var diff=阵列长度-原始长度；
var l=阵列长度；
var结果=arr；
对于（i=0；ilog（getcompositions（a，a.length））这是另一个可能有效的方法


var getcombines=函数（arr，originalLength）{
if（originalLength==0）返回arr；
var diff=阵列长度-原始长度；
var l=阵列长度；
var结果=arr；
对于（i=0；ilog（getcompositions（a，a.length））逻辑不清楚。为什么你从逻辑上可能的排列中选择了那些特殊的排列？@sawa我想，这里的逻辑是顺序无关紧要：例如，对于两个元素，只有3个结果，因为
ab===ba
（在这种情况下，这不是排列）。这是一个疯狂的猜测，当然我们回答者不应该猜测。。。投票以不清楚的方式结束。这不是排列。这是动力集。集合的所有子集的集合。逻辑清晰，没有重复的元素，元素只有一个顺序。您可以考虑将[i+1]对象增加为组合和n！的排序n^n！。逻辑并不清楚。为什么你从逻辑上可能的排列中选择了那些特殊的排列？@sawa我想，这里的逻辑是顺序无关紧要：例如，对于两个元素，只有3个结果，因为
ab===ba
（在这种情况下，这不是排列）。这是一个疯狂的猜测，当然我们回答者不应该猜测。。。投票以不清楚的方式结束。这不是排列。这是动力集。集合的所有子集的集合。逻辑清晰，没有重复的元素，元素只有一个顺序。您可以考虑将[i+1]对象增加为组合和n！的排序n^n！。这就是我的意思回答得好这就是我的意思回答得好