js如何压缩字符串

在JavaScript中，压缩字符串的常用方法有几种，包括使用正则表达式删除空格和重复字符、基于字典的压缩算法、以及基于哈夫曼编码的压缩算法。 其中，基于字典的压缩算法（如LZW）是比较常见的一种方法。使用正则表达式删除空格和重复字符可以有效地减小字符串的长度，但可能会影响数据的完整性。哈夫曼编码是一种较为复杂但压缩效果显著的方法。

一、正则表达式删除空格和重复字符

正则表达式是一种强大的工具，可以用来匹配字符串中的特定模式。在删除空格和重复字符时，正则表达式的效率和灵活性使其成为首选。

1. 删除空格

删除空格可以显著减少字符串的长度，尤其在处理包含大量空格的文本时。

function removeSpaces(str) {
    return str.replace(/s+/g, '');
}
let originalString = "This is a test string.";
let compressedString = removeSpaces(originalString);
console.log(compressedString);  // "Thisisateststring."

2. 删除重复字符

删除重复字符也能有效地压缩字符串，但需要注意的是，这可能会影响字符串的原始信息。

function removeDuplicateChars(str) {
    return str.replace(/(.)1+/g, '$1');
}
let originalString = "aaabbbbcccccddddeee";
let compressedString = removeDuplicateChars(originalString);
console.log(compressedString);  // "abcde"

二、基于字典的压缩算法（LZW）

LZW（Lempel-Ziv-Welch）算法是基于字典的压缩算法，通过构建词典来替换重复的字符串模式，从而达到压缩的效果。

1. 实现LZW压缩

function lzwCompress(uncompressed) {
    let dictionary = {};
    let data = (uncompressed + "").split("");
    let out = [];
    let currChar;
    let phrase = data[0];
    let code = 256;
    for (let i = 1; i < data.length; i++) {
        currChar = data[i];
        if (dictionary[phrase + currChar] != null) {
            phrase += currChar;
        } else {
            out.push(phrase.length > 1 ? dictionary[phrase] : phrase.charCodeAt(0));
            dictionary[phrase + currChar] = code;
            code++;
            phrase = currChar;
        }
    }
    out.push(phrase.length > 1 ? dictionary[phrase] : phrase.charCodeAt(0));
    return out;
}
let originalString = "TOBEORNOTTOBEORTOBEORNOT";
let compressedString = lzwCompress(originalString);
console.log(compressedString);  // [84, 79, 66, 69, 79, 82, 78, 79, 84, 256, 258, 260, 265, 259, 261, 263]

2. 实现LZW解压

function lzwDecompress(compressed) {
    let dictionary = {};
    let currChar = String.fromCharCode(compressed[0]);
    let oldPhrase = currChar;
    let out = [currChar];
    let code = 256;
    let phrase;
    for (let i = 1; i < compressed.length; i++) {
        let currCode = compressed[i];
        if (currCode < 256) {
            phrase = String.fromCharCode(compressed[i]);
        } else {
            phrase = dictionary[currCode] ? dictionary[currCode] : (oldPhrase + currChar);
        }
        out.push(phrase);
        currChar = phrase.charAt(0);
        dictionary[code] = oldPhrase + currChar;
        code++;
        oldPhrase = phrase;
    }
    return out.join("");
}
let compressedData = [84, 79, 66, 69, 79, 82, 78, 79, 84, 256, 258, 260, 265, 259, 261, 263];
let decompressedString = lzwDecompress(compressedData);
console.log(decompressedString);  // "TOBEORNOTTOBEORTOBEORNOT"

三、基于哈夫曼编码的压缩算法

哈夫曼编码是一种无损数据压缩算法，通过构建字符的最优二进制编码来实现压缩。

1. 构建频率表

首先，需要统计每个字符出现的频率。

function buildFrequencyTable(str) {
    let freq = {};
    for (let char of str) {
        if (freq[char]) {
            freq[char]++;
        } else {
            freq[char] = 1;
        }
    }
    return freq;
}
let originalString = "this is an example for huffman encoding";
let frequencyTable = buildFrequencyTable(originalString);
console.log(frequencyTable);

2. 构建哈夫曼树

通过频率表构建哈夫曼树，树的叶节点代表字符，路径代表编码。

class Node {
    constructor(char, freq, left = null, right = null) {
        this.char = char;
        this.freq = freq;
        this.left = left;
        this.right = right;
    }
}
function buildHuffmanTree(freqTable) {
    let nodes = Object.keys(freqTable).map(char => new Node(char, freqTable[char]));
    while (nodes.length > 1) {
        nodes.sort((a, b) => a.freq - b.freq);
        let left = nodes.shift();
        let right = nodes.shift();
        let newNode = new Node(null, left.freq + right.freq, left, right);
        nodes.push(newNode);
    }
    return nodes[0];
}
let huffmanTree = buildHuffmanTree(frequencyTable);
console.log(huffmanTree);

3. 生成哈夫曼编码表

从哈夫曼树生成字符的编码表。

function generateHuffmanCodes(node, prefix = "", codeTable = {}) {
    if (node.char !== null) {
        codeTable[node.char] = prefix;
    } else {
        generateHuffmanCodes(node.left, prefix + "0", codeTable);
        generateHuffmanCodes(node.right, prefix + "1", codeTable);
    }
    return codeTable;
}
let huffmanCodes = generateHuffmanCodes(huffmanTree);
console.log(huffmanCodes);

4. 压缩和解压字符串

使用生成的编码表对字符串进行压缩和解压。

function huffmanCompress(str, codeTable) {
    return str.split('').map(char => codeTable[char]).join('');
}
function huffmanDecompress(binaryStr, huffmanTree) {
    let node = huffmanTree;
    let result = '';
    for (let bit of binaryStr) {
        node = bit === '0' ? node.left : node.right;
        if (node.char !== null) {
            result += node.char;
            node = huffmanTree;
        }
    }
    return result;
}
let compressedString = huffmanCompress(originalString, huffmanCodes);
console.log(compressedString);
let decompressedString = huffmanDecompress(compressedString, huffmanTree);
console.log(decompressedString);

四、结论

在JavaScript中，压缩字符串的方法有多种，包括使用正则表达式删除空格和重复字符、基于字典的压缩算法（LZW）、以及基于哈夫曼编码的压缩算法。 每种方法都有其优点和应用场景。正则表达式方法简单高效，但可能影响数据完整性；LZW算法适合文本数据的压缩；哈夫曼编码则适合需要高效压缩和解压的数据。选择合适的压缩方法取决于具体需求和数据特性。在实际项目中，使用专业的项目管理系统如研发项目管理系统PingCode和通用项目协作软件Worktile可以有效地管理和协作项目，提升开发效率。