将字符串的一部分与javascript中的字符串数组匹配

Question

我有一个包含 1500 个 varint 字符串的数组，如下所示：

 var base = ["129;176;2","131;173;2","242;1","221;188;2","138;7","201;20","251;12","32"]

数组的字符串可以由单个数字（“32”）、两个数字（“242;1”）或三个数字（“131;173;2”）组成，不超过3个数字。

还有一个变量，其中包含从数组中包含的字符串的串联获得的字符串（该变量由用户创建，并且只能从可以在基本数组中找到的值列表中创建）。

 var userCreated = "129;176;2;32;131;173;2;184;3;201;20;251;12"

问题是在数组中找到完美匹配，但我不知道要检查的正确部分。

例如： 我不知道我是否必须匹配“129”或“129;176”或“129;176;2”，所以我需要一个可以匹配第一个数字，第一个和第二个数字，以及第一个的函数，第二个和第三个数字。当找到完美匹配时，必须将字符串的一部分存储在新变量中并从原始变量（userCreated）中删除。

一个数字我就可以做到：

 var divide = userCreated.split(";");
 for (var i = 0;i<divide.length; i++){
         if(base.indexOf(divide[i]) >= 0){
            var found + i = divide[i];
         }
 }

是否可以按顺序检查 var 中的字符串与数组以找到完美匹配，然后检查字符串的其余部分？重要的是要注意：匹配可以在“完美匹配”之前找到（检查“129”可以找到匹配，但在基本数组中可以有一个“129;176”（完美匹配）所以其他值可能不匹配...

编辑： 为了澄清这个问题： userCreated 字符串不能包含两次要在数组中匹配的值。例如：它可以包含 126;15 和 126;15;2 但不能包含 126;15 或 126;15;2 两次。 预期的结果可以是一系列变量，里面每个“完美匹配”，例如：

 var found0 = "129;176;2";
 var found1 = "242;1";
 var found2 = "32";

或者像原始数组这样的数组：

 var found = ["129;176;2", "242;1", "32"] // Maybe a better solution

总匹配数在 1 到 30 匹配范围内。

编辑（解决方案）： 在接受（和好的）答案之后，我尝试遵循类似的方式： 我已将原始数组拆分为 3 个数组，如下所示：

 base1 = ["28", "34", "16"];
 base2 = ["125;16", "200;45", "167;2"];
 base3 = ["209;145;2", "143;154;2", "211;170;2", "246;170;2", "247;170;2"];

然后：

 var divide = userCreated.split(";"),
     resultArray3 = [], resultArray2 = [], resultArray1 = [], final = [];
 function tri(divide){
 for (var i = 0, j = 1, k = 2; k<divide.length; i++, j++, k++){
    var tre = base3.indexOf(divide[i]+';'+divide[j]+';'divide[k]);
    if (tre !== -1){
        resultArray3.push(base3[tre]);
        divide.splice(i, 1, "none");
        divide.splice(j, 1, "none");
        divide.splice(k, 1, "none");
    }
 }
 }
 function two(divide){
     for (var i = 0, k = 1; k<divide.length; i++, k++){
            var due = base2.indexOf(divide[i]+';'+divide[k]);
        if (due !== -1){
            resultArray2.push(base2[due]);
            divide.splice(i, 1, "none");
            divide.splice(k, 1, "none");
        }
 }
 }
 function ones(divide){
 for (var k = 0; k<divide.length; k++){
    var uno = base1.indexOf(divide[k]);
        if (uno !== -1){
            resultArray1.push(base1[uno]);
            divide.splice(k, 1, "none");
        }
}
 }

最后：

final.push.apply(final, resultArray1);
final.push.apply(final, resultArray2);
final.push.apply(final, resultArray3);

Answer 1

正如@ObsidianAge 所说，可能有多种方法可以将输入字符串拆分为匹配的部分。如果可能的话，我会检查输入是否必须是这种方式。

我不确定是什么阻止了您追求您描述的解决方案...最简单的实现涉及递归：

let base = ["129", "129;176", "129;176;2","131;173;2","242;1","221;188;2","138;7","201;20","251;12","32", "184;3", "176"]
let userCreated = '129;176;2;32;131;173;2;184;3;201;20;251;12';

let appendSemicolon = (str) => str + ";";
let removeSemicolon = (str) => str.substr(0, str.length-1);

base = base.map(appendSemicolon); // so that '1' is not matched as a prefix of '12;34'

function findMatch(input, depth=0) {
  // returns an array of arrays where:
  //    solutions[i].join("") == input
  //    solutions[i][j] is a string from `base`
  // (empty array if no such solutions exist)
  let solutions = [];
  base.forEach((prefix) => {
    if (!input.startsWith(prefix)) return;
    let rest = input.substr(prefix.length);
    
    if (rest.length === 0) {
      // easy case: the input has a 'perfect match' in `base`
      console.log(" ".repeat(depth) + `checking '${prefix}' - matching complete!`)
      solutions.push([prefix]);
    } else {
      // we found a matching prefix. It will be a valid solution iff
      // the rest of input can be constructed from the strings in `base`
      console.log(" ".repeat(depth) + `checking '${prefix}' (rest='${rest}')`)
      let subSolutions = findMatch(rest, depth+1);
      solutions = solutions.concat(subSolutions.map((sol) => [prefix].concat(sol)));
    }
  });
  return solutions;
}

findMatch(userCreated + ";").map((parts) => parts.map(removeSemicolon));

请注意，您没有指定输入字符串中是否允许重复条目，我没有尝试对此进行优化，并且我使用的是 JS 较新版本中的一些语法，这可能不被普遍支持所有浏览器。