在给定更多输入的情况下确定值是否可能与正则表达式匹配

Question

我目前正在用 JavaScript 编写一个应用程序，其中将输入与正则表达式进行匹配，但我还需要找到一种将字符串与正则表达式的部分进行匹配的方法。

例如：

var invalid = "x",
    potentially = "g",
    valid = "ggg", 
    gReg = /^ggg$/;

gReg.test(invalid); //returns false (correct)
gReg.test(valid);   //returns true (correct)

现在我需要找到一种方法来确定 潜在 变量的值与 /^ggg$/ 表达式不完全匹配，但与更多输入，它可能可以！

例如，在本例中，潜在变量是g，但如果再附加两个g，它将匹配正则表达式 /^ggg$/

但在 invalid 的情况下，永远无法匹配 /^ggg$/ 表达式，无论如何您附加了许多字符。

---

那么如何确定一个字符串是否有可能匹配特定的正则表达式呢？

Answer 1

试试这个：

var str = "abcdefgh";
var len = str.length;
var reg = "";
for(var i = str.length - 1; i > 0; i--)
{
  //replace '(' with '(?:' to make it non capturing.
  reg = '(' + str[i] + reg + ')?'; 
}
reg = "^" + str[0] + reg + "$";

var regex = new RegExp(reg);

Answer 2

您只需“扭转”对此的想法，并将“潜力”转换为正则表达式，在另一个方向进行测试，例如

var invalid = "x",
    potentially = "g",
    valid = "ggg", 
    validReg = new RegExp("^"+valid+"$"),
    invalidReg = new RegExp(invalid),
    potentialReg = new RegExp(potentially);

//test actual matches
validReg.test(invalid); //returns false (correct)
validReg.test(valid);   //returns true (correct)

//test potential matches
potentialReg.test(valid); //returns true
invalidReg.test(valid);   //returns false

Answer 3

显然，下面的测试函数并不完全是您想要的......希望它能让您了解如何解决该问题。

function test(reg,string){
   var r = reg.exec(string);
     if(r){
         if(r.pop()){
             return true;
         }
         return "potentially";
     }
     return false;
}

var invalid = "x",
    potentially = "a",
    potentially2 = "ab",
    valid = "abc", 
    gReg = /^a(b(c)?)?$/;

alert(test(gReg,invalid)); //returns false (correct)
alert(test(gReg,potentially));   //returns "potentially" (correct)
alert(test(gReg,potentially2));   //returns "potentially" (correct)
alert(test(gReg,valid));   //returns true (correct)

Answer 4

没有通用的解决方案。如果正则表达式是一个简单的字符串，就像示例中的字符串（在这种情况下，使用正则表达式根本没有意义），您可以使用简单的字符串比较：

var invalid = "x",
potentially = "g",
valid = "ggg";
var gReg = "ggg";

function test(t, s) {
  if (t === s) return true;
  if (t.indexOf(s) === 0) return "potentially";
  return false;
}

test(gReg, invalid);     // false
test(gReg, potentially); // "potentially"
test(gReg, valid);       // true

否则，您可以手动构造另一个正则表达式，它接受每个的每个前缀字符串 gReg 接受。你必须使用（）？很多。

Answer 5

function have_potential(input, valid) {
    if ( (new RegExp('^' + valid + '
编辑：

缩短版本
function have_potential(input, valid) {
    return ( (new RegExp(input)).test( valid ) && !(new RegExp('^' + valid + '
编辑2：

首先，indexOf 会更好。函数需要平面字符串输入，并且“valid”可能包含由“|”分隔的列表
function have_potential(input, valid) {
    return ( valid.indexOf(input) !== -1 && !(new RegExp('^' + valid + '
)).test(input) ) return false;
    if ( (new RegExp(input)).test( valid ) ) return true;
    return false;
}

var valid = 'aaa|bbb';

console.log( have_potential('a',valid) )
// true
console.log( have_potential('c',valid) )
// false
console.log( have_potential('aaa',valid) )
// false

编辑：

缩短版本

编辑2：

首先，indexOf 会更好。函数需要平面字符串输入，并且“valid”可能包含由“|”分隔的列表

)).test(input) );
}

编辑2：

首先，indexOf 会更好。函数需要平面字符串输入，并且“valid”可能包含由“|”分隔的列表

)).test(input) ) return false;
    if ( (new RegExp(input)).test( valid ) ) return true;
    return false;
}

var valid = 'aaa|bbb';

console.log( have_potential('a',valid) )
// true
console.log( have_potential('c',valid) )
// false
console.log( have_potential('aaa',valid) )
// false

编辑：
缩短版本

编辑2：
首先，indexOf 会更好。函数需要平面字符串输入，并且“valid”可能包含由“|”分隔的列表

)).test(input) ); } )).test(input) ) return false; if ( (new RegExp(input)).test( valid ) ) return true; return false; } var valid = 'aaa|bbb'; console.log( have_potential('a',valid) ) // true console.log( have_potential('c',valid) ) // false console.log( have_potential('aaa',valid) ) // false

编辑：
缩短版本

编辑2：
首先，indexOf 会更好。函数需要平面字符串输入，并且“valid”可能包含由“|”分隔的列表

)).test(input) ); }

编辑2：
首先，indexOf 会更好。函数需要平面字符串输入，并且“valid”可能包含由“|”分隔的列表

)).test(input) ) return false; if ( (new RegExp(input)).test( valid ) ) return true; return false; } var valid = 'aaa|bbb'; console.log( have_potential('a',valid) ) // true console.log( have_potential('c',valid) ) // false console.log( have_potential('aaa',valid) ) // false

编辑：
缩短版本

编辑2：
首先，indexOf 会更好。函数需要平面字符串输入，并且“valid”可能包含由“|”分隔的列表