Dynamically create RegExps groups to match patterns lower than or greater than a desired value

Question

I've made two JavaScript functions to dynamically create RegExps groups that match numbers lower than or greater than the number that is sent in the parameter. The purpose of these functions is to do something like this or this but dynamically, I need it for an App for building RegExps, this code made a group that match a particular group of numbers, later you could use the returned group to complete your final RegExp.

Here is the function to create a RegExp to find patterns greater than a desired value:

//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("|") + ")";
}

Example of use:

var regstr = getGreaterUintRegEx(124);
// (12[5-9]|1[3-9]\d|[2-9]\d\d|\d{4,})

var regstr = getGreaterUintRegEx(500);
// (50[1-9]|5[1-9]\d|[6-9]\d\d|\d{4,})

And here is the function to create a RegExp to find patterns lower than a desired value:

//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("|") + ")";
}

Example of use:

var regstr = getLowerUintRegEx(498);
// (49[0-7]|4[0-8]\d|[0-3]\d\d|\d{1,2}|0)

var regstr = getLowerUintRegEx(125);
// (12[0-4]|1[0-1]\d|[1-9]\d|\d{1,2}|0)

I want to make these functions more simply and less slow. It takes more than a second with big numbers. Is there any other easier method? Somebody knows a robust algorithm with less steps?

Answer 1

This is not the way that I would solve the problem, but you are not looking for a better solution but actually want a review of your code, suggestions and optimisations that give the same functionality as your original (which is working code).

Anyway, below is a suggestion. The code is more readable, I have no intention of testing its performance.

var reduceRight = Function.prototype.call.bind(Array.prototype.reduceRight);

//Find greater than numbers
function getGreaterUintRegEx(n) {
  var s = String(n);
  var t = s.length - 1;
  var a = reduceRight(s, function(acc, v, i) {
    var x = s.slice(0, i);
    if (v === '9') {
      x = Number(x) + 1 + '0';
    } else if (v === '8') {
      x += '9';
    } else {
      x += '[' + (Number(v) + 1) + '-9]';
    }
    acc.push(x + '\\d'.repeat(t - i));
    return acc;
  }, []);
  a.push('\\d{' + (t + 2) + ',}');
  return '(' + a.join('|') + ')';
}

//Find greater than numbers: original
function getGreaterUintRegEx1(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("|") + ")";
}

var out = document.getElementById('out');
for (var i = 0; i < 100000; i += 1) {
  var suggested = getGreaterUintRegEx(i);
  var original = getGreaterUintRegEx1(i);
  if (suggested !== original) {
    var txt = suggested + '!==' + original;
    out.textContent = txt;
    throw new Error(txt);
  }
}
out.textContent = suggested + '\n' + original + '\nSame results';

<script src="https://cdnjs.cloudflare.com/ajax/libs/es5-shim/4.4.1/es5-shim.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/json3/3.3.2/json3.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/es6-shim/0.34.1/es6-shim.js"></script>
<pre id="out"></pre>

Answer 2

You'll get a big speedup just by removing unnecessary data structures (each call creates several Arrays and a Function, none are needed).

Here's a rewrite of just 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},})`;
}

I've used ES6 template strings just for readability. They're currently supported across evergreen browsers, but you'll want to swap them for the old '' + '' if you want to support IE11.

Answer 3

way to complicated, your approach. And way to limited.

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) )

or the more generic approach:

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) );