当前位置：首页 > JavaScript

js实现匹配

2026-02-02 06:16:36JavaScript

实现字符串匹配的方法

在JavaScript中，字符串匹配可以通过多种方式实现，包括正则表达式、字符串方法以及算法实现。以下是几种常见的方法：

使用正则表达式

正则表达式是字符串匹配的强大工具，可以用于复杂的模式匹配。

const str = "Hello, world!";
const pattern = /world/;
const result = pattern.test(str); // 返回true

使用match方法可以获取匹配的详细信息：

const matches = str.match(pattern);
console.log(matches[0]); // 输出 "world"

使用字符串方法

JavaScript提供了几个内置的字符串方法用于简单的匹配：

includes(): 检查字符串是否包含指定的子字符串
```
const hasWorld = str.includes("world"); // true
```
indexOf(): 返回子字符串首次出现的位置
```
const position = str.indexOf("world"); // 7
```

startsWith()和endsWith(): 检查字符串是否以特定子字符串开始或结束

const startsWithHello = str.startsWith("Hello"); // true
const endsWithWorld = str.endsWith("world!"); // true

实现字符串搜索算法

对于更高级的匹配需求，可以手动实现字符串搜索算法：

朴素字符串搜索算法

function naiveSearch(text, pattern) {
    let count = 0;
    for (let i = 0; i < text.length; i++) {
        for (let j = 0; j < pattern.length; j++) {
            if (pattern[j] !== text[i + j]) break;
            if (j === pattern.length - 1) count++;
        }
    }
    return count;
}

KMP算法

function computeLPSArray(pattern) {
    const lps = new Array(pattern.length).fill(0);
    let len = 0;
    let i = 1;
    while (i < pattern.length) {
        if (pattern[i] === pattern[len]) {
            len++;
            lps[i] = len;
            i++;
        } else {
            if (len !== 0) len = lps[len - 1];
            else {
                lps[i] = 0;
                i++;
            }
        }
    }
    return lps;
}

function KMPSearch(text, pattern) {
    const lps = computeLPSArray(pattern);
    let i = 0, j = 0;
    while (i < text.length) {
        if (pattern[j] === text[i]) {
            i++;
            j++;
        }
        if (j === pattern.length) {
            console.log("Found pattern at index " + (i - j));
            j = lps[j - 1];
        } else if (i < text.length && pattern[j] !== text[i]) {
            if (j !== 0) j = lps[j - 1];
            else i++;
        }
    }
}

模糊匹配实现

对于模糊匹配（如近似字符串匹配），可以使用Levenshtein距离算法：

function levenshteinDistance(a, b) {
    const matrix = [];
    for (let i = 0; i <= b.length; i++) {
        matrix[i] = [i];
    }
    for (let j = 0; j <= a.length; j++) {
        matrix[0][j] = j;
    }
    for (let i = 1; i <= b.length; i++) {
        for (let j = 1; j <= a.length; j++) {
            if (b.charAt(i - 1) === a.charAt(j - 1)) {
                matrix[i][j] = matrix[i - 1][j - 1];
            } else {
                matrix[i][j] = Math.min(
                    matrix[i - 1][j - 1] + 1,
                    matrix[i][j - 1] + 1,
                    matrix[i - 1][j] + 1
                );
            }
        }
    }
    return matrix[b.length][a.length];
}