Могу ли я определить пользовательские типы для пользовательских исключений в JavaScript? Если так, как бы я это сделал?
Пользовательский тип исключения
Ответ 1
Из веб-ссылки:
throw {
name: "System Error",
level: "Show Stopper",
message: "Error detected. Please contact the system administrator.",
htmlMessage: "Error detected. Please contact the <a href=\"mailto:[email protected]\">system administrator</a>.",
toString: function(){return this.name + ": " + this.message;}
};
Ответ 2
Вам необходимо создать настраиваемое исключение, которое наследует от ошибки. Например:
function InvalidArgumentException(message) {
this.message = message;
// Use V8 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!
Ответ 3
Вы можете реализовать свои собственные исключения и их обработку, например, как здесь:
// 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");
}
Ответ 4
Да. Вы можете выбросить все, что хотите: целые числа, строки, объекты, что угодно. Если вы хотите бросить объект, просто создайте новый объект так же, как вы создадите его при других обстоятельствах, а затем выбросите его. ссылка на JavaScript Javascript содержит несколько примеров.
Ответ 5
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();
}
Ответ 6
Короче говоря:
Если вы используете ES6 без транспортеров:
class CustomError extends Error { /* ... */}См. Распространение ошибки в Javascript с синтаксисом ES6, чтобы узнать, что в настоящее время рекомендуется
Если вы используете 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);
Если вы используете pure 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 framework
Объяснение:
Почему расширение класса Error с помощью ES6 и Babel является проблемой?
Потому что экземпляр CustomError больше не распознается как таковой.
class CustomError extends Error {}
console.log(new CustomError('test') instanceof Error);// true
console.log(new CustomError('test') instanceof CustomError);// false
Фактически из официальной документации Babel вы не можете расширять какие-либо встроенные классы JavaScript, такие как Date, Array, DOM или Error.
Проблема описана здесь:
- Native расширяет разрывы HTMLELement, Array и других
- объект класса, который расширяется базовым типом, таким как массив, число, объект, строка или ошибка, не является экземпляром этого класса
А как насчет других 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
Ответ 7
Вот как вы можете создавать собственные ошибки с полностью идентичным поведению 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 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 работает absolutle правильно и не будет включать вызов конструктора NotImplementedError (спасибо v8 Error.captureStackTrace()).
Примечание. Существует уродливое eval(). Единственная причина, по которой он используется, - это получить правильный err.constructor.name. Если вам это не нужно, вы можете немного упростить все.
Ответ 8
Я часто использую подход с прототипным наследованием. Переопределение toString() дает вам преимущество в том, что такие инструменты, как Firebug, будут записывать фактическую информацию вместо [object Object] в консоль для исключений uncaught.
Используйте instanceof, чтобы определить тип исключения.
main.js
// 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
Exception.js
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;
};
DuplicateIdException.js
ns.DuplicateIdException = function(message) {
this.name = 'Duplicate ID';
this.message = message;
};
ns.DuplicateIdException.prototype = new ns.Exception();
Ответ 9
Используйте throw.
JavaScript не волнует, что такое тип исключения (как это делает Java). JavaScript просто замечает, есть исключение, и когда вы его поймаете, вы можете "посмотреть", что исключение "говорит".
Если у вас есть разные типы исключений, которые вы должны бросить, я бы предложил использовать переменные, которые содержат строку/объект исключения, т.е. сообщение. Там, где вам это нужно, используйте "throw myException" и в catch, сравните исключенное исключение с myException.
Ответ 10
ES6
С новым классом и расширением ключевых слов теперь стало намного проще:
class CustomError extends Error {
constructor(message) {
super(message);
//something
}
}
Ответ 11
//create error object
var error = new Object();
error.reason="some reason!";
//business function
function exception(){
try{
throw error;
}catch(err){
err.reason;
}
}
Теперь мы устанавливаем добавление причины или любых свойств, которые мы хотим для объекта ошибки, и извлекаем их. Сделав ошибку более разумной.
Ответ 12
См. этот пример в MDN.
Если вам нужно определить несколько ошибок (проверьте код здесь!):
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;
Код в основном копируется из: Каков хороший способ расширения ошибки в JavaScript?
Ответ 13
Альтернатива ответа asselin для использования с классами ES2015
class InvalidArgumentException extends Error {
constructor(message) {
super();
Error.captureStackTrace(this, this.constructor);
this.name = "InvalidArgumentException";
this.message = message;
}
}