本文旨在探讨在JavaScript中如何灵活地检查一个数字的组成数字（或数字序列）是否存在于另一个数字中，特别是在传统`includes()`方法和简单正则表达式无法满足需求时。我们将通过动态正则表达式和数组高阶函数，提供两种主要解决方案：一种用于顺序无关的数字集合匹配，另一种用于顺序相关的数字序列匹配，并进一步展示如何扩展到检查整个数组的匹配情况。
在JavaScript开发中，我们有时会遇到一个特殊的需求：判断一个数字（例如 789）的构成数字是否“存在”于另一个更长的数字（例如 7189）中。这里的“存在”可能意味着 789 的所有数字（7、8、9）都可以在 7189 中找到，无论它们的顺序如何；也可能意味着这些数字必须以特定的顺序出现。传统的 Array.prototype.includes() 方法仅适用于精确的值匹配，而简单的正则表达式如 /(123)|(456)|(789)/g 只能匹配连续的子字符串，无法满足这种灵活的数字拆解与匹配需求。
1. 问题背景与传统方法的局限性
考虑以下场景： 我们有一个“获胜数字”数组 winArray = [123, 456, 789]，以及一个用户输入的数字 mergeUserArray = [7189]。我们希望判断 mergeUserArray 中的数字是否包含了 winArray 中某个数字的所有组成部分。
let winArray = [123, 456, 789];
let mergeUserArray = [7189]; // 期望匹配 789
// 传统 includes() 方法无法满足需求
if (winArray.includes(Number(mergeUserArray))) {
console.log("Number matched"); // 不会匹配，因为 7189 不等于 789
} else {
console.log("Number not matched"); // 输出 "Number not matched"
}
// 简单正则表达式也无法匹配非连续的数字
let regxWinArray = /(123)|(456)|(789)/g;
// '7189'.match(regxWinArray) 将返回 null在这种情况下，我们需要一种更精细的匹配策略。
2. 解决方案一：检查数字集合是否存在（顺序无关）
此方法用于判断 winArray 中的某个数字（item）的所有组成数字是否都存在于 mergeUserArray 中的某个数字（what）中，而不关心它们的排列顺序。
立即学习“Java免费学习笔记（深入）”；
核心思路：
- 将数字转换为字符串，以便进行字符级别的操作。
- 为 winArray 中的每个 item，创建一个动态正则表达式 new RegExp([${item}], 'g')。这个正则表达式会匹配 item 字符串中包含的任何一个字符。例如，如果 item 是 789，则正则表达式是 /[789]/g，它会匹配 '7'、'8' 或 '9'。
- 使用 what.toString().match(regex) 找出 what 中所有符合 regex 的字符。
- 比较匹配到的字符数组的长度与 item 字符串的长度。如果长度相等，则表示 item 的所有组成数字都已在 what 中找到。
- 使用 Array.prototype.some() 方法来检查 winArray 或 mergeUserArray 中是否存在至少一个匹配项。
示例代码：
你接手一个需求时，是不是经常这样："改一个小字段 → 结果把不相关的代码也改了"、"需求说得很模糊 → 做着做着发现跑偏了"、"数据库加个字段 → 上线才发现漏了数据兼容"、"做了个新功能 → 一个月后自己都忘了当时怎么设计的"、"写到一半被中断 → 再回来不知道从哪继续"；这个 Skill 就是专门解决这些问题的。 它会自动探测你的项目环境（JDK、Spring Boot、ORM、数据库、前端框架），记在
let winArray = [123, 456, 789];
let mergeUserArray = [7189]; // 期望匹配 789
let matchFound = winArray.some(item => { // 遍历 winArray 中的每个获胜数字
return mergeUserArray.some(what => { // 遍历 mergeUserArray 中的每个用户数字
const regex = new RegExp(`[${item}]`, 'g'); // 创建动态正则表达式，匹配 item 的任一数字
// 尝试匹配 what 的字符串形式，并检查匹配到的字符数量是否等于 item 的字符数量
// 例如：item = 789, what = 7189
// regex = /[789]/g
// '7189'.match(regex) 会得到 ['7', '8', '9']
// 其长度为 3，与 '789'.length 相等，因此匹配成功
return what.toString().match(regex)?.length === item.toString().length;
});
});
console.log("顺序无关匹配结果:", matchFound); // 输出: 顺序无关匹配结果: true3. 解决方案二：检查数字序列是否存在（顺序相关）
此方法在顺序无关的基础上，进一步要求 winArray 中的数字 item 的所有组成数字在 mergeUserArray 中的数字 what 中出现时，它们的相对顺序也必须与 item 相同，并且这些被匹配到的数字拼接后能形成 item。
核心思路：
- 与方法一相同，创建动态正则表达式 new RegExp([${item}], 'g')。
- 使用 what.toString().match(regex) 找出 what 中所有符合 regex 的字符。
- 将匹配到的字符数组使用 join('') 拼接成字符串。
- 比较拼接后的字符串是否与 item 的字符串形式完全相等。
示例代码：
let winArray = [123, 456, 789];
const hasMatchStrict = mergeUserArray => winArray.some(item => {
return mergeUserArray.some(what => {
const regex = new RegExp(`[${item}]`, 'g'); // 匹配 item 的任一数字
// 匹配 what 的字符串形式，并将匹配到的字符拼接
// 例如：item = 789, what = 7189
// '7189'.match(/[789]/g) 得到 ['7', '8', '9']
// ['7', '8', '9'].join('') 得到 '789'
// '789' === '789' 为 true，匹配成功
// 例如：item = 189, what = 1987
// '1987'.match(/[189]/g) 得到 ['1', '9', '8']
// ['1', '9', '8'].join('') 得到 '198'
// '198' === '189' 为 false，不匹配
return what.toString().match(regex)?.join('') === item.toString();
});
});
console.log("严格顺序匹配 [7189]:", hasMatchStrict([7189])); // 输出: 严格顺序匹配 [7189]: true
console.log("严格顺序匹配 [1897]:", hasMatchStrict([1897])); // 输出: 严格顺序匹配 [1897]: false (因为 1897 中没有 189 的顺序)
console.log("严格顺序匹配 [12345]:", hasMatchStrict([12345])); // 输出: 严格顺序匹配 [12345]: true (因为 12345 中有 123 的顺序)4. 扩展：检查 mergeUserArray 中所有值是否匹配
如果我们需要确保 mergeUserArray 中的 所有 数字都能在 winArray 中找到至少一个符合条件的匹配项，我们可以结合 Array.prototype.every() 方法。
核心思路： 使用 every() 遍历 mergeUserArray，确保每个元素都能通过 winArray.some(...) 找到一个匹配。这里我们沿用方法一（顺序无关）的匹配逻辑。
示例代码：
let winArray = [123, 456, 789];
let mergeUserArrayAll = [7189, 654]; // 期望 7189 匹配 789，654 匹配 456
let allMatched = mergeUserArrayAll.every(what => { // 遍历 mergeUserArrayAll 中的每个用户数字
return winArray.some(item => { // 检查它是否能在 winArray 中找到一个匹配
const regex = new RegExp(`[${item}]`, 'g');
return what.toString().match(regex)?.length === item.toString().length;
});
});
console.log("所有用户数字是否都找到匹配 (顺序无关):", allMatched); // 输出: 所有用户数字是否都找到匹配 (顺序无关): true
let mergeUserArrayPartial = [7189, 100]; // 100 无法匹配 winArray 中的任何数字
let allMatchedPartial = mergeUserArrayPartial.every(what => {
return winArray.some(item => {
const regex = new RegExp(`[${item}]`, 'g');
return what.toString().match(regex)?.length === item.toString().length;
});
});
console.log("所有用户数字是否都找到匹配 (部分匹配):", allMatchedPartial); // 输出: 所有用户数字是否都找到匹配 (部分匹配): false5. 注意事项与总结
- 数据类型转换： 在进行正则表达式匹配之前，务必将数字转换为字符串 (.toString())。这是因为正则表达式是针对字符串进行操作的。
- 动态正则表达式： 使用 new RegExp(pattern, flags) 构造函数可以根据变量动态创建正则表达式，这在处理可变匹配模式时非常有用。
- 全局匹配 g 标志： 在正则表达式中使用 g (global) 标志非常重要，它确保 match() 方法能找到所有匹配项，而不仅仅是第一个。
- 可选链操作符 ?.： match() 方法在没有找到任何匹配时会返回 null。使用可选链操作符 ?. 可以安全地访问其属性（如 length 或 join('')），避免在 null 上调用方法导致错误。
-
some() 与 every()：
- some()：只要数组中有一个元素满足条件，就返回 true。适用于“是否存在至少一个匹配”的场景。
- every()：只有数组中所有元素都满足条件，才返回 true。适用于“是否所有元素都匹配”的场景。
-
匹配逻辑的理解：
- what.toString().match(regex)?.length === item.toString().length 检查的是 item 中的 所有数字 是否都在 what 中出现，不考虑顺序。它本质上是比较两个数字的 字符集合 是否相等。
- what.toString().match(regex)?.join('') === item.toString() 检查的是 item 中的 所有数字 是否都在 what 中出现，并且它们在 what 中的 相对顺序 拼接起来后与 item 完全一致。
通过上述方法，我们可以灵活地处理数字集合或序列的匹配需求，超越了简单 includes() 和固定正则表达式的局限性，使得代码在处理此类业务逻辑时更加健壮和高效。选择哪种匹配逻辑取决于具体的业务需求：是只关心数字的存在性（顺序无关），还是也关心它们的排列顺序。
