recursal/MDN huggingface dataset:
Operador condicional (ternario)
===============================

El **operador condicional** (**ternario**) es el único operador en JavaScript que tiene tres operandos. Este operador se usa con frecuencia como atajo para la instrucción if.Sintaxis
--------
```

condición ? expr1 : expr2
```

### Parámetros

`condición`

Una expresión que se evalúa como true o false.

`expr1`, `expr2`

Expresión con valores de algún tipo.

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

Si la `condición` es `true`, el operador retorna el valor de la `expr1`; de lo contrario, devuelve el valor de `expr2`. Por ejemplo, para mostrar un mensaje diferente en función del valor de la variable *`isMember,`* se puede usar esta declaración:


```js
"La Cuota es de: " + (isMember ? "$2.00" : "$10.00");
```


También puedes asignar variables dependiendo del resultado de la condición ternaria:


```js
var elvisLives = Math.PI > 4 ? "Sip" : "Nop";
```


También es posible realizar evaluaciones ternarias múltiples (Nota: El operador condicional es asociativo):


```js
var firstCheck = false,
  secondCheck = false,
  access = firstCheck
    ? "Acceso Denegado"
    : secondCheck
      ? "Acceso Denegado"
      : "Acceso Permitido";

console.log(access); // muestra "Acceso Permitido"
```


También puede usar operaciones ternarias en espacio vacío con el propósito de realizar diferentes operaciones:


```js
var stop = false,
  age = 16;

age > 18 ? location.assign("continue.html") : (stop = true);
```


También puede realizar más de una operación por caso, separándolas con una coma:


```js
var stop = false,
  age = 23;

age > 18
  ? (alert("OK, puedes continuar."), location.assign("continue.html"))
  : ((stop = true), alert("Disculpa, eres menor de edad!"));
```


También puede realizar más de una operación durante la asignación de un valor. En este caso, ***el último valor separado por una coma del paréntesis* será el valor asignado**.


```js
var age = 16;

var url =
  age > 18
    ? (alert("OK, puedes continuar."),
      // alert devuelve "undefined", pero será ignorado porque
      // no es el último valor separado por comas del paréntesis
      "continue.html") // el valor a ser asignado si age > 18
    : (alert("Eres menor de edad!"),
      alert("Disculpa :-("),
      // etc. etc.
      "stop.html"); // el valor a ser asignado si !(age > 18)

location.assign(url); // "stop.html"
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-conditional-operator |

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

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

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

* if statement
Adición (+)
===========

El operador de adición (`+`) produce la suma de operandos numéricos o la concatenación de (cadenas) string.

Pruébalo
--------

La fuente para este ejemplo interactivo está almacenado en un repositorio Github. Si te gustaría contribuir al proyecto de ejemplos interactivos, por favor clona https://github.com/mdn/interactive-examples y envianos una pull-request.

Sintaxis
--------
```

Operator: x + y
```

Ejemplos
--------

### Adición numérica


```js
// Número + Número -> adición
1 + 2; // 3

// Booleano + Número -> adición
true + 1; // 2

// Booleano + Booleano -> adición
false + false; // 0
```

### Concatenación de (cadenas) String


```js
// String + String -> concatenación
"fut" + "bol"; // "futbol"

// Número + String -> concatenación
5 + "oh"; // "5oh"

// String + Booleano -> concatenación
"fut" + false; // "futfalse"
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-addition-operator-plus |

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

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

También revisa
--------------

* Subtraction operator
* Division operator
* Multiplication operator (en-US)
* Remainder operator
* Exponentiation operator (en-US)
* Increment operator (en-US)
* Decrement operator
* Unary negation operator (en-US)
* Unary plus operator (en-US)
Resto (%)
=========

El operador resto (`%`) devuelve el resto de la división entre dos operandos. Siempre toma el signo del dividendo.

Pruébalo
--------

El código fuente para este ejemplo interactivo se encuentra en un repositorio de GitHub. Si quieres contribuir al proyecto de ejemplos interactivas, por favor clona https://github.com/mdn/interactive-examples y realiza un pull request.

Tener en cuenta que en la mayoría de los lenguajes de programación, el operador de resto es '%', pero en otros (como Python, Perl) es el operador módulo. Ambos son iguales para valores positivos, pero cuando el divisor y el dividendo son de signos distintos, se obtienen distintos resultados. Para obtener el módulo en JavaScript, en lugar de `a % n`, usa `((a % n ) + n ) % n`.

Sintaxis
--------
```

Operador: var1 % var2
```

Ejemplos
--------

### Resto con dividendo positivo


```js
12 % 5; // 2
1 % -2; // 1
1 % 2; // 1
2 % 3; // 2
5.5 % 2; // 1.5
```

### Resto con dividendo negativo


```js
-12 % 5 // -2
-1 % 2  // -1
-4 % 2  // -0
```

### Resto con NaN


```js
NaN % 2; // NaN
```

### Resto con Infinity


```js
Infinity % 2; // NaN
Infinity % 0; // NaN
Infinity % Infinity; // NaN
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-multiplicative-operators |

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

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

Ver también
-----------

* Addition operator
* Subtraction operator
* Division operator
* Multiplication operator (en-US)
* Exponentiation operator (en-US)
* Increment operator (en-US)
* Decrement operator
* Unary negation operator (en-US)
* Unary plus operator (en-US)
null
====

Resumen
-------

El valor `null` es un literal de Javascript que representa intencionalmente un valor nulo o "vacío". Es uno de los valores primitivos de Javascript.

Pruébalo
--------

Sintaxis
--------
```

null
```

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

El valor `null` es un literal (no una propiedad del objeto global como podría ser `undefined`). En APIs, se devuelve `null` normalmente dónde se espera un objeto pero éste no es relevante. Al comparar con `null` o `undefined` hay que tener en cuenta las diferencias entre los operadores de igualdad (==) e identidad (===) (con el primero se realiza una conversión de tipo).


```js
// foo no existe, no está definido y nunca ha sido inicializado:
> foo
"ReferenceError: foo is not defined"

// foo existe, pero no tiene tipo ni valor:
> var foo = null; foo
"null"
```

### Diferencias entre `null` y `undefined`


```js
typeof null; // object (bug en ECMAScript, debería ser null)
typeof undefined; // undefined
null === undefined; // false
null == undefined; // true
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-null-value |

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

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

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

* `undefined`
* `NaN`
Operador de agrupación
======================

El operador de agrupación `( )` controla la precedencia de las expresiones a evaluar.

Sintaxis
--------
```

( )
```

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

El operador de agrupación consiste en un par de paréntesis alrededor de la expresión (o sub-expresión) que sobrescribe el comportamiento por defecto de la precedencia de operadores, lo que causa que expresiones con menor precedencia puedan ser evaluadas antes que expresiones con una mayor precedencia.

Ejemplos
--------

Sobrescribir la precedencia de operadores aritméticos por defecto para que se evalúe primero la adición y luego la multiplicación.


```js
var a = 1;
var b = 2;
var c = 3;

// precedencia por defecto
a + b \* c; // 7
// es evaluada por defecto como:
a + (b \* c); // 7

// ahora se sobrescribe la precedencia
// para que la adición se evalúe antes que la multiplicación
(a + b) \* c; // 9

// que es equivalente a:
a \* c + b \* c; // 9
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-grouping-operator |

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

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

Temas relacionados
------------------

* Precedencia de operadores
* `delete`
* `typeof`
Sustracción (-)
===============

El operador de sustracción (`-`) sustrae dos operandos, produciendo su diferencia.

Pruébalo
--------

Sintaxis
--------
```

Operator: x - y
```

Ejemplos
--------

### Sustracción con números


```js
5 - 3; // 2
3 - 5; // -2
```

### Sustracción de no numéricos


```js
"foo" - 3; // NaN
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-subtraction-operator-minus |

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

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

También revisa
--------------

* Addition operator
* Division operator
* Multiplication operator (en-US)
* Remainder operator
* Exponentiation operator (en-US)
* Increment operator (en-US)
* Decrement operator
* Unary negation operator (en-US)
* Unary plus operator (en-US)
expresión class
===============

La **expresión class** es una forma de definir una clase en ECMAScript 2015 (ES6). Similar a las funciones, las expresiones de clase pueden ser nombradas o no. Si se nombran, el nombre de la clase es local sólo en el cuerpo de la clase. Las clases en JavaScript utilizan herencia basada en prototipos.

Sintaxis
--------
```

var MyClass = class [className] [extends] {
  // class body
};
```

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

Una expresión de clase tiene una sintaxis similar a la declaración de una clase. Sin embargo, con las expresiones de clases, está permitido omitir el nombre de la clase ("identificador de enlace"), cosa que no se puede hacer con las declaraciones de clases. Además, las expresiones de clases permiten redefinir/redeclarar clases y **no lanzar** ningún tipo de error como las declaraciones de clases. La propiedad `constructor` es opcional. Y el *typeof* de las clases generadas con esta palabra clave siempre será "function".

Tal y como en la declaración de clases, el cuerpo de la expresión de clase se ejecuta en modo estricto.


```js
"use strict";
var Foo = class {}; // la propiedad constructor es opcional
var Foo = class {}; // Se permite repetir declaraciones

typeof Foo; // devuelve "function"
typeof class {}; // devuelve "function"

Foo instanceof Object; // true
Foo instanceof Function; // true
class Foo {} // Lanza TypeError, no permite volver a declararla
```

Ejemplo
-------

### Una clase sencilla

Esta es una sencilla expresión de clase anónima a la que se puede hacer referencia utilizando la variable "Foo".


```js
var Foo = class {
  constructor() {}
  bar() {
    return "Hello World!";
  }
};

var instance = new Foo();
instance.bar(); // "Hello World!"
Foo.name; // "Foo"
```

### Expresiones de clase con nombre

Si se quiere hacer referencia a la clase actual dentro del cuerpo de la clase, se puede crear una expresión de clase con nombre. Este nombre sólo será visible en el mismo contexto de la expresión de clase.


```js
var Foo = class NamedFoo {
  constructor() {}
  whoIsThere() {
    return NamedFoo.name;
  }
};
var bar = new Foo();
bar.whoIsThere(); // "NamedFoo"
NamedFoo.name; // ReferenceError: NamedFoo no está definido
Foo.name; // "NamedFoo"
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-class-definitions |

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

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

Ver también
-----------

* expresión `function`
* `declaración class`
* Clases
Expresión de función asíncrona
==============================

Baseline Widely available
-------------------------

This feature is well established and works across many devices and browser versions. It’s been available across browsers since April 2017.

* Learn more
* See full compatibility
* Report feedback
La palabra clave **`async function`** puede ser utilizada para definir funciones `async` dentro de expresiones.

También se pueden definir funciones asíncronas utilizando un enunciado de función asíncrona.

Sintaxis
--------
```

async function [nombre]([param1[, param2[, ..., paramN]]]) {
  enunciados
}
```


A partir de ES2015 (ES6), también se pueden emplear funciones flecha.

### Parámetros

`name`

El nombre de la función. Puede ser omitida, en cuyo caso la función es *anónima*. El nombre es sólo local al cuerpo de la función.

`paramN`

El nombre de un argumento a ser pasado a la función.

`statements`

Los enunciados que componen el cuerpo de la función.

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

Una expresión `async function` es muy similar, y casi tiene la misma sintaxis que, una `async function statement`. La principal diferencia entre una expresión `async function` y un enunciado `async function` es el *nombre de la función*, que puede ser omitido en una expresión `async function` para crear funciones *anonymous*. Una expresión `async function` puede ser utilizada como un IIFE (Expresión de función inmediatamente invocada, Immediately Invoked Function Expression) que se ejecuta tan rápido como es definida. Ver el capítulo sobre funciones para tener más información.

Ejemplos
--------

### Ejemplo sencillo


```js
function resuelve2SegundosDespues(x) {
  return new Promise((resolve) => {
    setTimeout(() => {
      resolve(x);
    }, 2000);
  });
}

const agregar = async function (x) {
  // Expresión de una función asíncrona asignada a una variable
  let a = await resuelve2SegundosDespues(20);
  let b = await resuelve2SegundosDespues(30);
  return x + a + b;
};

agregar(10).then((v) => {
  console.log(v); // imprime 60 después de 4 segundos.
});

(async function (x) {
  // expresión de una función asíncrona utilizada como una IIFE
  let p_a = resuelve2SegundosDespues(20);
  let p_b = resuelve2SegundosDespues(30);
  return x + (await p_a) + (await p_b);
})(10).then((v) => {
  console.log(v); // imprime 60 después de 2 segundos.
});
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-async-function-definitions |

Compatibilidad de los navegadores
---------------------------------

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

Ver también
-----------

* `async function`
* Objeto `AsyncFunction`
* `await`
Operador Coma
=============

El operador coma evalua cada uno de sus operandos (de izquierda a derecha) y retorna el valor del último operando.

Sintaxis
--------
```

expr1, expr2, expr3...
```

Parámetros
----------

`expr1`, `expr2, expr3...`

Cualquier expresión.

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

Puede usar el operador coma cuando deseé mútiples expresiones en una localización que requiere una sola expresión. El uso más común de este operador es proveer múltiples parámetros en un búcle for

Ejemplo
-------

Si a es un array de dos dimensiones con 10 elementos en un lado, el siguiente código usa el operador coma para incrementar dos variables a la vez. Note que la coma en la sentencia var **no** es el operador coma, porque no existe adentro de una expresión.Más bien, es un carácter especial en sentencias var para combinar a múltiples de ellas en una sola. Sin embargo, esa coma se comporta casi igual que el operador coma. El código imprime los valores de los elementos diagonales en el array:
```

for (var i = 0, j = 9; i <= 9; i++, j--)
  document.writeln("a[" + i + "][" + j + "] = " + a[i][j]);
```

### Procesar y luego retornar

Otro ejemplo de lo que se puede hacer con el operador coma es procesar antes de retornar. Como se mencionó, solo el último elemento será retornado pero todos los otros también van a ser evaluados. Así, se puede hacer:


```js
function myFunc() {
  var x = 0;

  return (x += 1), x; // the same as return ++x;
}
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-comma-operator |

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

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

Ver también
-----------

* for loop
Elementos
=========

**Referencia de XSLT y XPath**: Elementos XSLT, Funciones EXSLT, XPath:Funciones, XPath:Ejes
 En este documento se discutiran dos tipos de elementos: elementos raíz e instrucciones. Un elemento raíz debe aparecer como un hijo ya sea de `<xsl:stylesheet>` o `<xsl:transform>`. Por otro lado, una instrucción está asociada con una plantilla. Una hoja de estilo puede incluir varias plantillas. Un tercer tipo de elemento, no discutido aquí, es el elemento de resultado literal (LRE por sus siglas en inglés). Un LRE también aparece dentro de una plantilla, y consiste de cualquier elemento que no sea instrucción y que debe ser copiado tal cual al documento resultante, por ejemplo el elemento `<hr>` cuando se usa en una hoja de estilo para general HTML.
Como nota adicional, cualquier atributo en un LRE y algunos atributos de un conjunto específico de elemento XSLT también pueden incluir lo que se conoce como plantilla de valor de atributo. Que en pocas palabras significa que es una cadena de texto que especifíca una expresión XPath la cual indica el valor del atributo. En tiempo de ejecución la expresión es evaluada y el resultado es sustituido por la expresión XPath. Por ejemplo, asumamos que la variable "`image-dir`" es definida de la siguiente manera:


```xml
<xsl:variable name="image-dir">/images</xsl:variable>
```


La expresión a ser evaluada se escribe dentro de los símbolos de llaves:


```xml
<img src="{$image-dir}/mygraphic.jpg"/>
```


Esto generaría lo siguiente:


```html
<img src="/images/mygraphic.jpg"/>
```


El listado de elementos que sigue a continuación incluye una descripción, la sintaxis, la lista de atributos requeridos y opcionales, una descripción del tipo y la posición, su lugar de definición en la recomendación del W3C y una explicación del nivel de soporte en Gecko.

* xsl:apply-imports
* xsl:apply-templates
* xsl:attribute
* xsl:attribute-set
* xsl:call-template
* xsl:choose
* xsl:comment
* xsl:copy
* xsl:copy-of
* xsl:decimal-format
* xsl:element
* xsl:fallback *(sin soporte)*
* xsl:for-each
* xsl:if
* xsl:import *(casi completamente soportado)*
* xsl:include
* xsl:key
* xsl:message
* xsl:namespace-alias *(sin soporte)*
* xsl:number *(parcialmente soportado)*
* xsl:otherwise
* xsl:output *(parcialmente soportado)*
* xsl:param
* xsl:preserve-space
* xsl:processing-instruction
* xsl:sort
* xsl:strip-space
* xsl:stylesheet *(parcialmente soportado)*
* xsl:template
* xsl:text *(parcialmente soportado)*
* xsl:transform
* xsl:value-of *(parcialmente soportado)*
* xsl:variable
* xsl:when
* xsl:with-param

categorías

interwikis
with-param
==========

**Referencia de XSLT y XPath**: Elementos XSLT, Funciones EXSLT, XPath:Funciones, XPath:Ejes

El elemento `<xsl:with-param>` establece el valor de un parámetro que se pasará a una plantilla.

### Syntax
```

<xsl:with-param name=NOMBRE select=EXPRESIÓN>
  PLANTILLA
</xsl:with-param>
```

### Atributos requeridos

`name`

Dá a este parámetro un nombre.

### Atributos opcionales

`select`

Define el valor del parámtero a través de una expresión XPath. Si el elemento contiene una plantilla, se ignorará este atributo.

### Tipo

Subinstrucción, siempre aparece dentro de un elemento `<xsl:apply-templates>` o `<xsl:call-template>`.

### Definido

XSLT 11.6

### Soporte en Gecko

Soportado.
copy-of
=======

**Referencia de XSLT y XPath**: Elementos XSLT, Funciones EXSLT, XPath:Funciones, XPath:Ejes

El elemento `<xsl:copy-of>` crea una copia completa (incluyendo nodos descendientes) en el documento de salida de lo que sea que indique el atributo.

### Sintaxis
```

<xsl:copy-of select=EXPRESIÓN />
```

### Atributos requeridos

`select`

Indica la expresión XPath a utilizar para seleccionar lo que será copiado.

### Atributos opcionales

Ninguno.

### Tipo

Instrucción, aparece dentro de una plantilla.

### Definido

XSLT, sección 11.3.

### Soporte en Gecko

Soportado.
attribute
=========

**Referencia de XSLT y XPath**: Elementos XSLT, Funciones EXSLT, XPath:Funciones, XPath:Ejes

El elemento `<xsl:attribute>` genera un atributo en el documento de salida, usando cualquier valor que puede ser accedido desde la hoja de estilo. Este elemento tiene que ser la primer cosa que se encuentre dentro del elemento del documento de salida para el cual se desea generar el atributo.

### Sintaxis
```

<xsl:attribute name=NOMBRE namespace=URI>
  PLANTILLA
</xsl:attribute>
```

### Atributos requeridos

`name`

Indica el nombre del atributo a ser generado en el documento de salida. El nombre debe seguir las reglas de QName.

### Atributos opcionales

`namespace`

Define el URI del nombre de espacio para el atributo en el documento de salida. No se puede especificar el prefijo del nombre de espacio con este elemento.

### Tipo

Instrucción, aparece dentro de una plantilla o dentro del elemento `<xsl:attribute-set>`.

### Definido

XSLT, sección 7.1.3.

### Soporte en Gecko

Soportado.
key
===

**Referencia de XSLT y XPath**: Elementos XSLT, Funciones EXSLT, XPath:Funciones, XPath:Ejes

El elemento `<xsl:key>` declara una llave con nombre la cual puede ser usada en otro lugar dentro de la hoja de estilo usando la función `key( )`.

### Sintaxis
```

<xsl:key name=NOMBRE match=EXPRESIÓN
  use=EXPRESIÓN />
```

### Atributos requeridos

`name`

Indica el nombre para esta llave. Debe seguir las reglas de tipo QName.

`match`

Define el nodo para el que esta llave aplica.

`use`

Indica la expresión XPath que se usará para determinar el valor de la llave para cada uno de los nodos aplicables.

### Atributos opcionales

Ninguno.

### Tipo

Elemento raíz, debe ser hijo del elemento `<xsl:stylesheet>` o del elemento `<xsl:transform>`.

### Definido

XSLT, sección 12.2.

### Soporte en Gecko

Soportado.
element
=======

**Referencia de XSLT y XPath**: Elementos XSLT, Funciones EXSLT, XPath:Funciones, XPath:Ejes

El elemento `<xsl:element>` genera un elemento en el documento de salida.

### Sintaxis
```

<xsl:element name=NOMBRE namespace=URI use-attribute-sets=LISTA-DE-NOMBRES >
  PLANTILLA
</xsl:template>
```

### Atributos requeridos

`name`

Indica el nombre deseado del elemento de salida. El nombre debe seguir las reglas de QName.

### Atributos opcionales

`namespace`

Especifica el nombre de espacio del elemento de salida.

`use-attribute-sets`

Lista el conjunto de atributos a ser usados en el elemento de salida. Los nombres deberán estar separados por espacios en blanco.

### Tipo

Instrucción, aparece dentro de una plantilla.

### Definido

XSLT, sección 7.1.2.

### Soporte en Gecko

Soportado
choose
======


**Referencia de XSLT y XPath**: Elementos XSLT, Funciones EXSLT, XPath:Funciones, XPath:Ejes

 El elemento `<xsl:choose>` define una elección entre un número de alternativas. Funciona como una sentencia switch en los lenguajes procedurales.
### Sintaxis
```

<xsl:choose>
  <xsl:when>
  <xsl:otherwise> [opcional]
</<xsl:choose>
```

### Atributos necesarios

Ninguno.

### Atributos opcionales

Ninguno.

### Tipo

Instrucción, aparece con una plantilla. Contiene uno o mas elementos `<xsl:when>`, y, opcionalmente, un elemento `<xsl:otherwise>` final.

### Definido

XSLT, sección 9.2.

### Soporte en Gecko

Soportado.