正则表达式：如何匹配所有大于 954 的数字？

Question

我尝试了

^([0-9]\d|\d{4,})$

，但没有给出正确的结果。

Answer 1

我不会为此使用正则表达式，因为你会陷入丑陋的模式链中。

但是，如果仍然必须或想要使用它，您可以使用如下正则表达式：

[1-9]\d{3,}|9[6-9]\d|9[5-9]{2}

工作演示

这个正则表达式背后的想法是：

[1-9]\d{3,}   --> This will match 4 or more digit numbers
9[6-9]\d      --> This will match numbers between 960 to 999
9[5-9]{2}     --> This will match numbers between 955 to 999
                  you could write this pattern as `95[5-9]` to cover 
                  numbers from 955 to 959 if you wish (it's up to you)

Answer 2

您可以使用以下内容：

95[5-9]|9[6-9]\d|[1-9]\d{3,}

说明：

• 95[5-9]

  来自

  955-959

的比赛

• 9[6-9]\d

  来自

  960-999

的比赛

• [1-9]\d{3,}

  匹配

  > 1000

Answer 3

这是：

([1-9]\d{3,}|9[6-9]\d|95[5-9])

查看它在 regex101 上的实际操作。

还有一个漂亮的图表：

Answer 4

有点长，但设计为每个数字只有一个可能的路径（快速失败）：

^(?:
[1-8][0-9]{3,}
|
9 (?:
      [0-4][0-9]{2,}   
    |
      [6-9][0-9]+     
    |
      5 (?:
            [5-9][0-9]*
          |
            [0-4][0-9]+
        )
  )
)$

请注意，分支是按概率排序的。

浓缩：

^(?:[1-8][0-9]{3,}|9(?:[0-4][0-9]{2,}|[6-9][0-9]+|5(?:[5-9][0-9]*|[0-4][0-9]+)))$

注意：使用正则表达式模式执行此操作大多数时候是不合适且复杂的（正则表达式不是为解决算术问题而设计的）。因此，如果可以的话，将字符串转换为整数并通过简单的比较进行测试。

Answer 5

\b(?<!\.)0*(?:[1-9]\d{3,}|9(?:[6-9]\d|5[5-9]))(?:\.\d+)?\b

此行将匹配前导零和小数，但前提是整个值超过 954。因此它将匹配 955.62 和 0001253.125，但不匹配 00954.999 或 125.967。 正则表达式101

分解：

(?<!\.)

表示如果数字前面有句点则不匹配。这是为了避免匹配像 0.957 这样的东西。

e2：添加

0*

以与前导零进行完整匹配

(?:[1-9]\d{3,}|9(?:[6-9]\d|5[5-9]))

设置小数点左边所有重要内容的匹配。

[1-9]\d{3,}

匹配任何等于或大于 1000 的数字。 | 的另一边（或声明），

9(?:[6-9]\d|5[5-9])

将 900 以内的任何数字与嵌套在其中的另一个 或 相匹配。当十位和个位数字为 60-99 或 55-59 时，内部或将匹配。

(?:\.\d+)?

是匹配小数的语句。这 ？最后使它成为可选的，这样它将匹配没有小数点的数字。

e2：正则表达式被包裹在

\b

中以确保它是它自己的单词。正则表达式将不再匹配 so1337、the769s 或 960things。

EDIT1：忘记制作我的 .字面意思。

EDIT2：进行了标记为“e2：”的更改

Answer 6

我试图解析为特定查询捕获的数据库操作时间的应用程序日志文件。时间以毫秒为单位记录（例如 DatabaseTime=12035 ~ Database Time = ~12 秒）。为了进一步详细说明，我需要找到应用程序 UI 在 120 秒后超时的情况（即 DatabaseTime > 120000），以便我可以捕获同一行上的时间戳。

这是我想出的正则表达式模式：

[1-9][2-9][0-9]\d{3,}|[1-9]\d{6,}

这里的许多人都是正则表达式专家，足以在您的脑海中分解这一点，但对于那些不是的人，我已经在 regex101.com 上对此进行了测试，该网站还为您显示了正则表达式的细分：https：/ /regex101.com/r/hG2iU7/28

关于这个主题的一些想法/考虑（再次与原始问题完全相关）：

• 我觉得我采取了一种非常简约的方法，但是，它
  似乎已经满足了用例，这需要我进行搜索 使用 RegEx 搜索选项通过 NotePad ++ 中的日志进行记录。

• 我同意正则表达式不是模拟此类数字运算的解决方案 （否则最好使用正则表达式结合 编程/脚本语言）但我必须告诉你，如果你 需要在文本编辑器中快速搜索日志文件，例如 NotePad++，而您没有耐心或客户权限
  创建一些漂亮的代码或安装 Python 插件，正则表达式可能是
  你唯一的快速（而且无疑是贪婪）的选择，如果那就是
  案例中，这是一个非常有用的场景，需要了解
  工作场所。

最后，请允许我声明：在完成初步研究后，您将有足够的时间进行漂亮的编码和效率......当您甚至可能找不到您要寻找的内容时，为什么还要花时间编码呢？第一名？一点研究不会伤害任何人……每个人都知道罗马不是一天建成的。

Answer 7

我需要“整数正则表达式”以编程方式简化重复的对象关系。正如许多人所说，正则表达式用于检测字符串中的模式而不是比较整数。但是，如果您使用整数在字符串之间创建有序关系，则正则表达式将成为确定该关系的最干净的工具。 我不建议使用正则表达式来比较大量值，但这将为大多数数字生成必要的正则表达式（遇到 10^15 及更大的问题）。这又是愚蠢的不要使用正则表达式。

注意：这只适用于正整数

大于（954）

/^([9-9]([5-9][5-9]|[6-9][0-9])|[1-9][0-9]{3,})$/

小于（954）

/^([0-9]([0-5][0-3]|[0-4][0-9])|[0-8][0-9]{2}|[0-9]{0,2})$/

大于等于(1234567890)

/^([1-9][2-9][3-9][4-9][5-9][6-9][7-9][8-9][9-9][0-9]|[2-9][0-9]{9}|[1-9][0-9]{10,})$/

Javascript代码

const lessThanRegSingle = (int) => `[0-${int}]`;
const greaterThanRegSingle = (int) => `[${int}-9]`;
const lessThanFormat = (prefix, leadInt, length) => `(${prefix}|[0-${leadInt - 1}][0-9]{${length-1}}|[0-9]{0,${length-1}})`;
const greaterThanFormat = (prefix, leadInt, length) => {
  const greaterButSameLength = leadInt !== 9 ? '|[${leadInt + 1}-9][0-9]{${length-1}}' : ''
  return `(${prefix}${greaterButSameLength}|[1-9][0-9]{${length},})`;
}

const integerCompareReg = (lessThan, equalTo) => (integer, asString) => {
  lessThan = lessThan === true;
  const ints = (integer + '').split('');
  const compareFunc = lessThan ? lessThanRegSingle : greaterThanRegSingle;
  const compareOffset = lessThan ? -1 : 1;
  let offset = equalTo === true ? 0 : compareOffset;
  let leadInt;
  let reg = '';
  let endOrVals = [];
  let secondToLast;
  for (let index = 0; index < ints.length; index++) {
    const int = Number.parseInt(ints[index]);
    if (index === 0) leadInt = int;
    const str = index === ints.length - 1 ? compareFunc(int + offset) : compareFunc(int);
    if (index === ints.length - 2) secondToLast = int;
    const lastTwo = index > ints.length - 3;
    if (lastTwo && ((greaterThan && secondToLast !== 9) || (lessThan && secondToLast !== 0))) {
      endOrVals.push(str);
      const orValue = index !== ints.length - 1 ? compareFunc(int + compareOffset) : '[0-9]';
      endOrVals.push(orValue);
    } else reg += str;
  }
  if (endOrVals.length !== 0) reg = `${reg}(${endOrVals[0]}${endOrVals[2]}|${endOrVals[1]}${endOrVals[3]})`;
  reg = (lessThan ? lessThanFormat : greaterThanFormat)(reg, leadInt, ints.length);
  return asString ? reg : new RegExp(`^${reg}$`);
}

const lessThan = integerCompareReg(true, false);
const greaterThan = integerCompareReg(false, false);
const lessThanEqual = integerCompareReg(true, true);
const greaterThanEqual = integerCompareReg(false, true);

测试代码（以防万一我错过了一些边缘情况）

const test = (value, func, test) => {
  for (let index = 0; index < 2000; index++) {
    if (!test(index, `${index}`.match(func(value)))) {
      console.log('failed:', index);
      break;
    }
  }
}

test(954, lessThan, (index, result) => index < 954 ? result !== null : result === null);
test(954, lessThanEqual, (index, result) => index <= 954 ? result !== null : result === null);
test(954, greaterThan, (index, result) => index > 954 ? result !== null : result === null);
test(954, greaterThanEqual, (index, result) => index >= 954 ? result !== null : result === null);