Error
=====

O construtor de **`Error`** cria um objeto de erro. Instâncias de objetos `Error` são lançadas quando erros de tempo de execução ocorrem. O objeto `Error` também pode ser usado como objeto base para exceções definidas pelo usuário. Veja abaixo tipos de erro padrões embutidos.

Sintaxe
-------
```

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

### Parâmetros

`message`

Opcional. Descrição do erro legível para humanos.

`fileName` 
Non-standard

Opcional. O valor da propriedade `fileName` no objeto de erro criado. O padrão é o nome do arquivo contendo o código que chamou o construtor de `Error()`.

`lineNumber` 
Non-standard

Opcional. O valor da propriedade `lineNumber` no objeto de `Error` criado. O padrão é o número da linha contendo a invocação do construtor `Error()`.

Descrição
---------

Erros em tempo de execução resultam em novos objetos `Error` sendo criados e lançados.

Esta página documenta o uso do objeto `Error` em si e seu uso como uma função construtora. Para uma lista de propriedades e métodos herdados por instâncias de `Error`, veja `Error.prototype` (en-US).

### Tipos de erro

Além do construtor genérico de `Error`, existem outros seis construtores principais de erro no JavaScript. Para exceções em *client-side*, veja Exceções na captura de Instruções (en-US).

`EvalError`

Cria uma instância representando um erro que ocorre na função global. `eval()`.

`InternalError` 
Non-standard

Cria uma instância representando um erro que ocorre quando um erro interno na *engine* do JavaScript é lançado. Ex: "too much recursion".

`RangeError` (en-US)

Cria uma instância representando um erro que ocorre quando um valor ou parâmetro numérico está fora de seus limites válidos.

`ReferenceError`

Cria uma instância representando um erro que ocorre ao de-referenciar uma referência inválida.

`SyntaxError` (en-US)

Cria uma instância representando um erro que ocorre ao fazer o *parse* do código em `eval()`.

`TypeError`

Cria uma instância representando um erro que ocorre quando uma variável ou parâmetro não é de um tipo válido.

`URIError` (en-US)

Cria uma instância representando um erro que ocorre quando são passados parâmetros inválidos para `encodeURI()` ou `decodeURI()`.

Propriedades
------------

`Error.prototype` (en-US)

Permite a criação de propriedades para instâncias de `Error`.

Métodos
-------

O objeto `Error` global não contém métodos próprios, entretanto, ele herda alguns métodos através da cadeia de *prototypes*.

`Instâncias de Error`
---------------------

{{page('pt-BR/docs/JavaScript/Reference/Global\_Objects/Error/prototype', 'Description')}}### Propriedades

{{page('pt-BR/docs/JavaScript/Reference/Global\_Objects/Error/prototype', 'Properties')}}### Métodos

{{page('pt-BR/docs/JavaScript/Reference/Global\_Objects/Error/prototype', 'Methods')}}Exemplos
--------

### Lançando um erro genérico

Geralmente você cria um objeto `Error` com a intenção de lançá-lo usando a palavra-chave `throw`. Você pode capturar o erro usando uma construção de `try...catch`:


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

### Capturando um erro específico

Você pode escolher por capturar apenas tipos de erro específicos testando o tipo do erro com a propriedade `constructor` de erro ou, se você está escrevendo para *engines* de JavaScript modernas, a palavra-chave `instanceof`:


```js
try {
  Objeto.Metodo();
} catch (e) {
  if (e instanceof EvalError) {
    alert(e.name + ": " + e.message);
  } else if (e instanceof RangeError) {
    alert(e.name + ": " + e.message);
  }
  // ... etc
}
```

### Tipos de erro customizados

Você pode escolher definir seus próprios tipos de erro derivando de `Error` para conseguir usar `throw new MeuErro()` e usar `instanceof MeuErro` para checar o tipo de erro na captura da exceção. A forma comum para isso está demonstrada abaixo

**Aviso:** Note que as instâncias `MeuErro` lançadas vão reportar valores de `lineNumber` e `fileName` incorretos, ao menos no Firefox.

Veja também "esta discussão no Stackoverflow (em inglês): What's a good way to extend Error in JavaScript?".


```js
// Cria um novo objeto que herda o construtor de Error através do prototype.
function MeuErro(message) {
  this.name = "MeuErro";
  this.message = message || "Mensagem de erro padrão";
  this.stack = new Error().stack;
}
MeuErro.prototype = Object.create(MeuErro.prototype);
MeuErro.prototype.constructor = MeuErro;

try {
  throw new MeuErro();
} catch (e) {
  console.log(e.name); // 'MeuErro'
  console.log(e.message); // 'Mensagem de erro padrão'
}

try {
  throw new MeuErro("Mensagem customizada");
} catch (e) {
  console.log(e.name); // 'MeuErro'
  console.log(e.message); // 'Mensagem customizada'
}
```

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-error-objects |

Compatibilidade com navegadores
-------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Veja também
-----------

* `Error.prototype` (en-US)
* `throw`
* `try...catch`