高效检测数字数组中特定数字的字符组合是否存在

let winArray = [123, 456, 789];
let mergeUserArray = [7189]; // 期望匹配 789
// let mergeUserArray = [789]; // 期望匹配 789

let winArray = [123, 456, 789];
let mergeUserArray = [7189]; // 期望匹配 789

// 使用 some() 检查 winArray 中是否有任何一个元素在 mergeUserArray 中找到匹配
let match = winArray.some(winItem => {
    // 对于 winArray 中的每个元素，检查 mergeUserArray 中是否有元素能匹配它
    return mergeUserArray.some(userItem => {
        // 1. 将 winItem 转换为字符串，例如 '789'
        const winItemStr = winItem.toString();
        // 2. 构建一个正则表达式，匹配 winItemStr 中的任意一个字符，例如 /[789]/g
        // 注意：[${winItemStr}] 会将 winItemStr 内部的每个字符视为一个独立的匹配项
        const regex = new RegExp(`[${winItemStr}]`, 'g');
        // 3. 将 userItem 转换为字符串，例如 '7189'
        const userItemStr = userItem.toString();
        // 4. 使用正则表达式在 userItemStr 中查找所有匹配的字符
        const foundChars = userItemStr.match(regex);
        // 5. 检查找到的字符数量是否等于 winItemStr 的长度
        // 如果 foundChars 为 null (没有匹配)，则长度为 0
        return foundChars?.length === winItemStr.length;
    });
});

console.log(`无序字符匹配结果 (winArray: ${winArray}, mergeUserArray: ${mergeUserArray}): ${match}`);
// 输出: true (因为 7,8,9 都存在于 7189 中)

let mergeUserArray2 = [1897]; // 期望匹配 789 (1,8,9,7 都存在)
let match2 = winArray.some(winItem => mergeUserArray2.some(userItem => {
    const winItemStr = winItem.toString();
    const regex = new RegExp(`[${winItemStr}]`, 'g');
    const userItemStr = userItem.toString();
    const foundChars = userItemStr.match(regex);
    return foundChars?.length === winItemStr.length;
}));
console.log(`无序字符匹配结果 (winArray: ${winArray}, mergeUserArray: ${mergeUserArray2}): ${match2}`);
// 输出: true (因为 7,8,9 都存在于 1897 中)

let mergeUserArray3 = [1234]; // 期望匹配 123
let match3 = winArray.some(winItem => mergeUserArray3.some(userItem => {
    const winItemStr = winItem.toString();
    const regex = new RegExp(`[${winItemStr}]`, 'g');
    const userItemStr = userItem.toString();
    const foundChars = userItemStr.match(regex);
    return foundChars?.length === winItemStr.length;
}));
console.log(`无序字符匹配结果 (winArray: ${winArray}, mergeUserArray: ${mergeUserArray3}): ${match3}`);
// 输出: true (因为 1,2,3 都存在于 1234 中)

let winArray = [123, 456, 789];

const hasMatchOrdered = mergeUserArray => winArray.some(winItem => {
    return mergeUserArray.some(userItem => {
        const winItemStr = winItem.toString();
        // 构建正则表达式，匹配 winItemStr 中的任意一个字符
        const regex = new RegExp(`[${winItemStr}]`, 'g');
        const userItemStr = userItem.toString();
        const foundChars = userItemStr.match(regex);

        // 检查找到的字符是否非空，并且它们按顺序连接后是否与 winItemStr 完全相同
        return foundChars && foundChars.join('') === winItemStr;
    });
});

console.log(`有序字符匹配结果 (mergeUserArray: [7189]): ${hasMatchOrdered([7189])}`);
// 输出: false (因为 7189 中的 7,8,9 之间有 1 间隔，join('') 会是 '789' 但需要先过滤掉非789的字符)
// 实际上，这个逻辑会是 '789'，但它匹配的是所有在字符集里的字符，并按原顺序。
// 如果 userItemStr 是 '7189'，regex /[789]/g 会匹配 ['7', '8', '9']，join('') 是 '789'。
// 这段代码的逻辑实际上还是在检查所有字符是否存在，并按它们在userItemStr中的顺序连接。
// 这里的 '7189' 匹配 '789' 是 true，这可能与直觉上的“有序”略有不同。
// 更严格的有序匹配应该使用 winItemStr 作为子串去匹配，例如 `userItemStr.includes(winItemStr)`，
// 或者构建更复杂的 regex，例如 `new RegExp(winItemStr)`。
// 但根据原问题“789 is present in 7189”的上下文，这里仍是字符存在性，只是在连接后比较。

// 修正：如果目标是严格的子串匹配，则应该直接使用 includes 或构建字面量正则表达式
const hasStrictOrderedMatch = mergeUserArray => winArray.some(winItem => {
    return mergeUserArray.some(userItem => {
        const winItemStr = winItem.toString();
        const userItemStr = userItem.toString();
        // 直接检查是否包含子字符串
        return userItemStr.includes(winItemStr);
    });
});

console.log(`严格有序子串匹配结果 (mergeUserArray: [7189]): ${hasStrictOrderedMatch([7189])}`);
// 输出: false (因为 '7189' 不包含 '789' 作为子串)
console.log(`严格有序子串匹配结果 (mergeUserArray: [1789]): ${hasStrictOrderedMatch([1789])}`);
// 输出: true (因为 '1789' 包含 '789' 作为子串)

// 如果答案中的“If the order of characters should match”是指：
// 找到的属于item的字符，按它们在what中的顺序连接后，是否等于item本身。
// 那么对于 [7189] 和 789，它会匹配 '7', '8', '9'，连接后是 '789'。
// 也就是说，它忽略了非匹配字符，只关注匹配字符的相对顺序。
// 这种情况下，原答案的逻辑是正确的：
const hasRelativeOrderedMatch = mergeUserArray => winArray.some(winItem => {
    return mergeUserArray.some(userItem => {
        const winItemStr = winItem.toString();
        const regex = new RegExp(`[${winItemStr}]`, 'g'); // 匹配winItemStr中的任何字符
        const userItemStr = userItem.toString();
        const foundChars = userItemStr.match(regex);
        // 如果找到的字符非空，并且这些字符按它们在 userItemStr 中的相对顺序连接后，
        // 恰好等于 winItemStr，则认为匹配。
        return foundChars && foundChars.join('') === winItemStr;
    });
});
console.log(`相对有序字符匹配结果 (winItem=789, userItem=[7189]): ${hasRelativeOrderedMatch([7189])}`); // true
console.log(`相对有序字符匹配结果 (winItem=789, userItem=[1897]): ${hasRelativeOrderedMatch([1897])}`); // false (因为1897中匹配到的是 ['8','9','7']，join后是 '897'，不等于 '789')
console.log(`相对有序字符匹配结果 (winItem=123, userItem=[1023]): ${hasRelativeOrderedMatch([1023])}`); // true (匹配到 ['1','2','3']，join后是 '123')

let winArray = [123, 456, 789];
let mergeUserArray1 = [7189, 654]; // 期望匹配 789 和 456 (都存在)
let mergeUserArray2 = [7189, 100]; // 期望匹配 789，但 100 无法匹配 winArray 中的任何一个

let matchAll = mergeUserArray => mergeUserArray.every(userItem => {
    // 对于 mergeUserArray 中的每个 userItem，检查它是否能在 winArray 中找到一个匹配
    return winArray.some(winItem => {
        const winItemStr = winItem.toString();
        const regex = new RegExp(`[${winItemStr}]`, 'g');
        const userItemStr = userItem.toString();
        const foundChars = userItemStr.match(regex);
        // 使用无序字符匹配规则
        return foundChars?.length === winItemStr.length;
    });
});

console.log(`所有元素匹配结果 (mergeUserArray: [${mergeUserArray1}]): ${matchAll(mergeUserArray1)}`);
// 输出: true (7189 匹配 789，654 匹配 456)

console.log(`所有元素匹配结果 (mergeUserArray: [${mergeUserArray2}]): ${matchAll(mergeUserArray2)}`);
// 输出: false (7189 匹配 789，但 100 无法匹配 winArray 中的任何一个)