J*aScript 中高效检查数字集合或序列是否存在于另一个数字中

新闻中心 NEWS CENTER

您当前位置：首页 > 新闻中心 > 网络学院

J*aScript 中高效检查数字集合或序列是否存在于另一个数字中

2025-12-12

浏览次数：次

返回列表

javascript 中高效检查数字集合或序列是否存在于另一个数字中

本文旨在探讨在J*aScript中如何灵活地检查一个数字的组成数字（或数字序列）是否存在于另一个数字中，特别是在传统`includes()`方法和简单正则表达式无法满足需求时。我们将通过动态正则表达式和数组高阶函数，提供两种主要解决方案：一种用于顺序无关的数字集合匹配，另一种用于顺序相关的数字序列匹配，并进一步展示如何扩展到检查整个数组的匹配情况。

在J*aScript开发中，我们有时会遇到一个特殊的需求：判断一个数字（例如 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）中，而不关心它们的排列顺序。

核心思路：

将数字转换为字符串，以便进行字符级别的操作。
为 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 中是否存在至少一个匹配项。

示例代码：

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); // 输出: 顺序无关匹配结果: true

3. 解决方案二：检查数字序列是否存在（顺序相关）

此方法在顺序无关的基础上，进一步要求 winArray 中的数字 item 的所有组成数字在 mergeUserArray 中的数字 what 中出现时，它们的相对顺序也必须与 item 相同，并且这些被匹配到的数字拼接后能形成 item。

Ghiblio

专业AI吉卜力风格转换平台，将生活照变身吉卜力风格照

157 查看详情 Ghiblio

核心思路：

与方法一相同，创建动态正则表达式 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); // 输出: 所有用户数字是否都找到匹配 (部分匹配): false

5. 注意事项与总结

数据类型转换： 在进行正则表达式匹配之前，务必将数字转换为字符串 (.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 完全一致。