NodeJS：抛出错误仍然会带来性能损失吗？

Question

根据nodejs框架的不同，通常有两种方法来管理错误。

• 扔掉它们（即

  throw new Error('invalid id');

  ）
• 归还它们（即

  return { 400: 'invalid id' };

  ）

由于旧的建议是抛出错误效率低下，我总是尝试返回错误，但我更喜欢抛出错误，因为它们更方便。唯一提到性能影响的文章是指 Node v0。

这还是真的吗？

---

更新1

Nvm，我意识到我可以自己测试一下。以下代码供参考：

import { performance } from "perf_hooks";

function ThrowException() {
    throw new Error("invalid exception");
}
const _ATTEMPT = 1000000;
function ThrowingExceptions() {
    const p1 = performance.now();
    for (let i = 0; i < _ATTEMPT; i++) {
        try {
            ThrowException();
        } catch (ex: any) {
            // log error
        }
    }
    const p2 = performance.now();
    console.log(`ThrowingExceptions: ${p2 - p1}`);
}
function ReturnException() {
    return { error: { _: "invalid exception" } };
}
function ReturningExceptions() {
    const p1 = performance.now();
    for (let i = 0; i < _ATTEMPT; i++) {
        const ex = ReturnException();
        if (ex.error) {
            // log error
        }
    }
    const p2 = performance.now();
    console.log(`ReturningExceptions: ${p2 - p1}`);
}

function Process() {
    ThrowingExceptions();
    ReturningExceptions();
    ThrowingExceptions();
    ReturningExceptions();
}

Process();

结果

ThrowingExceptions: 15961.33209991455
ReturningExceptions: 5.09220027923584
ThrowingExceptions: 16461.43380022049
ReturningExceptions: 3.0963997840881348

---

更新2

制造错误会造成最大的惩罚。谢谢@Bergi

import { performance } from "perf_hooks";

const error = new Error("invalid exception");
function ThrowException() {
    throw error;
}
const _ATTEMPT = 1000000;
function ThrowingExceptions() {
    const p1 = performance.now();
    for (let i = 0; i < _ATTEMPT; i++) {
        try {
            ThrowException();
        } catch (ex: any) {
            // log error
        }
    }
    const p2 = performance.now();
    console.log(`ThrowingExceptions: ${p2 - p1}`);
}
function ReturnException() {
    return { error };
}
function ReturningExceptions() {
    const p1 = performance.now();
    for (let i = 0; i < _ATTEMPT; i++) {
        const ex = ReturnException();
        if (ex.error) {
            // log error
        }
    }
    const p2 = performance.now();
    console.log(`ReturningExceptions: ${p2 - p1}`);
}

function Process() {
    ThrowingExceptions();
    ReturningExceptions();
    ThrowingExceptions();
    ReturningExceptions();
}

Process();

结果

ThrowingExceptions: 2897.1585998535156
ReturningExceptions: 3.7821998596191406
ThrowingExceptions: 2905.3162999153137
ReturningExceptions: 4.0701003074646

Answer 1

实际上，与异常机制相比，返回函数调用的状态绝对是低效的。考虑一下：1）异常很少发生，因为它们被设计为仅处理异常情况（这与错误不同），2）由于其技术性质，异常会自动传播，并且，3）当异常不存在时抛出，它们不会产生任何性能成本，并且如果抛出，没有人关心性能，因为异常的抛出、传播和捕获仅在特殊情况下发生。

与异常相比，保持功能

return

对象的状态会在开发、维护和性能方面产生巨大的成本。想一想：如果您在一个函数中提供调用状态信息，则必须在调用该函数的函数中执行相同的操作，依此类推，形成整个调用链。异常不会发生类似的情况，它们只是传播。

事实上，唯一的性能成本是

try

。当人们尝试将

try

和

catch

包含在每个函数中时，我遇到了很多问题。但这违背了例外的目的，同样的事情也发生在许多

try

上。

try

块只能放置在特殊的、战略性选择的地方。异常的传播几乎永远不应该被阻止，除了极少数情况，通常每个线程仅一次，在某些特殊情况下 - 稍微多一点。