如何比较旧版 javascript 方法实现与新方法实现？

Question

我希望在重写遗留函数/方法时有一些简单的方法来支持我。

假设我们有一个遗留函数和一个重写的函数：

var legacyFunction = function() { return 1; };
var reloadedFunction = function() { return 1; };

是否可以在生产中执行的上下文中并排比较

legacyFunction

和

reloadedFunction

？

我心里有这样的想法：

return rewriteLegacyCode((usagePerDevice, steps) => {
    // broken implementation
   for (let i = 0; i < inclusiveVolumeSteps.length; i++) {
       if (usage >= steps[i].volume && usage < steps[i + 1].volume) {
           return inclusiveVolumeSteps[i];      
       }
    }
    return undefined;
}).withNewVersion((usagePerDevice, steps) => {
    return steps.findLast((step) => step.volume <= usagePerDevice});
})
.compareResults(usagePerDevice, inclusiveVolume)
.trustNewVersion();

我正在寻找一个好的实现

Answer 1

我自己编写了以下代码——到目前为止只处理非异步的东西：

    class RewriteHelper {
        #legacyVersion;
        #rewriteVersion;
        #results;

        legacyVersion(callback) {
            this.#legacyVersion = callback;
            return this;
        }

        withNewVersion(callback) {
            this.#rewriteVersion = callback;
            return this;
        }

        invokeAndLogException(version, callback, ...args) {
            console.debug(`*** ${version} version ***`);
            try {
                return callback(...args);
            } catch (e) {
                console.warn(`Error: ${e}`)
                return undefined
            }
        }

        compareResults(...args) {
            // with catch for the case the invoked function throws an exception

            let result1 = this.invokeAndLogException('legacy', this.#legacyVersion, ...args);
            let result2 = this.invokeAndLogException('rewritten', this.#rewriteVersion, ...args);

            let result1Json = JSON.stringify(result1, 2);
            let result2Json = JSON.stringify(result2, 2);

            console.log(`Comparing legacy implementation with rewritten one:\nold: ${result1Json}\nnew: ${result2Json}\nresult: ${result1Json === result2Json ? "OK ✅" : "ERROR ❌"}`);
            this.#results = [result1, result2];
            return this;
        }

        trustLegacyVersion() {
            return this.#results[0]
        }

        trustNewVersion() {
            return this.#results[1]
        }

    }

    const rewriteLegacyCode = (callback) => {
        return new RewriteHelper().legacyVersion(callback);
    }