JavaScript中如何用正则表达式移除结尾数字大于变量的单词？

Let's break down how to build a regex that dynamically targets words ending with numbers larger than your specified variable x, working seamlessly for both single and double-digit values of x.

Step-by-Step Implementation #

We'll construct the regex pattern dynamically based on x, focusing on two critical cases:

1. Numbers with more digits than x (these are always larger)
2. Numbers with the same number of digits as x but a greater value

Here's the complete, tested code with explanations:

let str = "selection1 selection2 selection3 selection4 selection29 selection30 selection100";
let x = 29; // Try changing this to 2, 5, 9, 15, etc.
const xStr = x.toString();
const digitCount = xStr.length;

let sameDigitPattern = '';

// Handle single-digit x
if (digitCount === 1) {
  if (x < 9) {
    // Match single digits greater than x (e.g., x=2 → [3-9])
    sameDigitPattern = `[${x + 1}-9]`;
  }
  // If x=9, no single-digit numbers are larger, so pattern stays empty
} 
// Handle double-digit x
else if (digitCount === 2) {
  const tensDigit = parseInt(xStr[0], 10);
  const unitsDigit = parseInt(xStr[1], 10);
  const patternParts = [];

  // Match double-digit numbers where tens digit > x's tens digit (e.g., x=29 → [3-9]\d)
  if (tensDigit < 9) {
    patternParts.push(`[${tensDigit + 1}-9]\\d`);
  }

  // Match double-digit numbers where tens digit equals x's, but units digit > x's (e.g., x=15 → 1[6-9])
  if (unitsDigit < 9) {
    patternParts.push(`${tensDigit}[${unitsDigit + 1}-9]`);
  }

  sameDigitPattern = patternParts.join('|');
}

// Match numbers with more digits than x (e.g., x=29 → \d{3,})
const longerDigitPattern = `\\d{${digitCount + 1},}`;

// Combine all parts: optional leading space + "selection" + number pattern
const fullPattern = `(?:\\s)?selection(?:${sameDigitPattern}${sameDigitPattern && longerDigitPattern ? '|' : ''}${longerDigitPattern})`;
const regExp = new RegExp(fullPattern, 'gi');

const filtered = str.replace(regExp, "");
console.log(filtered);

Key Details #

• (?:\s)?: Matches an optional leading space to remove both the target word and its preceding space, avoiding leftover gaps in the final string.
• Dynamic pattern building: Adjusts automatically based on whether x is single or double-digit, ensuring we only target numbers larger than x.
• Non-capturing groups ((?:...)): Keep the regex efficient and avoid unnecessary capture groups that could complicate results.

Test Case Examples #

• If x=2, the output will be: selection1 selection2
• If x=29, the output will be: selection1 selection2 selection3 selection4 selection29
• If x=9, the output will be: selection1 selection2 ... selection9 (removes all words with 2+ digit trailing numbers)

内容的提问来源于stack exchange，提问作者afriedman111