以上所有的答案都很糟糕，真的。即使是107个向上的那个!真正的答案在这里:

从Error对象继承- message属性在哪里?

TL; diana:

a .没有设置message的原因是Error是一个函数，它返回一个新的Error对象，并且不以任何方式操作它。

B.正确的方法是从构造函数返回apply的结果，以及以通常复杂的javascript方式设置原型:

function MyError() { var temp = Error.apply(this, arguments); temp.name = this.name = 'MyError'; this.message = temp.message; if(Object.defineProperty) { // getter for more optimizy goodness /*this.stack = */Object.defineProperty(this, 'stack', { get: function() { return temp.stack }, configurable: true // so you can change it if you want }) } else { this.stack = temp.stack } } //inherit prototype using ECMAScript 5 (IE 9+) MyError.prototype = Object.create(Error.prototype, { constructor: { value: MyError, writable: true, configurable: true } }); var myError = new MyError("message"); console.log("The message is: '" + myError.message + "'"); // The message is: 'message' console.log(myError instanceof Error); // true console.log(myError instanceof MyError); // true console.log(myError.toString()); // MyError: message console.log(myError.stack); // MyError: message \n // <stack trace ...> //for EMCAScript 4 or ealier (IE 8 or ealier), inherit prototype this way instead of above code: /* var IntermediateInheritor = function() {}; IntermediateInheritor.prototype = Error.prototype; MyError.prototype = new IntermediateInheritor(); */

您可能会使用一些技巧来枚举tmp Error的所有不可枚举属性来设置它们，而不是显式地只设置stack和message，但是ie<9不支持这种技巧

根据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

function InvalidValueError(value, type) {
    this.message = "Expected `" + type.name + "`: " + value;
    var error = new Error(this.message);
    this.stack = error.stack;
}
InvalidValueError.prototype = new Error();
InvalidValueError.prototype.name = InvalidValueError.name;
InvalidValueError.prototype.constructor = InvalidValueError;

构造函数需要类似于工厂方法，并返回您想要的内容。如果你需要额外的方法/属性，你可以在返回之前将它们添加到对象中。

function NotImplementedError(message) { return new Error("Not implemented", message); }

x = new NotImplementedError();

不过我不明白你为什么要这么做。为什么不直接使用new Error…？ 自定义异常在JavaScript(或任何非类型化语言)中并没有真正添加太多内容。

这在Cesium DeveloperError中很好地实现了:

文档 源

它的简化形式是:

var NotImplementedError = function(message) {
    this.name = 'NotImplementedError';
    this.message = message;
    this.stack = (new Error()).stack;
}

// Later on...

throw new NotImplementedError();

上面的很多方法都不起作用。

最后一个是一个实际的错误。如果您使用字符串，它看起来很好，但它不会提供堆栈跟踪。如果你抛出错误，你不能有“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!