undefined
=========

Resumo
------

O valor global `undefined` representa um valor indefinido. Trata-se de um dos tipos primitivos do JavaScript.

| Property attributes of `undefined` |
| --- |
| Writable | no |
| Enumerable | no |
| Configurable | no |

Sintaxe
-------
```

undefined
```

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

O `undefined` é uma propriedade do objeto `global`, ou seja, é uma variável no escopo global. O valor inicial de `undefined` é o valor primitivo `undefined`.

Nos browsers modernos (JavaScript 1.8.5 / Firefox 4+), a especificação ECMAScript 5 define que o `undefined` é uma propriedade não configurável e somente leitura. Mesmo quando esse não for o caso, evite sobrescrevê-lo.

Uma variável que não teve um valor atribuído é do tipo `undefined`. Um método ou sentença também retorna `undefined` se a variável que está sendo avaliada não tem um valor atribuído. Uma função retorna `undefined` se um valor não for `retornado`.

Uma vez que undefined não é uma `palavra reservada` (en-US), ele pode ser usado como um identificador (nome de variável) em qualquer escopo que não seja o escopo global.


```js
// escreve no console "foo string"
(function () {
  var undefined = "foo";
  console.log(undefined, typeof undefined);
})();

// escreve no console "foo string"
(function (undefined) {
  console.log(undefined, typeof undefined);
})("foo");
```

Exemplos
--------

### Igualdade estrita (===) e `undefined`

Voce pode utilizar `undefined` com os operadores de igualdade e desigualdade estritas para determinar se a variável possui um valor. No código a seguir, a variável `x` não foi definida, e o resultado do `if` é verdadeiro.


```js
var x;
if (x === undefined) {
  // sentenças aqui são executadas
} else {
  // o código aqui não é executado
}
```


**Nota:** Observação: O operador de igualdade estrita (`===`) tem que ser utilizado aqui uma vez que `x == undefined` também checa se `x` é nulo, enquanto o operador não o faz. `null` não é equivalente à `undefined`. Veja `operadores de comparação` (en-US) (em inglês) para maiores detalhes.

### `Operador Typeof` e `undefined`

Alternativamente, `typeof` pode ser usado:


```js
var x;
if (typeof x === "undefined") {
  // esse código é executado
}
```


Uma das principais razões para usar o `typeof` é que ele não lança erros caso a variável não tenha sido inicializada.


```js
// x não foi atribuída anteriormente
if (typeof x === "undefined") {
  // retorna verdadeiro sem lançar erros
  // esse código executa
}

if (x === undefined) {
  // lança um ReferenceError para x
}
```


No entanto, esse tipo de técnica deveria ser evitada. A linguagem JavaScript é uma linguagem com escopo estático, portanto o conhecimento sobre se uma variável está definida pode ser adquirido pela verificação de sua definição dentro do contexto à qual ela pertence. A única exceção é para o escopo global. No entanto, o escopo global é anexado ao objeto global, portanto a verificação da existência de uma variável no contexto global pode ser feita através de uma checagem na propriedade do objeto global usando o operador `in`, por exemplo.

### `Operador Void` e `undefined`

O operador `void` é a terceira alternativa.


```js
var x;
if (x === void 0) {
  // esse código executa
}

// y não foi definido antes
if (y === void 0) {
  // lança uma ReferenceError (ao contrário de `typeof`)
}
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-undefined |

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

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