为什么逻辑或不适用于 JavaScript 中的错误抛出？

Question

这是一种非常常见且有用的做法：

// default via value
var un = undefined
var v1 = un || 1

// default via a function call
var myval = () => 1
var v2 = un || myval()

但是在抛出错误时不起作用（SyntaxError）：

var v3 = un || throw new Error('un is not set!')

有没有办法以同样优雅的方式实现相同的效果？ 恕我直言，这是很多样板代码：

if (!un) {
    throw new Error('un is not set!')
}
var v3 = un

或者是否存在任何理论上的障碍，为什么这不可能，也永远不可能？

Answer 1

throw 只是一个声明；它可能不存在于需要 表达式 的位置。出于类似的原因，您不能在此处放置 if 语句，例如

var something = false || if (cond) { /* something */ }

也是无效的语法。

只有表达式（评估为值的东西）被允许分配给变量。如果你想throw，你必须把throw作为一个语句，这意味着你不能把它放在赋值的右边。

我想一种方法是在|| 的右侧使用 IIFE，允许您在该函数的第一行使用语句：

var un = undefined
var v2 = un || (() => { throw new Error('nope') })();

但这很奇怪。我更喜欢明确的if - throw。

Answer 2

你的问题是赋值需要一个表达式，但你给它一个语句

初始化/分配变量的语法是：

var|let|const <variableName> = <expression>

但你使用

var|let|const <variableName> = <statement>

这是无效的语法。

表达式

表达式是产生值的东西。

什么是“价值”？

值是 Javascript 中的任何类型

• 数字
• 字符串
• 布尔值
• 对象
• 数组
• 符号

表达式示例：

文字

var x = 5;

x 被赋值为“5”

函数调用

var x = myFunc();

myFunc() 产生一个赋值给 x 的值

一个函数的产生值就是它的返回值——一个函数总是返回，如果它没有显式地返回，它返回undefined。

函数的额外好处是能够在其主体中包含语句 - 这将是您问题的解决方案 - 但稍后会详细介绍。

声明

语句是执行动作的东西。例如：

一个循环

for (var i = 0; i < 10; i++) { /* loop body */ }

这个循环执行循环体执行10次的动作

抛出错误

throw new Error()

展开堆栈并停止当前帧的执行

那么为什么我们不能同时使用两者呢？

当你想给一个变量赋值时，你需要一个表达式，因为你希望变量有一个值。

如果您考虑一下，应该清楚它永远不会与语句一起使用。给变量一个“动作”是无稽之谈。这到底是什么意思？

因此您不能使用throw 语句，因为它不会产生值。

你只能有一个或另一个。 要么你 are (expression) 什么，要么你 do (statement) 什么。

修复

您可以通过将任何语句包装在函数中来将其转换为表达式，我建议使用IIFE (Immediately invoked function expression)（基本上是一个调用自身的函数）来做到这一点

var x = 5 || (() => throw new Error())()

这是可行的，因为右侧现在是一个函数，而一个函数是一个产生值的表达式，在这种情况下，该值是 undefined，但由于我们停止执行，所以无论如何都没关系。

未来的可能性

从技术上讲，没有什么可以阻止它的工作。

许多语言（c++，...）实际上已经将throw 视为表达式。有些 (kotlin, ...) 甚至完全省略了语句，并将所有内容都视为表达式。

其他（c#、php、...）提供解决方法，例如 ?? null-concealing 或 ?. elvis 运算符来解决这个用例。

也许将来我们会将这些功能之一纳入 ecmascript 标准 (there is even an open proposal to include this) 直到那时您最好的选择是使用如下功能：

function assertPresent(value, message)
{
  if(!value) {
    throw new Error(message);
  } else {
    return value;
  }
}

Answer 3

您可以将异常的抛出移到一个函数中，因为throw 是控制流的statement，而不是expression：

表达式是解析为值的任何有效代码单元。

const throwError = function (e) { throw new Error(e); };

var un = undefined,
    v3 = un || throwError('un is not set!');

Answer 4

正如其他答案所述，这是因为throw 是一个语句，不能在需要表达式的上下文中使用，例如|| 的右侧。正如其他人所说，您可以通过将异常包装在一个函数中并立即调用它来解决这个问题，但我要说明这样做是一个坏主意，因为它会使您的意图不太清楚。三行额外的代码对于使代码的意图非常清晰和明确来说并不是什么大问题。我个人认为 throw 是仅语句是一件好事，因为它鼓励编写更简单的代码，这样就不太可能导致其他开发人员在遇到您的代码时摸不着头脑。

|| 默认习语在您想为undefined、null 和其他虚假值提供默认值或替代值时很有用，但我认为在分支意义上使用它会失去很多清晰度.通过“分支意义”，我的意思是如果您的意图是在条件成立的情况下做某事（在这种情况下做某事是抛出异常），那么condition || do_something() 真的不是一个明确的方法表达这个意图，即使它在功能上与if (!condition) {do_something()} 相同。短路评估对每个开发人员来说并不是立即显而易见的，|| 默认之所以被理解，是因为它是 Javascript 中的一个常用习语。

我的一般经验法则是，如果一个函数有副作用（是的，异常算作副作用，特别是因为它们基本上是非本地 goto 语句），你应该使用 if 语句来表示它的条件，而不是|| 或 &&。你不是在打高尔夫球。

底线：哪个会减少混乱？

return value || (() => {throw new Error('an error occurred')})()

或

if (!value) {
    throw new Error('an error occurred')
}
return value

为了清晰而牺牲简洁性通常是值得的。

Answer 5

就像其他人所说的那样，问题在于throw 是一个语句而不是一个表达式。

然而，这种二分法确实没有必要。在有些语言中，一切都是表达式（没有语句），因此它们并不“劣质”；它简化了语法和语义（例如，您不需要单独的 if 语句和三元运算符 ?:）。

实际上，这只是 Javascript（语言）糟糕的众多原因之一，尽管 Javascript（运行时环境）非常棒。

一个简单的解决方法（也可以在具有类似限制的其他语言中使用，例如 Python）是：

function error(x) { throw Error(x); }

那么你可以简单地写

let x = y.parent || error("No parent");

将throw 作为静态类型语言的表达式存在一些复杂性：x() ? y() : throw(z) 的静态类型应该是什么？例如，C++ 有一个非常特殊的规则来处理三元运算符中的 throw 表达式（该类型取自另一个分支，即使正式地将 throw x 视为 void 类型的表达式）。