出于某种原因，在下面的代码段中，构造函数委托似乎不起作用:
function NotImplementedError() {
Error.apply(this, arguments);
}
NotImplementedError.prototype = new Error();
var nie = new NotImplementedError("some message");
console.log("The message is: '"+nie.message+"'")
运行该命令得到的消息是:"。有什么想法，为什么，或者是否有更好的方法来创建一个新的错误子类?是否有一个问题，应用到本机错误构造函数，我不知道?
当前回答
上面的很多方法都不起作用。
最后一个是一个实际的错误。如果您使用字符串，它看起来很好，但它不会提供堆栈跟踪。如果你抛出错误，你不能有“Uncaught BadError: bad”，所以你必须删除自定义错误(遗憾的是)。如果你抛出一个对象，它看起来有点偏离，最后一个只是一个平均错误。
此方法创建一个具有自定义名称的错误，同时保留堆栈跟踪:
var errProto = Object.create(Error.prototype, { constructor: { value: Error, enumerable: false, writable: true, configurable: true } }) var isFirefox = !!window.InstallTrigger // Hide stack for Firefox only, as stacks can cause problems with high "frame" counts. function createError(name, message, hideStack) { if (message == null) { message = "" } var customError = Error(message) customError.name = name Object.setPrototypeOf(customError, errProto) if (isFirefox && hideStack) { customError.stack = "" } else if (isFirefox) { var stack = customError.stack var newline = stack.indexOf("\n") + 1 stack = stack.slice(newline) customError.stack = stack var split = stack.split(":") if (split.length > 4) { var a = split[3] var b = split[4] var t = b.slice(0, b.indexOf("\n")) customError.lineNumber = Number(a) customError.columnNumber = Number(t) } } else { var stack = customError.stack var split = stack.split("\n") var secondPart = split.slice(2).join("\n") stack = split[0] + "\n" + secondPart customError.stack = stack var split = secondPart.split(":") var a = split[2] var b = split[3] } throw customError } var frame = 0 function aFunction() { if (++frame === 100) { createError("LazyError", "function getting lazy", false, true) } else { requestAnimationFrame(aFunction) } } setTimeout(aFunction, Math.random() * 500) * { font-family: Verdana; } Check your inspector!
其他回答
另一种替代方法可能并不适用于所有环境。至少可以保证它在nodejs 0.8中工作 这种方法使用了一种非标准的方法来修改内部原型道具
function myError(msg){
var e = new Error(msg);
_this = this;
_this.__proto__.__proto__ = e;
}
如果你使用Node/Chrome。下面的代码片段将为您提供满足以下要求的扩展。
err instanceof Error err instanceof CustomErrorType console.log() returns [CustomErrorType] when created with a message console.log() returns [CustomErrorType: message] when created without a message throw/stack provides the information at the point the error was created. Works optimally in Node.JS, and Chrome. Will pass instanceof checks in Chrome, Safari, Firefox and IE 8+, but will not have a valid stack outside of Chrome/Safari. I'm OK with that because I can debug in chrome, but code which requires specific error types will still function cross browser. If you need Node only you can easily remove the if statements and you're good to go.
片段
var CustomErrorType = function(message) {
if (Object.defineProperty) {
Object.defineProperty(this, "message", {
value : message || "",
enumerable : false
});
} else {
this.message = message;
}
if (Error.captureStackTrace) {
Error.captureStackTrace(this, CustomErrorType);
}
}
CustomErrorType.prototype = new Error();
CustomErrorType.prototype.name = "CustomErrorType";
使用
var err = new CustomErrorType("foo");
输出
var err = new CustomErrorType("foo");
console.log(err);
console.log(err.stack);
[CustomErrorType: foo]
CustomErrorType: foo
at Object.<anonymous> (/errorTest.js:27:12)
at Module._compile (module.js:456:26)
at Object.Module._extensions..js (module.js:474:10)
at Module.load (module.js:356:32)
at Function.Module._load (module.js:312:12)
at Function.Module.runMain (module.js:497:10)
at startup (node.js:119:16)
at node.js:906:3
/errorTest.js:30
throw err;
^
CustomErrorType: foo
at Object.<anonymous> (/errorTest.js:27:12)
at Module._compile (module.js:456:26)
at Object.Module._extensions..js (module.js:474:10)
at Module.load (module.js:356:32)
at Function.Module._load (module.js:312:12)
at Function.Module.runMain (module.js:497:10)
at startup (node.js:119:16)
at node.js:906:3
这是我的实现:
class HttpError extends Error {
constructor(message, code = null, status = null, stack = null, name = null) {
super();
this.message = message;
this.status = 500;
this.name = name || this.constructor.name;
this.code = code || `E_${this.name.toUpperCase()}`;
this.stack = stack || null;
}
static fromObject(error) {
if (error instanceof HttpError) {
return error;
}
else {
const { message, code, status, stack } = error;
return new ServerError(message, code, status, stack, error.constructor.name);
}
}
expose() {
if (this instanceof ClientError) {
return { ...this };
}
else {
return {
name: this.name,
code: this.code,
status: this.status,
}
}
}
}
class ServerError extends HttpError {}
class ClientError extends HttpError { }
class IncorrectCredentials extends ClientError {
constructor(...args) {
super(...args);
this.status = 400;
}
}
class ResourceNotFound extends ClientError {
constructor(...args) {
super(...args);
this.status = 404;
}
}
示例用法#1:
app.use((req, res, next) => {
try {
invalidFunction();
}
catch (err) {
const error = HttpError.fromObject(err);
return res.status(error.status).send(error.expose());
}
});
示例用法#2:
router.post('/api/auth', async (req, res) => {
try {
const isLogged = await User.logIn(req.body.username, req.body.password);
if (!isLogged) {
throw new IncorrectCredentials('Incorrect username or password');
}
else {
return res.status(200).send({
token,
});
}
}
catch (err) {
const error = HttpError.fromObject(err);
return res.status(error.status).send(error.expose());
}
});
这是最快的方法:
let thisVar = false
if (thisVar === false) {
throw new Error("thisVar is false. It should be true.")
}
根据Joyent的说法，你不应该乱搞堆栈属性(我在这里给出的很多答案中看到了)，因为它会对性能产生负面影响。他们是这么说的:
Stack:一般来说，不要搞砸这个。甚至不要扩大它。V8只在有人实际读取属性时才计算它，这极大地提高了可处理错误的性能。如果读取属性只是为了扩充它，即使调用者不需要堆栈，最终也会付出代价。
我喜欢并想要提到他们的想法，包装原始错误，这是一个很好的替代传递堆栈。
下面是我如何创建一个自定义错误，考虑到上面提到的:
es5版本:
function RError(options) { options = options || {}; // eslint-disable-line no-param-reassign this.name = options.name; this.message = options.message; this.cause = options.cause; // capture stack (this property is supposed to be treated as private) this._err = new Error(); // create an iterable chain this.chain = this.cause ? [this].concat(this.cause.chain) : [this]; } RError.prototype = Object.create(Error.prototype, { constructor: { value: RError, writable: true, configurable: true } }); Object.defineProperty(RError.prototype, 'stack', { get: function stack() { return this.name + ': ' + this.message + '\n' + this._err.stack.split('\n').slice(2).join('\n'); } }); Object.defineProperty(RError.prototype, 'why', { get: function why() { var _why = this.name + ': ' + this.message; for (var i = 1; i < this.chain.length; i++) { var e = this.chain[i]; _why += ' <- ' + e.name + ': ' + e.message; } return _why; } }); // usage function fail() { throw new RError({ name: 'BAR', message: 'I messed up.' }); } function failFurther() { try { fail(); } catch (err) { throw new RError({ name: 'FOO', message: 'Something went wrong.', cause: err }); } } try { failFurther(); } catch (err) { console.error(err.why); console.error(err.stack); console.error(err.cause.stack); }
es6版本:
class RError extends Error { constructor({name, message, cause}) { super(); this.name = name; this.message = message; this.cause = cause; } [Symbol.iterator]() { let current = this; let done = false; const iterator = { next() { const val = current; if (done) { return { value: val, done: true }; } current = current.cause; if (!val.cause) { done = true; } return { value: val, done: false }; } }; return iterator; } get why() { let _why = ''; for (const e of this) { _why += `${_why.length ? ' <- ' : ''}${e.name}: ${e.message}`; } return _why; } } // usage function fail() { throw new RError({ name: 'BAR', message: 'I messed up.' }); } function failFurther() { try { fail(); } catch (err) { throw new RError({ name: 'FOO', message: 'Something went wrong.', cause: err }); } } try { failFurther(); } catch (err) { console.error(err.why); console.error(err.stack); console.error(err.cause.stack); }
我已经把我的解决方案放到了一个模块中，这里是:https://www.npmjs.com/package/rerror
