undefined
=========

Resumen
-------

La propiedad global **undefined** representa el valor primitivo `undefined`. Es uno de los valores primitivos de JavaScript.

Pruébalo
--------

Valor
-----

El valor primitivo `undefined`.

| Atributos de la propiedad `undefined` |
| --- |
| Sobrescribir | No |
| Numerable | No |
| Configurable | No |

Descripción
-----------

`undefined` es una propiedad del *objeto global*, es decir, una variable de alcance global.

En navegadores modernos (JavaScript 1.8.5 / Firefox 4+), `undefined` es una propiedad *no-configurable*, *no-grabable* según la especificación ECMAScript 5. Aún cuando este no sea el caso, evite sobreescribirlo.

Una variable a la que no se le ha asignado valor es de tipo `undefined`. Un método o sentencia también devuelve `undefined` si la variable que se está evaluando no tiene asignado un valor. Una función devuelve `undefined` si no se ha `devuelto` un valor.

**Nota:** Aunque es posible usarlo como un identificador (nombre de variable) en cualquier otro ámbito que no sea el ámbito global (porque `undefined` no es una `palabra reservada` (en-US)), hacerlo es una mala idea que provocará que tú código sea difícil de mantener y depurar.


```js
//NO HAGAS ESTO

(() => {
  const undefined = "foo";
  console.log(undefined, typeof undefined);
})()(
  // foo string

  // registra "foo string"
  (undefined) => {
    console.log(undefined, typeof undefined); // foo string
  },
)("foo");
```


Ejemplos
--------

### Igualdad estricta y `undefined`

Puedes usar `undefined` y los operadores de igualdad y desigualdad estricta para determinar si una variable tiene un valor asignado. En el siguiente ejemplo la variable `x` no está inicializada, y la sentencia `if` se evalúa como verdadera.


```js
let x;
if (x === undefined) {
  // se ejecutan estas instrucciones
} else {
  // estas instrucciones no se ejecutan
}
```


**Nota:** Aquí se debe usar el operador de igualdad estricta en lugar del operador de igualdad estándar, ya que `x == undefined` también verifica si `x` es `null`, mientras que el de igualdad estricta no. `null` no es equivalente a `undefined`. Vea `operadores de comparación` para más detalles.

### Typeof operador y `undefined`

Alternativamente se puede usar `typeof`. Recuerda que este siempre devolverá una cadena de texto con el tipo:


```js
let x;
if (typeof x === "undefined") {
  // se ejecutan estas instrucciones
}
```


Una razón para usar `typeof` es que no devuelve un error si la variable no fue declarada.


```js
// x no fue declarada antes
if (typeof x === "undefined") {
  // devuelve true
  //se ejecutan estas instrucciones
}

if (x === undefined) {
  // lanza un ReferenceError
}
```


Sin embargo, existe otra alternativa. JavaScript es un lenguaje de ámbito estático, por lo que determinar si una variable se encuentra declarada puede ser definido al ver si está declarada en el contexto que la contiene.

El alcance global está vinculado al objeto global (en-US), por lo que se puede comprobar la existencia de una variable en el contexto global comprobando la existencia de una propiedad en el objeto global, utilizando el operador `in`, por ejemplo:


```js
if ("x" in window) {
  // estas instrucciones se ejecutan sólo si x está definido globalmente.
}
```

### Operador void y `undefined`

El operador `void` es una tercer alternativa.


```js
let x;
if (x === void 0) {
  // se ejecutan estas instrucciones
}

// y no fue declarada antes
if (y === void 0) {
  // lanza un ReferenceError (a diferencia de `typeof`)
}
```

Especificaciones
----------------

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

Compatibilidad con navegadores
------------------------------

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