在JavaScript中是否有任何预构建的方法来查找给定字符串的所有排列？

我是JavaScript领域的新手。正如标题提到的，我想知道JavaScript中是否有任何预构建的方法来查找给定字符串的所有可能排列

例如，给定输入：

the

<pre>
<script>

var count = 0;
var duplicate = false;

function FindAllPermutations(str, index) {
    for (var i = index; i < str.length; i++) {
        var newstr;

        if (index == i) newstr = str;
            else newstr = SwapLetters(str, index, i);

        if (!duplicate) {
            count++;
            document.write(newstr + "\n");
            if (i == index) duplicate = true;
        } else if (i != index) duplicate = false;

        FindAllPermutations(newstr, index + 1);
      }
  }

function SwapLetters(str, index1, index2) {
    if (index1 == index2) return str;
    str = str.split("");
    var temp = str[index1];
    str[index1] = str[index2];
    str[index2] = temp;
    return str.join("");
}

FindAllPermutations("ABCD", 0); // will output all 24 permutations with no duplicates
document.write("Count: " + count);

</script>

期望输出：

the
teh
eht
eth
het
hte

---

没有预构建，但是编写这样的函数是可能的。。以下是使用两个函数的一种相对简单的方法：

function FindAllPermutations(str, index, buffer) {
    if (typeof str == "string")
        str = str.split("");
    if (typeof index == "undefined")
        index = 0;
    if (typeof buffer == "undefined")
        buffer = [];
    if (index >= str.length)
        return buffer;
    for (var i = index; i < str.length; i++)
        buffer.push(ToggleLetters(str, index, i));
    return FindAllPermutations(str, index + 1, buffer);
}

function ToggleLetters(str, index1, index2) {
    if (index1 != index2) {
        var temp = str[index1];
        str[index1] = str[index2];
        str[index2] = temp;
    }
    return str.join("");
}

现场测试用例：

---

这只是一个基本的实现，它不会删除重复项，也没有优化。但是，对于小字符串，您不会有任何问题，可以像上面的测试用例中那样添加时间度量，看看您的合理限制是什么。

假设搜索一个大字符串，您可以使用正则表达式

要检查首先匹配字母和字母总数的一组可能性

并返回与模式使用相同字母集的匹配项

//（不区分大小写）

字母集（“the”）.sort（）

var计数=0；
var duplicate=false；
函数FindAllPermutations（str，index）{
对于（var i=索引；i

//字符串置换
函数置换（开始，字符串）{
//基本情况
if（string.length==1）{
返回[开始+字符串]；
}否则{
var returnResult=[]；
对于（变量i=0；i对于（var j=0；j这是类似的，但从一个单词数组中查找所有的字谜/排列。我在一次采访中遇到了这个问题。给定一个单词数组['cat'，'dog'，'tac'，'god'，'act'，]，返回一个数组，将所有的字谜组合在一起。确保字谜是唯一的

function swap(a, b, str) {
  if (a == b)
    str = str;

  else {
    str = str.split("");
    var temp = str[a];
    str[a] = str[b];
    str[b] = temp;
    str = str.join("");
  }
}

function anagram(a1, b1, ar) {
  if (a1 == b1)
    document.write(ar + "<br/>");

  else
    for (i = a1; i < b1; i++) {
      swap(a1, b1, ar);
      anagram((a1) ++, b1, ar);
      swap(a1, b1, ar);
    }
}

var-arr=['cat'，'dog'，'tac'，'god'，'act']；
var allAnagrams=功能（arr）{
变量anagrams={}；
arr.forEach（函数（str）{
var recurse=函数（ana，str）{
如果（str==''）
anagrams[ana]=1；
对于（变量i=0；i功能交换（a、b、str）{
如果（a==b）
str=str；
否则{
str=str.split（“”）；
var-temp=str[a]；
str[a]=str[b]；
str[b]=温度；
str=str.join（“”）；
}
}
函数字谜（a1、b1、ar）{
如果（a1==b1）
文件。写入（ar+“
”）；
其他的
对于（i=a1；i
js中没有任何内置函数（我不相信它是用任何编码语言编写的）……不管怎么说，这是一个功能齐全的程序，它省略了任何重复，还显示了排列的数量

function permutations(str){
  if (str.length === 1)
      return str;
  var permut = [];
  for (var i=0; i<str.length; i++){
      var s = str[0];
      var _new =  permutations(str.slice(1, str.length));
      for(var j=0; j<_new.length; j++)
          permut.push(s + _new[j]);
      str = str.substr(1, str.length -1) + s;
  }
  return permut; }

var n=0；
var计数器=0；
var storarr=新数组（）；
函数swap（a，b，str）{//交换str[a]和str[b]这两个术语并返回最终的str
str=str.split（“”）；
var-temp=str[a]；
str[a]=str[b]；
str[b]=温度；
返回str.join（“”）；
}
函数变位符（_a，_b，ar）{//产生变位符的实际函数
如果（_a==_b）{
storarr[n]=ar；
n++；
计数器++；
}
否则{
对于（var i=_a；i
函数置换（str）{
如果（str.length==1）
返回str；
var permut=[]；
对于（var i=0；i当你说预构建时，你是指内置的吗？如果是的话，答案是No.+1这是一个有趣的问题。它归结为获取一组元素并返回这些元素的所有唯一有序集的集合。是的，我只说内置函数！我对js非常陌生，请告诉我找到它的任何方法！@Antoarvith there不是内置函数。你必须编写一个算法。然后要聪明地使其达到O（n logn）的速度。此外，应用于单词“foobar”的函数返回720个结果；）“combines”返回4.79亿个结果results@Raynos：我是个新手，要解决这个问题对新手来说非常困难：）-1这必须被打破。
Hello World
有可计数的输出数。它应该有11个！结果。例如，字符串
Hello wordl
丢失了。@Raynos感谢改进版的提示：但仍然缺少很多排列…仍在进行完整修复。FTR，“Hello World”应返回包含39916800项的数组。但我无法理解此函数的任何内容。但无论如何，谢谢：）@Shadow Better:
index=index | | 0；
和
buffer=buffer | |[]；
@Anto它将只返回三个字母字符串的正确结果。对于其余部分，它将只返回部分结果。尽管如此，您仍然可以从中获得一些想法，请随意询问有关代码中特定行的解释。非常高级！但我仍然可以找出此代码的作用！这将返回一个空数组，无论为什么我尝试输入。这不起作用。FindAllPermutations（“DUDE”，0）；生成重复项。Sant询问是否有任何内置Javascript方法，一点也没有
//string permutation

function permutation(start, string) {

    //base case
    if ( string.length == 1 ) {
        return [ start + string ];
    } else {

        var returnResult = [];
        for (var i=0; i < string.length; i++) {
            var result = permutation (string[i], string.substr(0, i) + string.substr(i+1));
            for (var j=0; j<result.length; j++) {
                returnResult.push(start + result[j]);
            }
        }

        return returnResult;
    }
}

var arr = ['cat', 'dog', 'tac', 'god', 'act'];

var allAnagrams = function(arr) {
    var anagrams = {};
    arr.forEach(function(str) {
        var recurse = function(ana, str) {
            if (str === '') 
                anagrams[ana] = 1;
            for (var i = 0; i < str.length; i++)
                recurse(ana + str[i], str.slice(0, i) + str.slice(i + 1));
        };
        recurse('', str);
    });
    return Object.keys(anagrams);
}

console.log(allAnagrams(arr));
//["cat", "cta", "act", "atc", "tca", "tac", "dog", "dgo", "odg", "ogd", "gdo", "god"]

function swap(a, b, str) {
  if (a == b)
    str = str;

  else {
    str = str.split("");
    var temp = str[a];
    str[a] = str[b];
    str[b] = temp;
    str = str.join("");
  }
}

function anagram(a1, b1, ar) {
  if (a1 == b1)
    document.write(ar + "<br/>");

  else
    for (i = a1; i < b1; i++) {
      swap(a1, b1, ar);
      anagram((a1) ++, b1, ar);
      swap(a1, b1, ar);
    }
}

var n=0;
var counter=0;
var storarr=new Array();

function swap(a,b,str) {        //swaps the terms str[a] and str[b] and returns the final str
        str = str.split("");
        var temp = str[a];
        str[a] = str[b];
        str[b] = temp;
        return str.join("");
}

function anagram(_a,_b,ar) {        //actual function which produces the anagrams
    if(_a == _b) {
    storarr[n]=ar;
    n++;
    counter++;
    }
    else {
        for(var i= _a;i<= _b;i++) {
            ar=swap(_a,i,ar);
            anagram(_a+1,_b,ar);
            ar=swap(_a,i,ar);
        }
    }
}

function factorial(a) {         //return a!
    var x=1;
    for(var i=1;i<=a;i++)
    x=x*i;
    return x;
}

var strl=prompt("Enter String:","");
var l=strl.length;
anagram(0,l-1,strl);
storarr.sort();             //sorts the storarr alphabetically
var storlen=storarr.length;
var cai=0;
var counterarr = new Array();
strl.split("");

for(var i=0;i<l;i=i+c) {        //determines the number of times a term is repeating
    var c=1;
    for(var j=i+1;j<l;j++) {
        if(strl[i]==strl[j])
            c++;    
    }
    counterarr[cai]=c;
    cai++;
}

var yellow=1;

for(var i=0;i<counterarr.length;i++) {      //multiplies the terms of the counter array
    yellow=yellow*factorial(counterarr[i]);
}

counter=counter/yellow;
document.write("Count : " + counter + "<br />");

for(var i=0;i<storlen;i=i+yellow) {     //prints the non-flagged terms in storarr
    document.write(storarr[i] + "<br />");
}

strl.join("");

function permutations(str){
  if (str.length === 1)
      return str;
  var permut = [];
  for (var i=0; i<str.length; i++){
      var s = str[0];
      var _new =  permutations(str.slice(1, str.length));
      for(var j=0; j<_new.length; j++)
          permut.push(s + _new[j]);
      str = str.substr(1, str.length -1) + s;
  }
  return permut; }