JavaScript正则表达式生成器

正则表达式代码

// Global extractor: captures full order id, date, and sequence in groups 1–3
const ORDER_ID_RE = /(?:(?<=\[)|(?<=")|(?<=')|(?<![\w-]))(ORD-(\d{8})-(\d{6}))(?:(?=\])|(?=")|(?=')|(?![\w-]))/g;

// Example extractor function
function extractOrders(text) {
  const results = [];
  for (const m of text.matchAll(ORDER_ID_RE)) {
    // m[1] = full order id, m[2] = date (YYYYMMDD), m[3] = sequence (6 digits)
    results.push({
      id: m[1],
      date: m[2],
      seq: m[3],
      index: m.index, // start index of the match (the order id itself)
    });
  }
  return results;
}

代码解释

• Pattern: (?:(?<=\[)|(?<=")|(?<=')|(?<![\w-]))(ORD-(\d{8})-(\d{6}))(?:(?=\])|(?=")|(?=')|(?![\w-]))
• Modifiers:
  • g (global): find all matches in the text.

Breakdown:

• Left boundary assertion (?:(?<=\[)|(?<=")|(?<=')|(?<![\w-]))
  • (?<=\[)|(?<=")|(?<='): If the ID is wrapped, assert it is immediately preceded by [, " or '.
  • (?<![\w-]): Otherwise, ensure the ID is not glued to a word character or a hyphen on its left. This avoids partial matches inside longer tokens.
• Main capture (ORD-(\d{8})-(\d{6}))
  • Group 1: ORD-YYYYMMDD-XXXXXX (the full order number).
  • Group 2: \d{8} (the date, 8 digits, no leap-year validation by design).
  • Group 3: \d{6} (the 6-digit sequence).
• Right boundary assertion (?:(?=\])|(?=")|(?=')|(?![\w-]))
  • (?=\])|(?=")|(?='): If wrapped, assert the matching closing ], " or ' immediately follows.
  • (?![\w-]): Otherwise, ensure the right neighbor is not a word character or hyphen.

Notes on wrapper handling:

• The ID may appear unwrapped, or wrapped by square brackets [...], single quotes '...', or double quotes "...".
• The wrapper characters are not part of the match due to lookarounds, so Group 1 contains only the ID.
• The lookarounds are fixed-width and efficient, and they keep capturing groups clean: only 3 groups, exactly as required.

使用示例

1. Basic extraction from a mixed log:

const log = `
INFO created: ORD-20250101-000123
DEBUG payload: "ORD-20240229-123456" processed
WARN missing id 'ORD-20231231-654321'
OK list: [ORD-20240315-000001] and also ORD-20250101-888888 end
`;

const matches = extractOrders(log);
console.log(matches);
/*
[
  { id: 'ORD-20250101-000123', date: '20250101', seq: '000123', index: 15 },
  { id: 'ORD-20240229-123456', date: '20240229', seq: '123456', index: 39 },
  { id: 'ORD-20231231-654321', date: '20231231', seq: '654321', index: 83 },
  { id: 'ORD-20240315-000001', date: '20240315', seq: '000001', index: 117 },
  { id: 'ORD-20250101-888888', date: '20250101', seq: '888888', index: 153 }
]
*/

2. Extract and normalize into a simple array of IDs:

const ids = Array.from(log.matchAll(ORDER_ID_RE), m => m[1]);
console.log(ids);
// ['ORD-20250101-000123', 'ORD-20240229-123456', 'ORD-20231231-654321', 'ORD-20240315-000001', 'ORD-20250101-888888']

3. Post-filtering by date prefix (e.g., only 2025 orders):

const only2025 = [];
for (const m of log.matchAll(ORDER_ID_RE)) {
  if (m[2].startsWith('2025')) only2025.push({ id: m[1], date: m[2], seq: m[3] });
}
console.log(only2025);
// [{ id: 'ORD-20250101-000123', date: '20250101', seq: '000123' }, { id: 'ORD-20250101-888888', date: '20250101', seq: '888888' }]

注意事项

• Lookbehind support: The pattern uses fixed-width lookbehinds (?<=/?<!). Most modern engines (Node.js 10+, recent Chrome/Edge/Firefox/Safari) support them. If you must support environments without lookbehind, use a two-pass approach:
  1. Find core IDs with /ORD-(\d{8})-(\d{6})/g,
  2. Then inspect the character before and after the match to accept plain, [...], '...', or "..." contexts.
• Wrapper symmetry: This extractor ensures the ID is properly adjacent to a closing ], ' or ", or separated from word/hyphen characters. It does not strictly enforce that the opening and closing wrappers are the same character in a single, indivisible branch. In typical logs with well-formed wrappers this is sufficient for extraction. If strict pairing is required, consider a two-pass validation (as described above) or a parser that checks both sides explicitly.
• Date validity: The date part is 8 digits as requested; it does not validate month/day ranges or leap years. If you need stricter date validation, apply an additional check after extraction.
• Case sensitivity: The regex expects uppercase ORD-. If your logs may contain lowercase or mixed-case, add the i flag and optionally verify the prefix in code.

正则表达式代码

// 路径：/users/:id/photos/:photoId?
// 要求：id 与 photoId 为数字；photoId 可选；可忽略末尾斜杠；整串匹配；依次捕获 id 与 photoId

// 推荐：使用位置捕获，确保依次捕获 id（第1组）与 photoId（第2组）
const routeRe = /^\/users\/(\d+)\/photos(?:\/(\d+))?\/?$/;

// 可选（增强可读性，同时仍保持捕获顺序 1:id, 2:photoId）
// const routeRe = /^\/users\/(?<id>\d+)\/photos(?:\/(?<photoId>\d+))?\/?$/;

function parsePath(path) {
  const match = routeRe.exec(path);
  if (!match) return null;

  // 依次捕获：match[1] 为 id，match[2] 为 photoId（可能为 undefined）
  const id = parseInt(match[1], 10);
  const photoId = match[2] !== undefined ? parseInt(match[2], 10) : null;

  return { id, photoId };
}

// 简单测试
console.log(parsePath('/users/123/photos/456')); // { id: 123, photoId: 456 }
console.log(parsePath('/users/123/photos'));     // { id: 123, photoId: null }
console.log(parsePath('/users/123/photos/456/'));// { id: 123, photoId: 456 }
console.log(parsePath('/users/123/photos/'));    // { id: 123, photoId: null }
console.log(parsePath('/users/abc/photos'));     // null

代码解释

• ^ 与 $：锚定字符串开始与结束，确保整串匹配（避免前后有多余字符）。
• /users/：匹配固定路径前缀 /users/。
• (\d+)：
  • 第1个捕获组，匹配 id，仅允许数字（1 位或更多）。
• /photos：匹配固定路径片段 /photos。
• (?:/(\d+))?：
  • 非捕获分组 (?:...)：仅用于结构化与可选性，不生成捕获组。
  • 其中的 /(\d+) 为第2个捕获组，匹配 /photoId（仅数字）。
  • 整体加 ? 表示 photoId 这一段是可选的。
• /?：末尾可选斜杠，满足“忽略末尾斜杠”的要求。
• 修饰符：无（不使用 g/i，因为需整串、区分大小写的路径匹配）。

匹配逻辑：

• 路径必须以 /users/<数字>/photos 开始。
• 可继续匹配 /<数字> 作为 photoId（可省略）。
• 路径可有也可没有末尾斜杠。
• 成功匹配时依次捕获：
  • 组1：id
  • 组2：photoId（可能为 undefined）

使用示例

• 场景1：路由中间件参数解析

  const path = '/users/987/photos/321';
  const m = routeRe.exec(path);
  if (m) {
    const id = Number(m[1]);
    const photoId = m[2] ? Number(m[2]) : null;
    // 继续执行业务逻辑
  }
  

• 场景2：统一解析函数（用于服务端或前端路由）

  function matchUserPhotoPath(path) {
    const m = routeRe.exec(path);
    if (!m) return null;
    return { id: Number(m[1]), photoId: m[2] ? Number(m[2]) : null };
  }
  
  console.log(matchUserPhotoPath('/users/42/photos'));      // { id: 42, photoId: null }
  console.log(matchUserPhotoPath('/users/42/photos/99/'));  // { id: 42, photoId: 99 }
  

• 场景3：批量校验与提取

  const paths = ['/users/1/photos', '/users/2/photos/3', '/users/abc/photos'];
  const results = paths.map(p => {
    const m = routeRe.exec(p);
    return m ? { ok: true, id: +m[1], photoId: m[2] ? +m[2] : null } : { ok: false };
  });
  console.log(results);
  // [{ok:true,id:1,photoId:null},{ok:true,id:2,photoId:3},{ok:false}]
  

注意事项

• 本正则只匹配纯路径，不包含查询字符串或哈希。例如若可能出现 /users/1/photos?x=1，请在匹配前先剥离查询/哈希部分，或扩展正则。
• 数字格式：
  • 允许前导零（如 /users/001/photos/0002）。如需禁止或限制位数，可将 \d+ 改为更严格的模式（例如 [1-9]\d* 限制不以 0 开头；或 \d{1,9} 限制长度）。
• 路径大小写敏感：/Users/ 与 /users/ 不等同。如需大小写不敏感，可在构造正则时添加 i 修饰符，但一般路由建议区分大小写。
• 性能与安全：
  • 正则已通过 ^ 与 $ 锚定，结构线性、无灾难性回溯风险，适合在线请求实时匹配。
• 若需可读性更高的命名捕获（现代环境支持），可使用命名组版本并通过 match.groups.id 与 match.groups.photoId 访问；但位置捕获依旧按顺序返回，满足“依次捕获 id 与 photoId”的要求。