匹配字符串中的子串？

Question

我正在尝试查找字符串中的所有子字符串。这与压缩函数中的减少非常相似。

正则表达式不支持这样的事情。

下面的代码正在运行，但是条目的数量在运行时是指数级的。 问题是当有很长的重复时，下面描述了很多重叠：

doodoodoodoo => dood, oodo, odoo

这导致许多不必要的检查。

我认为这应该快得多，我只是不知道如何解决它。

const reduce = (code) => {
    const results = {};

    let level = 0;
    results[level] = {};

    // Simple value => positions
    [...code].forEach((value, position) => {
        if (!results[level][value]) {
            results[level][value] = [];
        }

        results[level][value].push(position);
    });

    // Now we check combinations
    while (true) {
        const entries = Object.entries(results[level]);

        level = level + 1;

        entries.forEach(([value_1, positions_1], k1) => {
            const result = {};

            positions_1.forEach((position_1, k2) => {
                // We don't need to check repeats, so can slice
                entries.slice(k1).forEach(([value_2, positions_2]) => {
                    let array = [];

                    if (positions_1 === positions_2) {
                        // We don't need to check itself and repeats
                        array = positions_2.slice(k2 + 1);
                    } else {
                        array = positions_2;
                    }

                    array.forEach((position_2) => {
                        const vector = position_1 - position_2;
                        // Checking both sides so we can slice above
                        const direction = Math.sign(vector);

                        if (direction !== 0) {
                            const distance = Math.abs(vector);

                            const get_parts = {
                                '1': [value_2, value_1, position_2],
                                '-1': [value_1, value_2, position_1]
                            };

                            const [part_1, part_2, position] = get_parts[direction];

                            if (distance !== 0 && distance === part_1.length) {
                                const value = `${part_1}${part_2}`;

                                if (!result[value]) {
                                    result[value] = [];

                                    result[value].push(position);
                                } else {
                                    if (!results[level]) {
                                        results[level] = {};
                                    }

                                    // Only add if there is > 2 length
                                    if (!results[level][value]) {
                                        results[level][value] = result[value];
                                    }

                                    results[level][value].push(position);
                                }
                            }
                        }
                    });
                });
            });
        });

        if (!results[level]) {
            break;
        }
    }

    return results;
};