Javascript 动态创建RegExps组以匹配小于或大于所需值的模式

我制作了两个

JavaScript

函数来动态创建

regexp

组，这些组匹配的数字小于或大于参数中发送的数字。这些函数的目的是做一些类似或但动态的事情，我需要它用于构建

RegExps

的应用程序，此代码生成一个与特定数字组匹配的组，稍后您可以使用返回的组来完成最终的

RegExp

以下是创建

RegExp

以查找大于所需值的模式的函数：

//Find greater than numbers
function getGreaterUintRegEx(n) {
  var s = String(n);
  var t = s.length,
    a = [];
  for (var i = 1; i < t + 1; i++) {
    switch (s.charAt(t - i)) {
      case "9":
        a.push((Number(s.slice(0, t - i)) + 1) + "0" + (new Array(i)).join("\\d"));
        break;
      case "8":
        a.push(s.slice(0, t - i) + "9" + (new Array(i)).join("\\d"));
        break;
      default:
        a.push(s.slice(0, t - i) + "[" + (Number(s.charAt(t - i)) + 1) + "-9]" + (new Array(i)).join("\\d"));
    }
  }
  a.push("\\d{" + (t + 1) + ",}");
  a = a.filter(function(s, i) {
    return a.indexOf(s) == i;
  });
  return "(" + a.join("|") + ")";
}

//Find lower than numbers
function getLowerUintRegEx(n) {
  if (n == 0) return false;
  if (n == 1) return "(0)";
  if (n > 0 && n < 10) return "[0-" + (n - 1) + "]";
  var s = String(n);
  var t = s.length,
    a = [];
  for (var i = 1; i < t + 1; i++) {
    switch (s.charAt(t - i)) {
      case "0":
        a.push(((s.slice(0, t - i) == "1") ? "" : (Number(s.slice(0, t - i)) - 1)) + "9" + (new Array(i)).join("\\d"));
        break;
      case "1":
        a.push("[1-9]" + (new Array(i - 1)).join("\\d"));
        break;
      default:
        a.push(s.slice(0, t - i) + "[0-" + (Number(s.charAt(t - i)) - 1) + "]" + (new Array(i)).join("\\d"));
    }
  }
  if (t - 1 > 1) a.push("\\d{1," + (t - 1) + "}");
  a.push("0");
  a = a.filter(function(s, i) {
    return a.indexOf(s) == i;
  });
  return "(" + a.join("|") + ")";
}

下面是创建

RegExp

以查找低于所需值的模式的函数：

//Find greater than numbers
function getGreaterUintRegEx(n) {
  var s = String(n);
  var t = s.length,
    a = [];
  for (var i = 1; i < t + 1; i++) {
    switch (s.charAt(t - i)) {
      case "9":
        a.push((Number(s.slice(0, t - i)) + 1) + "0" + (new Array(i)).join("\\d"));
        break;
      case "8":
        a.push(s.slice(0, t - i) + "9" + (new Array(i)).join("\\d"));
        break;
      default:
        a.push(s.slice(0, t - i) + "[" + (Number(s.charAt(t - i)) + 1) + "-9]" + (new Array(i)).join("\\d"));
    }
  }
  a.push("\\d{" + (t + 1) + ",}");
  a = a.filter(function(s, i) {
    return a.indexOf(s) == i;
  });
  return "(" + a.join("|") + ")";
}

//Find lower than numbers
function getLowerUintRegEx(n) {
  if (n == 0) return false;
  if (n == 1) return "(0)";
  if (n > 0 && n < 10) return "[0-" + (n - 1) + "]";
  var s = String(n);
  var t = s.length,
    a = [];
  for (var i = 1; i < t + 1; i++) {
    switch (s.charAt(t - i)) {
      case "0":
        a.push(((s.slice(0, t - i) == "1") ? "" : (Number(s.slice(0, t - i)) - 1)) + "9" + (new Array(i)).join("\\d"));
        break;
      case "1":
        a.push("[1-9]" + (new Array(i - 1)).join("\\d"));
        break;
      default:
        a.push(s.slice(0, t - i) + "[0-" + (Number(s.charAt(t - i)) - 1) + "]" + (new Array(i)).join("\\d"));
    }
  }
  if (t - 1 > 1) a.push("\\d{1," + (t - 1) + "}");
  a.push("0");
  a = a.filter(function(s, i) {
    return a.indexOf(s) == i;
  });
  return "(" + a.join("|") + ")";
}

---

我想让这些功能更简单，速度也更慢。使用大数字需要一秒钟以上的时间。还有其他更简单的方法吗？有人知道一个步骤少的稳健算法吗？

你的方法很复杂。而且是有限的

function getInts(str){
    return String(str).match(/[+-]?\d+/g).map(Number);
}
function greaterThan(w){
    return function(v){ return v > w } 
}
function lowerThan(w){ //
    return function(v){ return v < w } 
}

getInts(someString).filter( greaterThan(473) )

函数getInts（str）{ 返回字符串（str）.match（/[+-]？\d+/g）.map（Number）； } 大于（w）的函数{ 返回函数（v）{return v>w} } 函数lowerThan（w）{// 返回函数（v）{return v 或者更通用的方法：

var is = (function(is){
    for(var key in is) is[key] = Function("w", "return function(v){return v " + is[key] + " w}");
    return is;
})({
    eq: "===",
    neq: "!==",
    gt: ">",
    lt: "<",
    gteq: ">=",
    lteq: "<="
});
is.typeof = function(w){ return function(v){ return typeof v === w }};

getInts(someString).filter( is.lt(92) );

var is=（函数（is）{
对于（is中的var key）is[key]=函数（“w”，“返回函数（v）{return v”+is[key]+“w}”）；
回报是；
})({
等式：“=”，
neq:“！==”，
gt:“>”，
lt:“=”，
lteq:“这不是我解决问题的方法，但您并不是在寻找更好的解决方案，而是希望对您的代码、建议和优化进行审查，以提供与原始代码相同的功能（即工作代码）

无论如何，下面是一个建议。代码更具可读性，我无意测试它的性能


var reduceRight=Function.prototype.call.bind（Array.prototype.reduceRight）；
//查找大于数字的值
函数getgreateruintreex（n）{
var s=字符串（n）；
var t=s.长度-1；
var a=减速器右侧（s，功能（acc，v，i）{
var x=s.切片（0，i）；
如果（v=='9'）{
x=数字（x）+1+'0'；
}else if（v=='8'）{
x+='9'；
}否则{
x+='['+（数字（v）+1）+'-9]；
}
acc.push（x+'\\d'.重复（t-i））；
返回acc；
}, []);
a、 推送（'\\d{'+（t+2）+'，}'）；
返回“（”+a.join（“|”）+”）”；
}
//查找大于的数字：原始
函数getgreateruintreex1（n）{
var s=字符串（n）；
var t=s.长度，
a=[]；
对于（变量i=1；i

只需删除不必要的数据结构（每次调用都会创建几个
数组和一个
函数，不需要任何函数），就可以大大提高速度

下面是对getGreaterUintRegEx的重写：

function getGreaterUintRegEx(n) {
  var nStr = String(n);
  var len = nStr.length;
  var result = '(';
  var ds = '';
  var i;

  for (i = len - 1; i >= 0; i--) {
    switch (nStr.charAt(i)) {
      case '9': result += `${+nStr.slice(0, i) + 1}0${ds}|`; break;
      case '8': result += `${nStr.slice(0, i)}9${ds}|`; break;
      default:  result += `${nStr.slice(0, i)}[${+nStr.charAt(i) + 1}-9]${ds}|`;
    }
    ds += '\\d';
  }
  return `${result}\\d{${len + 1},})`;
}

我使用ES6模板字符串只是为了可读性。目前evergreen浏览器都支持这些字符串，但如果您想支持IE11，您需要将它们替换为旧的
'+'
。
有什么理由使用RegExp而不是简单地拆分字符串并转换为数字？字符串可以是那个或任何其他文本（该字符串只是一个示例），
RegExp
可以在任何类型的文本中查找模式。因此该字符串可以是
d131dd02c5e6eec4 693d9a0698aff95c 2fcab58712467eab 4004583eb8fb7f89
，如果是
getLowerInTregex（500），您会期望得到什么结果
？@Xotic750当您将500作为参数传递时，函数总是返回相同的值，它只创建如下字符串（499 | 49\d |[0-4]\d\d | \d{1,2}| 0）。此
字符串
与0-499之间的数字匹配。您发布的
字符串
可以作为示例，具体取决于情况和我要提取的匹配项，方法将是一种或另一种。例如，如果我要提取所有整数（边上没有数字）小于500的
字符串
我可以做到这一点：例如，对于前导为零的数字字符串
06
，或者像
54.1
或
0.21
这样的浮点数字符串，你会有什么期望呢？我对你的规格非常不确定。请阅读我的帖子。我不想搜索单个数字模式（这不是我的意图），我想得到一个
RegExp
来向用户显示它，然后这个
RegExp
组可以用来符合一个更复杂的表达式。我知道这很复杂，我正在寻找一种不太复杂的方法来从所需的数字中得到一个
RegExp
组。
这不是我解决问题的方法如果你有更好的解决办法，请给我（我在问题中要求过）。我从来没有说过我不想要另一个解决方案，我只是说我需要一个
RegExp
组，而不是一个替换函数，因为我的应用程序需要一个
RegExp
，如果结果是
RegExp
组的文本表示形式匹配一个小于或大于另一个的数字，那么任何解决方案都将是w