JavaScript中如何从嵌套回调中终止函数执行

首先得明确核心问题：如果你的func_1/func_2/func_3是异步回调（比如常见的API请求、文件操作回调），那么myFunc里的"code after"代码会在所有回调触发前就已经执行了——这不是return能不能终止的问题，而是异步代码的执行顺序导致的。下面分两种场景给你可行方案：

场景1：回调是异步的（绝大多数情况） #

方案1：把后续代码封装成函数，按需调用 #

最可靠的方式是把"code after"的逻辑封装成独立函数，只在需要执行的分支里调用它，不需要执行的分支就跳过调用：

const myFunc = () => {
    // 封装后续需要执行的代码
    const executeAfter = () => {
        var a = 2, b = 3;
        var c = a + b;
        // 原来的所有"code after"逻辑都放这里
    };

    func_1(data, (status) => {
        if (!status) {
            func_2(data, (status, result) => {
                if (status) {
                    if (result) {
                        func_3(data, result => {
                            // 这里不调用executeAfter，直接终止当前回调，后续逻辑不会执行
                            return;
                        });
                    } else {
                        // do stuff
                        executeAfter(); // 需要执行后续代码时调用
                    }
                } else {
                    // 如果else分支也需要执行后续代码，这里也要调用
                    executeAfter();
                }
            });
        } else {
            // func_1返回true时，需要执行后续代码就调用
            executeAfter();
        }
    });
}

方案2：用标志位+延迟执行（依赖事件循环顺序） #

如果不想大改结构，可以用setImmediate（或setTimeout）延迟执行后续代码，同时用标志位控制是否执行：

const myFunc = () => {
    let shouldRun = true;

    // 延迟执行后续代码，让回调有机会修改标志位
    setImmediate(() => {
        if (shouldRun) {
            var a = 2, b = 3;
            var c = a + b;
        }
    });

    func_1(data, (status) => {
        if (!status) {
            func_2(data, (status, result) => {
                if (status) {
                    if (result) {
                        func_3(data, result => {
                            // 修改标志位，阻止后续代码执行
                            shouldRun = false;
                            return;
                        });
                    } else {
                        // do stuff，标志位保持true，后续代码会执行
                    }
                }
            });
        }
    });
}

注意：这个方案依赖JS事件循环的顺序，可靠性不如方案1，仅适合临时应急。

场景2：回调是同步的 #

如果你的func_1/func_2/func_3是同步执行的回调（比如遍历、同步计算的回调），可以用标志位在后续代码前判断是否终止：

const myFunc = () => {
    let cancelExecution = false;

    func_1(data, (status) => {
        if (!status) {
            func_2(data, (status, result) => {
                if (status) {
                    if (result) {
                        func_3(data, result => {
                            // 设置终止标志
                            cancelExecution = true;
                            return;
                        });
                    } else {
                        // do stuff     
                    }
                }
            });
        }
    });

    // 检查标志位，决定是否执行后续代码
    if (cancelExecution) return;
    // code after
    var a = 2, b = 3;
    var c = a + b;
}

内容的提问来源于stack exchange，提问作者Robert