Your Search Results

    Error

    Summary

    The Error constructor creates an error object. Instances of Error objects are thrown when runtime errors occur. The Error object can also be used as a base objects for user-defined exceptions. See below for standard built-in error types.

    Syntax

    new Error([message[, fileName[,lineNumber]]])

    Parameters

    message
    Human-readable description of the error
    fileName
    The value for the fileName property on the created Error object. Defaults to the name of the file containing the code that called the Error() constructor.
    lineNumber
    The value for the lineNumber property on the created Error object. Defaults to the line number containing the Error() constructor invocation.

    Description

    Runtime errors result in new Error objects being created and thrown.

    This page documents the use of the Error object itself and its use as a constructor function. For a list of properties and methods inherited by Error instances, see Error.prototype.

    Error types

    Besides the generic Error constructor, there are six other core error constructors in JavaScript. For client-side exceptions, see Exception Handling Statements.

    EvalError
    Creates an instance representing an error that occurs regarding the global function eval().
    InternalError
    Creates an instance representing an error that occurs when an internal error in the JavaScript engine is thrown. E.g. "too much recursion".
    RangeError
    Creates an instance representing an error that occurs when a numeric variable or parameter is outside of its valid range.
    ReferenceError
    Creates an instance representing an error that occurs when de-referencing an invalid reference.
    SyntaxError
    Creates an instance representing a syntax error that occurs while parsing code in eval().
    TypeError
    Creates an instance representing an error that occurs when a variable or parameter is not of a valid type.
    URIError
    Creates an instance representing an error that occurs when encodeURI() or decodeURl() are passed invalid parameters.

    Properties

    Error.prototype
    Allows the addition of properties to Error instances.

    Methods

    The global Error object contains no methods of its own, however, it does inherit some methods through the prototype chain.

    Error instances

    All Error instances and instances of non-generic errors inherit from Error.prototype. As with all constructor functions, you can use the prototype of the constructor to add properties or methods to all instances created with that constructor.

    Properties

    Standard properties

    Error.prototype.constructor
    Specifies the function that created an instance's prototype.
    Error.prototype.message
    Error message.
    Error.prototype.name
    Error name.

    Vendor-specific extensions

    Non-standard
    This feature is non-standard and is not on a standards track. Do not use it on production sites facing the Web: it will not work for every user. There may also be large incompatibilities between implementations and the behavior may change in the future.

    Microsoft

    Error.prototype.description
    Error description. Similar to message.
    Error.prototype.number
    Error number.

    Mozilla

    Error.prototype.fileName
    Path to file that raised this error.
    Error.prototype.lineNumber
    Line number in file that raised this error.
    Error.prototype.columnNumber
    Column number in line that raised this error.
    Error.prototype.stack
    Stack trace.

    Methods

    Error.prototype.toSource()
    Returns a string containing the source of the specified Error object; you can use this value to create a new object. Overrides the Object.prototype.toSource() method.
    Error.prototype.toString()
    Returns a string representing the specified object. Overrides the Object.prototype.toString() method.

    Examples

    Example: Throwing a generic error

    Usually you create an Error object with the intention of raising it using the throw keyword. You can handle the error using the try...catch construct:

    try {
      throw new Error("Whoops!");
    } catch (e) {
      alert(e.name + ": " + e.message);
    }
    

    Example: Handling a specific error

    this should probably be removed You can choose to handle only specific error types by testing the error type with the error's constructor property or, if you're writing for modern JavaScript engines, instanceof keyword:

    try {
      foo.bar();
    } catch (e) {
      if (e instanceof EvalError) {
        alert(e.name + ": " + e.message);
      } else if (e instanceof RangeError) {
        alert(e.name + ": " + e.message);
      }
      // ... etc
    }
    

    Custom Error Types

    You might want to define your own error types deriving from Error to be able to throw new MyError() and use instanceof MyError to check the kind of error in the exception handler. The common way to do this is demonstrated below.

    Note that the thrown MyError will report incorrect lineNumber and fileName at least in Firefox.

    See also the "What's a good way to extend Error in JavaScript?" discussion on Stackoverflow.

    // Create a new object, that prototypally inherits from the Error constructor.
    function MyError(message) {
      this.name = "MyError";
      this.message = message || "Default Message";
    }
    MyError.prototype = new Error();
    MyError.prototype.constructor = MyError;
    
    try {
      throw new MyError();
    } catch (e) {
      console.log(e.name);     // "MyError"
      console.log(e.message);  // "Default Message"
    }
    
    try {
      throw new MyError("custom message");
    } catch (e) {
      console.log(e.name);     // "MyError"
      console.log(e.message);  // "custom message"
    }
    

    Specifications

    Specification Status Comment
    ECMAScript 1st Edition. Standard Initial definition.
    Implemented in JavaScript 1.1
    ECMAScript 5.1 (ECMA-262)
    The definition of 'Error' in that specification.
    Standard  
    ECMAScript 6 (ECMA-262)
    The definition of 'Error' in that specification.
    Draft  

    Browser compatibility

    Feature Chrome Firefox (Gecko) Internet Explorer Opera Safari
    Basic support (Yes) (Yes) (Yes) (Yes) (Yes)
    Feature Android Chrome for Android Firefox Mobile (Gecko) IE Mobile Opera Mobile Safari Mobile
    Basic support (Yes) (Yes) (Yes) (Yes) (Yes) (Yes)

    See also