我可以在JavaScript中为用户定义的异常定义自定义类型吗？如果可以的话，我该怎么做？
答案 0 :(得分：221)
来自WebReference：
throw {
name: "System Error",
level: "Show Stopper",
message: "Error detected. Please contact the system administrator.",
htmlMessage: "Error detected. Please contact the <a href=\"mailto:sysadmin@acme-widgets.com\">system administrator</a>.",
toString: function(){return this.name + ": " + this.message;}
};
答案 1 :(得分：82)
您应该创建一个原型继承自Error的自定义异常。例如：
function InvalidArgumentException(message) {
this.message = message;
// Use V8's native method if available, otherwise fallback
if ("captureStackTrace" in Error)
Error.captureStackTrace(this, InvalidArgumentException);
else
this.stack = (new Error()).stack;
}
InvalidArgumentException.prototype = Object.create(Error.prototype);
InvalidArgumentException.prototype.name = "InvalidArgumentException";
InvalidArgumentException.prototype.constructor = InvalidArgumentException;
这基本上是上面发布的disfated的简化版本，其中增强了堆栈跟踪在Firefox和其他浏览器上的工作。它满足了他发布的相同测试：
用法：
throw new InvalidArgumentException();
var err = new InvalidArgumentException("Not yet...");
它的行为是预期的：
err instanceof InvalidArgumentException // -> true
err instanceof Error // -> true
InvalidArgumentException.prototype.isPrototypeOf(err) // -> true
Error.prototype.isPrototypeOf(err) // -> true
err.constructor.name // -> InvalidArgumentException
err.name // -> InvalidArgumentException
err.message // -> Not yet...
err.toString() // -> InvalidArgumentException: Not yet...
err.stack // -> works fine!
答案 2 :(得分：79)
您可以实现自己的例外及其处理，例如：
// define exceptions "classes"
function NotNumberException() {}
function NotPositiveNumberException() {}
// try some code
try {
// some function/code that can throw
if (isNaN(value))
throw new NotNumberException();
else
if (value < 0)
throw new NotPositiveNumberException();
}
catch (e) {
if (e instanceof NotNumberException) {
alert("not a number");
}
else
if (e instanceof NotPositiveNumberException) {
alert("not a positive number");
}
}
还有另一种捕获类型异常的语法，虽然这不适用于每个浏览器（例如不在IE中）：
// define exceptions "classes"
function NotNumberException() {}
function NotPositiveNumberException() {}
// try some code
try {
// some function/code that can throw
if (isNaN(value))
throw new NotNumberException();
else
if (value < 0)
throw new NotPositiveNumberException();
}
catch (e if e instanceof NotNumberException) {
alert("not a number");
}
catch (e if e instanceof NotPositiveNumberException) {
alert("not a positive number");
}
答案 3 :(得分：37)
是。你可以扔任何你想要的东西：整数，字符串，对象，等等。如果要抛出一个对象，那么只需创建一个新对象，就像在其他情况下创建一个对象一样，然后抛出它。 Mozilla's Javascript reference有几个例子。
答案 4 :(得分：25)
function MyError(message) {
this.message = message;
}
MyError.prototype = new Error;
这允许使用像..
try {
something();
} catch(e) {
if(e instanceof MyError)
doSomethingElse();
else if(e instanceof Error)
andNowForSomethingCompletelyDifferent();
}
答案 5 :(得分：11)
以下是如何创建与原始Error行为完全相同的自定义错误。此技术目前仅适用于Chrome和node.js 。如果你不明白它的作用，我也不建议使用它。
Error.createCustromConstructor = (function() {
function define(obj, prop, value) {
Object.defineProperty(obj, prop, {
value: value,
configurable: true,
enumerable: false,
writable: true
});
}
return function(name, init, proto) {
var CustomError;
proto = proto || {};
function build(message) {
var self = this instanceof CustomError
? this
: Object.create(CustomError.prototype);
Error.apply(self, arguments);
Error.captureStackTrace(self, CustomError);
if (message != undefined) {
define(self, 'message', String(message));
}
define(self, 'arguments', undefined);
define(self, 'type', undefined);
if (typeof init == 'function') {
init.apply(self, arguments);
}
return self;
}
eval('CustomError = function ' + name + '() {' +
'return build.apply(this, arguments); }');
CustomError.prototype = Object.create(Error.prototype);
define(CustomError.prototype, 'constructor', CustomError);
for (var key in proto) {
define(CustomError.prototype, key, proto[key]);
}
Object.defineProperty(CustomError.prototype, 'name', { value: name });
return CustomError;
}
})();
作为一种结果，我们得到了
/**
* name The name of the constructor name
* init User-defined initialization function
* proto It's enumerable members will be added to
* prototype of created constructor
**/
Error.createCustromConstructor = function(name, init, proto)
然后你可以像这样使用它：
var NotImplementedError = Error.createCustromConstructor('NotImplementedError');
并像使用NotImplementedError一样使用Error：
throw new NotImplementedError();
var err = new NotImplementedError();
var err = NotImplementedError('Not yet...');
它的行为是预期的：
err instanceof NotImplementedError // -> true
err instanceof Error // -> true
NotImplementedError.prototype.isPrototypeOf(err) // -> true
Error.prototype.isPrototypeOf(err) // -> true
err.constructor.name // -> NotImplementedError
err.name // -> NotImplementedError
err.message // -> Not yet...
err.toString() // -> NotImplementedError: Not yet...
err.stack // -> works fine!
请注意，error.stack的工作方式绝对正确，不会包含NotImplementedError构造函数调用（感谢v8的Error.captureStackTrace()）。
请注意。有丑陋的eval()。使用它的唯一原因是得到正确的err.constructor.name。如果你不需要它，你可以稍微简化一切。
答案 6 :(得分：11)
我经常使用原型继承的方法。覆盖toString()为您提供的优势是，像Firebug这样的工具会将实际信息而非[object Object]记录到控制台，以防止未捕获的异常。
使用instanceof确定例外类型。
// just an exemplary namespace
var ns = ns || {};
// include JavaScript of the following
// source files here (e.g. by concatenation)
var someId = 42;
throw new ns.DuplicateIdException('Another item with ID ' +
someId + ' has been created');
// Firebug console:
// uncaught exception: [Duplicate ID] Another item with ID 42 has been created
ns.Exception = function() {
}
/**
* Form a string of relevant information.
*
* When providing this method, tools like Firebug show the returned
* string instead of [object Object] for uncaught exceptions.
*
* @return {String} information about the exception
*/
ns.Exception.prototype.toString = function() {
var name = this.name || 'unknown';
var message = this.message || 'no description';
return '[' + name + '] ' + message;
};
ns.DuplicateIdException = function(message) {
this.name = 'Duplicate ID';
this.message = message;
};
ns.DuplicateIdException.prototype = new ns.Exception();
答案 7 :(得分：10)
简而言之：
如果您使用ES6 没有转发：
class CustomError extends Error { /* ... */}
请参阅Extending Error in Javascript with ES6 syntax了解当前的最佳做法
如果您使用 Babel transpiler ：
选项1：使用babel-plugin-transform-builtin-extend
选项2：自己动手（灵感来自同一个图书馆）
function CustomError(...args) {
const instance = Reflect.construct(Error, args);
Reflect.setPrototypeOf(instance, Reflect.getPrototypeOf(this));
return instance;
}
CustomError.prototype = Object.create(Error.prototype, {
constructor: {
value: Error,
enumerable: false,
writable: true,
configurable: true
}
});
Reflect.setPrototypeOf(CustomError, Error);
如果您使用纯ES5 ：
function CustomError(message, fileName, lineNumber) {
const instance = new Error(message, fileName, lineNumber);
Object.setPrototypeOf(instance, Object.getPrototypeOf(this));
return instance;
}
CustomError.prototype = Object.create(Error.prototype, {
constructor: {
value: Error,
enumerable: false,
writable: true,
configurable: true
}
});
if (Object.setPrototypeOf){
Object.setPrototypeOf(CustomError, Error);
} else {
CustomError.__proto__ = Error;
}
替代方案：使用Classtrophobic框架
<强>解释
为什么使用ES6和Babel扩展Error类是个问题？
因为不再能识别出CustomError的实例。
class CustomError extends Error {}
console.log(new CustomError('test') instanceof Error);// true
console.log(new CustomError('test') instanceof CustomError);// false
事实上，根据Babel的官方文档，您cannot extend any built-in JavaScript classes，例如Date，Array，DOM或Error。
这里描述了这个问题：
其他SO答案怎么样？
所有给出的答案都解决了instanceof问题，但您丢失了常规错误console.log：
console.log(new CustomError('test'));
// output:
// CustomError {name: "MyError", message: "test", stack: "Error↵ at CustomError (<anonymous>:4:19)↵ at <anonymous>:1:5"}
使用上述方法，您不仅可以解决instanceof问题，还可以保留常规错误console.log：
console.log(new CustomError('test'));
// output:
// Error: test
// at CustomError (<anonymous>:2:32)
// at <anonymous>:1:5
答案 8 :(得分：5)
使用throw声明。
JavaScript并不关心异常类型是什么（就像Java那样）。 JavaScript只是注意到，有一个例外，当你抓住它时，你可以“看”异常“说”。
如果您必须抛出不同的异常类型，我建议使用包含异常的字符串/对象的变量，即消息。在需要的地方使用“throw myException”并在catch中将捕获的异常与myException进行比较。
答案 9 :(得分：4)
<强> ES6
使用新类和扩展关键字现在更加容易：
class CustomError extends Error {
constructor(message) {
super(message);
//something
}
}
答案 10 :(得分：1)
//create error object
var error = new Object();
error.reason="some reason!";
//business function
function exception(){
try{
throw error;
}catch(err){
err.reason;
}
}
现在我们设置为错误对象添加我们想要的原因或任何属性并检索它。通过使错误更合理。
答案 11 :(得分：1)
请参阅MDN中的this example。
如果您需要定义多个错误（测试代码here！）：
function createErrorType(name, initFunction) {
function E(message) {
this.message = message;
if (Error.captureStackTrace)
Error.captureStackTrace(this, this.constructor);
else
this.stack = (new Error()).stack;
initFunction && initFunction.apply(this, arguments);
}
E.prototype = Object.create(Error.prototype);
E.prototype.name = name;
E.prototype.constructor = E;
return E;
}
var InvalidStateError = createErrorType(
'InvalidStateError',
function (invalidState, acceptedStates) {
this.message = 'The state ' + invalidState + ' is invalid. Expected ' + acceptedStates + '.';
});
var error = new InvalidStateError('foo', 'bar or baz');
function assert(condition) { if (!condition) throw new Error(); }
assert(error.message);
assert(error instanceof InvalidStateError);
assert(error instanceof Error);
assert(error.name == 'InvalidStateError');
assert(error.stack);
error.message;
答案 12 :(得分：1)
用于ES2015课程的asselin答案的替代
class InvalidArgumentException extends Error {
constructor(message) {
super();
Error.captureStackTrace(this, this.constructor);
this.name = "InvalidArgumentException";
this.message = message;
}
}