Operador lógico OR (||)
=======================

El **operador lógico OR (`||`)** (disyunción lógica) es verdadero para un conjunto de operandos si y solo si uno o más de sus operandos es verdadero. Es normalmente usado con valores booleanos (lógicos). Cuando es así, retorna un valor booleano. Sin embargo, el operador `||` puede retornar el valor de uno de los operandos especificados, por lo que si este operador es usado con valores no booleanos, retornará un valor no booleano.

Pruébalo
--------

Sintaxis
--------


```js
x || y
```

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

Si `x` puede ser convertida a `true`, retorna `x`; en caso contrario, retorna `y`.

Si un valor puede ser convertido a `true`, el valor es conocido como *truthy*. Si un valor puede ser convertido a `false`, el valor es conocido como *falsy (en-US)*.

Ejemplos de expresiones que pueden ser convertidas a `false` son:

* `null`;
* `NaN`;
* `0`;
* cadena vacía (`""` o `''` o ````);
* `undefined`.

 Aunque el operador `||` puede ser usado con operandos que no son valores booleanos, aún puede ser considerado un operador booleano ya que su valor de retorno siempre puede ser convertido a un booleano primitivo.
 Para explícitamente convertir su valor de retorno (o cualquier expresión en general) al correspondiente valor booleano, se debe usar un doble (operador lógico NOT (en-US)) o el contructor del objeto `Boolean`.

### Evaluación de cortocircuito (Short-circuit)

La expresión lógica OR es evaluada de izquierda a derecha, es posible una evaluación de cortocircuito (*short-circuit*) usando la siguiente regla:

`(alguna expresión *truthy*) || expresión` es evaluada por cortocircuito (*short-circuit*) a la expresión *truthy*.

Cortocircuito (*Short-circuit*) significa que la parte de la `expresión` de arriba **no es evaluada**, por lo que ningún efecto secundario resultante de ella es realizado (por ejemplo, si la `expresión` es una llamada a una función, la llamada nunca es realizada). Esto ocurre porque el valor del operador ya está determinado después de la evaluación del primer operando. Veamos un ejemplo:


```js
function A() {
  console.log("llamada a A");
  return false;
}
function B() {
  console.log("llamada a B");
  return true;
}

console.log(B() || A());
// Imprime "llamada a B" por la llamada a la función,
// después imprime `true` (que es el valor resultante del operador)
```

### Precedencia de operadores

Las siguientes expresiones pueden parecer equivalentes, pero no lo son, porque el operador `&&` es ejecutado antes del operador `||` (véase precedencia de operadores).


```js
true || false && false; // retorna `true`, porque `&&` es ejecutado primero
(true || false) && false; // retorna `false`, porque la agrupación tiene la más alta precedencia
```

Ejemplos
--------

### Usando el operador lógico OR

El siguiente código muestra ejemplos del operador lógico OR (`||`).


```js
true || true; // t || t retorna `true`
false || true; // f || t retorna `true`
true || false; // t || f retorna `true`
false || 3 === 4; // f || f retorna `false`
"Cat" || "Dog"; // t || t retorna "Cat"
false || "Cat"; // f || t retorna "Cat"
"Cat" || false; // t || f retorna "Cat"
"" || false; // f || f retorna `false`
false || ""; // f || f retorna ""
false || varObject; // f || objeto retorna varObject
```


**Nota:** Si se usa este operador para proveer un valor por defecto a alguna variable, se debe ser consciente que cualquier valor *falsy* no será usado. Si solo se necesita filtrar `null` o `undefined`, considere usar el operador de coalescencia nula (??).

### Reglas de conversión para booleanos

#### Convirtiendo el operador lógico AND al operador lógico OR

La siguiente operación involucra booleanos:


```js
bCondition1 && bCondition2
```


es siempre igual a:


```js
!(!bCondition1 || !bCondition2)
```


#### Convirtiendo el operador lógico OR al operador lógico AND

La siguiente operación involucra booleanos:


```js
bCondition1 || bCondition2
```


es siempre igual a:


```js
!(!bCondition1 && !bCondition2)
```

### Removiendo paréntesis anidados

Ya que las expresiones lógicas son evaluadas de izquierda a derecha, siempre es posible remover los paréntesis de una expresión compleja siguiendo las siguientes reglas.

La siguiente operación compuesta involucra booleanos:


```js
bCondition1 && (bCondition2 || bCondition3)
```


es siempre igual a:


```js
!(!bCondition1 || !bCondition2 && !bCondition3)
```

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

| Specification |
| --- |
| ECMAScript Language Specification # prod-LogicalORExpression |

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

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

Véase también
-------------

* Operador de coalescencia nula (??)
* `Boolean`
* Truthy
* Falsy (en-US)