throw new Error()用于抛出指定的错误。但如果你想做自定义错误处理，最好使用throw {example: 'error'}。

也就是说，如果你想知道指定的错误，使用throw new error ("example string")，如果你想自定义处理错误，使用throw。

function makeErrorResponse(err = {}, httpStatus, status, message, message) {
    const error = new Error();

    error.httpStatus = httpStatus;
    error.status = status;
    error.message = message;
    error.err = err;

    return error;
  }

throw makeErrorResponse({}, 500, 500, 'server error');

'throw new Error'和'throw someObject'在javascript中的区别在于，throw new Error将传递给它的错误以以下格式包装

{name: '错误'，消息:'传入构造函数的字符串' ｝

throw someObject将按原样抛出对象，并且不允许从try块执行任何进一步的代码，即与throw new Error相同。

下面是关于Error对象和抛出自己的错误的一个很好的解释

错误对象

在发生错误时，我们能从中提取什么?所有浏览器中的Error对象都支持以下两个属性:

name:错误的名称，或者更具体地说，错误所属的构造函数的名称。 message:错误的描述，该描述因浏览器而异。

name属性可以返回六个可能的值，如前所述，它对应于错误构造函数的名称。它们是:

Error Name          Description

EvalError           An error in the eval() function has occurred.

RangeError          Out of range number value has occurred.

ReferenceError      An illegal reference has occurred.

SyntaxError         A syntax error within code inside the eval() function has occurred.
                    All other syntax errors are not caught by try/catch/finally, and will
                    trigger the default browser error message associated with the error. 
                    To catch actual syntax errors, you may use the onerror event.

TypeError           An error in the expected variable type has occurred.

URIError            An error when encoding or decoding the URI has occurred 
                   (ie: when calling encodeURI()).

抛出自己的错误(异常)

在控制自动从try块转移到catch块之前，您不必等待6种类型错误中的一种发生，还可以显式地抛出自己的异常，以强制按需发生这种情况。这对于创建关于错误是什么以及何时应该将控制转移到catch的定义非常有用。

你可以把它作为对象抛出

throw ({message: 'This Failed'})

例如在try/catch中

try {
//
} catch(e) {
    console.log(e); //{message: 'This Failed'}
    console.log(e.message); //This Failed
}

或者只是抛出一个字符串错误

throw ('Your error')

try {
//
} catch(e) {
    console.log(e); //Your error
}

throw new Error //only accept a string

throw new Error()用于抛出指定的错误。但如果你想做自定义错误处理，最好使用throw {example: 'error'}。

也就是说，如果你想知道指定的错误，使用throw new error ("example string")，如果你想自定义处理错误，使用throw。

function makeErrorResponse(err = {}, httpStatus, status, message, message) {
    const error = new Error();

    error.httpStatus = httpStatus;
    error.status = status;
    error.message = message;
    error.err = err;

    return error;
  }

throw makeErrorResponse({}, 500, 500, 'server error');

Error构造函数用于创建错误对象。发生运行时错误时抛出错误对象。Error对象还可以用作用户定义异常的基对象。

用户定义错误通过throw语句抛出。程序控制将被传递给调用堆栈中的第一个catch块。

有和没有error对象时抛出错误的区别:

throw {'hehe':'haha'};

在chrome中，devtools是这样的:

Chrome告诉我们，我们有一个未捕获的错误，这只是一个JS对象。对象本身可能有关于错误的信息，但我们仍然不知道它来自哪里。在我们处理代码和调试它的时候，这不是很有用。

throw new Error({'hehe':'haha'}); 

在chrome中，devtools是这样的:

与error对象一起抛出的错误在展开堆栈时提供堆栈跟踪。这为我们提供了有价值的信息，错误准确地来自哪里，这在调试代码时通常是有价值的信息。进一步注意，错误说的是[object object]，这是因为error构造函数期望一个消息字符串作为第一个参数。当它接收到一个对象时，它会将其强制转换为一个字符串。

The Error class includes debugging information (as properties of its instances), such as the error's call stack. JS interpreters know how to serialise those properties into an informative error message string, and they can also be consumed by debugging software - such as browser dev tools - to construct a more informative GUI representation of the error. This is why it's generally more useful to throw an instance of the Error class rather than simply throwing, for example, a string describing the error, or a number representing an error code.

使用自定义错误

特别有用的是创建自己的Error子类，它允许您使用描述性名称和机器可读的惟一标识不同类型的错误……

调试线索， 信息，以便更好地面向用户的错误消息，或者 帮助从错误中恢复的信息。

然后，在处理错误时，可以使用简洁的instanceof操作符来检查发生了什么类型的错误。例如:

class ShoesTooBig extends Error {}

class DangerousWaterCurrent extends Error {
    constructor(waterSpeed){
        super(`These waters are moving at ${waterSpeed} metres per second - too fast to cross!`) // Provide a `message` argument to the Error() constructor
        this.waterSpeed = waterSpeed // This passes some context about why/how the error occurred back to whichever function is going to catch & handle it
    }
}

// ...later...

try {
    swimAcrossRiver(footwear, river)
} catch (thrownValue) {
    if (thrownValue instanceof DangerousWaterCurrent) {
        constructDam(river, thrownValue.waterSpeed)
    } else {
        throw thrownValue // "Re-throw" the error back up the execution chain, for someone else to handle
    }
}

new Error() vs Error()

There is a "convenient" shorthand way to make an instance of Error: by calling Error(message), instead of new Error(message), the way you'd make an instance of a normal class. This is a deliberate exception, inserted by the language designers, to the rule. There are similar shorthands for other in-language classes, like Number() and String(). They also let you call these classes with () as if they were functions, not classes. JS doesn't allow normal classes to do this, even though they're all actually functions under the syntactical sugar of "classes". Try in a REPL:

> class E extends Error {}
undefined
> Error(); 'a value'
"a value"
> E(); 'a value'
Uncaught TypeError: Class constructor E cannot be invoked without 'new'
    at <anonymous>:2:1

就我个人而言，我认为这个决定是错误的，因为它为JavaScript规则添加了更多的例外。而不是c++ /Java的new关键字，简单地调用一个类，就好像它是一个函数(如在Number("abc123")))应该执行类的构造函数，并将其绑定到实例，就像通常发生的new关键字一样(这是Python的语法工作方式，它最终更易于阅读和方便)。