Пользовательский тип исключения

Могу ли я определить пользовательские типы для пользовательских исключений в JavaScript? Если так, как бы я это сделал?

Из веб-ссылки :

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;} 
}; 

Вы должны создать пользовательское исключение, которое прототипно наследуется от 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;

Это в основном упрощенная версия того, что было опубликовано выше, с улучшением работы стековых трассировок в 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!

Вы можете реализовать свои собственные исключения и их обработку, например, здесь:

// 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");
}

Да. Вы можете бросить все, что вы хотите: целые числа, строки, объекты, что угодно. Если вы хотите бросить объект, просто создайте новый объект, как если бы вы создали его при других обстоятельствах, а затем бросьте его. У ссылки Mozilla на Javascript есть несколько примеров.

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();
}

Коротко:

• Если вы используете ES6 без транспортеров :

  class CustomError extends Error { /* ... */}

  См. Распространение ошибок в Javascript с синтаксисом ES6, чтобы узнать, каков текущий лучший метод

• Если вы используете транспортер Babel :

Вариант 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 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

В самом деле, из официальной документации Вавилонского, вы не можете расширить любой встроенные классы JavaScript , такие как Date, Array, DOMили Error.

Проблема описана здесь:

• Родной расширяет разрывы 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

Вот как вы можете создавать собственные ошибки, полностью идентичные Errorповедению native . Эта техника пока работает только в 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. Если вам это не нужно, вы можете все немного упростить.

Я часто использую подход с наследованием прототипов. Переопределение toString()дает вам преимущество в том, что такие инструменты, как Firebug, будут записывать фактическую информацию, а не [object Object]в консоль для необработанных исключений.

Используйте 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();

ES6

С новым классом и расширением ключевых слов теперь стало намного проще:

class CustomError extends Error {
  constructor(message) {
    super(message);
    //something
  }
}

Используйте оператор throw .

JavaScript не заботится о типе исключения (как это делает Java). JavaScript просто замечает, есть исключение, и когда вы поймаете его, вы можете «посмотреть», что «исключение» «говорит».

Если у вас есть разные типы исключений, которые вы должны выбросить, я бы предложил использовать переменные, которые содержат строку / объект исключения, т.е. сообщение. Там, где это необходимо, используйте «throw myException» и в подвохе сравните пойманное исключение с myException.

Смотрите этот пример в 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;

Код в основном копируется из: Каков хороший способ расширить Error в JavaScript?

Альтернатива ответу асселин для использования с классами ES2015

class InvalidArgumentException extends Error {
    constructor(message) {
        super();
        Error.captureStackTrace(this, this.constructor);
        this.name = "InvalidArgumentException";
        this.message = message;
    }
}

//create error object
var error = new Object();
error.reason="some reason!";

//business function
function exception(){
    try{
        throw error;
    }catch(err){
        err.reason;
    }
}

Теперь мы добавляем причину или любые свойства, которые мы хотим, к объекту ошибки и извлекаем его. Делая ошибку более разумной.