From a55b575e8089ee6cab7c5c262a7e6db55d0e34d6 Mon Sep 17 00:00:00 2001 From: Florian Merz Date: Thu, 11 Feb 2021 14:46:50 +0100 Subject: unslug es: move --- .../operadores/adici\303\263n/index.html" | 77 --- .../operadores/aritm\303\251ticos/index.html" | 315 --------- .../referencia/operadores/asignacion/index.html | 62 -- .../operadores/assignment_operators/index.html | 462 ------------- .../operadores/async_function/index.html | 102 --- .../referencia/operadores/await/index.html | 102 --- .../operadores/bitwise_operators/index.html | 722 --------------------- .../referencia/operadores/class/index.html | 157 ----- .../referencia/operadores/comparacion/index.html | 129 ---- .../operadores/comparison_operators/index.html | 262 -------- .../operadores/conditional_operator/index.html | 171 ----- .../referencia/operadores/decremento/index.html | 83 --- .../referencia/operadores/delete/index.html | 242 ------- .../operadores/destructuring_assignment/index.html | 442 ------------- .../referencia/operadores/division/index.html | 77 --- .../operadores/encadenamiento_opcional/index.html | 187 ------ .../referencia/operadores/function/index.html | 73 --- .../operadores/function_star_/index.html | 91 --- .../referencia/operadores/grouping/index.html | 128 ---- .../javascript/referencia/operadores/in/index.html | 139 ---- .../javascript/referencia/operadores/index.html | 280 -------- .../referencia/operadores/instanceof/index.html | 88 --- .../referencia/operadores/miembros/index.html | 85 --- .../referencia/operadores/new.target/index.html | 139 ---- .../referencia/operadores/new/index.html | 179 ----- .../referencia/operadores/operador_coma/index.html | 132 ---- .../operadores_l\303\263gicos/index.html" | 296 --------- .../operadores/operator_precedence/index.html | 297 --------- .../operadores/pipeline_operator/index.html | 78 --- .../referencia/operadores/resto/index.html | 82 --- .../operadores/sintaxis_spread/index.html | 242 ------- .../operadores/spread_operator/index.html | 220 ------- .../operadores/strict_equality/index.html | 101 --- .../referencia/operadores/super/index.html | 178 ----- .../operadores/sustracci\303\263n/index.html" | 65 -- .../referencia/operadores/this/index.html | 239 ------- .../referencia/operadores/typeof/index.html | 76 --- .../referencia/operadores/void/index.html | 36 - .../referencia/operadores/yield/index.html | 130 ---- .../referencia/operadores/yield_star_/index.html | 199 ------ 40 files changed, 7165 deletions(-) delete mode 100644 "files/es/web/javascript/referencia/operadores/adici\303\263n/index.html" delete mode 100644 "files/es/web/javascript/referencia/operadores/aritm\303\251ticos/index.html" delete mode 100644 files/es/web/javascript/referencia/operadores/asignacion/index.html delete mode 100644 files/es/web/javascript/referencia/operadores/assignment_operators/index.html delete mode 100644 files/es/web/javascript/referencia/operadores/async_function/index.html delete mode 100644 files/es/web/javascript/referencia/operadores/await/index.html delete mode 100644 files/es/web/javascript/referencia/operadores/bitwise_operators/index.html delete mode 100644 files/es/web/javascript/referencia/operadores/class/index.html delete mode 100644 files/es/web/javascript/referencia/operadores/comparacion/index.html delete mode 100644 files/es/web/javascript/referencia/operadores/comparison_operators/index.html delete mode 100644 files/es/web/javascript/referencia/operadores/conditional_operator/index.html delete mode 100644 files/es/web/javascript/referencia/operadores/decremento/index.html delete mode 100644 files/es/web/javascript/referencia/operadores/delete/index.html delete mode 100644 files/es/web/javascript/referencia/operadores/destructuring_assignment/index.html delete mode 100644 files/es/web/javascript/referencia/operadores/division/index.html delete mode 100644 files/es/web/javascript/referencia/operadores/encadenamiento_opcional/index.html delete mode 100644 files/es/web/javascript/referencia/operadores/function/index.html delete mode 100644 files/es/web/javascript/referencia/operadores/function_star_/index.html delete mode 100644 files/es/web/javascript/referencia/operadores/grouping/index.html delete mode 100644 files/es/web/javascript/referencia/operadores/in/index.html delete mode 100644 files/es/web/javascript/referencia/operadores/index.html delete mode 100644 files/es/web/javascript/referencia/operadores/instanceof/index.html delete mode 100644 files/es/web/javascript/referencia/operadores/miembros/index.html delete mode 100644 files/es/web/javascript/referencia/operadores/new.target/index.html delete mode 100644 files/es/web/javascript/referencia/operadores/new/index.html delete mode 100644 files/es/web/javascript/referencia/operadores/operador_coma/index.html delete mode 100644 "files/es/web/javascript/referencia/operadores/operadores_l\303\263gicos/index.html" delete mode 100644 files/es/web/javascript/referencia/operadores/operator_precedence/index.html delete mode 100644 files/es/web/javascript/referencia/operadores/pipeline_operator/index.html delete mode 100644 files/es/web/javascript/referencia/operadores/resto/index.html delete mode 100644 files/es/web/javascript/referencia/operadores/sintaxis_spread/index.html delete mode 100644 files/es/web/javascript/referencia/operadores/spread_operator/index.html delete mode 100644 files/es/web/javascript/referencia/operadores/strict_equality/index.html delete mode 100644 files/es/web/javascript/referencia/operadores/super/index.html delete mode 100644 "files/es/web/javascript/referencia/operadores/sustracci\303\263n/index.html" delete mode 100644 files/es/web/javascript/referencia/operadores/this/index.html delete mode 100644 files/es/web/javascript/referencia/operadores/typeof/index.html delete mode 100644 files/es/web/javascript/referencia/operadores/void/index.html delete mode 100644 files/es/web/javascript/referencia/operadores/yield/index.html delete mode 100644 files/es/web/javascript/referencia/operadores/yield_star_/index.html (limited to 'files/es/web/javascript/referencia/operadores') diff --git "a/files/es/web/javascript/referencia/operadores/adici\303\263n/index.html" "b/files/es/web/javascript/referencia/operadores/adici\303\263n/index.html" deleted file mode 100644 index 888845158a..0000000000 --- "a/files/es/web/javascript/referencia/operadores/adici\303\263n/index.html" +++ /dev/null @@ -1,77 +0,0 @@ ---- -title: Adición (+) -slug: Web/JavaScript/Referencia/Operadores/Adición -translation_of: Web/JavaScript/Reference/Operators/Addition ---- -
{{jsSidebar("Operators")}}
- -

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

- -
{{EmbedInteractiveExample("pages/js/expressions-addition.html")}}
- -
- - - -

Sintaxis

- -
Operator: x + y
-
- -

Ejemplos

- -

Adición numérica

- -
// 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

- -
// String + String -> concatenación
-'fut' + 'bol' // "futbol"
-
-// Número + String -> concatenación
-5 + 'oh' // "5oh"
-
-// String + Booleano -> concatenación
-'fut' + false // "futfalse"
- -

Especificación

- - - - - - - - - - -
Specification
{{SpecName('ESDraft', '#sec-addition-operator-plus', 'Addition operator')}}
- -

Compatibilidad de Explorador

- - - -

{{Compat("javascript.operators.addition")}}

- -

También revisa

- - diff --git "a/files/es/web/javascript/referencia/operadores/aritm\303\251ticos/index.html" "b/files/es/web/javascript/referencia/operadores/aritm\303\251ticos/index.html" deleted file mode 100644 index 71968fda85..0000000000 --- "a/files/es/web/javascript/referencia/operadores/aritm\303\251ticos/index.html" +++ /dev/null @@ -1,315 +0,0 @@ ---- -title: Operadores Aritméticos -slug: Web/JavaScript/Referencia/Operadores/Aritméticos -tags: - - JavaScript - - Operador -translation_of: Web/JavaScript/Reference/Operators -translation_of_original: Web/JavaScript/Reference/Operators/Arithmetic_Operators ---- -
{{jsSidebar("Operators")}}
- -

Los operadores Aritméticos toman valores numéricos (ya sean literales o variables) como sus operandos y retornan un valor numérico único. Los operadores aritméticos estándar son adición o suma (+), sustracción o resta (-), multiplicación (*), y división (/).

- -

Estos operadores trabajan al igual que en la mayoría de otros lenguajes de programacion, excepto el operador /, que retorna una división de punto flotante en JavaScript, no una división truncada como en lenguajes tales como C o Java. Por ejemplo:

- -

{{EmbedInteractiveExample("pages/js/expressions-arithmetic.html")}}

- -

Suma o adición (+)

- -

La operación suma se produce mediante la suma de número o strings concatenados.

- -

Sintaxis

- -
Operador: x + y
- -

Ejemplos:

- -
// Número + Número = Adición
-
-1 + 2 // 3
-
-// Bolean + Número = Adición
-
-true + 1 // 2
-
-// Bolean + Bolean // Adición
-
-false + false // 0
-
-// Número + String = Concatenación
-
-5 + 'foo' // "5foo"
-
-// String + Bolean = Concatenación
-
-'foo' + true // "footrue"
-
-// String + String = Concatenación
-
-'foo' + 'bar' // "foobar"
-
- -

Resta o sustracción (-)

- -

La resta se produce cuando se sutraen el resultado de los operadores, produciendo su diferencia.

- -

Sintaxis

- -
Operador: x - y
- -

Ejemplos

- -
5 - 3     // 2
-3 - 5     // -2
-'foo' - 3 // NaN
-
- -

División (/)

- -

El operador división se produce el cociente de la operación donde el operando izquierdo es el dividendo y el operando derecho es el divisor.

- -

Sintaxis

- -
Operador: x / y
- -

Ejemplos

- -
1 / 2      // devuelve 0.5 en JavaScript
-1 / 2      // devuelve 0 en Java
-// (Ninguno de los números es explícitamente un número de punto flotante)
-
-1.0 / 2.0  // devuelve 0.5 en JavaScript y Java
-
-2.0 / 0    // devuelve Infinito en JavaScript
-2.0 / 0.0  // devuelve Infinito
-2.0 / -0.0 // devuelve -Infinito en JavaScript
-
- -

Multiplicación (*)

- -

El operador multiplicación produce el producto de la multiplicación de los operandos.

- -

Sintaxis

- -
Operador: x * y
- -

Ejemplos

- -
2 * 2 // 4
--2 * 2 // -4
-Infinito * 0 // NaN
-Infinito * Infinito // Infinito
-'foo' * 2 // NaN
- -

Resto o Residuo  (%)

- -

El operador resto devuelve el resto que queda cuando un operando se divide por un segundo operando. Siempre toma el signo del dividendo, no el divisor. Utiliza una función de modulo incorporada para producir el resultado, que es el resto entero de dividir var1 por var2 - por ejemplo - var1 modulo var2. Existe una propuesta para obtener un operador de módulo real en una versión futura de ECMAScript, con la diferencia de que el resultado del operador de módulo tomaría el signo del divisor, no el dividendo.

- -

Sintaxis

- -
Operador: var1 % var2
- -

Ejemplos

- -
12 % 5  // 2
--1 % 2  // -1
-1 % -2  // 1
-NaN % 2 // NaN
-1 % 2   // 1
-2 % 3   // 2
--4 % 2  // -0
-5.5 % 2 // 1.5
- -

Exponenciación (**)

- -

El operador de exponenciación devuelve el resultado de elevar el primer operando al segundo operando de potencia. es decir, var1var2, en la declaración anterior, donde var1 y var2 son variables. El operador de exponenciación es asociativo a la derecha. a ** b ** c es igual a a ** (b ** c).

- -

Sintaxis

- -
Operador: var1 ** var2
- -

 

- -

Notas

- -

En la mayoría de los lenguajes como PHP y Python y otros que tienen un operador de exponenciación (**), el operador de exponenciación se define para tener una precedencia más alta que los operadores unarios, como unario + y unario -, pero hay algunas excepciones. Por ejemplo, en Bash, el operador ** se define como de menor precedencia que los operadores unarios. En JavaScript, es imposible escribir una expresión de exponenciación ambigua, es decir, no se puede poner un operador unario (+/-/~/!/delete/void/typeof) inmediatamente antes del número de base.

- -
-2 ** 2;
-// 4 en Bash, -4 en otros idiomas.
-// Esto no es válido en JavaScript, ya que la operación es ambigua.
-
-
--(2 ** 2);
-// -4 en JavaScript y la intención del autor no es ambigua.
- -

Ejemplos

- -
2 ** 3        // 8
-3 ** 2        // 9
-3 ** 2.5      // 15.588457268119896
-10 ** -1      // 0.1
-NaN ** 2      // NaN
-
-2 ** 3 ** 2   // 512
-2 ** (3 ** 2) // 512
-(2 ** 3) ** 2 // 64
- -

Para invertir el signo del resultado de una expresión de exponenciación:

- -
-(2 ** 2) // -4
- -

Para forzar la base de una expresión de exponenciación a ser un número negativo:

- -
(-2) ** 2 // 4
- -
-

Nota: JavaScript también tiene un operador bit a bit ^ (logical XOR). ** y ^ son diferentes (por ejemplo: 2 ** 3 === 8 cuando 2 ^ 3 === 1.)

-
- -

 

- -

Incremento (++)

- -

 

- -

El operador de incremento incrementa (agrega uno a) su operando y devuelve un valor.

- - - -

Sintaxis

- -
Operador: x++ o ++x
- -

Ejemplos

- -
// Postfijo
-var x = 3;
-y = x++; // y = 3, x = 4
-
-// Prefijo
-var a = 2;
-b = ++a; // a = 3, b = 3
-
- -

Decremento (--)

- -

El operador de decremento disminuye (resta uno de) su operando y devuelve un valor.

- - - -

Sintaxis

- -
Operador: x-- o --x
- -

Ejemplos

- -
// Postfijo
-var x = 3;
-y = x--; // y = 3, x = 2
-
-// Prefijo
-var a = 2;
-b = --a; // a = 1, b = 1
- -

 

- -

Negación unaria (-)

- -

El operador de negación unaria precede su operando y lo niega.

- -

Sintaxis

- -
Operador: -x
- -

Ejemplos

- -
var x = 3;
-y = -x; // y = -3, x = 3
-
-// el operador de negación unario puede convertir no-números en un número
-var x = "4";
-y = -x; // y = -4
- -

Unario más (+)

- -

El operador unario más precede su operando y evalúa su operando, pero intenta convertirlo en un número, si no lo está. Aunque la negación unaria (-) también puede convertir no números, unario plus es la manera más rápida y preferida de convertir algo en un número, porque no realiza ninguna otra operación en el número. Puede convertir representaciones de cadenas de enteros y flotantes, así como los valores que no sean cadenas true, false y null. Se admiten enteros en formato decimal y hexadecimal ("0x" -prefijado). Los números negativos son compatibles (aunque no para hexadecimal). Si no puede analizar un valor particular, evaluará a NaN.

- -

Sintaxis

- -
Operador: +x
- -

Ejemplos

- -
+3     // 3
-+'3'   // 3
-+true  // 1
-+false // 0
-+null  // 0
-+function(val){  return val } // NaN
- -

 

- -

Especificaciones

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
EspecificaciónEstadoComentario
{{SpecName('ES1')}}{{Spec2('ES1')}}Definición inicial.
{{SpecName('ES5.1', '#sec-11.3')}}{{Spec2('ES5.1')}} -

Definido en varias secciones de la especificación: Operadores aditivos, Operadores multiplicativos, Expresiones Postfijas, Operadores unarios.

-
{{SpecName('ES2015', '#sec-postfix-expressions')}}{{Spec2('ES2015')}} -

Definido en varias secciones de la especificación: Operadores aditivos, Operadores multiplicativos, Expresiones Postfijas, Operadores unarios.

-
{{SpecName('ES2016', '#sec-postfix-expressions')}}{{Spec2('ES2016')}}Operador de exponenciación agregado.
{{SpecName('ES2017', '#sec-postfix-expressions')}}{{Spec2('ES2017')}} 
{{SpecName('ESDraft', '#sec-additive-operators')}}{{Spec2('ESDraft')}} 
- -

Compatibilidad con navegadores

- -

{{Compat("javascript.operators.arithmetic")}}

- -

Ver también

- - - -

 

diff --git a/files/es/web/javascript/referencia/operadores/asignacion/index.html b/files/es/web/javascript/referencia/operadores/asignacion/index.html deleted file mode 100644 index 1fa4b79ac4..0000000000 --- a/files/es/web/javascript/referencia/operadores/asignacion/index.html +++ /dev/null @@ -1,62 +0,0 @@ ---- -title: Asignacion (=) -slug: Web/JavaScript/Referencia/Operadores/Asignacion -tags: - - JS - - JavaScript - - Operador de Asignacion - - Operadores JavaScript - - Referências -translation_of: Web/JavaScript/Reference/Operators/Assignment ---- -
{{jsSidebar("Operators")}}
- -

El operador de asignación (=) se utiliza para asignar un valor a una variable. La operación de asignación evalúa el valor asignado. Es posible encadenar el operador de asignación para asignar un solo valor a múltiples variables

- -
{{EmbedInteractiveExample("pages/js/expressions-assignment.html")}}
- -
- - - -

Sintaxis

- -
Operador: x = y
-
- -

Ejemplos

- -

Asignación

- -
// Asumimos las siguientes variables
-//  x = 5
-//  n = 10
-//  z = 25
-
-x = n     // La variable x contiene el valor 10
-x = n = z // x = n (es decir 10) y z pisa el valor total remplazandolo por 25
- -

Especificaciones

- - - - - - - - - - -
Especificación
{{SpecName('ESDraft', '#sec-assignment-operators', 'Assignment operators')}}
- -

Compatibilidad con Navegadores

- - - -

{{Compat("javascript.operators.assignment")}}

- -

Ver también

- - diff --git a/files/es/web/javascript/referencia/operadores/assignment_operators/index.html b/files/es/web/javascript/referencia/operadores/assignment_operators/index.html deleted file mode 100644 index 979eff63f2..0000000000 --- a/files/es/web/javascript/referencia/operadores/assignment_operators/index.html +++ /dev/null @@ -1,462 +0,0 @@ ---- -title: Operadores de asignación -slug: Web/JavaScript/Referencia/Operadores/Assignment_Operators -tags: - - JavaScript - - Operador -translation_of: Web/JavaScript/Reference/Operators#Assignment_operators -translation_of_original: Web/JavaScript/Reference/Operators/Assignment_Operators ---- -
{{jsSidebar("Operators")}}
- -

Un operador de asignacion asigna un valor al operando de la izquierda basado en el valor del operando de la derecha.

- -

Visión general

- -

El operador de asignación basico es el igual (=), el cual asigna el valor del operando derecho al operando izquierdo. Es decir, x = y asigna el valor de y a x. El otro operador de asignacion son usualmente son abreviaciones para operaciones estandar, como se muestra en las siguientes definiciones y ejemplos.

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
NombresAbreviacionesSignificado
Asignaciónx = yx = y
Asignación de adiciónx += yx = x + y
Asignación de sustracciónx -= yx = x - y
Asignación de multiplicaciónx *= yx = x * y
Asignación de divisiónx /= yx = x / y
Asignación de Restox %= yx = x % y
Asignación de exponenciaciónx **= yx = x ** y
Asignación de desplazamiento a la izquierdax <<= yx = x << y
Asignación de desplazamiento a la derechax >>= yx = x >> y
Asignación sin signo de desplazamiento a la derechax >>>= yx = x >>> y
Asignacion ANDx &= yx = x & y
Asignacion XORx ^= yx = x ^ y
Asignacion ORx |= yx = x | y
- -

Asignación

- -

Operador de asignación simple que asigna un valor a una variable. EL operador de asignación evalua al valor asignado. Encadenando el operador de asignación es posible en orden de asignar un solo valor a multiples variables. Vea el ejemplo.

- -

Sintaxis

- -
Operador: x = y
-
- -

Ejemplos

- -
// Asumiendo las siguientes variables
-//  x = 5
-//  y = 10
-//  z = 25
-
-
-x = y     // x es 10
-x = y = z // x, y, z son todas 25
-
- -

Asignación de Adición

- -

El operador de asignación de suma agrega el valor del operando derecho a la variable y le asigna el resultado a la variable. Los dos tipos de operandos determinan el comportamiento del operador de asignación de adición. Adición o concatenación es posible. Mira el {{jsxref("Operators/Arithmetic_Operators", "operador de adición", "#Addition", 1)}} para más detalles.

- -

Sintaxis

- -
Operador: x += y
-Significado:  x  = x + y
-
- -

Ejemplos

- -
// Asuma las siguientes variables
-//  foo = "foo"
-//  bar = 5
-//  baz = true
-
-
-// Number + Number -> Adición
-bar += 2 // 7
-
-// Boolean + Number -> Adición
-baz += 1 // 2
-
-// Boolean + Boolean -> Adición
-baz += false // 1
-
-// Number + String -> concatenación
-bar += "foo" // "5foo"
-
-// String + Boolean -> concatenación
-foo += false // "foofalse"
-
-// String + String -> concatenación
-foo += "bar" // "foobar"
-
- -

Asignación de Sustracción

- -

El operador de asignación de sustracción sustrae el valor del operador derecho desde la variable y asigna el resultado a la variable. Mira el {{jsxref("Operators/Arithmetic_Operators", "operador de sustracción", "#Subtraction", 1)}} para mas detalles.

- - - -

Sintaxis

- - - -
Operador: x -= y
-Significado:  x  = x - y
-
- -

Ejemplos

- -
// Asumiendo las siguientes variables
-//  bar = 5
-
-bar -= 2     // 3
-bar -= "foo" // NaN
-
- -

Asignación de Multiplicación 

- -

El operador de asignación de multiplicación multiplica la variable por el valor del operando derecho y asigna el resultado a la variable. Vea el  {{jsxref("Operators/Arithmetic_Operators", "Operador de Multiplicación", "#Multiplication", 1)}} para mas detalles.

- -

Sintaxis

- -
Operador: x *= y
-Significado:  x  = x * y
-
- -

Ejemplos

- -
// Asumiendo la siguiente variable
-//  bar = 5
-
-bar *= 2     // 10
-bar *= "foo" // NaN
-
- -

Asignación de división

- -

El operador de asignación de división divide la variable por el valor del operando derecho y asigna el resultado a la variable. Vea el {{jsxref("Operators/Arithmetic_Operators", "operador de división", "#Division", 1)}} para mas detalles.

- -

Sintaxis

- -
Operador: x /= y
-Significado:  x  = x / y
-
- -

Ejemplos

- -
// Asumiendo la siguiente variable
-//  bar = 5
-
-bar /= 2     // 2.5
-bar /= "foo" // NaN
-bar /= 0     // Infinity
-
- -

Asignación  de resto

- -

El operador de asignación de resto divide la variable por el valor del operador derecho y asigna el resto a la variable. Vea el {{jsxref("Operators/Arithmetic_Operators", "Operador de resto", "#Remainder", 1)}} para mas detelles.

- -

Sintaxis

- -
Operador: x %= y
-Significado:  x  = x % y
-
- -

Ejemplos

- -
// Asumiendo la siguiente variable
-//  bar = 5
-
-bar %= 2     // 1
-bar %= "foo" // NaN
-bar %= 0     // NaN
-
- -

Asignación de exponenciación

- -

El operador de asignación de exponente evalua el resultado de elevar primero el operando a la potencia del segundo operando. Vea el {{jsxref("Operators/Bitwise_Operators", "operador de exponenciación", "#Left_shift", 1)}}para mas detalles

- -

Sintaxis

- -
Operador: x **= y
-Significado:  x  = x ** y
-
- -

Ejemplos

- -
// Asumiendo la siguiente variable
-//  bar = 5
-
-bar **= 2     // 25
-bar **= "foo" // NaN
- -

Asignación de desplazamiento a la izquierda

- -

El operador de asignación de desplazamiento a la izquierda mueve una cantidad especifica de bits a la izquierda y asigna el resultado a la variable. Vea el {{jsxref("Operators/Bitwise_Operators", "operador de desplazamiento a la izquierda", "#Left_shift", 1)}} para mas detalles.

- -

Sintaxis

- -
Operador: x <<= y
-Significado:  x   = x << y
-
- -

Ejemplos

- -
var bar = 5; //  (00000000000000000000000000000101)
-bar <<= 2; // 20 (00000000000000000000000000010100)
-
- -

Asignación de desplazamiento a la derecha

- -

El operador de asignación de desplazamiento a la derecha mueve una cantidad especifica de bits a la derecha y asigna el resultado a la variable. Vea el {{jsxref("Operators/Bitwise_Operators", "operador de desplazamiento a la derecha", "#Right_shift", 1)}} para mas detalles.

- -

Sintaxis

- -
Operador: x >>= y
-Significado:  x   = x >> y
-
- -

Ejemplos

- -
var bar = 5; //   (00000000000000000000000000000101)
-bar >>= 2;   // 1 (00000000000000000000000000000001)
-
-var bar -5; //    (-00000000000000000000000000000101)
-bar >>= 2;  // -2 (-00000000000000000000000000000010)
-
- -

Asignación sin signo de desplazamiento a la derecha

- -

El operador de asignación sin signo de desplazamiento a la derecha mueve una cantidad especifica de bits a la derecha y asigna el resultado a la variable. Vea el {{jsxref("Operators/Bitwise_Operators", "operador sin signo de desplazamiento a la derecha", "#Unsigned_right_shift", 1)}} para mas detalles.

- -

Sintaxis

- -
Operador: x >>>= y
-Significado:  x    = x >>> y
-
- -

Ejemplo

- -
var bar = 5; //   (00000000000000000000000000000101)
-bar >>>= 2;  // 1 (00000000000000000000000000000001)
-
-var bar = -5; // (-00000000000000000000000000000101)
-bar >>>= 2; // 1073741822 (00111111111111111111111111111110)
- -

Asignación AND

- -

El operador de asignacion AND usa la representación binaria de ambos operandos, hace una operacion AND en ellos y asigna el resultado a la variable. Vea el {{jsxref("Operators/Bitwise_Operators", "operador AND", "#Bitwise_AND", 1)}} para mas detalles.

- -

Sintaxis

- -
Operador: x &= y
-Significado:  x  = x & y
-
- -

Ejemplo

- -
var bar = 5;
-// 5:     00000000000000000000000000000101
-// 2:     00000000000000000000000000000010
-bar &= 2; // 0
-
- -

Asignación XOR

- -

El operador de asignacion XOR usa la representación binaria de ambos operandos, hace una operacion XOR en ellos y asigna el resultado a la variable. Vea el {{jsxref("Operators/Bitwise_Operators", "operador XOR", "#Bitwise_XOR", 1)}} para mas detalles

- -

Sintaxis

- -
Operador: x ^= y
-Significado:  x  = x ^ y
-
- -

Ejemplo

- -
var bar = 5;
-bar ^= 2; // 7
-// 5: 00000000000000000000000000000101
-// 2: 00000000000000000000000000000010
-// -----------------------------------
-// 7: 00000000000000000000000000000111
-
- -

Asignación OR

- -

El operador de asignacion OR usa la representación binaria de ambos operandos, hace una operacion OR en ellos y asigna el resultado a la variable. Vea el {{jsxref("Operators/Bitwise_Operators", "operador OR", "#Bitwise_XOR", 1)}} para mas detalles

- -

Sintaxis

- -
Operador: x |= y
-Significado:  x  = x | y
-
- -

Ejemplo

- -
var bar = 5;
-bar |= 2; // 7
-// 5: 00000000000000000000000000000101
-// 2: 00000000000000000000000000000010
-// -----------------------------------
-// 7: 00000000000000000000000000000111
-
- -

Ejemplos

- -

Operador izquierdo con otros operadores de asignación

- -

En situaciones inusuales, el operador de asignacion (e.g x += y) no es identico al significado de la expresión (aca x = x + y). Cuando el operando izquierdo de un mismo operador de asignación contiene un operador de asignaciónm el operando izquierdo es evaluado una vez. por ejemplo:

- -
a[i++] += 5         // i es evaluado una vez
-a[i++] = a[i++] + 5 // i es evaluado dos veces
-
- -

Especificaciones

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
EspecificaciónEstadoComentario
{{SpecName('ESDraft', '#sec-assignment-operators', 'Operadores de asignación')}}{{Spec2('ESDraft')}}
{{SpecName('ES6', '#sec-assignment-operators', 'Operadores de asignación')}}{{Spec2('ES6')}}
{{SpecName('ES5.1', '#sec-11.13', 'Operadores de asignación')}}{{Spec2('ES5.1')}}
{{SpecName('ES1', '#sec-11.13', 'Operadores de asignación')}}{{Spec2('ES1')}} -

Definición inicial

-
- -

Compatibilidad de Navegadores

- -

{{CompatibilityTable}}

- -
- - - - - - - - - - - - - - - - - - - -
CaracterísticaChromeFirefox (Gecko)Internet ExplorerOperaSafari
Soporte basico{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
-
- -
- - - - - - - - - - - - - - - - - - - - - -
CaracterísticaAndroidChrome para AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Soporte basico{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
-
- -

Vea tambien

- - diff --git a/files/es/web/javascript/referencia/operadores/async_function/index.html b/files/es/web/javascript/referencia/operadores/async_function/index.html deleted file mode 100644 index 12e76e6ce5..0000000000 --- a/files/es/web/javascript/referencia/operadores/async_function/index.html +++ /dev/null @@ -1,102 +0,0 @@ ---- -title: Expresión de función asíncrona -slug: Web/JavaScript/Referencia/Operadores/async_function -tags: - - Expresión Primaria - - JavaScript - - Operador - - función -translation_of: Web/JavaScript/Reference/Operators/async_function ---- -
{{jsSidebar("Operators")}}
- -

La palabra clave async function puede ser utilizada para definir funciones async dento 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 cuy caso la función es anónima. El nombre es sólo local al cuerpo de la función The name is only local to the function body.
-
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 miuy similar, y casi tiene la misma sintaxis que, una {{jsxref('Statements/async_function', '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 {{Glossary("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

- -
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

- - - - - - - - - - - - -
Especificación
{{SpecName('ESDraft', '#sec-async-function-definitions', 'async function')}}
- -

Compatibilidad de los navegadores

- -
- - -

{{Compat("javascript.operators.async_function_expression")}}

-
- -

Ver también

- - diff --git a/files/es/web/javascript/referencia/operadores/await/index.html b/files/es/web/javascript/referencia/operadores/await/index.html deleted file mode 100644 index d1a84251f1..0000000000 --- a/files/es/web/javascript/referencia/operadores/await/index.html +++ /dev/null @@ -1,102 +0,0 @@ ---- -title: await -slug: Web/JavaScript/Referencia/Operadores/await -translation_of: Web/JavaScript/Reference/Operators/await ---- -
{{jsSidebar("Operators")}}
- -
El operador await es usado para esperar a una {{jsxref("Promise")}}. Sólo puede ser usado dentro de una función {{jsxref("Statements/async_function", "async function")}}.
- -

Sintaxis

- -
[rv] = await expression;
- -
-
expression
-
Una {{jsxref("Promise")}} o cualquier otro valor por el cual haya que esperar.
-
rv
-
-

Regresa el valor terminado de la promesa o solamente un valor si no es unaPromise.

-
-
- -

Descripción

- -

La expresión await provoca que la ejecución de una función async sea pausada hasta que una Promise sea terminada o rechazada, y regresa a la ejecución de la función async después del término. Al regreso de la ejecución, el valor de la expresión await es la regresada por una promesa terminada.

- -

Si la Promise es rechazada, el valor de la expresión await tendrá el valor de rechazo.

- -

Si el valor de la expresión seguida del operador await  no es una promesa, será convertido a una resolved Promise.

- -

Ejemplos

- -

Si una Promise se pasa a una expresión await, espera a que la Promise se resuelva y devuelve el valor resuelto.

- -
function resolveAfter2Seconds(x) {
-  return new Promise(resolve => {
-    setTimeout(() => {
-      resolve(x);
-    }, 2000);
-  });
-}
-
-async function f1() {
-  var x = await resolveAfter2Seconds(10);
-  console.log(x); // 10
-}
-f1();
-
- -

Si el valor no es una Promise, convierte el valor a una Promise resuelta, y espera por dicho valor.

- -
async function f2() {
-  var y = await 20;
-  console.log(y); // 20
-}
-f2();
- -

Si la Promise es rechazada, se lanza una excepción con dicho el valor.

- -
async function f3() {
-  try {
-    var z = await Promise.reject(30);
-  } catch(e) {
-    console.log(e); // 30
-  }
-}
-f3();
- -

Especificaciones

- - - - - - - - - - - - - - - - -
SpecificationStatusComment
{{SpecName('ESDraft', '#sec-async-function-definitions', 'async functions')}}{{Spec2('ESDraft')}}Initial definition in ES2017.
- -

Compatibilidad con navegadores

- -
- - -

{{Compat("javascript.operators.await")}}

-
- -

Véase también

- - diff --git a/files/es/web/javascript/referencia/operadores/bitwise_operators/index.html b/files/es/web/javascript/referencia/operadores/bitwise_operators/index.html deleted file mode 100644 index c4276c1c95..0000000000 --- a/files/es/web/javascript/referencia/operadores/bitwise_operators/index.html +++ /dev/null @@ -1,722 +0,0 @@ ---- -title: Operadores a nivel de bit -slug: Web/JavaScript/Referencia/Operadores/Bitwise_Operators -tags: - - JavaScript - - Operador -translation_of: Web/JavaScript/Reference/Operators -translation_of_original: Web/JavaScript/Reference/Operators/Bitwise_Operators ---- -
{{jsSidebar("Operators")}}
- -

Los operadores a nivel de bit tratan sus operandos como una secuencia de 32 bits (unos y ceros) en lugar de números decimales, hexadecimales u octales.  Por ejemplo, el número decimal nueve tiene una representación binaria de 1001. Los operadores a nivel de bit realizan las operaciones en esas representaciones binarias, pero los valores devueltos son los valores numéricos estándar de JavaScript.

- -

La siguiente tabla resume los operadores a nivel de bit de JavaScript:

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
OperadorUsoDescripción
AND binarioa & bDevuelve un uno en cada posición en la que ambos operandos sea uno.
OR binario a | bDevuelve un uno en cada posición en la que uno o ambos operandos sea uno.
Bitwise XORa ^ bDevuelve un uno en cada posición en la que los bits correspondientes en cada uno de los operandos, pero no en ambos, es uno. 
Bitwise NOT~ aInvierte los bits del operando.
Left shifta << bDesplaza en representación binaria b (< 32) bits a la izquierda, desplazando en ceros desde la derecha.
Sign-propagating right shifta >> bDesplaza en representación binaria b (< 32) bits a la derecha, descartando los bits desplazados fuera.
Zero-fill right shifta >>> bDesplaza en representación binaria b (< 32) bits a la derecha, desplazando en ceros desde la izquierda.
- -

Enteros con signo de 32 bits

- -

Los operandos de todas las operaciones bitwise son convertidos a enteros con signo de 32 bits en complemento a dos. Complemento a dos significa que el equivalente negativo de un número (por ejemplo, 5 y -5) es igual a todos los bits del número invertido (un NOT del número, también conocido como el compelemento a uno del número) más uno. Por ejemplo, a continuación se codifica el entero 314:

- -
00000000000000000000000100111010
-
- -

A continuación se codifica ~314 como complemento a uno de 314:

- -
11111111111111111111111011000101
-
- -

Por último, se codifica -314 como complemento a dos de 314:

- -
11111111111111111111111011000110
-
- -

El complemento a dos garantiza que el bit más a la izquierda es 0 cuando el número es positivo, y 1 cuando el número es negativo. Por esto es llamado bit de signo.

- -

El número 0 es el entero compuesto íntegramente por bits en 0.

- -
0 (base 10) = 00000000000000000000000000000000 (base 2)
-
-
- -

El número -1 es el entero compuesto íntegramente por bits de 1.

- -
-1 (base 10) = 11111111111111111111111111111111 (base 2)
-
- -

El número -2147483648 (representación hexadecimal: -0x80000000) es el entero compuesto íntegramente por bits de 0 excepto el de más a la izquierda.

- -
-2147483648 (base 10) = 10000000000000000000000000000000 (base 2)
-
- -

El número 2147483647 (representación hexadecimal: 0x7fffffff) es el entero compuesto íntegramente por bits de 1 excepto el de más a la izquierda. 

- -
2147483647 (base 10) = 01111111111111111111111111111111 (base 2)
-
- -

Los números -2147483648 and 2147483647 son el mínimo y el máximo entero que se pueden representar con signo de 32 bits.

- -

Operadores lógicos a nivel de bit

- -

Conceptualmente, los operadores lógicos bit a bit funcionan de la siguiente manera:

- - - -

& (Bitwise AND o AND a nivel de bits)

- -

Corresponde al operador lógico & o "Y". Ejecuta la operación AND en cada par de bits, a AND b es 1 sólo si tanto a como b son 1. La tabla de verdad del operador AND es:

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
aba AND b
000
010
100
111
- -
     9 (base 10) = 00000000000000000000000000001001 (base 2)
-    14 (base 10) = 00000000000000000000000000001110 (base 2)
-                   --------------------------------
-14 & 9 (base 10) = 00000000000000000000000000001000 (base 2) = 8 (base 10)
-
- -

El resultado de hacer un AND de cualquier número x con 0 es 0, mientras que el de hacer un AND de cualquier número x con -1 da como resultado x. 

- -

| (Bitwise OR o  OR a nivel de bits)

- -

Realiza la operación OR en cada par de bits. a OR b devuelve 1 si a o b son 1. La tabla de verdad para la operación OR es la siguiente:

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
aba OR b
000
011
101
111
- -
     9 (base 10) = 00000000000000000000000000001001 (base 2)
-    14 (base 10) = 00000000000000000000000000001110 (base 2)
-                   --------------------------------
-14 | 9 (base 10) = 00000000000000000000000000001111 (base 2) = 15 (base 10)
-
- -

Ejecutar la operación OR sobre cualquier número x y 0 devuelve x. Ejecutar OR sobre cualquier número X y -1 devuelve -1.

- -

^ (Bitwise XOR o XOR a nivel de bits)

- -

Realiza la operación XOR en cada par de bits. a OR b devuelve 1 si a o b son diferentes. La tabla de verdad para la operación OR es la siguiente:

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
aba XOR b
000
011
101
110
- -
     9 (base 10) = 00000000000000000000000000001001 (base 2)
-    14 (base 10) = 00000000000000000000000000001110 (base 2)
-                   --------------------------------
-14 ^ 9 (base 10) = 00000000000000000000000000000111 (base 2) = 7 (base 10)
-
- -

Ejecutar la operación XOR sobre cualquier número x y 0 devuelve x. Ejecutar la operación XOR sobre cualquier número x y -1 devuelve ~x

- -

~ (Bitwise NOT o Negación a nivel de bits)

- -

Realiza la operación NOT a cada bit. NOT devuelve el valor invertido ( conocido como complementario). La tabla de verdad para la operación NOT es la siguiente:

- - - - - - - - - - - - - - - - -
aNOT a
01
10
- -

 

- -
 9 (base 10) = 00000000000000000000000000001001 (base 2)
-               --------------------------------
-~9 (base 10) = 11111111111111111111111111110110 (base 2) = -10 (base 10)
-
- -

 

- -

Ejecutar la operación NOT sobre cualquier número x devuelve -(x+1). Por ejemplo -5 devuelve 4.

- -

Ejemplo con indexOf:

- -
var str = 'rawr';
-var searchFor = 'a';
-
-// esta es un forma alternativa de escribir (-1*str.indexOf('a') <= 0)
-if (~str.indexOf(searchFor)) {
-  // searchFor esta en el string
-} else {
-  // searchFor no esta en el string
-}
-
-// aquí verás los valores que retorna (~str.indexOf(searchFor))
-// r == -1
-// a == -2
-// w == -3
-
- -

Operadores de desplazamiento a nivel de bit

- -

Los operadores de desplazamiento toman dos operandos: el primero es la cantidad a ser desplazados, y el segundo especifica el número de posiciones bits que el primer operando debe ser desplazado. El sentido del operador de desplazamiento es determinado por el operador utilizado.

- -

Shift operators u operadores de desplazamiento, convierten sus operandos a enteros de 32-bit en orden big-endian y retorna el resultado del mismo tipo que el operando izquierdo. El operador derecho debe ser menor que 32, de lo contrario solo se usaran los ultimos cinco bits mas bajos.

- -

<< (Desplazamiento a la izquierda)

- -

Este operador desplaza el primer operando el número especificado de bits a la izquierda. Los bits en exceso desplazados hacia la izquierda se descartan. Los bits cero se desplazan desde la derecha.

- -

Por ejemplo, 9 << 2 devuelve 36:

- -
     9 (base 10): 00000000000000000000000000001001 (base 2)
-                  --------------------------------
-9 << 2 (base 10): 00000000000000000000000000100100 (base 2) = 36 (base 10)
-
- -

Desplazar a la izquierda cualquier número x por y bits da por resultado x * 2^y.

- -

>> (Desplazamiento a la derecha con propagación de signo o Desplazamiento aritmético a la derecha)

- -

Este operador desplaza el primer operando la cantidad de bits especificada a la derecha. Los bits en exceso desplazados a la derecha se descartan. Las copias del bit del extremo izquierdo se desplazan desde la izquierda. Como el nuevo bit más a la izquierda tiene el mismo valor que el bit anterior más a la izquierda, el bit de signo (el bit más a la izquierda) no cambia. De ahí el nombre "propagación de signo".

- -

Por ejemplo, 9 >> 2 devuelve 2:

- -
     9 (base 10): 00000000000000000000000000001001 (base 2)
-                  --------------------------------
-9 >> 2 (base 10): 00000000000000000000000000000010 (base 2) = 2 (base 10)
-
- -

Igualmente, -9 >> 2 devuelve-3, porque se mantiene el signo:

- -
     -9 (base 10): 11111111111111111111111111110111 (base 2)
-                   --------------------------------
--9 >> 2 (base 10): 11111111111111111111111111111101 (base 2) = -3 (base 10)
-
- -

>>> (Desplazamiento a la derecha con relleno de ceros o Desplazamiento lógico )

- -

Este operador desplaza el primer operando la cantidad de bits especificada a la derecha. Los bits en exceso desplazados a la derecha se descartan. Ceros son despalzadas o introducidos desde la izquierda. El bit de signo aútomaticamente se convierte 0, así que el resultado siempre es pósitivo. 

- -


- Para números no negativos, el desplazamiento lógico y arítmetico dan el mismo resultado. Por ejemplo, 9 >>> 2 da 2, al igual que 9 >> 2:

- -
      9 (base 10): 00000000000000000000000000001001 (base 2)
-                   --------------------------------
-9 >>> 2 (base 10): 00000000000000000000000000000010 (base 2) = 2 (base 10)
-
- -

Sin embargo, no es el caso para números negativos. Por ejemplo, -9 >>> 2 da 1073741821, que es diferente de  -9 >> 2 (que da -3):

- -
      -9 (base 10): 11111111111111111111111111110111 (base 2)
-                    --------------------------------
--9 >>> 2 (base 10): 00111111111111111111111111111101 (base 2) = 1073741821 (base 10)
-
- -

Ejemplos

- -

Banderas y máscaras de bits

- -

Los operadores lógicos a nivel de bits se utilizan a menudo para crear, manipular y leer secuencias de indicadores, que son como variables binarias. Se podrían usar variables en lugar de estas secuencias, pero las banderas binarias toman mucho menos memoria (por un factor de 32).

- -

Supongamos que hay 4 banderas:

- - - -

Estas banderas están representadas por una secuencia de bits: DCBA. Cuando se establece un indicador, tiene un valor de 1. Cuando se elimina un indicador, tiene un valor de 0. Suponga que los indicadores de una variable tienen el valor binario 0101:

- -
var flags = 5;   // binary 0101
-
- -

Este valor indica:

- - - -

Dado que los operadores bitwise son de 32 bits, 0101 es en realidad 0000000000000000000000000000000101, pero los ceros anteriores pueden ignorarse ya que no contienen información significativa.

- -

Una máscara de bits es una secuencia de bits que puede manipular y / o leer banderas. Normalmente, se define una máscara de bits "primitiva" para cada bandera:

- -
var FLAG_A = 1; // 0001
-var FLAG_B = 2; // 0010
-var FLAG_C = 4; // 0100
-var FLAG_D = 8; // 1000
-
- -

Se pueden crear nuevas máscaras de bits utilizando los operadores lógicos a nivel de bits en estas máscaras de bits primitivas. Por ejemplo, la máscara de bits 1011 se puede crear mediante ORing FLAG_A, FLAG_B y FLAG_D:

- -
var mask = FLAG_A | FLAG_B | FLAG_D; // 0001 | 0010 | 1000 => 1011
-
- -

Los valores de los indicadores individuales se pueden extraer mediante AND con una máscara de bits, donde cada bit con el valor de uno "extraerá" el indicador correspondiente. La máscara de bits enmascara las marcas no relevantes mediante AND con ceros (de ahí el término "bitmask"). Por ejemplo, la máscara de bits 0101 se puede usar para ver si el indicador C está establecido:

- -
// if we own a cat
-if (flags & FLAG_C) { // 0101 & 0100 => 0100 => true
-   // do stuff
-}
-
- -

Una máscara de bits con varios indicadores establecidos actúa como un "either/or". Por ejemplo, los siguientes dos son equivalentes:

- -
// if we own a bat or we own a cat
-// (0101 & 0010) || (0101 & 0100) => 0000 || 0100 => true
-if ((flags & FLAG_B) || (flags & FLAG_C)) {
-   // do stuff
-}
-
- -
// if we own a bat or cat
-var mask = FLAG_B | FLAG_C; // 0010 | 0100 => 0110
-if (flags & mask) { // 0101 & 0110 => 0100 => true
-   // do stuff
-}
-
- -

Los indicadores se pueden establecer mediante ORing con una máscara de bits, donde cada bit con el valor uno establecerá el indicador correspondiente, si ese indicador no está ya establecido. Por ejemplo, la máscara de bits 1100 se puede utilizar para establecer los indicadores C y D:

- -
// yes, we own a cat and a duck
-var mask = FLAG_C | FLAG_D; // 0100 | 1000 => 1100
-flags |= mask;   // 0101 | 1100 => 1101
-
- -

Los indicadores se pueden borrar ANDing con una máscara de bits, donde cada bit con el valor cero borrará el indicador correspondiente, si aún no se ha borrado. Esta máscara de bits se puede crear NOTing las máscaras de bits primitivas. Por ejemplo, la máscara de bits 1010 se puede utilizar para borrar los indicadores A y C:

- -
// no, we don't have an ant problem or own a cat
-var mask = ~(FLAG_A | FLAG_C); // ~0101 => 1010
-flags &= mask;   // 1101 & 1010 => 1000
-
- -

La máscara también podría haberse creado con ~ FLAG_A & ~ FLAG_C (ley de De Morgan):

- -
// no, we don't have an ant problem, and we don't own a cat
-var mask = ~FLAG_A & ~FLAG_C;
-flags &= mask;   // 1101 & 1010 => 1000
-
- -

Los indicadores se pueden alternar mediante XORing con una máscara de bits, donde cada bit con el valor uno cambiará el indicador correspondiente. Por ejemplo, la máscara de bits 0110 se puede utilizar para alternar los indicadores B y C:

- -
// if we didn't have a bat, we have one now,
-// and if we did have one, bye-bye bat
-// same thing for cats
-var mask = FLAG_B | FLAG_C;
-flags = flags ^ mask;   // 1100 ^ 0110 => 1010
-
- -

Finalmente, todas las banderas se pueden voltear con el operador NOT:

- -
// entering parallel universe...
-flags = ~flags;    // ~1010 => 0101
-
- -

Fragmentos de conversión

- -

Convert a binary String to a decimal Number:

- -
var sBinString = "1011";
-var nMyNumber = parseInt(sBinString, 2);
-alert(nMyNumber); // prints 11, i.e. 1011
-
- -

 

- -

Convierte una cadena binaria a un número decimal:

- -

 

- -
var nMyNumber = 11;
-var sBinString = nMyNumber.toString(2);
-alert(sBinString); // prints 1011, i.e. 11
-
- -

Automatiza la creación de una máscara.

- -

Si tiene que crear muchas máscaras a partir de algunos valores booleanos, puede automatizar el proceso:

- -
function createMask () {
-  var nMask = 0, nFlag = 0, nLen = arguments.length > 32 ? 32 : arguments.length;
-  for (nFlag; nFlag < nLen; nMask |= arguments[nFlag] << nFlag++);
-  return nMask;
-}
-var mask1 = createMask(true, true, false, true); // 11, i.e.: 1011
-var mask2 = createMask(false, false, true); // 4, i.e.: 0100
-var mask3 = createMask(true); // 1, i.e.: 0001
-// etc.
-
-alert(mask1); // prints 11, i.e.: 1011
-
- -

Algoritmo inverso: una matriz de valores booleanos de una máscara

- -

Si desea crear una matriz de valores booleanos a partir de una máscara, puede usar este código:

- -
function arrayFromMask (nMask) {
-  // nMask must be between -2147483648 and 2147483647
-  if (nMask > 0x7fffffff || nMask < -0x80000000) {
-    throw new TypeError("arrayFromMask - out of range");
-  }
-  for (var nShifted = nMask, aFromMask = []; nShifted;
-       aFromMask.push(Boolean(nShifted & 1)), nShifted >>>= 1);
-  return aFromMask;
-}
-
-var array1 = arrayFromMask(11);
-var array2 = arrayFromMask(4);
-var array3 = arrayFromMask(1);
-
-alert("[" + array1.join(", ") + "]");
-// prints "[true, true, false, true]", i.e.: 11, i.e.: 1011
-
- -

Puedes probar ambos algoritmos al mismo tiempo ...

- -
var nTest = 19; // our custom mask
-var nResult = createMask.apply(this, arrayFromMask(nTest));
-
-alert(nResult); // 19
-
- -

Solo para fines didácticos (ya que existe el método Number.toString (2)), mostramos cómo es posible modificar el algoritmo arrayFromMask para crear una cadena que contenga la representación binaria de un número, en lugar de una matriz de booleanos:

- -
function createBinaryString (nMask) {
-  // nMask must be between -2147483648 and 2147483647
-  for (var nFlag = 0, nShifted = nMask, sMask = ""; nFlag < 32;
-       nFlag++, sMask += String(nShifted >>> 31), nShifted <<= 1);
-  return sMask;
-}
-
-var string1 = createBinaryString(11);
-var string2 = createBinaryString(4);
-var string3 = createBinaryString(1);
-
-alert(string1);
-// prints 00000000000000000000000000001011, i.e. 11
-
- -

Specifications

- - - - - - - - - - - - - - - - - - - - - - - - -
SpecificationStatusComment
{{SpecName('ES1')}}{{Spec2('ES1')}}Definicion inicial
{{SpecName('ES5.1', '#sec-11.7')}}{{Spec2('ES5.1')}}Definido en varias secciones de la especificación: operador NOT a nivel de bit, operadores de cambio a nivel de bit, operadores a nivel de bit binarios
{{SpecName('ES6', '#sec-bitwise-shift-operators')}}{{Spec2('ES6')}}Definido en varias secciones de la especificación: operador NOT a nivel de bit, operadores de cambio a nivel de bit, operadores a nivel de bit binarios
- -

Compatibilidad del navegador

- -

{{CompatibilityTable}}

- -
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Bitwise NOT (~){{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
Bitwise AND (&){{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
Bitwise OR (|){{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
Bitwise XOR (^){{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
Left shift (<<){{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
Right shift (>>){{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
Unsigned right shift (>>>){{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
-
- -
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
FeatureAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Bitwise NOT (~){{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
Bitwise AND (&){{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
Bitwise OR (|){{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
Bitwise XOR (^){{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
Left shift (<<){{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
Right shift (>>){{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
Unsigned right shift (>>>){{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
-
- -

Ver también

- - diff --git a/files/es/web/javascript/referencia/operadores/class/index.html b/files/es/web/javascript/referencia/operadores/class/index.html deleted file mode 100644 index e654359035..0000000000 --- a/files/es/web/javascript/referencia/operadores/class/index.html +++ /dev/null @@ -1,157 +0,0 @@ ---- -title: expresión class -slug: Web/JavaScript/Referencia/Operadores/class -tags: - - Classes - - ECMAScript6 - - Expression - - JavaScript - - Operator - - Reference -translation_of: Web/JavaScript/Reference/Operators/class ---- -
{{jsSidebar("Operators")}}
- -

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.

- -
'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".

- -
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.

- -
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

- - - - - - - - - - - - - - - - - - - -
EspecificaciónEstadoComentario
{{SpecName('ES6', '#sec-class-definitions', 'Class definitions')}}{{Spec2('ES6')}}Definición inicial.
{{SpecName('ESDraft', '#sec-class-definitions', 'Class definitions')}}{{Spec2('ESDraft')}} 
- -

Compatibilidad en navegadores

- -

{{CompatibilityTable}}

- -
- - - - - - - - - - - - - - - - - - - -
CaracterísticaChromeFirefox (Gecko)Internet ExplorerOperaSafari
Soporte básico{{CompatChrome(42.0)}}{{CompatGeckoDesktop(45)}}{{CompatUnknown}}{{CompatUnknown}}{{CompatUnknown}}
-
- -
- - - - - - - - - - - - - - - - - - - - - - - -
CaracterísticaAndroidAndroid WebviewFirefox Mobile (Gecko)IE MobileOpera MobileSafari MobileChrome para Android
Soporte básico{{CompatNo}}{{CompatChrome(42.0)}}{{CompatGeckoMobile(45)}}{{CompatUnknown}}{{CompatUnknown}}{{CompatUnknown}}{{CompatChrome(42.0)}}
-
- -

Ver también

- - diff --git a/files/es/web/javascript/referencia/operadores/comparacion/index.html b/files/es/web/javascript/referencia/operadores/comparacion/index.html deleted file mode 100644 index c60efcaada..0000000000 --- a/files/es/web/javascript/referencia/operadores/comparacion/index.html +++ /dev/null @@ -1,129 +0,0 @@ ---- -title: Comparación (==) -slug: Web/JavaScript/Referencia/Operadores/Comparacion -tags: - - JS - - JavaScript - - Operador de comparacion - - Operadores - - Referências -translation_of: Web/JavaScript/Reference/Operators/Equality ---- -
{{jsSidebar("Operators")}}
- -

El operador de comparacion  (==) comprueba si sus dos operandos son iguales y devuelve un resultado booleano. A diferencia del operador de igualdad estricta (===), es que este convierte y compara operandos que son de diferentes tipos.

- -
{{EmbedInteractiveExample("pages/js/expressions-equality.html")}}
- - - -

Sintaxis

- -
x == y
-
- -

Descripción

- -

Los operadores de igualdad (==y !=) Utilizan el algoritmo de comparación de igualdad abstracta para comparar dos operandos. Esto se puede resumir a grandes rasgos como:

- - - -

La diferencia más notable entre este operador y el operador de igualdad estricta (===) es que el operador de igualdad estricta no realiza la conversión de tipos. 

- -

Ejemplos

- -

Comparación sin conversión de tipo

- -
1 == 1;              // true
-"Hola" == "Hola";  // true
- -

Comparación con conversión de tipos

- -
"1" ==  1;            // true
-1 == "1";             // true
-0 == false;           // true
-0 == null;            // false
-0 == undefined;       // false
-0 == !!null;          // true, Operador Logico NOT
-0 == !!undefined;     // true, Operador Logico NOT
-null == undefined;    // true
-
-const number1 = new Number(3);
-const number2 = new Number(3);
-number1 == 3;         // true
-number1 == number2;   // false
- -

Comparación de objetos

- -
const object1 = {"key": "value"}
-const object2 = {"key": "value"};
-
-object1 == object2 // false
-object2 == object2 // true
- -

Comparar String y objetos String

- -

Tenga en cuenta que las cadenas construidas con new String() son objetos. Si compara uno de estos con un String literal, el objeto String se convertirá en un String literal y se comparará el contenido. Sin embargo, si ambos operandos son objetos de tipo String, entonces se comparan como objetos y deben hacer referencia al mismo objeto para que la comparación sea exitosa:

- -
const string1 = "Hola";
-const string2 = String("Hola");
-const string3 = new String("Hola");
-const string4 = new String("Hola");
-
-console.log(string1 == string2); // true
-console.log(string1 == string3); // true
-console.log(string2 == string3); // true
-console.log(string3 == string4); // false
-console.log(string4 == string4); // true
- -

Comparación de fechas y cadenas

- -
const d = new Date('December 17, 1995 03:24:00');
-const s = d.toString(); // Por ejemplo: "Sun Dec 17 1995 03:24:00 GMT-0800 (Hora estándar del Pacífico)"
-console.log(d == s);    //true
- -

Especificaciones

- - - - - - - - - - - - -
Especificaciones
{{SpecName('ESDraft', '#sec-equality-operators', 'Equality operators')}}
- -

Compatibilidad con Navegadores

- - - -

{{Compat("javascript.operators.equality")}}

- -

Ver también

- - diff --git a/files/es/web/javascript/referencia/operadores/comparison_operators/index.html b/files/es/web/javascript/referencia/operadores/comparison_operators/index.html deleted file mode 100644 index 8685790d2c..0000000000 --- a/files/es/web/javascript/referencia/operadores/comparison_operators/index.html +++ /dev/null @@ -1,262 +0,0 @@ ---- -title: Operadores de Comparación -slug: Web/JavaScript/Referencia/Operadores/Comparison_Operators -tags: - - JavaScript - - Operador - - Referencia -translation_of: Web/JavaScript/Reference/Operators -translation_of_original: Web/JavaScript/Reference/Operators/Comparison_Operators ---- -
{{jsSidebar("Operators")}}
- -

JavaScript tiene comparaciones estrictas y de conversión de tipos. Una comparación estricta (por ejemplo, ===) solo es verdadera si los operandos son del mismo tipo y los contenidos coinciden. La comparación abstracta más comúnmente utilizada (por ejemplo, ==) convierte los operandos al mismo tipo antes de hacer la comparación. Para las comparaciones abstractas relacionales (p. Ej., <=), Los operandos primero se convierten en primitivos, y luego en el mismo tipo, antes de la comparación.

- -

Las cadenas se comparan en base al orden lexicográfico estándar, utilizando valores Unicode.

- -
console.log(1 == 1)
-// Esperamos True
-
-console.log("1" == 1 )
-// Esperamos true
-
-console.log( 1 === 1)
-// Esperamos true
-
-console.log( "1" === 1)
-// Esperamos false
-
- -

Características de las comparaciones:

- - - -

Operadores de igualdad

- -

Igualdad (==)

- -

El operador de igualdad convierte los operandos si no son del mismo tipo, luego aplica una comparación estricta. Si ambos operandos son objetos, entonces JavaScript compara las referencias internas que son iguales cuando los operandos se refieren al mismo objeto en la memoria.

- -

Sintaxis

- -
x == y
-
- -

Ejemplos

- -
1    ==  1         // true
-'1'  ==  1         // true
-1    == '1'        // true
-0    == false      // true
-0    == null       // false
-var object1 = {'key': 'value'}, object2 = {'key': 'value'};
-object1 == object2 // false
-0    == undefined  // false
-null == undefined  // true
-
- -

Desigualdad (!=)

- -

El operador de desigualdad devuelve verdadero si los operandos no son iguales. Si los dos operandos no son del mismo tipo, JavaScript intenta convertir los operandos a un tipo apropiado para la comparación. Si ambos operandos son objetos, entonces JavaScript compara las referencias internas que no son iguales cuando los operandos se refieren a diferentes objetos en la memoria.

- -

Sintaxis

- -
x != y
- -

Ejemplos

- -
1 !=   2     // true
-1 !=  '1'    // false
-1 !=  "1"    // false
-1 !=  true   // false
-0 !=  false  // false
-
- -

Identidad / igualdad estricta (===)

- -

El operador de identidad devuelve verdadero si los operandos son estrictamente iguales (ver arriba) sin conversión de tipo.

- -

Sintaxis

- -
x === y
- -

Ejemplos

- -
3 === 3   // true
-3 === '3' // false
-var object1 = {'key': 'value'}, object2 = {'key': 'value'};
-object1 === object2 // false
- - - -

Sin identidad / desigualdad estricta (!==)

- -

El operador sin identidad devuelve verdadero si los operandos no son iguales y / o no del mismo tipo.

- -

Sintaxis

- -
x !== y
- -

Ejemplos

- -
3 !== '3' // true
-4 !== 3   // true
-
- -

Operadores relacionales

- -

Cada uno de estos operadores llamará a la función valueOf() en cada operando antes de realizar una comparación.

- -

Operador mayor que (>)

- -

El operador mayor que, devuelve verdadero si el operando izquierdo es mayor que el operando derecho.

- -

Sintaxis

- -
x > y
- -

Ejemplos

- -
4 > 3 // true
-
- -

Operador mayor o igual (>=)

- -

El operador mayor o igual que, devuelve verdadero si el operando izquierdo es mayor o igual que el operando derecho.

- -

Sintaxis

- -
 x >= y
- -

Ejemplos

- -
4 >= 3 // true
-3 >= 3 // true
-
- -

Operador menor que (<)

- -

El operador menor que devuelve verdadero si el operando de la izquierda es menor que el operando de la derecha.

- -

Sintaxis

- -
 x < y
- -

Ejemplos

- -
3 < 4 // true
-
- -

Operador menor o igual (<=)

- -

El operador menor o igual devuelve verdadero si el operando izquierdo es menor o igual que el operando derecho.

- -

Sintaxis

- -
 x <= y
- -

Ejemplos

- -
3 <= 4 // true
-
- -

Usando los operadores de igualdad

- -

Los operadores de igualdad estándar (== y !=) utilizan el Algoritmo de Comparación de Igualdad Abstracta para comparar dos operandos. Si los operandos son de tipos diferentes, intentará convertirlos al mismo tipo antes de hacer la comparación, por ejemplo, en la expresión 5 == '5', la cadena de la derecha se convierte a {{jsxref("Number")}} antes de realizar la comparación.

- -

Los operadores de igualdad estricta (=== y !==) usan el Algoritmo de Comparación de Igualdad Estricta y están destinados a realizar comparaciones de igualdad en operandos del mismo tipo. Si los operandos son de tipos diferentes, el resultado siempre es false, entonces 5 !== '5'.

- -

Utilice operadores de igualdad estrictos si los operandos deben ser de un tipo específico así como de valor o si el tipo exacto de los operandos es importante. De lo contrario, utilice los operadores de igualdad estándar, que le permiten comparar la identidad de dos operandos, incluso si no son del mismo tipo.

- -

Cuando la conversión de tipo está involucrada en la comparación (es decir, comparación no estricta), JavaScript convierte los tipos {{jsxref("String")}}, {{jsxref("Number")}}, {{jsxref("Boolean")}} o {{jsxref("Object")}} operandos de la siguiente manera:

- - - -
Nota: Los objetos de cadena son Tipo Objeto, no String! Los objetos de cadena rara vez se utilizan, por lo que los siguientes resultados pueden ser sorprendentes:
- -
// true, ya que ambos operandos son de tipo String (es decir, primitivas de cadena):
-'foo' === 'foo'
-
-var a = new String('foo');
-var b = new String('foo');
-
-// false como a y b son tipo Objeto y referencia a diferentes objetos
-a == b
-
-// false como a y b son tipo Objeto y referencia a diferentes objetos
-a === b
-
-// true como a y 'foo' son de tipo diferente y, el Objeto (a)
-// se convierte en cadena 'foo' antes de la comparación
-a == 'foo'
- -

Especificaciones

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
EspecificaciónEstadoComentario
{{SpecName('ES1')}}{{Spec2('ES1')}}Definición inicial. Implementado en JavaScript 1.0
{{SpecName('ES3')}}{{Spec2('ES3')}} -

Agrega === y !== operadores. Implementado en JavaScript 1.3

-
{{SpecName('ES5.1', '#sec-11.8')}}{{Spec2('ES5.1')}} -

Definido en varias secciones de la especificación: Operadores Relacionales, Operadores de Igualdad

-
{{SpecName('ES6', '#sec-relational-operators')}}{{Spec2('ES6')}} -

Definido en varias secciones de la especificación: Operadores Relacionales, Operadores de Igualdad

-
{{SpecName('ESDraft', '#sec-relational-operators')}}{{Spec2('ESDraft')}} -

Definido en varias secciones de la especificación: Operadores Relacionales, Operadores de Igualdad

-
- -

Compatibilidad con navegadores

- - - -

{{Compat("javascript.operators.comparison")}}

- -

Ver también

- - diff --git a/files/es/web/javascript/referencia/operadores/conditional_operator/index.html b/files/es/web/javascript/referencia/operadores/conditional_operator/index.html deleted file mode 100644 index 6b48295902..0000000000 --- a/files/es/web/javascript/referencia/operadores/conditional_operator/index.html +++ /dev/null @@ -1,171 +0,0 @@ ---- -title: Operador condicional (ternario) -slug: Web/JavaScript/Referencia/Operadores/Conditional_Operator -tags: - - JavaScript - - Operador -translation_of: Web/JavaScript/Reference/Operators/Conditional_Operator ---- -
{{jsSidebar("Operators")}}
- -
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:

- -
"La Cuota es de:  " + (isMember ? "$2.00" : "$10.00")
-
- -

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

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

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

- -
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:

- -
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:

- -
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.

- -
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

- - - - - - - - - - - - - - - - - - - - - - - - -
EspecificaciónEstadoComentario
{{SpecName('ES6', '#sec-conditional-operator', 'Conditional Operator')}}{{Spec2('ES6')}} 
{{SpecName('ES5.1', '#sec-11.12', 'The conditional operator')}}{{Spec2('ES5.1')}} 
{{SpecName('ES1', '#sec-11.12', 'The conditional operator')}}{{Spec2('ES1')}}Definición inicial implementada en JavaScript 1.0.
- -

Compatibilidad de navegadores

- -

{{CompatibilityTable}}

- -
- - - - - - - - - - - - - - - - - - - -
CaracterísticaChromeFirefox (Gecko)Internet ExplorerOperaSafari
Soporte básico{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
-
- -
- - - - - - - - - - - - - - - - - - - - - -
CaracterísticaAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Soporte básico{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
-
- -

Véase también

- - diff --git a/files/es/web/javascript/referencia/operadores/decremento/index.html b/files/es/web/javascript/referencia/operadores/decremento/index.html deleted file mode 100644 index 01fa5f0ee2..0000000000 --- a/files/es/web/javascript/referencia/operadores/decremento/index.html +++ /dev/null @@ -1,83 +0,0 @@ ---- -title: Decremento(--) -slug: Web/JavaScript/Referencia/Operadores/Decremento -tags: - - Decremento - - JavaScript - - JavaScript basico - - Operadores -translation_of: Web/JavaScript/Reference/Operators/Decrement ---- -
{{jsSidebar("Operators")}}
- -

El operador de decremento (--) disminuye (o resta de a uno) su operando y retorna un valor.

- -
{{EmbedInteractiveExample("pages/js/expressions-decrement.html")}}
- -
- - - -

Sintaxis

- -
Operadores: x-- o --x
-
- -

Descripción

- -

Si usamos la forma de sufijo, operador después del operando (por ejemplo, x--), el operador de disminución disminuye y devuelve el valor antes de disminuir.

- -

Si se usamos la forma de prefijo, operador antes del operando (por ejemplo, --x), el operador de disminución disminuye y devuelve el valor después de disminuir.

- -

Ejemplos

- -

Usando Sufijo 

- -
let x = 3;
-y = x--;
-
-// y = 3
-// x = 2
-
- -

Usando Prefijo

- -
let a = 2;
-b = --a;
-
-// a = 1
-// b = 1
-
- -

Especificaciones

- - - - - - - - - - -
Especificaciones
{{SpecName('ESDraft', '#sec-postfix-decrement-operator', 'Decrement operator')}}
- -

Compatibilidad con navegadores

- - - -

{{Compat("javascript.operators.decrement")}}

- -

Ver también

- - diff --git a/files/es/web/javascript/referencia/operadores/delete/index.html b/files/es/web/javascript/referencia/operadores/delete/index.html deleted file mode 100644 index 99ec3e73dd..0000000000 --- a/files/es/web/javascript/referencia/operadores/delete/index.html +++ /dev/null @@ -1,242 +0,0 @@ ---- -title: operador delete -slug: Web/JavaScript/Referencia/Operadores/delete -translation_of: Web/JavaScript/Reference/Operators/delete ---- -
-
{{jsSidebar("Operators")}}
-
- -

Resumen

- -

El operador delete  elimina una propiedad de un objeto.

- -

Sintaxis

- -
delete expresión
- -

donde la expresión debe evaluar una referencia de la propiedad, por ejemplo:

- -
delete objeto.propiedad
-delete objeto['propiedad']
-
- -

Parámetros

- -
-
objeto
-
El nombre de un objeto, o una expresión que evalua a un objeto.
-
propiedad
-
La propiedad a eliminar.
-
- -

Retorno

- -

En modo estricto arroja una excepción si la propiedad no es configurable (retorna false en modo no estricto). Retorna true en cualquier otro caso.

- -

Descripción

- -

Al contrario de lo que se podría pensar, el operador delete no tiene nada que ver con liberar memoria (sólo lo hace de manera indirecta eliminando referencias. Más detalles en la página de gestión de memoria).

- -

Si la operación delete funciona correctamente, eliminará la propiedad del objeto por completo. Sin embargo, si existe otra propiedad con el mismo nombre en la cadena del prototype del objeto, éste heredará la propiedad del prototype.

- -

delete sólo es efectivo en propiedades de objetos. No tiene ningún efecto en variables o en nombres de funciones.
- Aunque a veces son mal identificados como variables globales, las asignaciones que no especifican al objeto (ejemplo: x = 5), son en realidad propiedades que se asignan al objeto global.

- -

delete no puede eliminar ciertas propiedades de los objetos predefinidos (como Object, Array, Math etc). Estos están descritos en ECMAScript 5 y más tarde como no configurables.

- -

Temporal dead zone

- -

The "temporal dead zone" (TDZ), specified in ECMAScript 6 for const and let declarations, also applies to the delete operator. Thus, code like the following will throw a {{jsxref("ReferenceError")}}.

- -
function foo() {
-  delete x;
-  let x;
-}
-
-function bar() {
-  delete y;
-  const y;
-}
- -

Ejemplos

- -
x = 42;         // crea la propiedad x en el objeto global
-var y = 43;     // crea la propiedad y en el objeto global, y la marca como no configurable
-myobj = {
-  h: 4,
-  k: 5
-};
-
-// x es una propiedad del objeto global y puede ser eliminada
-delete x;       // retorna true
-
-// y no es configurable, por lo tanto no puede ser eliminada
-delete y;       // retorna false
-
-// delete no afecta a ciertas propiedades predefinidas
-delete Math.PI; // retorna false
-
-// las propiedades definidas por el usuario pueden eliminarse
-delete myobj.h; // retorna true
-
-// myobj es una propiedad del objeto global, no una variable,
-// por lo tanto puede eliminarse
-delete myobj;   // retorna true
-
-function f() {
-  var z = 44;
-
-  // delete no afecta a nombres de variables locales
-  delete z;     // retorna false
-}
-
- -

Si el objeto hereda una propiedad de un prototype, y no tiene la propiedad en sí, la propiedad no puede ser eliminada por referencia al objeto. Aun así, puedes eliminarla directamente en el prototype.

- -

If the object inherits a property from a prototype, and doesn't have the property itself, the property can't be deleted by referencing the object. You can, however, delete it directly on the prototype.

- -
function Foo(){}
-Foo.prototype.bar = 42;
-var foo = new Foo();
-
-// retorna true, pero sin ningún efecto,
-// ya que bar es una propiedad heredada
-delete foo.bar;
-
-// logs 42, propiedad aún heredada
-console.log(foo.bar);
-
-// elimina la propiedad en el prototype
-delete Foo.prototype.bar;
-
-// logs "undefined", propiedad no heredada
-console.log(foo.bar);
- -

Eliminando elementos de un array

- -

Cuando eliminas un elemento de un array, la longitud del array no se ve afectada. Esta se mantiene incluso si eliminas el último elemento del array.

- -

Cuando el operador delete elimina un elemento de un array, este elemento ya no está en el array. En el siguiente ejemplo, trees[3] es eliminado mediante delete.

- -
var trees = ["redwood","bay","cedar","oak","maple"];
-delete trees[3];
-if (3 in trees) {
-    // esto no se ejecuta
-}
- -

Si quieres que exista un elemento de un array pero que tengo un valor no definido, utiliza el valor undefined en vez del operador delete. En el siguiente ejemplo, trees[3] es asignado con el valor undefined, pero el elemento del array aún existe:

- -
var trees = ["redwood","bay","cedar","oak","maple"];
-trees[3] = undefined;
-if (3 in trees) {
-    // esto se ejecuta
-}
- -

Especificaciones

- - - - - - - - - - - - - - - - - - - - - - - - -
EspecificaciónEstadoComentario
ECMAScript 1st Edition.StandardDefinición inicial. Implementado en JavaScript 1.2
{{SpecName('ES5.1', '#sec-11.4.1', 'The delete Operator')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-delete-operator', 'The delete Operator')}}{{Spec2('ES6')}} 
- -

Compatibilidad de navegador

- -

{{CompatibilityTable}}

- -
- - - - - - - - - - - - - - - - - - - - - - - - - - - -
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Basic support{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
Temporal dead zone{{CompatUnknown}}{{CompatGeckoDesktop(36)}}{{CompatUnknown}}{{CompatUnknown}}{{CompatUnknown}}
-
- -
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
FeatureAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Basic support{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{ CompatVersionUnknown() }}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
Temporal dead zone{{CompatUnknown}}{{CompatUnknown}}{{CompatGeckoMobile(36)}}{{CompatUnknown}}{{CompatUnknown}}{{CompatUnknown}}
-
- -

Cross-browser issues

- -

Although ECMAScript makes iteration order of objects implementation-dependent, it may appear that all major browsers support an iteration order based on the earliest added property coming first (at least for properties not on the prototype). However, in the case of Internet Explorer, when one uses delete on a property, some confusing behavior results, preventing other browsers from using simple objects like object literals as ordered associative arrays. In Explorer, while the property value is indeed set to undefined, if one later adds back a property with the same name, the property will be iterated in its old position--not at the end of the iteration sequence as one might expect after having deleted the property and then added it back.

- -

So, if you want to simulate an ordered associative array in a cross-browser environment, you are forced to either use two separate arrays (one for the keys and the other for the values), or build an array of single-property objects, etc.

- -

Ver también

- - diff --git a/files/es/web/javascript/referencia/operadores/destructuring_assignment/index.html b/files/es/web/javascript/referencia/operadores/destructuring_assignment/index.html deleted file mode 100644 index b56e3d3b52..0000000000 --- a/files/es/web/javascript/referencia/operadores/destructuring_assignment/index.html +++ /dev/null @@ -1,442 +0,0 @@ ---- -title: La desestructuración -slug: Web/JavaScript/Referencia/Operadores/Destructuring_assignment -tags: - - Característica del lenguaje - - Desestructuración - - Desestructurar arreglos y objetos anidados - - ECMAScript 2015 - - ES6 - - JavaScript - - Objetos anidados y desestructuración de array - - Operador -translation_of: Web/JavaScript/Reference/Operators/Destructuring_assignment ---- -
{{jsSidebar("Operators", "Operadores")}}
- -

La sintaxis de desestructuración es una expresión de JavaScript que permite desempacar valores de arreglos o propiedades de objetos en distintas variables.

- -
{{EmbedInteractiveExample("pages/js/expressions-destructuringassignment.html", "taller")}}
- - - -

Sintaxis

- -
let a, b, rest;
-[a, b] = [10, 20];
-console.log(a); // 10
-console.log(b); // 20
-
-[a, b, ...rest] = [10, 20, 30, 40, 50];
-console.log(a); // 10
-console.log(b); // 20
-console.log(rest); // [30, 40, 50]
-
-({ a, b } = { a: 10, b: 20 });
-console.log(a); // 10
-console.log(b); // 20
-
-
-// Propuesta de etapa 4 (terminada)
-({a, b, ...rest} = {a: 10, b: 20, c: 30, d: 40});
-console.log(a); // 10
-console.log(b); // 20
-console.log(rest); // {c: 30, d: 40}
-
- -

Descripción

- -

Las expresiones de objetos y arreglos literales proporcionan una manera fácil de crear paquetes de datos ad hoc.

- -
const x = [1, 2, 3, 4, 5];
- -

La desestructuración utiliza una sintaxis similar, pero en el lado izquierdo de la asignación para definir qué valores desempacar de la variable origen.

- -
const x = [1, 2, 3, 4, 5];
-const [y, z] = x;
-console.log(y); // 1
-console.log(z); // 2
-
- -

Esta capacidad es similar a las características presentes en lenguajes como Perl y Python.

- -

Ejemplos

- -

Desestructuración de arreglos

- -

Asignación básica de variables

- -
const foo = ['one', 'two', 'three'];
-
-const [red, yellow, green] = foo;
-console.log(red); // "one"
-console.log(yellow); // "two"
-console.log(green); // "three"
-
- -

Asignación separada de la declaración

- -

A una variable se le puede asignar su valor mediante una desestructuración separada de la declaración de la variable.

- -
let a, b;
-
-[a, b] = [1, 2];
-console.log(a); // 1
-console.log(b); // 2
-
- -

Valores predeterminados

- -

A una variable se le puede asignar un valor predeterminado, en el caso de que el valor desempacado del arreglo sea undefined.

- -
let a, b;
-
-[a=5, b=7] = [1];
-console.log(a); // 1
-console.log(b); // 7
-
- -

Intercambio de variables

- -

Los valores de dos variables se pueden intercambiar en una expresión de desestructuración.

- -

Sin desestructurar la asignación, intercambiar dos valores requiere una variable temporal (o, en algunos lenguajes de bajo nivel, el algoritmo del truco XOR-swap).

- -
let a = 1;
-let b = 3;
-
-[a, b] = [b, a];
-console.log(a); // 3
-console.log(b); // 1
-
-const arr = [1,2,3];
-[arr[2], arr[1]] = [arr[1], arr[2]];
-console.log(arr); // [1,3,2]
-
-
- -

Analizar un arreglo devuelto por una función

- -

Siempre ha sido posible devolver un arreglo desde una función. La desestructuración puede hacer que trabajar con un valor de retorno de arreglo sea más conciso.

- -

En este ejemplo, f() devuelve los valores [1, 2] como su salida, que se puede procesar en una sola línea con desestructuración.

- -
function f() {
-  return [1, 2];
-}
-
-let a, b;
-[a, b] = f();
-console.log(a); // 1
-console.log(b); // 2
-
- -

Ignorar algunos valores devueltos

- -

Puedes ignorar los valores de retorno que no te interesan:

- -
function f() {
-  return [1, 2, 3];
-}
-
-const [a, , b] = f();
-console.log(a); // 1
-console.log(b); // 3
-
-const [c] = f();
-console.log(c); // 1
-
- -

También puedes ignorar todos los valores devueltos:

- -
[,,] = f();
-
- -

Asignar el resto de un arreglo a una variable

- -

Al desestructurar un arreglo, puedes desempacar y asignar la parte restante a una variable usando el patrón resto:

- -
const [a, ...b] = [1, 2, 3];
-console.log(a); // 1
-console.log(b); // [2, 3]
- -

Ten en cuenta que se lanzará un {{jsxref("SyntaxError")}} si se usa una coma final en el lado derecho con un elemento resto:

- -
const [a, ...b,] = [1, 2, 3];
-
-// SyntaxError: el elemento rest no puede tener una coma al final
-// Siempre considera usar el operador rest como último elemento
-
- -

Desempacar valores coincidentes con una expresión regular

- -

Cuando el método de expresión regular {{jsxref("Global_Objects/RegExp/exec", "exec()", "", 1)}} encuentra una coincidencia, devuelve un arreglo que contiene primero toda la parte coincidente de la cadena y luego las partes de la cadena que coinciden con cada grupo entre paréntesis en la expresión regular. La desestructuración te permite desempacar fácilmente las partes de este arreglo, ignorando la coincidencia completa si no es necesaria.

- -
function parseProtocol(url) {
-  const parsedURL = /^(\w+)\:\/\/([^\/]+)\/(.*)$/.exec(url);
-  if (!parsedURL) {
-    return false;
-  }
-  console.log(parsedURL);
-  // ["https://developer.mozilla.org/es/Web/JavaScript",
-      "https", "developer.mozilla.org", "es/Web/JavaScript"]
-
-  const [, protocol, fullhost, fullpath] = parsedURL;
-  return protocol;
-}
-
-console.log(parseProtocol('https://developer.mozilla.org/es/Web/JavaScript'));
-// "https"
-
- -

Desestructuración de objetos

- -

Asignación básica

- -
const user = {
-    id: 42,
-    is_verified: true
-};
-
-const {id, is_verified} = user;
-
-console.log(id); // 42
-console.log(is_verified); // true
-
- -

Asignación sin declaración

- -

A una variable se le puede asignar su valor con desestructuración separada de su declaración.

- -
let a, b;
-
-({a, b} = {a: 1, b: 2});
- -
-

Notas: los paréntesis (...) alrededor de la declaración de asignación son obligatorios cuando se usa la desestructuración de un objeto literal sin una declaración.

- -

{a, b} = {a: 1, b: 2} no es una sintaxis independiente válida, debido a que {a, b} en el lado izquierdo se considera un bloque y no un objeto literal.

- -

Sin embargo, ({a, b} = {a: 1, b: 2}) es válido, al igual que const {a, b} = {a: 1, b: 2}

- -

tu expresión ( ... ) debe estar precedida por un punto y coma o se puede usar para ejecutar una función en la línea anterior.

-
- -

Asignar a nuevos nombres de variable

- -

Una propiedad se puede desempacar de un objeto y asignar a una variable con un nombre diferente al de la propiedad del objeto.

- -
const o = {p: 42, q: true};
-const {p: foo, q: bar} = o;
-
-console.log(foo); // 42
-console.log(bar); // true
- -

Aquí, por ejemplo, const {p: foo} = o toma del objeto o la propiedad llamada p y la asigna a una variable local llamada foo.

- -

Valores predeterminados

- -

A una variable se le puede asignar un valor predeterminado, en el caso de que el valor desempacado del objeto sea undefined.

- -
const {a = 10, b = 5} = {a: 3};
-
-console.log(a); // 3
-console.log(b); // 5
- -

Asignar nombres a nuevas variables y proporcionar valores predeterminados

- -

Una propiedad puede ser ambas

- - - -
const {a: aa = 10, b: bb = 5} = {a: 3};
-
-console.log(aa); // 3
-console.log(bb); // 5
-
- -

Desempacar campos de objetos pasados como parámetro de función

- -
const user = {
-  id: 42,
-  displayName: 'jdoe',
-  fullName: {
-    firstName: 'John',
-    lastName: 'Doe'
-  }
-};
-
-function userId({id}) {
-  return id;
-}
-
-function whois({displayName, fullName: {firstName: name}}) {
-  return `${displayName} es ${name}`;
-}
-
-console.log(userId(user)); // 42
-console.log(whois(user));  // "jdoe es John"
- -

Esto desempaca el id, displayName y firstName del objeto user y los imprime.

- -

Establecer el valor predeterminado de un parámetro de función

- -
function drawChart({size = 'big', coords = {x: 0, y: 0}, radius = 25} = {}) {
-  console.log(size, coords, radius);
-  // haz un dibujo de gráfico
-}
-
-drawChart({
-  coords: {x: 18, y: 30},
-  radius: 30
-});
- -
-

En la firma de la función para drawChart anterior, el lado izquierdo desestructurado se asigna a un objeto literal vacío en el lado derecho: {size = 'big', coords = {x: 0, y: 0}, radius = 25} = {}. También podrías haber escrito la función sin la asignación del lado derecho. Sin embargo, si omites la asignación del lado derecho, la función buscará al menos un argumento para ser proporcionado cuando se invoca, mientras que en su forma actual, simplemente puedes llamar a drawChart() sin proporcionar ningún parámetro. El diseño actual es útil si deseas poder llamar a la función sin proporcionar ningún parámetro, el otro puede ser útil cuando deseas asegurarte de que se pase un objeto a la función.

-
- -

Desestructuración de arreglos y objetos anidados

- -
const metadata = {
-  title: 'Scratchpad',
-  translations: [
-    {
-      locale: 'de',
-      localization_tags: [],
-      last_edit: '2020-08-29T08:43:37',
-      url: '/de/docs/Tools/Scratchpad',
-      title: 'JavaScript-Umgebung'
-    }
-  ],
-  url: '/es/docs/Tools/Scratchpad'
-};
-
-let {
-  title: englishTitle, // renombrar
-  translations: [
-    {
-       title: localeTitle, // renombrar
-    },
-  ],
-} = metadata;
-
-console.log(englishTitle); // "Scratchpad"
-console.log(localeTitle);  // "JavaScript-Umgebung"
- -

Iteración "for...of" y desestructuración

- -
const people = [
-  {
-    name: 'Mike Smith',
-    family: {
-      mother: 'Jane Smith',
-      father: 'Harry Smith',
-      sister: 'Samantha Smith'
-    },
-    age: 35
-  },
-  {
-    name: 'Tom Jones',
-    family: {
-      mother: 'Norah Jones',
-      father: 'Richard Jones',
-      brother: 'Howard Jones'
-    },
-    age: 25
-  }
-];
-
-for (const {name: n, family: {father: f}} of people) {
-  console.log('Nombre: ' + n + ', Padre: ' + f);
-}
-
-// "Nombre: Mike Smith, Padre: Harry Smith"
-// "Nombre: Tom Jones, Padre: Richard Jones"
-
- -

Nombres de propiedades de objetos calculados y desestructuración

- -

Los nombres de propiedad calculados, como en un {{jsxref("Operators/Object_initializer", "Objeto literal", "#Computed_property_names", 1)}}, se pueden usar con la desestructuración.

- -
let key = 'z';
-let {[key]: foo} = {z: 'bar'};
-
-console.log(foo); // "bar"
-
- -

Rest en la desestructuración de objetos

- -

La propuesta Propiedades rest/propagación para ECMAScript (etapa 4) agrega la sintaxis {{jsxref("Functions/rest_parameters", "rest", "", 1)}} para desestructurar. Las propiedades de rest recopilan las claves de propiedades enumerables restantes que aún no han sido seleccionadas por el patrón de desestructuración.

- -
let {a, b, ...rest} = {a: 10, b: 20, c: 30, d: 40}
-a; // 10
-b; // 20
-rest; // { c: 30, d: 40 }
- -

Identificador de JavaScript no válido como nombre de propiedad

- -

La desestructuración se puede utilizar con nombres de propiedad que no son {{Glossary("Identifier", "identificadores")}} válidos en JavaScript proporcionando un identificador alternativo que sea válido.

- -
const foo = { 'fizz-buzz': true };
-const { 'fizz-buzz': fizzBuzz } = foo;
-
-console.log(fizzBuzz); // "true"
-
- -

Desestructuración combinada de arreglos y objetos

- -

La desestructuración de arreglos y objetos se puede combinar. Supongamos que deseas manipular el tercer elemento del siguiente arreglo props, y luego deseas la propiedad name en el objeto, puedes hacer lo siguiente:

- -
const props = [
-  { id: 1, name: 'Fizz'},
-  { id: 2, name: 'Buzz'},
-  { id: 3, name: 'FizzBuzz'}
-];
-
-const [,, { name }] = props;
-
-console.log(name); // "FizzBuzz"
-
- -

Se busca la cadena de prototipos al desestructurar el objeto.

- -

Al deconstruir un objeto, si no se accede a una propiedad en sí misma, continuará buscando a lo largo de la cadena de prototipos.

- -
let obj = {self: '123'};
-obj.__proto__.prot = '456';
-const {self, prot} = obj;
-// self "123"
-// prot "456" (Acceso a la cadena de prototipos)
- -

Especificaciones

- - - - - - - - - - - - -
Especificación
{{SpecName('ESDraft', '#sec-destructuring-assignment', 'Desestructuración de asignación')}}
- -

Compatibilidad del navegador

- -
- - -

{{Compat("javascript.operators.destructuring")}}

-
- -

Ve también

- - diff --git a/files/es/web/javascript/referencia/operadores/division/index.html b/files/es/web/javascript/referencia/operadores/division/index.html deleted file mode 100644 index d29816e37a..0000000000 --- a/files/es/web/javascript/referencia/operadores/division/index.html +++ /dev/null @@ -1,77 +0,0 @@ ---- -title: Division (/) -slug: Web/JavaScript/Referencia/Operadores/Division -tags: - - JS - - JavaScript - - Operador de Division - - Operadores - - Referências -translation_of: Web/JavaScript/Reference/Operators/Division ---- -
{{jsSidebar("Operators")}}
- -

El operador de división (/) produce el cociente de sus operandos donde el operando izquierdo es el dividendo y el operando derecho es el divisor.

- -
{{EmbedInteractiveExample("pages/js/expressions-division.html")}}
- -
- - - -

Sintaxis

- -
Operador: x / y
-
- -

Ejemplos

- -

Division basica

- -
1 / 2              // 0.5
-
-Math.floor(3 / 2) // 1
-
-1.0 / 2.0         // 0.5
-
- -

Division por cero

- -
2.0 / 0     // Retorna Infinity
-
-2.0 / 0.0   // Retorna Infinity, Dado que 0.0 === 0
-
-2.0 / -0.0  // Retorna -Infinity
- -

Especificaciones

- - - - - - - - - - -
Specification
{{SpecName('ESDraft', '#sec-multiplicative-operators', 'Division operator')}}
- -

Compatibilidad con Navegadores

- - - -

{{Compat("javascript.operators.division")}}

- -

Ver también

- - diff --git a/files/es/web/javascript/referencia/operadores/encadenamiento_opcional/index.html b/files/es/web/javascript/referencia/operadores/encadenamiento_opcional/index.html deleted file mode 100644 index 06ccb5a999..0000000000 --- a/files/es/web/javascript/referencia/operadores/encadenamiento_opcional/index.html +++ /dev/null @@ -1,187 +0,0 @@ ---- -title: Encadenamiento opcional -slug: Web/JavaScript/Referencia/Operadores/Encadenamiento_opcional -translation_of: Web/JavaScript/Reference/Operators/Optional_chaining ---- -
{{JSSidebar("Operators")}}
- -

El operador de encadenamiento opcional ?. permite leer el valor de una propiedad ubicada dentro de una cadena de objetos conectados sin tener que validar expresamente que cada referencia en la cadena sea válida. El operador ?. funciona de manera similar a el operador de encadenamiento ., excepto que en lugar de causar un error si una referencia es casi-nula ({{JSxRef("null")}} o {{JSxRef("undefined")}}), la expresión hace una evaluación de circuito corto con un valor de retorno de undefined. Cuando se usa con llamadas a funciones, devuelve undefined si la función dada no existe.

- -

Esto da como resultado expresiones más cortas y simples cuando se accede a propiedades encadenadas dónde existe la posibilidad de que falte una referencia. También puede ser útil al explorar el contenido de un objeto cuando no hay una garantía conocida de qué propiedades se requieren.

- -
{{EmbedInteractiveExample("pages/js/expressions-optionalchainingoperator.html", "taller")}}
- - - -

Sintaxis

- -
obj?.prop
-obj?.[expr]
-arr?.[index]
-func?.(args)
-
- -

Descripción

- -

El operador de encadenamiento opcional proporciona una forma de simplificar el acceso a los valores a través de objetos conectados cuando es posible que una referencia o función sea undefined o null.

- -

Por ejemplo, considere un objeto obj que tiene una estructura anidada. Sin encadenamiento opcional, buscar una subpropiedad profundamente anidada requiere validar las referencias intermedias, como:

- -
let nestedProp = obj.first && obj.first.second;
-
- -

Se confirma que el valor de obj.first no es null (y no es undefined) antes de acceder al valor de obj.first.second. Esto evita el error que ocurriría si simplemente accediera a obj.first.second directamente sin probar obj.first.

- -

Sin embargo, con el operador de encadenamiento opcional (?.), No tiene que probar explícitamente, ni realizar una evaluación de circuito corto basada en el estado de obj.first antes de intentar acceder a obj.first.second:

- -
let nestedProp = obj.first?.second;
-
- -

Al usar el operador ?. en lugar de solo el ., JavaScript sabe verificar implícitamente para asegurarse de que obj.first no es null o undefined antes de intentar acceder  obj.first.second. Si obj.first es null o undefined, la expresión hace una evaluación de circuito corto automáticamente y retorna undefined.

- -

Esto es equivalente a lo siguiente, excepto que la variable temporal es de hecho no creada:

- -
let temp = obj.first;
-let nestedProp = ((temp === null || temp === undefined) ? undefined : temp.second);
-
- -

Encadenamiento opcional con llamadas a funciones

- -

Puede usar el encadenamiento opcional cuando intente llamar a un método que puede no existir. Esto puede ser útil, por ejemplo, cuando se usa una API en la que un método podría no estar disponible, ya sea debido a la antigüedad de la implementación o debido a una característica que no está disponible en el dispositivo del usuario.

- -

El uso de encadenamiento opcional con llamadas a funciones hace que la expresión regrese automáticamente undefined en lugar de lanzar una excepción si no se encuentra el método:

- -
let result = someInterface.customMethod?.();
- -
-

Nota: Si hay una propiedad con ese nombre y que no es una función, usar ?. aún levantará una excepción {{JSxRef("TypeError")}} (x.y is not a function).

-
- -

Manejo de callbacks opcionales o manejadores de eventos

- -

Si utiliza callbacks o métodos de recuperación de un objeto con una asignación de desestructuración, es posible que tenga valores inexistentes que no puede llamar como funciones a menos que haya probado su existencia. Usando ?., Puede evitar esta prueba adicional:

- -
// Escrito a partir de ES2019
-function doSomething(onContent, onError) {
-  try {
-    // ... hacer algo con los datos
-  }
-  catch (err) {
-    if (onError) { // Probando si onError realmente existe
-      onError(err.message);
-    }
-  }
-}
-
- -
// Usando encadenamiento opcional con llamado de funciones
-function doSomething(onContent, onError) {
-  try {
-   // ... hacer algo con los datos
-  }
-  catch (err) {
-    onError?.(err.message); // Sin excepción si onError esta undefined
-  }
-}
-
- -

Encadenamiento opcional con expresiones

- -

También puede usar el operador de encadenamiento opcional al acceder a propiedades con una expresión usando la notación de corchetes:

- -
let nestedProp = obj?.['prop' + 'Name'];
-
- -

El encadenamiento opcional no es válido al lado izquierdo de una asignación

- -
let object = {};
-object?.property = 1; // Uncaught SyntaxError: Invalid left-hand side in assignment
- -

Acceso a elementos de un arreglo con encadenamiento opcional

- -
let arrayItem = arr?.[42];
- -

Ejemplos

- -

Ejemplo básico

- -

Este ejemplo busca el valor de la propiedad name para el miembro bar en un mapa cuando no existe dicho miembro. El resultado es por lo tanto es undefined.

- -
let myMap = new Map();
-myMap.set("foo", {name: "baz", desc: "inga"});
-
-let nameBar = myMap.get("bar")?.name;
- -

Evaluación de circuito corto

- -

Cuando se usa el encadenamiento opcional con expresiones, si el operando izquierdo es null o undefined, la expresión no se evaluará. Por ejemplo:

- -
let potentiallyNullObj = null;
-let x = 0;
-let prop = potentiallyNullObj?.[x++];
-
-console.log(x); // 0 como x no se incrementó
-
- -

Apilando el operador de encadenamiento opcional

- -

Con estructuras anidadas, es posible usar encadenamiento opcional varias veces:

- -
let customer = {
-  name: "Carl",
-  details: {
-    age: 82,
-    location: "Paradise Falls" // "detailed address" es desconocida
-  }
-};
-let customerCity = customer.details?.address?.city;
-
-// … esto también funciona con la función opcional de encadenamiento
-let duration = vacations.trip?.getTime?.();
-
- -

Combinando con el operador de fusión nulo

- -

El {{JSxRef("Operators/Nullish_Coalescing_Operator", "operador de fusión nulo", '', 1)}} se puede usar después del encadenamiento opcional para generar un valor predeterminado cuando no se encontró ninguno:

- -
let customer = {
-  name: "Carl",
-  details: { age: 82 }
-};
-const customerCity = customer?.city ?? "Unknown city";
-console.log(customerCity); // Unknown city
- -

Especificaciones

- - - - - - - - - - - - -
Specification
{{SpecName('ESDraft', '#prod-OptionalExpression', 'optional expression')}}
- -

Compatibilidad de navegadores

- -
- - -

{{Compat("javascript.operators.optional_chaining")}}

-
- -

Progreso de implementación

- -

La siguiente tabla proporciona un estado de implementación diaria para esta característica, porque esta característica aún no ha alcanzado la estabilidad entre navegadores. Los datos se generan ejecutando las pruebas de características relevantes en Test262, el conjunto de pruebas estándar de JavaScript, en la compilación nocturna o la última versión del motor de JavaScript de cada navegador.

- -
{{EmbedTest262ReportResultsTable("optional-chaining")}}
- -

Ver también

- - diff --git a/files/es/web/javascript/referencia/operadores/function/index.html b/files/es/web/javascript/referencia/operadores/function/index.html deleted file mode 100644 index d5739239b2..0000000000 --- a/files/es/web/javascript/referencia/operadores/function/index.html +++ /dev/null @@ -1,73 +0,0 @@ ---- -title: function -slug: Web/JavaScript/Referencia/Operadores/function -tags: - - Function - - JavaScript - - Operator - - Primary Expressions -translation_of: Web/JavaScript/Reference/Operators/function ---- -
{{jsSidebar("Operators")}}
- -

Resumen

- -

El operador function define una función dentro de una expresión.

- -

Sintaxis

- -
function [name]([param1, param2, ..., paramN]) {
-   statements
-}
-
- -

Parámetros

- -
-
name
-
El nombre de la función. Puede ser omitido, en cuyo caso la función es anonymous. El nombre sólo es local para el cuerpo de la función.
-
- -
-
paramN
-
El nombre de un argumento que será pasado a la función. Una función puede tener hasta 255 argumentos.
-
- -
-
statements
-
Las declaraciones que conforman el cuerpo de la función.
-
- -

Descripción

- -

La expresión de una función es muy similar y tiene casi la misma sintaxis que la declaración de una función (véase {{jsxref("Sentencias/function", "function")}} para más detalles). Véase Funciones para ver más información sobre las diferencias  entre declaraciones de funciones y expresiones de funciones.

- -

Ejemplos

- -

El siguiente ejemplo define una función sin nombre y se le asigna a la variable x. La función devuelve como resultado el cuadrado de su argumento:

- -
var x = function(y) {
-   return y * y;
-};
-
- -

Expresión de función nombrada

- -

Si quiere referirse a la función actual dentro del cuerpo de la función, debe crear una expresión de función nombrada. Luego, este nombre será local solo para el cuerpo de la función (alcance). Esto también evita usar la propiedad no estándar {{jsxref("Funciones/arguments/callee", "arguments.callee")}}.

- -
var math = {
-  'factorial': function factorial(n) {
-    if (n <= 1)
-      return 1;
-    return n * factorial(n - 1);
-  }
-};
-
- -

Consulte también

- - diff --git a/files/es/web/javascript/referencia/operadores/function_star_/index.html b/files/es/web/javascript/referencia/operadores/function_star_/index.html deleted file mode 100644 index 9c38872b7e..0000000000 --- a/files/es/web/javascript/referencia/operadores/function_star_/index.html +++ /dev/null @@ -1,91 +0,0 @@ ---- -title: expresión function* -slug: Web/JavaScript/Referencia/Operadores/function* -tags: - - ECMAScript 2015 - - Expresión Primaria - - Function - - Iterator - - JavaScript - - Operator -translation_of: Web/JavaScript/Reference/Operators/function* ---- -
{{jsSidebar("Operators")}}
- -

La palabra clave function* puede ser utilizada para definir una función generadora en una expresión.

- -
{{EmbedInteractiveExample("pages/js/expressions-functionasteriskexpression.html")}}
- - - -

Sintaxis

- -
function* [nombre]([param1[, param2[, ..., paramN]]]) {
-   sentencias
-}
- -

Parámetros

- -
-
nombre
-
Nombre de la función. Puede ser omitido, en cuyo caso la funcipón es anínima. El nombre sólo es local al cuerpo de la función.
-
paramN
-
Nombre de un parámetro a ser pasado a la función. Una función puede tener hasta 255 argumentos.
-
sentencias
-
Sentencias que componen el cuerpo de la función.
-
- -

Descripción

- -

Una expresión function* es muy similar y tiene casi la misma sintaxis que una {{jsxref('Statements/function*', 'function* statement')}}. La principal diferencia entre una expresión function* y una sentencia function* es el nombre de la función, que en expresiones function* puede ser omitido para creaar funciones generadoras anónimas. Para más información vea también el capítulo acerca de funciones.

- -

Ejemplos

- -

El siguiente ejemplo define una función generadora sin nombre y la asigna a x. La función produce el cuadrado de su argumento:

- -
var x = function*(y) {
-   yield y * y;
-};
-
- -

Especificaciones

- - - - - - - - - - - - - - - - - - - -
EspecificaciónEstadoComentario
{{SpecName('ES2015', '#', 'function*')}}{{Spec2('ES2015')}}Definición Inicial.
{{SpecName('ESDraft', '#', 'function*')}}{{Spec2('ESDraft')}} 
- -

Compatibilidad con navegadores

- - - -

{{Compat("javascript.operators.function_star")}}

- -

Vea también

- - diff --git a/files/es/web/javascript/referencia/operadores/grouping/index.html b/files/es/web/javascript/referencia/operadores/grouping/index.html deleted file mode 100644 index ec78e8518f..0000000000 --- a/files/es/web/javascript/referencia/operadores/grouping/index.html +++ /dev/null @@ -1,128 +0,0 @@ ---- -title: Operador de agrupación -slug: Web/JavaScript/Referencia/Operadores/Grouping -tags: - - Expresiones primarias - - JavaScript - - Operador -translation_of: Web/JavaScript/Reference/Operators/Grouping ---- -
{{jsSidebar("Operators")}}
- -

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.

- -
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

- - - - - - - - - - - - - - - - - - - - - - - - -
EspecificaciónEstatusComentario
ECMAScript 1st Edition.EstándarDefinición inicial. Implementado en JavaScript 1.0
{{SpecName('ES5.1', '#sec-11.1.6', 'The Grouping Operator')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-grouping-operator', 'The Grouping Operator')}}{{Spec2('ES6')}} 
- -

Compatibilidad en navegadores

- -

{{CompatibilityTable}}

- -
- - - - - - - - - - - - - - - - - - - -
CaracterísticaChromeFirefox (Gecko)Internet ExplorerOperaSafari
Basic support{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
-
- -
- - - - - - - - - - - - - - - - - - - - - -
CaracterísticaAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Soporte básico{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
-
- -

Temas relacionados

- - diff --git a/files/es/web/javascript/referencia/operadores/in/index.html b/files/es/web/javascript/referencia/operadores/in/index.html deleted file mode 100644 index 051056a25f..0000000000 --- a/files/es/web/javascript/referencia/operadores/in/index.html +++ /dev/null @@ -1,139 +0,0 @@ ---- -title: in -slug: Web/JavaScript/Referencia/Operadores/in -tags: - - JavaScript - - Operator - - Relational Operators -translation_of: Web/JavaScript/Reference/Operators/in ---- -
{{jsSidebar("Operators")}}
- -
El operador in devuelve true si la propiedad especificada está en el objeto especificado o su prototipo.
- -

Sintaxis

- -
prop in object
- -

Parámetros

- -
-
prop
-
Una cadena o expresión númerica que representa el nombre de una propiedad o el índice de un array (lo que no sea un símbolo se forzará a string).
-
- -
-
object
-
El objeto (o su cadena de prototipo) sobre el que comprobar si contiene la propiedad con el nombre especificado.
-
- -

Descripción

- -

Los siguientes ejemplos muestran algunos de los usos del operador in.

- -
// Arrays
-var arboles = new Array("secoya", "pino", "cedro", "roble", "arce");
-0 in arboles        // devuelve true
-3 in arboles        // devuelve true
-6 in arboles        // devuelve false
-"pino" in arboles   // devuelve false (debe especificar el número de índice,
-                    // no el valor del índice)
-"length" in arboles // devuelve true (length es una propiedad de Array)
-
-// Objetos predefinidos
-"PI" in Math        // devuelve true
-
-// Objetos personalizados
-var micoche = {marca: "Honda", modelo: "Accord", año: 1998};
-"marca" in micoche  // devuelve true
-"modelo" in micoche // devuelve true
-
- -

Debe especificar un objeto en el lado derecho del operador in. Por ejemplo, puede especificar una cadena creada con el constructor String , pero no puede especificar una cadena literal.

- -
var color1 = new String("verde");
-"length" in color1 // devuelve true
-
-var color2 = "coral";
-"length" in color2 // genera un error (color2 no es un objeto String)
-
- -

Usando in con propiedades eliminadas o no definidas

- -

Si se elimina una propiedad con el operador {{jsxref("Operadores/delete", "delete")}}, el operador in devuelve false para esa propiedad.

- -
var micoche= {marca: "Honda", modelo: "Accord", año: 1998};
-delete micoche.marca;
-"marca" in micoche;  // devuelve false
-
-var arboles = new Array("secoya", "pino", "cedro", "roble", "arce");
-delete arboles[3];
-3 in arboles; // devuelve false
-
- -

Si se cambia una propiedad a {{jsxref("Objetos_globales/undefined", "undefined")}} pero no se elimina, el operador in devuelve true para esa propiedad.

- -
var micoche = {marca: "Honda", modelo: "Accord", año: 1998};
-micoche.marca = undefined;
-"marca" in micoche;  // devuelve true
-
- -
var arboles = new Array("secayo", "pino", "cedro", "roble", "arce");
-arboles[3] = undefined;
-3 in arboles; // devuelve true
-
- -

Propiedades heredadas

- -

El operador in devuelve true para propiedades en la cadena del prototipo.

- -
"toString" in {}; // devuelve true
-
- -

Especificaciones

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
EspecificaciónEstadoComentario
{{SpecName('ESDraft', '#sec-relational-operators', 'Relational Operators')}}{{Spec2('ESDraft')}} 
{{SpecName('ES2015', '#sec-relational-operators', 'Relational Operators')}}{{Spec2('ES2015')}} 
{{SpecName('ES5.1', '#sec-11.8.7', 'The in Operator')}}{{Spec2('ES5.1')}} 
{{SpecName('ES3', '#sec-11.8.7', 'The in Operator')}}{{Spec2('ES3')}}Definición inicial. Implementado en JavaScript 1.4.
- -

Compatibilidad en navegadores

- - - -

{{Compat("javascript.operators.in")}}

- -

Vea también

- - diff --git a/files/es/web/javascript/referencia/operadores/index.html b/files/es/web/javascript/referencia/operadores/index.html deleted file mode 100644 index dca4964faa..0000000000 --- a/files/es/web/javascript/referencia/operadores/index.html +++ /dev/null @@ -1,280 +0,0 @@ ---- -title: Expresiones y operadores -slug: Web/JavaScript/Referencia/Operadores -tags: - - Descripción - - JavaScript - - Operadores - - Operators - - Referencia -translation_of: Web/JavaScript/Reference/Operators ---- -
{{jsSidebar("Operators", "Operadores")}}
- -

Este capítulo documenta todos los operadores, expresiones y palabras clave del lenguaje JavaScript.

- -

Expresiones y operadores por categoría

- -

Para obtener una lista alfabética, consulta la barra lateral de la izquierda.

- -

Expresiones primarias

- -

Palabras clave básicas y expresiones generales en JavaScript.

- -
-
{{jsxref("Operators/this", "this")}}
-
La palabra clave this se refiere a una propiedad especial de un contexto de ejecución.
-
{{jsxref("Operators/function", "function")}}
-
La palabra clave function define una expresión de función.
-
{{jsxref("Operators/class", "class")}}
-
La palabra clave class define una expresión de clase.
-
{{jsxref("Operators/function", "function")}}
-
La palabra clave function* define una expresión de función generadora.
-
{{jsxref("Operators/yield", "yield")}}
-
Pausar y reanudar una función generadora.
-
{{jsxref("Operators/yield*", "yield*")}}
-
Delegar a otra función generadora u objeto iterable.
-
{{jsxref("Operators/async_function", "async function")}}
-
La async function define una expresión de función asíncrona.
-
{{jsxref("Operators/await", "await")}}
-
Pausa y reanuda una función asíncrona y espera la resolución/rechazo de la promesa.
-
{{jsxref("Global_Objects/Array", "[]")}}
-
Iniciador de arreglo/sintaxis literal.
-
{{jsxref("Operators/Object_initializer", "{}")}}
-
Iniciador de objeto/sintaxis literal.
-
{{jsxref("Global_Objects/RegExp", "/ab+c/i")}}
-
Sintaxis de expresión regular literal.
-
{{jsxref("Operators/Grouping", "( )")}}
-
Operador de agrupación.
-
- -

Expresiones del lado izquierdo

- -

Los valores de la izquierda son el destino de una asignación.

- -
-
{{jsxref("Operators/Property_accessors", "Propiedad accessors", "", 1)}}
-
Los operadores miembro proporcionan acceso a una propiedad o método de un objeto
- (object.property y object["property"]).
-
{{jsxref("Operators/new", "new")}}
-
El operador new crea una instancia auxiliado por un constructor.
-
{{jsxref("Operators/new%2Etarget", "new.target")}}
-
En los constructores, new.target se refiere al constructor que fue invocado por {{jsxref("Operators/new", "new")}}.
-
{{jsxref("Operators/super", "super")}}
-
La palabra clave super llama al constructor padre.
-
{{jsxref("Operators/Spread_syntax", "...obj")}}
-
La sintaxis de extensión permite expandir una expresión en lugares donde se esperan múltiples argumentos (para llamadas a funciones) o múltiples elementos (para arreglos literales).
-
- -

Incremento y decremento

- -

Operadores de incremento sufijo/prefijo y decremento sufijo/prefijo.

- -
-
{{jsxref("Operators/Increment", "A++")}}
-
Operador de incremento sufijo.
-
{{jsxref("Operators/Decrement", "A--")}}
-
Operador de incremento sufijo.
-
{{jsxref("Operators/Increment", "A++")}}
-
Operador de incremento prefijo.
-
{{jsxref("Operators/Decrement", "--A")}}
-
Operador de decremento prefijo.
-
- -

Operadores unarios

- -

Una operación unaria es una operación con un solo operando.

- -
-
{{jsxref("Operators/delete", "delete")}}
-
El operador delete elimina una propiedad de un objeto.
-
{{jsxref("Operators/void", "void")}}
-
El operador void descarta el valor de retorno de una expresión.
-
{{jsxref("Operators/typeof", "typeof")}}
-
El operador typeof determina el tipo de un objeto dado.
-
{{jsxref("Operators/Unary_plus", "+")}}
-
El operador unario más convierte su operando al tipo Number.
-
{{jsxref("Operators/Unary_negation", "-")}}
-
El operador unario de negación convierte su operando al tipo Number y luego lo niega.
-
{{jsxref("Operators/Bitwise_NOT", "~")}}
-
Operador NOT bit a bit.
-
{{jsxref("Operators/Logical_NOT", "!")}}
-
Operador NOT lógico.
-
- -

Operadores aritméticos

- -

Los operadores aritméticos toman valores numéricos (ya sean literales o variables) como sus operandos y devuelven un solo valor numérico.

- -
-
{{jsxref("Operators/Addition", "+")}}
-
Operador de adición o suma.
-
{{jsxref("Operators/Subtraction", "-")}}
-
Operador de sustracción o resta.
-
{{jsxref("Operators/Division", "/")}}
-
Operador de división.
-
{{jsxref("Operators/Multiplication", "*")}}
-
Operador de multiplicación.
-
{{jsxref("Operators/Remainder", "%")}}
-
Operador de residuo.
-
{{jsxref("Operators/Exponentiation", "**")}}
-
Operador de exponenciación.
-
- -

Operadores relacionales

- -

Un operador de comparación compara sus operandos y devuelve un valor Boolean basado en si la comparación es verdadera o no.

- -
-
{{jsxref("Operators/in", "in")}}
-
El operador in determina si un objeto tiene una determinada propiedad.
-
{{jsxref("Operators/instanceof", "instanceof")}}
-
El operador instanceof determina si un objeto es una instancia de otro objeto.
-
{{jsxref("Operators/Less_than", "<")}}
-
Operador menor que.
-
{{jsxref("Operators/Greater_than", ">")}}
-
Operador mayor que.
-
{{jsxref("Operators/Less_than_or_equal", "<=")}}
-
Operador menor o igual a.
-
{{jsxref("Operators/Greater_than_or_equal", ">=")}}
-
Operador mayor o igual a.
-
- -
-

Nota: => no es un operador, sino la notación para {{jsxref("Functions/Arrow_functions", "Funciones de flecha")}}.

-
- -

Operadores de igualdad

- -

El resultado de evaluar un operador de igualdad siempre es de tipo Boolean basado en si la comparación es verdadera.

- -
-
{{jsxref("Operators/Equality", "==")}}
-
Operador de igualdad.
-
{{jsxref("Operators/Inequality", "!=")}}
-
Operador de desigualdad.
-
{{jsxref("Operators/Strict_equality", "===")}}
-
Operador de igualdad estricta.
-
{{jsxref("Operators/Strict_inequality", "!==")}}
-
Operador de desigualdad estricta.
-
- -

Operadores de desplazamiento de bits

- -

Operaciones para cambiar todos los bits del operando.

- -
-
{{jsxref("Operators/Left_shift", "<<")}}
-
Operador de desplazamiento bit a bit a la izquierda.
-
{{jsxref("Operators/Right_shift", ">>")}}
-
Operador de desplazamiento bit a bit a la derecha.
-
{{jsxref("Operators/Unsigned_right_shift", ">>>")}}
-
Operador de desplazamiento bit a bit a la derecha sin signo.
-
- -

Operadores binarios bit a bit

- -

Los operadores bit a bit tratan a sus operandos como un conjunto de 32 bits (ceros y unos) y devuelven valores numéricos estándar de JavaScript.

- -
-
{{jsxref("Operators/Bitwise_AND", "&")}}
-
AND bit a bit.
-
{{jsxref("Operators/Bitwise_OR", "|")}}
-
OR bit a bit.
-
{{jsxref("Operators/Bitwise_XOR", "^")}}
-
XOR bit a bit.
-
- -

Operadores lógicos binarios

- -

Los operadores lógicos se utilizan normalmente con valores booleanos (lógicos); cuando lo son, devuelven un valor booleano.

- -
-
{{jsxref("Operators/Logical_AND", "&&")}}
-
AND lógico.
-
{{jsxref("Operators/Logical_OR", "||")}}
-
OR lógico.
-
- -

Operador condicional (ternario)

- -
-
{{jsxref("Operators/Conditional_Operator", "(condition ? ifTrue : ifFalse)")}}
-
-

El operador condicional devuelve uno de dos valores según el valor lógico de la condición.

-
-
- -

Operadores de asignación

- -

Un operador de asignación asigna un valor a su operando izquierdo basándose en el valor de su operando derecho.

- -
-
{{jsxref("Operators/Assignment", "=")}}
-
Operador de asignación.
-
{{jsxref("Operators/Multiplication_assignment", "*=")}}
-
Asignación de multiplicación.
-
{{jsxref("Operators/Division_assignment", "/=")}}
-
Asignación de división.
-
{{jsxref("Operators/Remainder_assignment", "%=")}}
-
Asignación de residuo.
-
{{jsxref("Operators/Addition_assignment", "+=")}}
-
Asignación de suma.
-
{{jsxref("Operators/Subtraction_assignment", "-=")}}
-
Asignación de sustracción
-
{{jsxref("Operators/Left_shift_assignment", "<<=")}}
-
Asignación de desplazamiento a la izquierda.
-
{{jsxref("Operators/Right_shift_assignment", ">>=")}}
-
Asignación de desplazamiento a la derecha.
-
{{jsxref("Operators/Unsigned_right_shift_assignment", ">>>=")}}
-
Asignación de desplazamiento a la derecha sin signo.
-
{{jsxref("Operators/Bitwise_AND_assignment", "&=")}}
-
Asignación de AND bit a bit.
-
{{jsxref("Operators/Bitwise_XOR_assignment", "^=")}}
-
Asignación de XOR bit a bit.
-
{{jsxref("Operators/Bitwise_OR_assignment", "|=")}}
-
Asignación de OR bit a bit.
-
{{jsxref("Operators/Logical_AND_assignment", "&&=")}}
-
Asignación de AND lógico.
-
{{jsxref("Operators/Logical_OR_assignment", "||=")}}
-
Asignación de OR lógico.
-
{{jsxref("Operators/Logical_nullish_assignment", "??=")}}
-
Asignación de anulación lógica.
-
{{jsxref("Operators/Destructuring_assignment", "[a, b] = [1, 2]")}}
- {{jsxref("Operators/Destructuring_assignment", "{a, b} = {a:1, b:2}")}}
-
-

La desestructuración te permite asignar las propiedades de un arreglo u objeto a variables utilizando una sintaxis que se parece a los arreglos u objetos literales.

-
-
- -

Operador coma

- -
-
{{jsxref("Operators/Comma_Operator", ",")}}
-
El operador coma permite evaluar múltiples expresiones en una sola declaración y devuelve el resultado de la última expresión.
-
- -

Especificaciones

- - - - - - - - - - -
Especificación
{{SpecName('ESDraft', '#sec-ecmascript-language-expressions', 'ECMAScript Language: Expressions')}}
- -

Compatibilidad del navegador

- - - -

{{Compat("javascript.operators")}}

- -

Ve también

- - diff --git a/files/es/web/javascript/referencia/operadores/instanceof/index.html b/files/es/web/javascript/referencia/operadores/instanceof/index.html deleted file mode 100644 index 3b9a45162d..0000000000 --- a/files/es/web/javascript/referencia/operadores/instanceof/index.html +++ /dev/null @@ -1,88 +0,0 @@ ---- -title: instanceof -slug: Web/JavaScript/Referencia/Operadores/instanceof -tags: - - JavaScript - - Operator - - Relational Operators -translation_of: Web/JavaScript/Reference/Operators/instanceof ---- -
{{jsSidebar("Operators")}}
- -

Resumen

- -

El operador instanceof verifica si un objeto en su cadena de prototipos contiene la propiedad prototype de un constructor.

- -

Sintaxis

- -
objeto instanceof constructor
- -

Parámetros

- -
-
objeto
-
Objeto a verificar.
-
- -
-
constructor
-
Función contra la que se hará la verificación.
-
- -

Descripción

- -

Utilice instanceof cuando necesite confirmar el tipo de un objeto en tiempo de ejecución. Por ejemplo, cuando controle excepciones, puede recurrir a diferentes códigos de manipulación de excepciones dependiendo del tipo de excepción tomada.

- -

Debe especificar un objeto en el lado derecho del operador instanceof. Por ejemplo, puede especificar una cadena creada con el constructor String, pero no puede especificar un literal de cadena.

- -
color1=new String("verde")
-color1 instanceof String // devuelve verdadero (true)
-color2="coral"
-color2 instanceof String // devuelve falso (color2 no es un objeto String)
-
- -

Ejemplos

- -

También vea los ejemplos de {{jsxref("Sentencias/throw", "throw")}}.

- -

Ejemplo: Determinando si elDia es un objeto Date

- -

El siguiente código utiliza instanceof para determinar si elDia es un objeto Date. Debido a que elDia es un objeto Date, las instrucciones de la sentencia if se ejecutan.

- -
elDia = new Date(1995, 12, 17)
-if (elDia instanceof Date) {
-   // instrucciones a ejecutar
-}
-
- -

Ejemplo: Demostrando que String y Date son del tipo Object

- -

El siguiente código utiliza instanceof para demostrar que los objetos String y Date son también del tipo Object (éstos se derivan de Object).

- -
miCadena = new String()
-miFecha = new Date()
-
-miCadena instanceof String // devuelve true
-miCadena instanceof Object // devuelve true
-miCadena instanceof Date   // devuelve false
-
-miFecha instanceof Date     // devuelve true
-miFecha instanceof Object   // devuelve true
-miFecha instanceof String   // devuelve false
-
- -

Ejemplo: Demostrando que miCoche es del tipo Coche y del tipo Object

- -

El siguiente código crea un objeto del tipo Coche y una instancia de ese tipo de objeto, miCoche. El operador instanceof demuestra que el objeto miCoche es del tipo Coche y del tipo Object.

- -
function Coche(fabricante, modelo, ejercicio) {
-   this.fabricante = fabricante
-   this.modelo = modelo
-   this.ejercicio= ejercicio
-}
-miCoche = new Coche("Honda", "Accord", 1998)
-a = miCoche instanceof Coche // devuelve verdadero (true)
-b = miCoche instanceof Object // devuelve verdadero (true)
-
- -
 
diff --git a/files/es/web/javascript/referencia/operadores/miembros/index.html b/files/es/web/javascript/referencia/operadores/miembros/index.html deleted file mode 100644 index 565a8b7f92..0000000000 --- a/files/es/web/javascript/referencia/operadores/miembros/index.html +++ /dev/null @@ -1,85 +0,0 @@ ---- -title: Miembros -slug: Web/JavaScript/Referencia/Operadores/Miembros -tags: - - JavaScript - - Operator -translation_of: Web/JavaScript/Reference/Operators/Property_Accessors ---- -
{{jsSidebar("Operators")}}
- -

Resumen

- -

Los operadores de miembros proporcionan acceso a las propiedades y métodos de un objeto.

- -

Un objeto es en realidad un arreglo asociativo (por ejemplo map ,dictionary ,hash ,lookup table ). Las claves en este arreglo son los nombres de las propiedades y los métodos (propiedades que hacen referencia a funciones). Hay dos modos de acceder a estas propiedades: notación por punto y notación por corchete (es decir, operador de subscripción).

- -

Nota: La especificación ECMAScript etiqueta estos operadores como "property accessors" en vez de "operadores de miembro" (member operators).

- -

Notación por punto

- -
get = objeto.propiedad;
-objeto.propiedad = set;
-
- -

propiedad debe ser un identificador válido de JavaScript, esto es, una secuencia alfanumérica de caracteres, incluyendo también el guión bajo ("_") y el signo dolar ("$"), que no puede comenzar por un número. Por ejemplo, objeto.$1 es válido, mientras que objeto.1 no lo es.

- -

Ejemplo:

- -
document.createElement('pre');
-
- -

Aquí, el método llamado "createElement" se recupera de document y se le llama.

- -

Notación por corchetes

- -
get = objeto[nombre_propiedad];
-objeto[nombre_propiedad] = set;
-
- -

nombre_propiedad es una cadena. La cadena no tiene que ser un identificador válido; puede tener cualquier valor, por ejemplo "1foo", "!bar!", o incluso " " (un espacio).

- -

Ejemplo:

- -
document['createElement']('pre');
-
- -

Esto hace exactamente lo mismo que el ejemplo anterior.

- -

Nombres de propiedades

- -

Los nombres de propiedades deben ser cadenas. Esto significa que no pueden usarse objetos distintos a cadenas como claves en un objeto. Cualquier objeto que no sea una cadena, incluyendo números, se convierte al tipo cadena a través de su método {{jsxref("Object.toString")}}.

- -

Ejemplos:

- -
var objeto = {};
-objeto['1'] = 'valor';
-alert(objeto[1]);
-
- -

Ésto tendrá como resultado "valor", ya que 1 se convertirá por tipo a '1'.

- -
var foo = {propiedad_unica: 1}, bar = {propiedad_unica: 2}, objeto = {};
-objeto[foo] = 'valor';
-alert(objeto[bar]);
-
- -

Ésto también tiene como resultado "valor", ya que tanto foo como bar se convierten a la misma cadena. En el motor de JavaScript SpiderMonkey, esta cadena sería "{{ mediawiki.external('objeto Object') }}".

- -

Enlace a métodos

- -

Un método no está enlazado al objeto del que es método. Específicamente, this no está establecido en un método, es decir, this no se refiere necesariamente a un objeto conteniendo el método. this, en cambio, se "pasa" mediante la llamada de función.

- -

Vea enlace a métodos.

- -

Nota sobre eval

- -

Los principiantes en JavaScript a menudo tienen el error de usar {{jsxref("eval")}} cuando la notación por corchetes puede usarse a cambio. Por ejemplo, la siguiente sintaxis se ve a menudo en muchos scripts.

- -
x = eval('document.nombre_formulario.' + cadenaControlFormulario + '.value');
-
- -

eval es lenta y se debería evitar en la medida de lo posible. Es mejor usar la notación por corchetes a cambio:

- -
x = document.nombre_formulario[cadenaControlFormulario].value;
-
diff --git a/files/es/web/javascript/referencia/operadores/new.target/index.html b/files/es/web/javascript/referencia/operadores/new.target/index.html deleted file mode 100644 index 0faa0f0878..0000000000 --- a/files/es/web/javascript/referencia/operadores/new.target/index.html +++ /dev/null @@ -1,139 +0,0 @@ ---- -title: new.target -slug: Web/JavaScript/Referencia/Operadores/new.target -tags: - - Clases - - ECMAScript6 - - JavaScript - - Referencia -translation_of: Web/JavaScript/Reference/Operators/new.target ---- -
{{JSSidebar("Operators")}}
- -

La propiedad new.target te permite detectar si una función o constructor fue llamado usando el operador new. En constructores y funciones instanciadas con el operador new, new.target devuelve una referencia al constructor o función. En llamadas a funciones normales, new.target es {{jsxref("undefined")}}.

- -

Sintaxis

- -
new.target
- -

Descripción

- -

La sintaxis new.target consiste en el keyword "new", un punto, y el nombre de propiedad "target". Normalmente "new." sirve como contexto para el acceso a la propiedad, pero aquí, "new." no es realmente un objeto. En llamadas a constructores, sin embargo, new.target hace referencia al constructor invocado por new por lo que "new." se convierte en un contexto virtual.

- -

La propiedad new.target es una meta propiedad que está disponible para todas las funciones. En funciones flecha, new.target se refiere al new.target de la función que la contiene.

- -

Ejemplos

- -

new.target en llamadas a funciones

- -

En llamadas a funciones normales (en contraposición a llamadas a constructores), new.target es {{jsxref("undefined")}}. Esto te permite detectar si la función fue llamada con new como constructor.

- -
function Foo() {
-  if (!new.target) throw 'Foo() debe ser llamado con new';
-  console.log('Foo instanciado con new');
-}
-
-Foo(); // Lanza "Foo() debe ser llamado con new"
-new Foo(); // escribe en el log "Foo instanciado con new"
-
- -

new.target en constructores

- -

En constructores de clase, new.target hace referencia al constructor que fue directamente invocado por new. Este también es el caso si el constructor está en una clase padre y fue delegado desdes el constructor hijo.

- -
class A {
-  constructor() {
-    console.log(new.target.name);
-  }
-}
-
-class B extends A { constructor() { super(); } }
-
-var a = new A(); // escribe en el log "A"
-var b = new B(); // escribe en el log "B"
-
- -

Especificaciones

- - - - - - - - - - - - - - - - - - - -
EspecificaciónEstatusComentario
{{SpecName('ES2015', '#sec-built-in-function-objects', 'Built-in Function Objects')}}{{Spec2('ES2015')}}Initial definition.
{{SpecName('ESDraft', '#sec-built-in-function-objects', 'Built-in Function Objects')}}{{Spec2('ESDraft')}} 
- -

Compatibilidad en navegadores

- -

{{CompatibilityTable}}

- -
- - - - - - - - - - - - - - - - - - - -
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Basic support{{CompatChrome(46.0)}}{{CompatGeckoDesktop(41)}}{{CompatNo}}{{CompatNo}}{{CompatNo}}
-
- -
- - - - - - - - - - - - - - - - - - - - - - - -
FeatureAndroidAndroid WebviewFirefox Mobile (Gecko)IE MobileOpera MobileSafari MobileChrome for Android
Basic support{{CompatNo}}{{CompatChrome(46.0)}}{{CompatGeckoMobile(41)}}{{CompatNo}}{{CompatNo}}{{CompatNo}}{{CompatChrome(46.0)}}
-
- -

Ver también

- - diff --git a/files/es/web/javascript/referencia/operadores/new/index.html b/files/es/web/javascript/referencia/operadores/new/index.html deleted file mode 100644 index 4635b12402..0000000000 --- a/files/es/web/javascript/referencia/operadores/new/index.html +++ /dev/null @@ -1,179 +0,0 @@ ---- -title: Operador new -slug: Web/JavaScript/Referencia/Operadores/new -tags: - - Expresiones del lado izquierdo - - JavaScript - - Left-hand-side expressions - - Operador - - Operator - - Referencia -translation_of: Web/JavaScript/Reference/Operators/new ---- -
{{jsSidebar("Operators", "Operadores")}}
- -

El operador new permite a los desarrolladores crear una instancia de un tipo de objeto definido por el usuario o de uno de los tipos de objeto integrados que tiene un función constructora.

- -
{{EmbedInteractiveExample("pages/js/expressions-newoperator.html")}}
- -

Sintaxis

- -
new constructor[([arguments])]
- -

Parámetros

- -
-
constructor
-
Una clase o función que especifica el tipo de instancia del objeto.
-
- -
-
arguments
-
Una lista de valores con los que se llamará al constructor.
-
- -

Descripción

- -

La palabra clave new hace lo siguiente:

- -
    -
  1. Crea un objeto JavaScript simple y en blanco;
    2. -
  2. Vincula (establece el constructor de) este objeto a otro objeto;
    3. -
  3. Pasa el objeto recién creado del Paso 1 como el contexto this;
    4. -
  4. Devuelve this si la función no devuelve un objeto.
    5. -
- -

La creación de un objeto definido por el usuario requiere dos pasos:

- -
    -
  1. Defina el tipo de objeto escribiendo una función.
    2. -
  2. Crea una instancia del objeto con new.
    3. -
- -

Para definir un tipo de objeto, crea una función para el tipo de objeto que especifique su nombre y propiedades. Un objeto puede tener una propiedad que en sí misma es otro objeto. Ve los siguientes ejemplos.

- -

Cuando se ejecuta el código new Foo(...), sucede lo siguiente:

- -
    -
  1. Se crea un nuevo objeto, heredado de Foo.prototype.
    2. -
  2. La función constructora Foo se llama con los argumentos especificados y con {{JSxRef("Operators/this", "this")}} vinculado al objeto recién creado. new Foo es equivalente a new Foo(), es decir, si no se especifica una lista de argumentos, Foo se llama sin argumentos.
    3. -
  3. El objeto (no nulo, false, 3.1415 u otros tipos primitivos) devuelto por la función constructora se convierte en el resultado de toda la expresión new. Si la función constructora no devuelve explícitamente un objeto, en su lugar se utiliza el objeto creado en el paso 1. (Normalmente, los constructores no devuelven un valor, pero pueden elegir hacerlo si quieren redefinir el proceso normal de creación de objetos).
    4. -
- -

Siempre puedes agregar una propiedad a un objeto definido previamente. Por ejemplo, la instrucción car1.color = "black" agrega una propiedad color a car1 y le asigna un valor de "black". Sin embargo, esto no afecta a ningún otro objeto. Para agregar la nueva propiedad a todos los objetos del mismo tipo, debes agregar la propiedad a la definición del tipo de objeto Car.

- -

Puedes agregar una propiedad compartida a un tipo de objeto definido previamente mediante la propiedad {{JSxRef("Global_Objects/Function/prototype", "Function.prototype")}}. Esto define una propiedad que comparten todos los objetos creados con esa función, en lugar de solo una instancia del tipo de objeto. El siguiente código agrega una propiedad de color con el valor "color original" a todos los objetos de tipo Car, y luego redefine ese valor con la cadena "black" solo en la instancia car1 del objeto. Para obtener más información, consulta {{JSxRef("Global_Objects/Function/prototype", "prototype")}}.

- -
function Car() {}
-car1 = new Car();
-car2 = new Car();
-
-console.log(car1.color);    // undefined
-
-Car.prototype.color = 'color original';
-console.log(car1.color);    // 'color original'
-
-car1.color = 'black';
-console.log(car1.color);    // 'black'
-
-console.log(Object.getPrototypeOf(car1).color); // 'color original'
-console.log(Object.getPrototypeOf(car2).color); // 'color original'
-console.log(car1.color);   // 'black'
-console.log(car2.color);   // 'color original'
-
- -
-

Si no escribiste el operador new, la función constructor se invocará como cualquier función normal, sin crear un objeto. En este caso, el valor de this también es diferente.

-
- -

Ejemplos

- -

Tipo de objeto e instancia de objeto

- -

Supongamos que deseas crear un tipo de objeto para cars. Quieres que este tipo de objeto se llame Car, y quieres que tenga propiedades para marca, modelo y año (make, model y year en inglés respectivamente). Para ello, podrías escribir la siguiente función:

- -
function Car(make, model, year) {
-  this.make = make;
-  this.model = model;
-  this.year = year;
-}
-
- -

Ahora puedes crear un objeto llamado myCar de la siguiente manera:

- -
var myCar = new Car('Eagle', 'Talon TSi', 1993);
-
- -

Esta declaración crea myCar y le asigna los valores especificados para sus propiedades. Entonces el valor de myCar.make es la cadena "Eagle", myCar.year es el entero 1993, y así sucesivamente.

- -

Puedes crear cualquier número de objetos car mediante llamadas a new. Por ejemplo:

- -
var kensCar = new Car('Nissan', '300ZX', 1992);
-
- -

Propiedad del objeto que en sí mismo es otro objeto

- -

Supongamos que defines un objeto llamado Person de la siguiente manera:

- -
function Person(name, age, sex) {
-  this.name = name;
-  this.age = age;
-  this.sex = sex;
-}
-
- -

Y luego creas una instancia de dos nuevos objetos Person de la siguiente manera:

- -
var rand = new Person('Rand McNally', 33, 'M');
-var ken = new Person('Ken Jones', 39, 'M');
-
- -

Luego, puedes reescribir la definición de Car para incluir una propiedad para owner (propietario en español) que tome un objeto Person, de la siguiente manera:

- -
function Car(make, model, year, owner) {
-  this.make = make;
-  this.model = model;
-  this.year = year;
-  this.owner = owner;
-}
-
- -

Para crear instancias de los nuevos objetos, utiliza lo siguiente:

- -
var car1 = new Car('Eagle', 'Talon TSi', 1993, rand);
-var car2 = new Car('Nissan', '300ZX', 1992, ken);
-
- -

En lugar de pasar una cadena literal o un valor entero al crear los nuevos objetos, las declaraciones anteriores pasan los objetos rand y ken como parámetros para los propietarios. Para conocer el nombre del propietario de car2, puedes acceder a la siguiente propiedad:

- -
car2.owner.name
-
- -

Especificaciones

- - - - - - - - - - - - -
Especificación
{{SpecName('ESDraft', '#sec-new-operator', 'El operador new')}}
- -

Compatibilidad del navegador

- - - -

{{Compat("javascript.operators.new")}}

- -

Ve también

- - diff --git a/files/es/web/javascript/referencia/operadores/operador_coma/index.html b/files/es/web/javascript/referencia/operadores/operador_coma/index.html deleted file mode 100644 index a62701b3e1..0000000000 --- a/files/es/web/javascript/referencia/operadores/operador_coma/index.html +++ /dev/null @@ -1,132 +0,0 @@ ---- -title: Operador Coma -slug: Web/JavaScript/Referencia/Operadores/operador_coma -tags: - - JavaScript -translation_of: Web/JavaScript/Reference/Operators/Comma_Operator ---- -
{{jsSidebar("Operators")}}
- -

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:

- -
function myFunc () {
-  var x = 0;
-
-  return (x += 1, x); // the same as return ++x;
-}
- -

Específicaciones

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
EspecificaciónEstadoComentario
{{SpecName('ESDraft', '#sec-comma-operator', 'Comma operator')}}{{Spec2('ESDraft')}} 
{{SpecName('ES6', '#sec-comma-operator', 'Comma operator')}}{{Spec2('ES6')}} 
{{SpecName('ES5.1', '#sec-11.14', 'Comma operator')}}{{Spec2('ES5.1')}} 
{{SpecName('ES1', '#sec-11.14', 'Comma operator')}}{{Spec2('ES1')}}Definición inicial
- -

Compatibilidad en navegadores

- -

{{CompatibilityTable}}

- -
- - - - - - - - - - - - - - - - - - - -
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Basic support{{CompatVersionUnknown}}{{CompatVersionUnknown}}3.0{{CompatVersionUnknown}}{{CompatVersionUnknown}}
-
- -
- - - - - - - - - - - - - - - - - - - - - -
FeatureAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Basic support{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
-
- -

Ver también

- - diff --git "a/files/es/web/javascript/referencia/operadores/operadores_l\303\263gicos/index.html" "b/files/es/web/javascript/referencia/operadores/operadores_l\303\263gicos/index.html" deleted file mode 100644 index 4c9cb860a9..0000000000 --- "a/files/es/web/javascript/referencia/operadores/operadores_l\303\263gicos/index.html" +++ /dev/null @@ -1,296 +0,0 @@ ---- -title: Operadores lógicos -slug: Web/JavaScript/Referencia/Operadores/Operadores_lógicos -translation_of: Web/JavaScript/Reference/Operators -translation_of_original: Web/JavaScript/Reference/Operators/Logical_Operators ---- -
{{jsSidebar("Operadores_lógicos")}}
- -

Los operadores lógicos se usan típicamente con valores {{jsxref("Boolean")}}. En tal caso, regresan un valor Boolean. Sin embargo, los operadores && y || regresan en realidad el valor de uno de los operandos especificados, por lo que si estos operadores se usan con valores no Boolean, posiblemente regresen un valor no Boolean.

- -

Descripción

- -

Los operadores lógicos se describen en la tabla siguiente:

- - - - - - - - - - - - - - - - - - - - - - - - -
OperadorUsoDescripción
AND (&&) lógicoexpr1 && expr2 -

Regresa expr1 si tal puede convertirse a false; de lo contrario, regresa expr2. De esta forma, cuando se usa con valores Boolean, && regresa true si ambos operandos son verdaderos; de lo contrario regresa false.

-
OR (||) lógicoexpr1 || expr2 -

Regresa expr1 si tal puede convertirse a true; de lo contrario, regresa expr2. De esta forma, cuando se usa con valores Boolean, || regresa true si cualquier operando es verdadero; pero si ambos son falsos, regresa "false".

-
NOT (!) lógico!expr -

Regresa false si su único operando puede convertirse a true; de lo contrario, regresa true.

-
- -

Algunos ejemplos de expresiones que pueden convertirse a false son aquellas que evalúan a null, 0, un string vacío (""), o undefined.

- -

A pesar de que los operadores && y ||  pueden ser usados con operandos que no son valores Boolean, aún pueden ser considerados como operadores Boolean porque sus valores de regreso siempre pueden convertirse a valores Boolean.

- -

Evaluación contra "corto circuitos"

- -

Ya que las expresiones lógicas son evaluadas de izquierda a derecha, se prueban con una evaluación contra posibles "cortos circuitos" usando las siguientes normas:

- - - -

Las reglas de lógica garantizan que estas evaluaciones siempre son correctas. Se debe notar que la parte de "cualquier valor" en las expresiones anteriores no se evalúa, para que tal acción no afecte de ninguna forma. Además, es de notar que la parte de "cualquier valor" en las expresiones anteriores debe ser cualquier expresión lógica (lo que se indica con los paréntesis).

- -

Por ejemplo, las siguientes dos expresiones son equivalentes.

- -
function shortCircuitEvaluation() {
-  doSomething() || doSomethingElse()
-}
-
-function equivalentEvaluation() {
-  var flag = doSomething();
-  if (!flag) {
-    doSomethingElse();
-  }
-}
-
- -

Sin embargo, las siguientes expresiones no son equivalentes debido a la precedencia de operadores, y con tal ejemplo se enfatiza la importancia de que la parte derecha sea una única expresión (agrupada en paréntesis si es necesario).

- -
false && true  || true      // regresa true
-false && (true || true)     // regresa false
- -

AND (&&) lógico

- -

El siguiente código muestra ejemplos del operador && (AND lógico).

- -
a1 = true  && true      // t && t regresa true
-a2 = true  && false     // t && f regresa false
-a3 = false && true      // f && t regresa false
-a4 = false && (3 == 4)  // f && f regresa false
-a5 = "Cat" && "Dog"     // t && t regresa "Dog"
-a6 = false && "Cat"     // f && t regresa false
-a7 = "Cat" && false     // t && f regresa false
-
- -

OR (||) lógico

- -

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

- -
o1 = true  || true       // t || t regresa true
-o2 = false || true       // f || t regresa true
-o3 = true  || false      // t || f regresa true
-o4 = false || (3 == 4)   // f || f regresa false
-o5 = "Cat" || "Dog"      // t || t regresa "Cat"
-o6 = false || "Cat"      // f || t regresa "Cat"
-o7 = "Cat" || false      // t || f regresa "Cat"
-
- -

Logical NOT (!)

- -

El siguiente código muestra ejemplos del operador ! (NOT lógico).

- -
n1 = !true              // !t regresa false
-n2 = !false             // !f regresa true
-n3 = !"Cat"             // !t regresa false
-
- -

Reglas de conversión

- -

Convertir de AND a OR

- -

la siguiente operación que involucra Booleans:

- -
bCondition1 && bCondition2
- -

siempre es igual a:

- -
!(!bCondition1 || !bCondition2)
- -

Convertir de OR a AND

- -

la siguiente operación que involucra Booleans:

- -
bCondition1 || bCondition2
- -

siempre es igual a:

- -
!(!bCondition1 && !bCondition2)
- -

Convertir entre operadores NOT

- -

la siguiente operación que involucra Booleans:

- -
!!bCondition
- -

siempre es igual a:

- -
bCondition
- -

Eliminando paréntesis anidados

- -

Ya que las expresiones lógicas son evaluadas de izquierda a derecha, siempre es posible eliminar paréntesis en una expresión compleja, si se siguen ciertas reglas.

- -

Eliminando operadores AND anidados

- -

La siguiente operación compleja que involucra Booleans:

- -
bCondition1 || (bCondition2 && bCondition3)
- -

siempre es igual a:

- -
bCondition1 || bCondition2 && bCondition3
- -

Eliminando operadores OR anidados

- -

La siguiente operación compleja que involucra Booleans:

- -
bCondition1 && (bCondition2 || bCondition3)
- -

siempre es igual a:

- -
!(!bCondition1 || !bCondition2 && !bCondition3)
- -

Especificaciones

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
EspecificaciónEstadoComentarios
{{SpecName('ES1')}}{{Spec2('ES1')}}Definición inicial.
{{SpecName('ES5.1', '#sec-11.11')}}{{Spec2('ES5.1')}} -

Definido en varias secciones de la especificación: Logical NOT Operator, Binary Logical Operators

-
{{SpecName('ES6', '#sec-binary-logical-operators')}}{{Spec2('ES6')}}Definido en varias secciones de la especificación: Logical NOT Operator, Binary Logical Operators
{{SpecName('ESDraft', '#sec-binary-logical-operators')}}{{Spec2('ESDraft')}}Definido en varias secciones de la especificación: Logical NOT Operator, Binary Logical Operators
- -

Compatibilidad entre navegadores

- -

{{CompatibilityTable}}

- -
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
CaracterísticaChromeFirefox (Gecko)Internet ExplorerOperaSafari
AND (&&) lógico{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
OR (||) lógico{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
NOT (!) lógico{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
-
- -
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
CaracterísticaAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
AND (&&) lógico{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
OR (||) lógico{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
NOT (!) lógico{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
-
- -

Ver también

- - diff --git a/files/es/web/javascript/referencia/operadores/operator_precedence/index.html b/files/es/web/javascript/referencia/operadores/operator_precedence/index.html deleted file mode 100644 index 2ff0464afd..0000000000 --- a/files/es/web/javascript/referencia/operadores/operator_precedence/index.html +++ /dev/null @@ -1,297 +0,0 @@ ---- -title: Precedencia de operadores -slug: Web/JavaScript/Referencia/Operadores/Operator_Precedence -tags: - - JavaScript - - Operator - - operator details - - operator precedence -translation_of: Web/JavaScript/Reference/Operators/Operator_Precedence ---- -
{{jsSidebar("Operators")}}
- -

Sumario

- -

La precedencia de operadores determina el orden en el cual los operadores son evaluados. Los operadores con mayor precedencia son evaluados primero.

- -

Ejemplo:

- -
3 + 4 * 5 // retorna 23
-
- -

El operador de multiplicación ("*") tiene una precedencia mas alta que el operador de suma ("+") y por eso sera evaluado primero.

- -

Asociatividad

- -

La asociatividad determina el orden en el cual los operadores con el mismo nivel de precedencia son procesados. Por ejemplo:

- -
a OP b OP c
-
- -

La asociatividad de izquierda a derecha significa que esa expresión es procesada como (a OP b) OP c, mientras que la asociatividad de derecha a izquierda significa que es procesada como a OP (b OP c). Los operadores de asignación tienen asociatividad de derecha a izquierda, por lo que puedes escribir:

- -
a = b = 5;
-
- -

para asignar 5 a las dos variables. Esto es porque el operador de asignación retorna el valor que asignó. Primero b es inicializada a 5. Despues a es inicializada al valor de b.

- -

Tabla

- -

La siguiente tabla esta ordenada de la precedencia más alta (0) a la más baja (18).

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
PrecedenciaTipo de operadorAsociatividadOperador
0groupingn/a(…)
1memberleft-to-right….…
…[…]
newn/anew … (…)
2function callleft-to-right…(…)
newright-to-leftnew …
3incrementn/a…++
decrementn/a…--
4logical-notright-to-left!…
bitwise notright-to-left~…
unary +right-to-left+…
unary negationright-to-left-…
typeofright-to-lefttypeof …
voidright-to-leftvoid …
deleteright-to-leftdelete …
5multiplicationleft-to-right*
divisionleft-to-right/
modulusleft-to-right%
6additionleft-to-right+
subtractionleft-to-right-
7bitwise shiftleft-to-right<<
>>
>>>
8relationalleft-to-right<
<=
>
>=
inleft-to-rightin
instanceofleft-to-rightinstanceof
9equalityleft-to-right==
!=
===
!==
10bitwise-andleft-to-right&
11bitwise-xorleft-to-right^
12bitwise-orleft-to-right|
13logical-andleft-to-right&&
14logical-orleft-to-right||
15conditionalright-to-left… ? … : …
16assignmentright-to-left=
+=
-=
*=
/=
%=
<<=
>>=
>>>=
&=
^=
|=
17yieldright-to-leftyield…
18commaleft-to-right,
- -

diff --git a/files/es/web/javascript/referencia/operadores/pipeline_operator/index.html b/files/es/web/javascript/referencia/operadores/pipeline_operator/index.html deleted file mode 100644 index cb671264cc..0000000000 --- a/files/es/web/javascript/referencia/operadores/pipeline_operator/index.html +++ /dev/null @@ -1,78 +0,0 @@ ---- -title: Operador Pipeline -slug: Web/JavaScript/Referencia/Operadores/Pipeline_operator -tags: - - Encadenamiento - - Experimental - - JavaScript - - Operador - - Pipeline -translation_of: Web/JavaScript/Reference/Operators/Pipeline_operator ---- -
{{jsSidebar("Operators")}} {{SeeCompatTable}}
- -

El operador experimental pipeline |> (actualmente en su fase1) conduce el valor de una expresión dentro de una función. Esto permite la creación de llamadas de función en cadena de un modo más legible. El resultado es una simplificación sintáctica en la cual la llamada a una función con un único parámetro puede ser escrita del siguiente modo:

- -
let url = "%21" |> decodeURI;
- -

La llamada equivalente en sintaxis tradicional tiene este aspecto:

- -
let url = decodeURI("%21");
-
- -

Sintaxis

- -
expression |> function
-
- -

El valor especificado en la expression se pasa dentro de la  function como su único parámetro.

- -

Ejemplos

- -

Encadenando llamadas  a funciones

- -

El operador pipeline puede mejorar la legibilidad cuando se encadenan varias funciones entre si.

- -
const double = (n) => n * 2;
-const increment = (n) => n + 1;
-
-// sin operador pipeline
-double(increment(double(double(5)))); // 42
-
-// con operador pipeline
-5 |> double |> double |> increment |> double; // 42
-
- -

Especificaciones

- - - - - - - - - - - - - - - - -
EspecificaciónEstadoComentario
Borrador del operador PipelineFase 1Todavía no forma parte de la especificación ECMAScript
- -

Compatibilidad con navegadores

- -
- - -

{{Compat("javascript.operators.pipeline")}}

-
- -

Ver también

- - diff --git a/files/es/web/javascript/referencia/operadores/resto/index.html b/files/es/web/javascript/referencia/operadores/resto/index.html deleted file mode 100644 index 1a6a7c56da..0000000000 --- a/files/es/web/javascript/referencia/operadores/resto/index.html +++ /dev/null @@ -1,82 +0,0 @@ ---- -title: Resto (%) -slug: Web/JavaScript/Referencia/Operadores/Resto -translation_of: Web/JavaScript/Reference/Operators/Remainder ---- -
{{jsSidebar("Operators")}}
- -

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

- -
{{EmbedInteractiveExample("pages/js/expressions-remainder.html")}}
- -
- - - -

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

- -
 12 % 5  //  2
- 1 % -2 //  1
- 1 % 2  //  1
- 2 % 3  //  2
-5.5 % 2 // 1.5
-
- -

Resto con dividendo negativo

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

Resto con NaN

- -
NaN % 2 // NaN
- -

Resto con Infinity

- -
Infinity % 2 // NaN
-Infinity % 0 // NaN
-Infinity % Infinity // NaN
-
- -

Especificaciones

- - - - - - - - - - -
Especificación
{{SpecName('ESDraft', '#sec-multiplicative-operators', 'Remainder operator')}}
- -

Compatibilidad con navegadores

- - - -

{{Compat("javascript.operators.remainder")}}

- -

Ver también

- - diff --git a/files/es/web/javascript/referencia/operadores/sintaxis_spread/index.html b/files/es/web/javascript/referencia/operadores/sintaxis_spread/index.html deleted file mode 100644 index 5a17cd05a2..0000000000 --- a/files/es/web/javascript/referencia/operadores/sintaxis_spread/index.html +++ /dev/null @@ -1,242 +0,0 @@ ---- -title: Sintáxis Spread -slug: Web/JavaScript/Referencia/Operadores/Sintaxis_Spread -tags: - - ECMAScript6 - - Iteradores - - JavaScript -translation_of: Web/JavaScript/Reference/Operators/Spread_syntax ---- -
{{jsSidebar("Operators")}}
- -
La sintaxis extendida o spread syntax permite a un elemento iterable tal como un arreglo o cadena ser expandido en lugares donde cero o más argumentos (para llamadas de  función) o elementos (para Array literales) son esperados, o a un objeto ser expandido en lugares donde cero o más pares de valores clave (para literales Tipo Objeto) son esperados.
- -
{{EmbedInteractiveExample("pages/js/expressions-spreadsyntax.html")}}
- -
- - - -

Sintaxis

- -

Para llamadas de funciones:

- -
myFunction(...iterableObj);
-
- -

Para arreglos literales o cadenas de caracteres:

- -
[...iterableObj, '4', 'five', 6];
- -

Para objetos literales (nuevo en ECMAScript 2018):

- -
let objClone = { ...obj };
- -

Ejemplos

- -

Spread en llamadas de función

- -

Reemplaza "apply"

- -

Es frecuente usar {{jsxref( "Function.prototype.apply")}} en casos donde quieres usar los elementos de un arreglo como argumentos de una función.

- -
function myFunction(x, y, z) { }
-var args = [0, 1, 2];
-myFunction.apply(null, args);
- -

Con la sintaxis expandida (spread syntax), el código anterior puede ser escrito como:

- -
function myFunction(x, y, z) { }
-var args = [0, 1, 2];
-myFunction(...args);
- -

Cualquier argumento en la lista de argumentos puede usar la sintáxis expandida y esto puede ser usado varias veces.

- -
function myFunction(v, w, x, y, z) { }
-var args = [0, 1];
-myFunction(-1, ...args, 2, ...[3]);
- -

"Apply" para "new"

- -

Cuando se llama un constructor con new, no es posible usar directamente un arreglo y apply (apply hace un [[Call]] y no un [[Construct]]). Sin embargo, un arreglo puede ser fácilmente usado con un new gracias a la sintáxis expandida:

- -
var dateFields = [1970, 0, 1];  // 1 Jan 1970
-var d = new Date(...dateFields);
-
- -

Para usar new con un arreglo de parámetros sin la sintáxis expandida, podrías tener que hacerlo indirectamente a través de una aplicación parcial:

- -
function applyAndNew(constructor, args) {
-   function partial () {
-      return constructor.apply(this, args);
-   };
-   if (typeof constructor.prototype === "object") {
-      partial.prototype = Object.create(constructor.prototype);
-   }
-   return partial;
-}
-
-
-function myConstructor () {
-   console.log("arguments.length: " + arguments.length);
-   console.log(arguments);
-   this.prop1="val1";
-   this.prop2="val2";
-};
-
-var myArguments = ["hi", "how", "are", "you", "mr", null];
-var myConstructorWithArguments = applyAndNew(myConstructor, myArguments);
-
-console.log(new myConstructorWithArguments);
-// (internal log of myConstructor):           arguments.length: 6
-// (internal log of myConstructor):           ["hi", "how", "are", "you", "mr", null]
-// (log of "new myConstructorWithArguments"): {prop1: "val1", prop2: "val2"}
- -

Expandir Array literales

- -

Un literal Array más poderoso

- -

Sin sintaxis expandida (spread syntax), para crear un nuevo arreglo usando un arreglo existente como parte de él,no es suficiente la sintaxis de Array literal y en su lugar se debe usar código imperativo con una combinación de push, splice, concat, etc. Con la sintaxis expandida, esto se vuelve mucho mas práctico:

- -
var parts = ['shoulders', 'knees'];
-var lyrics = ['head', ...parts, 'and', 'toes'];
-// ["head", "shoulders", "knees", "and", "toes"]
-
- -

Así como para expandir listas de argumentos, ... puede ser usado en cualquier parte dentro del Array literal, y múltiples veces.

- -

Copiar un arreglo

- -
var arr = [1, 2, 3];
-var arr2 = [...arr]; // like arr.slice()
-arr2.push(4);
-
-// arr2 becomes [1, 2, 3, 4]
-// arr remains unaffected
-
- -

Nota: La sintaxis expandida efectivamente va a un nivel de profundidad mientras copia un arreglo. Por lo tanto, esto no permite copiar arreglos multidimensionales como se muestra en los siguientes ejemplos (es lo mismo con {{jsxref("Object.assign()")}} y sintaxis spread).

- -
var a = [[1], [2], [3]];
-var b = [...a];
-b.shift().shift(); // 1
-// Now array a is affected as well: [[], [2], [3]]
-
- -

Una forma mejor para concatenar arreglos

- -

{{jsxref("Array.concat")}} es usada a menudo para concatenar un arreglo al final de un arreglo ya existente. Sin la sintaxis spread se realiza:

- -
var arr1 = [0, 1, 2];
-var arr2 = [3, 4, 5];
-// Append all items from arr2 onto arr1
-arr1 = arr1.concat(arr2);
- -

Con la sintaxis spread se transforma en:

- -
var arr1 = [0, 1, 2];
-var arr2 = [3, 4, 5];
-arr1 = [...arr1, ...arr2];
-
- -

{{jsxref("Array.unshift")}} es a menudo usada para insertar un arreglo de valores al inicio de un arreglo existente. Sin la sintáxis spread, esto es hecho como:

- -
var arr1 = [0, 1, 2];
-var arr2 = [3, 4, 5];
-// Prepend all items from arr2 onto arr1
-Array.prototype.unshift.apply(arr1, arr2) // arr1 is now [3, 4, 5, 0, 1, 2]
- -

Con la sintaxis spread se convierte en [Observa, sin embargo, que esto crea un nuevo arreglo arr1.  Diferente a {{jsxref("Array.unshift")}}, esto no modifica el arreglo original en sitio arr1]:

- -
var arr1 = [0, 1, 2];
-var arr2 = [3, 4, 5];
-arr1 = [...arr2, ...arr1]; // arr1 is now [3, 4, 5, 0, 1, 2]
-
- -

Spread en literales tipo Objeto

- -

La propuesta Propiedades Rest/Spread para ECMAScript (etapa 4) agrega propiedades spread a los literales Tipo Objeto. Esto copia sus propiedades enumerables desde un objeto provisto dentro de un nuevo objeto.

- -

Shallow-cloning (excluyendo prototype) o la combinación de objetos es ahora posible usando una sintaxis más corta que {{jsxref("Object.assign()")}}.

- -
var obj1 = { foo: 'bar', x: 42 };
-var obj2 = { foo: 'baz', y: 13 };
-
-var clonedObj = { ...obj1 };
-// Object { foo: "bar", x: 42 }
-
-var mergedObj = { ...obj1, ...obj2 };
-// Object { foo: "baz", x: 42, y: 13 }
- -

Observa que {{jsxref("Object.assign()")}} desencadena setters mientras que la sintaxis spread no lo hace.

- -

Observa que tú no puedes reemplazar o replicar la función {{jsxref("Object.assign()")}}:

- -
var obj1 = { foo: 'bar', x: 42 };
-var obj2 = { foo: 'baz', y: 13 };
-const merge = ( ...objects ) => ( { ...objects } );
-
-var mergedObj = merge ( obj1, obj2);
-// Object { 0: { foo: 'bar', x: 42 }, 1: { foo: 'baz', y: 13 } }
-
-var mergedObj = merge ( {}, obj1, obj2);
-// Object { 0: {}, 1: { foo: 'bar', x: 42 }, 2: { foo: 'baz', y: 13 } }
- -

En el ejemplo de arriba, el operador spread no trabaja como uno podría esperar: este dispersa un arreglo de argumentos en el literal Tipo Objeto, debido al parámetro rest.

- -

Sólo para iterables

- -

La sintaxis Spread (otra que en el caso de las propiedades spread) puede ser aplicada sólo a los objetos iterables:

- -
var obj = {'key1': 'value1'};
-var array = [...obj]; // TypeError: obj is not iterable
-
- -

Spread con muchos valores

- -

Cuando se usa la sintaxis spread para llamados de funciones, tenga en cuenta la posibilidad de exceder el límite de longitud de argumentos del motor de JavaScript. Vea apply() para más detalles.

- -

Sintaxis Rest (parámetros)

- -

La sintaxis Rest luce exactamente como la sintaxis spread, pero esto es usado por la desestructuración de arreglos y objetos. De cierta forma, la sintaxis rest es la opuesta a la sintaxis spread: spread 'expande' un arreglo en sus elementos, mientras rest agrupa múltiples elementos y los 'condensa' en un único elemento. Consulta parámetros rest.

- -

Especificaciones

- - - - - - - - - - - - - - - - - - - - - - - - - - -
SpecificationStatusComment
{{SpecName('ES2015', '#sec-array-initializer')}}{{Spec2('ES2015')}}Definido en varias secciones de la especificación: Array Initializer, Argument Lists
{{SpecName('ESDraft', '#sec-array-initializer')}}{{Spec2('ESDraft')}}Sin cambios.
{{SpecName('ESDraft', '#sec-object-initializer')}}{{Spec2('ESDraft')}}Definido en Object Initializer
- -

Compatibilidad del navegador

- - - -

{{Compat("javascript.operators.spread")}}

- -

Vea también

- - diff --git a/files/es/web/javascript/referencia/operadores/spread_operator/index.html b/files/es/web/javascript/referencia/operadores/spread_operator/index.html deleted file mode 100644 index 050a2026f6..0000000000 --- a/files/es/web/javascript/referencia/operadores/spread_operator/index.html +++ /dev/null @@ -1,220 +0,0 @@ ---- -title: Operador de propagación -slug: Web/JavaScript/Referencia/Operadores/Spread_operator -tags: - - Experimental - - Expérimental(2) - - JavaScript - - Operador -translation_of: Web/JavaScript/Reference/Operators/Spread_syntax -translation_of_original: Web/JavaScript/Reference/Operators/Spread_operator ---- -
{{jsSidebar("Operators")}}
- -

El operador de propagación spread operator permite que una expresión sea expandida en situaciones donde se esperan múltiples argumentos (llamadas a funciones) o múltiples elementos (arrays literales).

- -

Sintaxis

- -

Llamadas a funciones:

- -
f(...iterableObj);
-
- -

Arrays literales:

- -
[...iterableObj, 4, 5, 6]
- -

Desestructuración destructuring:

- -
[a, b, ...iterableObj] = [1, 2, 3, 4, 5];
- -

Ejemplos

- -

Un mejor método apply

- -

Ejemplo: Es común usar {{jsxref( "Function.prototype.apply")}} en casos donde se require un array como contenedor de los argumentos que se enviarán a una llamada de función:

- -
function f(x, y, z) { }
-var args = [0, 1, 2];
-f.apply(null, args);
- -

Con el operador spread de ES6, el ejemplo anterior se puede rescribir como:

- -
function f(x, y, z) { }
-var args = [0, 1, 2];
-f(...args);
- -

Cualquier argumento en la lista de argumentos puede usar la sintaxis de propagación spread, donde además puede ser usada varias veces.

- -
function f(v, w, x, y, z) { }
-var args = [0, 1];
-f(-1, ...args, 2, ...[3]);
- -

Un array literal mas poderoso

- -

Ejemplo: La sintaxis de un array literal que existe hoy en día no es suficiente si se requiere agregar los elementos de un array dentro de otro array existente. Actualmente se debe escribir código imperativo usando una combinación de métodos como push, splice, concat, etc. Con la sintaxis de propagación spread esta tarea resulta mucho mas concisa:

- -
var parts = ['shoulder', 'knees'];
-var lyrics = ['head', ...parts, 'and', 'toes'];
- -

Al igual que con una lista de argumentos, en este caso también puede ser usado en cualquier ubicación dentro del array literal, además de poderse incluir una o varias veces.

- -

Combinación del método apply y el operador new

- -

Ejemplo: En ES5 no es posible combinar new y apply (en ES5  el método apply crea un [[Call]] y no un [[Construct]]). En ES6 la sintaxis de propagación spread soporta esto de forma natural:

- -
var dateFields = readDateFields(database);
-var d = new Date(...dateFields);
- -

Un método push mejorado

- -

Ejemplo: {{jsxref("Global_Objects/Array/push", "push")}} suele usarse para agregar los elementos de un array al final de otro array existente. En ES5 esta tarea puede ser realizada de la siguiente manera:

- -
var arr1 = [0, 1, 2];
-var arr2 = [3, 4, 5];
-// Agregar todos los elementos de arr2 a arr1
-Array.prototype.push.apply(arr1, arr2);
- -

Usando el operador de propagación spread de ES6, este sería el resultado:

- -
var arr1 = [0, 1, 2];
-var arr2 = [3, 4, 5];
-arr1.push(...arr2);
- -

Solo funciona para iterables

- -
var obj = {"key1":"value1"};
-function myFunction(x) {
-    console.log(x); // undefined
-}
-myFunction(...obj);
-var args = [...obj];
-console.log(args, args.length) //[] 0
- -

Operador Rest

- -

El operador Rest es exactamente igual a la sintaxis del operador de propagación, y se utiliza para desestructurar arrays y objetos. En cierto modo, Rest es lo contrario de spread. Spread 'expande' un array en sus elementos, y Rest recoge múltiples elementos y los 'condensa' en uno solo.

- -

Especificaciones

- - - - - - - - - - - - - - - - -
EspecificaciónEstadoCommentario
-

{{SpecName('ES6', '#sec-array-initializer', 'Array Initializer')}}
- {{SpecName('ES6', '#sec-argument-lists', 'Argument Lists')}}

- 		{{Spec2('ES6')}} -
    -
  • 12.2.4 Array Initializer
    • -
  • 12.3.6 Argument Lists
    • -
-
- -

Compatibilidad en navegadores

- -

{{CompatibilityTable}}

- -
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
CaracterísticaChromeFirefox (Gecko)Internet ExplorerOperaSafari (WebKit)
Operación de spread en arrays literales{{CompatNo}}
- v8 issue 3018		{{ CompatGeckoDesktop("16") }}
- {{ CompatGeckoDesktop("36") }} (Symbol.iterator)		{{CompatNo}}{{CompatNo}}7.1
Operación de spread en llamadas a funciones{{CompatNo}}{{ CompatGeckoDesktop("27") }}
- {{ CompatGeckoDesktop("36") }} (Symbol.iterator)		{{CompatNo}}{{CompatNo}}7.1
Operación de spread en desestructuración
- destructuring		{{CompatUnknown}}{{ CompatGeckoDesktop("34") }}
- {{ CompatGeckoDesktop("36") }} (Symbol.iterator)		{{CompatUnknown}}{{CompatUnknown}}{{CompatUnknown}}
-
- -
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
CaracterísticasAndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Operación de spread en arrays literales{{CompatNo}}{{ CompatGeckoMobile("16") }}
- {{ CompatGeckoMobile("36") }} (Symbol.iterator)		{{CompatNo}}{{CompatNo}}iOS 8
Operación de spread en llamadas a funciones{{CompatNo}}{{ CompatGeckoMobile("27") }}
- {{ CompatGeckoMobile("36") }} (Symbol.iterator)		{{CompatNo}}{{CompatNo}}iOS 8
Operación de spread en desestructuración
- destructuring		{{CompatUnknown}}{{ CompatGeckoDesktop("34") }}
- {{ CompatGeckoMobile("36") }} (Symbol.iterator)		{{CompatUnknown}}{{CompatUnknown}}{{CompatUnknown}}
-
- -

Temas relacionados

- - diff --git a/files/es/web/javascript/referencia/operadores/strict_equality/index.html b/files/es/web/javascript/referencia/operadores/strict_equality/index.html deleted file mode 100644 index 0d09b1de71..0000000000 --- a/files/es/web/javascript/referencia/operadores/strict_equality/index.html +++ /dev/null @@ -1,101 +0,0 @@ ---- -title: Igualdad Estricta (===) -slug: Web/JavaScript/Referencia/Operadores/Strict_equality -translation_of: Web/JavaScript/Reference/Operators/Strict_equality ---- -
{{jsSidebar("Operators")}}
- -

El operador de estricta igualdad (===) revisa si dos operandos son iguales y produce un resultado Booleano. A diferencia del operador de igualdad regular (==), el operador de estricta igualdad siempre considera que los operandos de distinto tipo de valor son diferentes y nunca similares.

- -
{{EmbedInteractiveExample("pages/js/expressions-strict-equality.html")}}
- - - -

Sintaxis

- -
x === y
- -

Descripción

- -

Los operadores de estricta igualdad (=== y !==) usan el Algoritmo Estricto Comparativo de Igualdad  para comparar dos operandos:

- - - -

La diferencia más notable entre este operador y el operador de igualdad regular (==) es que si los operandos son de distinto tipo de valor, el operador == intenta convertir los valores a un mismo tipo de dato antes de compararlos.

- -

Ejemplos

- -

Comparando operandos del mismo tipo

- -
console.log("hello" === "hello");   // true
-console.log("hello" === "hola");    // false
-
-console.log(3 === 3);               // true
-console.log(3 === 4);               // false
-
-console.log(true === true);         // true
-console.log(true === false);        // false
-
-console.log(null === null);         // true
- -

Comparando operandos de distinto tipo

- -
console.log("3" === 3);           // false
-
-console.log(true === 1);          // false
-
-console.log(null === undefined);  // false
- -

Comparando objetos

- -
const object1 = {
-  name: "hello"
-}
-
-const object2 = {
-  name: "hello"
-}
-
-console.log(object1 === object2);  // false
-console.log(object1 === object1);  // true
- -

Especificaciones

- - - - - - - - - - - - -
Specification
{{SpecName('ESDraft', '#sec-equality-operators', 'Equality operators')}}
- -

Compatibilidad entre exploradores

- - - -

{{Compat("javascript.operators.strict_equality")}}

- -

También revisa

- - diff --git a/files/es/web/javascript/referencia/operadores/super/index.html b/files/es/web/javascript/referencia/operadores/super/index.html deleted file mode 100644 index ff2ac5ae0e..0000000000 --- a/files/es/web/javascript/referencia/operadores/super/index.html +++ /dev/null @@ -1,178 +0,0 @@ ---- -title: super -slug: Web/JavaScript/Referencia/Operadores/super -tags: - - Clases - - ECMAScript 2015 - - JavaScript - - Operador -translation_of: Web/JavaScript/Reference/Operators/super ---- -
{{jsSidebar("Operators")}}
- -

La palabra clave super es usada para acceder y llamar funciones del padre de un objeto.

- -

Las expresiones super.prop y super[expr] son válidas en cualquier definición de método tanto para clases como para objetos literales.

- -

Sintaxis

- -
// llama al método constructor del objeto padre.
-super([arguments]);
-
-// llama cualquier otro método del objeto padre.
-super.functionOnParent([arguments]);
-
- -

Descripción

- -

Cuando es usado en un constructor, la palabra clave super aparece  sola lo cual invoca el constructor del objeto padre. En este caso debe usarse antes de que la palabra clave this sea usada. La palabra clave super también puede utilizarse para llamar otras funciones del objeto padre.

- -

Ejemplo

- -

Usando super en clases

- -

Este fragmento de código se toma del ejemplo de clases (demo en vivo). Aquí se llama a super() para evitar la duplicación de las partes del constructor que son comunes entre Rectangle y Square.

- -
class Rectangle {
-  constructor(height, width) {
-    this.name = 'Rectangle';
-    this.height = height;
-    this.width = width;
-  }
-  sayName() {
-    console.log('Hi, I am a ', this.name + '.');
-  }
-  get area() {
-    return this.height * this.width;
-  }
-  set area(value) {
-    this.height = this.width = Math.sqrt(value);
-  }
-}
-
-class Square extends Rectangle {
-  constructor(length) {
-    this.height; // ReferenceError, super necesita ser llamado primero!
-
-    // Aquí, llama al constructor de la clase padre con las longitudes
-    // previstas para el ancho y la altura de Rectangle
-    super(length, length);
-
-    // Nota: En las clases derivadas, se debe llamar a super() antes de
-    // poder usar 'this'. Salir de esto provocará un error de referencia.
-    this.name = 'Square';
-  }
-}
- -

Super-llamando a métodos estáticos

- -

También puede llamar a super en métodos estáticos.

- -
class Rectangle {
-  constructor() {}
-  static logNbSides() {
-    return 'I have 4 sides';
-  }
-}
-
-class Square extends Rectangle {
-  constructor() {}
-  static logDescription() {
-    return super.logNbSides() + ' which are all equal';
-  }
-}
-Square.logDescription(); // 'Tengo 4 lados que son todos iguales'
-
- -

Eliminar propiedades super generará un error

- -

No puede usar el operador de eliminación y super.prop o super[expr] para eliminar la propiedad de una clase principal, lanzará {{jsxref("ReferenceError")}}.

- -
class Base {
-  constructor() {}
-  foo() {}
-}
-class Derived extends Base {
-  constructor() {}
-  delete() {
-    delete super.foo; // esto es malo
-  }
-}
-
-new Derived().delete(); // ReferenceError: eliminación no válida que implica 'super'. 
- -

super.prop no puede sobrescribir las propiedades no modificables

- -

Al definir propiedades que no se pueden escribir, p. Ej. {{jsxref("Object.defineProperty")}}, super no puede sobrescribir el valor de la propiedad.

- -
class X {
-  constructor() {
-    Object.defineProperty(this, 'prop', {
-      configurable: true,
-      writable: false,
-      value: 1
-    });
-  }
-  f() {
-    super.prop = 2;
-  }
-}
-
-var x = new X();
-x.f(); // TypeError: "prop" es de solo lectura
-console.log(x.prop); // 1
-
- -

Usando super.prop en objetos literales

- -

Super también se puede usar en el inicializador de objetos / notación literal. En este ejemplo, dos objetos definen un método. En el segundo objeto, super llama al primer método del objeto. Esto funciona con la ayuda de {{jsxref("Object.setPrototypeOf()")}} con el que podemos establecer el prototipo de obj2 en obj1, de modo que super pueda encontrar el method1 en obj1.

- -
var obj1 = {
-  method1() {
-    console.log('method 1');
-  }
-}
-
-var obj2 = {
-  method2() {
-   super.method1();
-  }
-}
-
-Object.setPrototypeOf(obj2, obj1);
-obj2.method2(); // logs "method 1"
-
- -

Especificaciones

- - - - - - - - - - - - - - - - - - - -
EspecificaciónEstadoComentario
{{SpecName('ES2015', '#sec-super-keyword', 'super')}}{{Spec2('ES2015')}}Definición inicial.
{{SpecName('ESDraft', '#sec-super-keyword', 'super')}}{{Spec2('ESDraft')}} 
- -

Compatibilidad con navegadores

- - - -

{{Compat("javascript.operators.super")}}

- -

Ver también

- - diff --git "a/files/es/web/javascript/referencia/operadores/sustracci\303\263n/index.html" "b/files/es/web/javascript/referencia/operadores/sustracci\303\263n/index.html" deleted file mode 100644 index 21bfd3a1ac..0000000000 --- "a/files/es/web/javascript/referencia/operadores/sustracci\303\263n/index.html" +++ /dev/null @@ -1,65 +0,0 @@ ---- -title: Sustracción (-) -slug: Web/JavaScript/Referencia/Operadores/Sustracción -tags: - - JavaScript -translation_of: Web/JavaScript/Reference/Operators/Subtraction ---- -
{{jsSidebar("Operators")}}
- -

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

- -
{{EmbedInteractiveExample("pages/js/expressions-subtraction.html")}}
- -
- - - -

Sintaxis

- -
Operator: x - y
-
- -

Ejemplos

- -

Sustracción con números

- -
5 - 3     // 2
-3 - 5     // -2
- -

Sustracción de no numéricos

- -
'foo' - 3 // NaN
- -

Especificaciones

- - - - - - - - - - -
Specification
{{SpecName('ESDraft', '#sec-subtraction-operator-minus', 'Subtraction operator')}}
- -

Compatibilidad entre exploradores

- - - -

{{Compat("javascript.operators.subtraction")}}

- -

También revisa

- - diff --git a/files/es/web/javascript/referencia/operadores/this/index.html b/files/es/web/javascript/referencia/operadores/this/index.html deleted file mode 100644 index 74ed62bb60..0000000000 --- a/files/es/web/javascript/referencia/operadores/this/index.html +++ /dev/null @@ -1,239 +0,0 @@ ---- -title: this -slug: Web/JavaScript/Referencia/Operadores/this -translation_of: Web/JavaScript/Reference/Operators/this ---- -
{{jsSidebar("Operators")}}
- -

Introducción

- -

La palabra clave this de una función se comporta un poco diferente en Javascript en comparación con otros lenguajes. Además tiene algunas diferencias entre el modo estricto y el modo no estricto.

- -

En general, el valor de this está determinado por cómo se invoca a la función. No puede ser establecida mediante una asignación en tiempo de ejecución, y puede ser diferente cada vez que la función es invocada. ES5 introdujo el método {{jsxref("Function.bind()", "bind()")}} para establecer el valor de la función this independientemente de como es llamada, y ES2015 introdujo las funciones flecha que no proporcionan su propio "binding" de this (se mantiene el valor de this del contexto léxico que envuelve a la función)

- -

{{EmbedInteractiveExample("pages/js/expressions-this.html")}}

- -

Sintaxis

- -
this
- -

Valor

- -

El objeto contexto de JavaScript en el cual se está ejecutando el código actual.

- -

Contexto global

- -

En el contexto de ejecución global (fuera de cualquier función), this se refiere al objeto global, ya sea en modo estricto o no.

- -
console.log(this.document === document); // true
-
-// En los navegadores web, el objeto window también es un objeto global:
-console.log(this === window); // true
-
-this.a = 37;
-console.log(window.a); // 37
-
- -
-

Nota: Puedes obtener el objeto global usando la propieda global globalThis, no importa el contexto donde se ejecute esta propiedad, siempre hará referencia al objeto global. 

-
- -

Contexto de la función

- -

Dentro de una función, el valor de this depende de cómo la función es llamada.

- -

Llamada simple

- -
function f1(){
-  return this;
-}
-
-f1() === window; // objeto global
-
- -
En este caso, el valor de this no está establecido por la llamada. Dado que el código no está en modo estricto, el valor de this debe ser siempre un objeto por lo que por defecto es el objeto global.
- -
- -
-
function f2(){
-  "use strict"; // consultar modo estricto
-  return this;
-}
-
-f2() === undefined;
-
- -
En modo estricto, el valor de this se mantiene en lo que está establecida al entrar en el contexto de ejecución. Si no está definido, permanece undefined. También se puede ajustar a cualquier valor, tales como null o 42 o "Yo no soy this".
- -
- -
-

Nota: En el segundo ejemplo, this debería ser {{jsxref("undefined")}}, porque f2 fue llamado sin proporcionar ninguna base (ej. window.f2()). Esta característica no fue implementada en algunos navegadores cuando se comenzó a dar soporte al modo estricto. Como resultado, retorna incorrectamente el objeto window.

-
- -
Como un método de un objeto
- -

Cuando una función es llamada como un método de un objeto, el this cambia por el metodo del objeto llamado.

- -

En el siguiente ejemplo, cuando o.f() es invocado, dentro de la función this es ligado al objeto o.

- -
var o = {
-  prop: 37,
-  f: function() {
-    return this.prop;
-  }
-};
-
-console.log(o.f()); // logs 37
-
- -

Note que el comportamiento no es del todo afectado por cómo o dónde la función fue definida. En el ejemplo anterior, nosotros definimos la función en línea como el elemento f durante la definición de o.  Sin embargo, podriamos haber definido con la misma facilidad la primera función y luego  adjuntarlo a o.f. Hacerlo da como resultado el mismo comportamiento.

- -
var o = {prop: 37};
-
-function independent() {
-  return this.prop;
-}
-
-o.f = independent;
-
-console.log(o.f()); // logs 37
-
- -

Esto demuestra que sólo importa que la función fue invocada del elemento f de o.

- -

Asimismo, el enlace this sólo se ve afectado por la referencia del miembro más inmediata. En el siguiente ejemplo, cuando invocamos a la función, lo llamamos como metodo g del objeto o.b. Esta vez durante la ejecución, this dentro de la función se referirá a o.b. El hecho de que el objeto es en sí mismo un elemento de o no tiene ninguna consecuencia, la referencia más inmediata es todo lo que importa.

- -
o.b = {g: independent, prop: 42};
-console.log(o.b.g()); // logs 42
-
- -

... en la cadena de prototipo

- -

El mismo concepto es válido para los métodos definidos en alguna parte de la cadena de prototipo del objeto. Si el método esta sobre una cadena de prototipo del objeto, this se referirá al objeto donde está el método de donde fue llamado. Como si ese método estuviera dentro del objeto. 

- -
var o = {f:function(){ return this.a + this.b; }};
-var p = Object.create(o);
-p.a = 1;
-p.b = 4;
-
-console.log(p.f()); // 5
-
- -

En este ejemplo, el objeto asignado a la variable p no tiene su propia propiedad f, esto lo hereda de su prototipo. Pero no importa que la búsqueda de f eventualmente encuentre un elemento con ese nombre en o; la búsqueda comenzó como una referencia a p.f, asi this dentro de la funcion toma el valor del objeto referido como p. Es decir, desde que f es llamado como método de p, su this refiere a p. Esto es una interesante característica de la herencia de prototipo de JavaScript.

- -

... o como un getter o setter

- -

Nuevamente, el mismo concepto es válido cuando una función es invocada de un getter o un setter. Una función usado como getter o setter tiene su enlace this al objeto desde el cual la propiedad esta siendo establecida u obtenida.

- -
function modulus(){
-  return Math.sqrt(this.re * this.re + this.im * this.im);
-}
-
-var o = {
-  re: 1,
-  im: -1,
-  get phase(){
-    return Math.atan2(this.im, this.re);
-  }
-};
-
-Object.defineProperty(o, 'modulus', {get: modulus, enumerable:true, configurable:true});
-
-console.log(o.phase, o.modulus); // logs -0.78 1.4142
-
- -

Como un constructor

- -

Cuando una función es usada como un constructor (con la palabra clave {{jsxref("Operadores/new", "new")}}), su this es enlazado al nuevo objeto en construcción, a menos que la ejecución de los resultados del constructor en el motor JavaScript encuentren una instrucción de retorno donde el valor de retorno sea un objeto.

- -
/*
- * Los constructores trabajan algo asi:
- *
- * function MyConstructor(){
- *   // El cuerpo del código de la función actual va aquí.  Crear las propiedades en |this| como
- *   // se desee mediante la asignación a los mismos.  E.g.,
- *   this.fum = "nom";
- *   // etcetera...
- *
- *   // Si la función tiene una sentencia de retorno este retorna un objeto,
- *   // este objeto será el resultado de la expresión |new|.  Por otro lado, el
- *   // resultado de la expresión es el objeto actualmente enlazado a |this|
- *   // (i.e., el caso más común suele verse).
- * }
- */
-
-function C(){
-  this.a = 37;
-}
-
-var o = new C();
-console.log(o.a); // logs 37
-
-
-function C2(){
-  this.a = 37;
-  return {a:38};
-}
-
-o = new C2();
-console.log(o.a); // logs 38
-
- -

En el último ejemplo (C2), debido a que un objeto fue devuelto durante la construcción, el nuevo objeto que fue enlazado a this simplemente se descarta.( Esto esencialmente hace de la declaración "this.a = 37;" codigo muerto. No esta exactamente muerto,porque es ejecutado pero se puede eliminar sin efectos externos.)

- -

call y apply

- -

Cuando una función usa la plabra clave this en su cuerpo, su valor puede ser enlazado a un objeto particular durante la ejecución del método {{jsxref("Function.call()", "call()")}} or {{jsxref("Function.apply()", "apply()")}} que todas las funciones hereden de  Function.prototype.

- -
function add(c, d){
-  return this.a + this.b + c + d;
-}
-
-var o = {a:1, b:3};
-
-// El primer parámetro es el objeto a usar como 'this', parámetros posteriores se pasan como argumentos
-// en la llamada a la función
-add.call(o, 5, 7); // 1 + 3 + 5 + 7 = 16
-
-//El primer parámetro es el objeto a usar como 'this''this', la segunda es una matriz cuyos elementos
-//  se utilizan como argumentos en la llamada a la función
-add.apply(o, [10, 20]); // 1 + 3 + 10 + 20 = 34
-
- -

Funciones enlazadas

- -

ECMAScript 5 introduce {{jsxref("Function.prototype.bind()")}}. Llamando a f.bind(someObject) crea una nueva función con el mismo cuerpo y alcance de f, pero donde this se produce en la función original, en la nueva función esto esta permanentemente ligado al primer argumento de bind, independientemente de cómo la función está siendo utilizada.

- -
function f(){
-  return this.a;
-}
-
-var g = f.bind({a:"azerty"});
-console.log(g()); // azerty
-
-var o = {a:37, f:f, g:g};
-console.log(o.f(), o.g()); // 37, azerty
-
- -

Como un controlador de eventos DOM

- -

Cuando una función es usada como un controlador de eventos, su this es cambiado desde el elemento del evento disparado (algunos navegadores no siguen esta convención para los listeners agregados dinámicamente con otros métodos addEventListener).

- -
// Cuando se llama como un listener, convierte en azul el elemento
-// relacionado
-function bluify(e){
-  console.log(this === e.currentTarget); // Siempre true
-  console.log(this === e.target);        // true cuando currentTarget y target son el mismo objeto
-  this.style.backgroundColor = '#A5D9F3';
-}
-
-// Consigue una lista de cada elemento en un documento
-var elements = document.getElementsByTagName('*');
-
-// Añade bluify como un click listener asi cuando se hace click sobre el elemento,
-// este cambia a azul
-for(var i=0 ; i<elements.length ; i++){
-  elements[i].addEventListener('click', bluify, false);
-}
diff --git a/files/es/web/javascript/referencia/operadores/typeof/index.html b/files/es/web/javascript/referencia/operadores/typeof/index.html deleted file mode 100644 index 088791f228..0000000000 --- a/files/es/web/javascript/referencia/operadores/typeof/index.html +++ /dev/null @@ -1,76 +0,0 @@ ---- -title: typeof -slug: Web/JavaScript/Referencia/Operadores/typeof -tags: - - JavaScript - - Operator - - Unary -translation_of: Web/JavaScript/Reference/Operators/typeof ---- -
{{jsSidebar("Operators")}}
- -

Resumen

- -

El operador typeof se usa en cualquiera de los siguientes modos:

- -
    -
  1. typeof operando
    2. -
  2. typeof (operando)
    3. -
- -

El operador typeof devuelve una cadena que indica el tipo del operando sin evaluarlo. operando es la cadena, variable, palabra clave u objeto para el que se devolverá su tipo. Los paréntesis son opcionales.

- -

Suponga que define las siguientes variables:

- -
var miFuncion = new Function("5+2")
-var forma = "redonda"
-var tamano = 1
-var hoy = new Date()
-
- -

El operador typeof devuelve los siguientes resultados para estas variables

- -
typeof miFuncion === 'function'
-typeof forma === 'string'
-typeof tamano === 'number'
-typeof hoy === 'object'
-typeof noExiste === 'undefined'
-
- -

Para las palabras clave true y null, el operador typeof devuelve los siguientes resultados:

- -
typeof true === 'boolean'
-typeof null === 'object'
-
- -

Para un número o una cadena, el operador typeof devuelve los siguientes resultados:

- -
typeof 62 === 'number'
-typeof 'Hola mundo' === 'string'
-
- -

Para valores de propiedades, el operador typeof devuelve el tipo del valor que contiene la propiedad:

- -
typeof document.lastModified === 'string'
-typeof window.length === 'number'
-typeof Math.LN2 === 'number'
-
- -

Para métodos y funciones, el operador typeof devuelve los resultados siguientes:

- -
typeof blur === 'function'
-typeof eval === 'function'
-typeof parseInt === 'function'
-typeof shape.split === 'function'
-
- -

Para objetos predefinidos, el operador typeof devuelve los siguientes resultados:

- -
typeof Date === 'function'
-typeof Function === 'function'
-typeof Math === 'object'
-typeof Object === 'function'
-typeof String === 'function'
-
- -

 

diff --git a/files/es/web/javascript/referencia/operadores/void/index.html b/files/es/web/javascript/referencia/operadores/void/index.html deleted file mode 100644 index 0bf8048b21..0000000000 --- a/files/es/web/javascript/referencia/operadores/void/index.html +++ /dev/null @@ -1,36 +0,0 @@ ---- -title: void -slug: Web/JavaScript/Referencia/Operadores/void -tags: - - JavaScript - - Operator - - Unary -translation_of: Web/JavaScript/Reference/Operators/void ---- -
{{jsSidebar("Operators")}}
- -

Resumen

- -

El operador void se usa en cualquiera de los siguientes modos:

- -
    -
  1. void (expresion )
    2. -
  2. void expresion
    3. -
- -

El operador void especifica una expresión que se evalúa sin devolver un valor. expresion es una expresión JavaScript para evaluar. El paréntesis rodeando la expresión es opcional, pero usarlos es una buena práctica al programar.

- -

Puede usar el operador void para especificar una expresión como un enlace de hipertexto. La expresión se evalúa pero no se carga en lugar del documento actual.

- -

El siguiente código crea un enlace de hipertexto que no hace nada cuando el usuario hace click en él. Cuando el usuario hace click en el enlace, void(0) se evalúa como 0, pero eso no tiene ningún efecto en JavaScript.

- -
<a href="javascript:void(0)">Haga click aquí para no hacer nada</a>
-
- -

El siguiente código crea un enlace de hipertexto que envía un formulario cuando el usuario hace click en él.

- -
<a href="javascript:void(document.forms["miFormulario"].submit())">
-Haga click aquí para enviar</a>
-
- -
diff --git a/files/es/web/javascript/referencia/operadores/yield/index.html b/files/es/web/javascript/referencia/operadores/yield/index.html deleted file mode 100644 index 7237b6d689..0000000000 --- a/files/es/web/javascript/referencia/operadores/yield/index.html +++ /dev/null @@ -1,130 +0,0 @@ ---- -title: yield -slug: Web/JavaScript/Referencia/Operadores/yield -tags: - - Característica del lenguaje - - ECMAScript 2015 - - Generadores - - Iterador - - JavaScript - - Operador -translation_of: Web/JavaScript/Reference/Operators/yield ---- -
{{jsSidebar("Operadores")}}
- -

La palabra clave yield se usa para pausar y reanudar una función generadora ({{jsxref("Statements/function*", "function*")}} o {{jsxref("Statements/Legacy_generator_function", "función generadora heredada")}}).

- -
{{EmbedInteractiveExample("pages/js/expressions-yield.html", "taller")}}
- - - -

Sintaxis

- -
[rv] = yield [expression]
- -
-
expression {{optional_inline}}
-
Define el valor que se devolverá desde la función generadora a través del {{jsxref("Iteration_protocols", "protocolo iterador", "#El_protocolo_iterador")}}. Si se omite, devuelve undefined en su lugar.
-
rv {{optional_inline}}
-
-

Recupera el valor opcional pasado al método next() del generador para reanudar su ejecución.

-
-
- -

Descripción

- -

La palabra clave yield detiene la ejecución de la función del generador y el valor de la expresión que sigue a la palabra clave yield se devuelve al llamador del generador. Se puede considerar como una versión basada en un generador de la palabra clave return.

- -

yield solo se puede llamar directamente desde la función generadora que la contiene. No se puede llamar desde funciones anidadas o retrollamadas.

- -

La palabra clave yield hace que la llamada al método next() del generador devuelva un objeto IteratorResult con dos propiedades: value y done. La propiedad value es el resultado de evaluar la expresión yield, y done es false, lo cual indica que la función generadora no se ha completado completamente.

- -

Una vez en pausa en una expresión yield, la ejecución del código del generador permanece en pausa hasta que se llama al método next() del generador. Cada vez que se llama al método next() del generador, el generador reanuda la ejecución y se ejecuta hasta que alcanza uno de los siguientes:

- - - -

Si se pasa un valor opcional al método next() del generador, ese valor se convierte en el valor devuelto por la operación yield actual del generador.

- -

Entre la ruta del código del generador, sus operadores yield y la capacidad de especificar un nuevo valor inicial pasándolo a {{jsxref("Generator.prototype.next()")}}, los generadores ofrecen enorme poder y control.

- -
-

Desafortunadamente, next() es asimétrico, pero eso no se puede evitar: siempre envía un valor al yield actualmente suspendido, pero devuelve el operando del siguiente yield.

-
- -

Ejemplos

- -

Usar yield

- -

El siguiente código es la declaración de una función generadora de ejemplo.

- -
function* countAppleSales () {
-  let saleList = [3, 7, 5]
-  for (let i = 0; i < saleList.length; i++) {
-    yield saleList[i]
-  }
-}
- -

Una vez que se define una función generadora, se puede usar construyendo un iterador como el siguiente.

- -
let appleStore = countAppleSales()  // Generator { }
-console.log(appleStore.next())      // { value: 3, done: false }
-console.log(appleStore.next())      // { value: 7, done: false }
-console.log(appleStore.next())      // { value: 5, done: false }
-console.log(appleStore.next())      // { value: undefined, done: true }
- -

También puedes enviar un valor con next(value) al generador. 'step' se evalúa como un valor de retorno en esta sintaxis [rv] = yield [expression]

- -
function* counter(value) {
- let step;
-
- while (true) {
-   step = yield ++value;
-
-   if (step) {
-     value += step;
-   }
- }
-}
-
-const generatorFunc = counter(0);
-console.log(generatorFunc.next().value);   // 1
-console.log(generatorFunc.next().value);   // 2
-console.log(generatorFunc.next().value);   // 3
-console.log(generatorFunc.next(10).value); // 14
-console.log(generatorFunc.next().value);   // 15
-console.log(generatorFunc.next(10).value); // 26
- -

Especificaciones

- - - - - - - - - - - - -
Especificación
{{SpecName('ESDraft', '#prod-YieldExpression', 'Yield')}}
- -

Compatibilidad del navegador

- - - -

{{Compat("javascript.operators.yield")}}

- -

Ve también

- - diff --git a/files/es/web/javascript/referencia/operadores/yield_star_/index.html b/files/es/web/javascript/referencia/operadores/yield_star_/index.html deleted file mode 100644 index e2167b8c41..0000000000 --- a/files/es/web/javascript/referencia/operadores/yield_star_/index.html +++ /dev/null @@ -1,199 +0,0 @@ ---- -title: yield* -slug: Web/JavaScript/Referencia/Operadores/yield* -tags: - - ECMAScript6 - - JavaScript -translation_of: Web/JavaScript/Reference/Operators/yield* ---- -
{{jsSidebar("Operators")}}
- -

La expresión yield* es usada para delegar a otro {{jsxref("Statements/function*", "generator")}} u objeto iterable.

- -

Sintaxis

- -
 yield* [[expression]];
- -
-
expression
-
La expresión que retorna un objeto iterable
-
- -

Descripción

- -

La expresión yield* itera sobre el operador realizando yield de cada valor retornado por este.

- -

El valor de la expresion yield* es el valor retornado por el iterador en si mismo cuando es finalizado (ej., cuando done es true).

- -

Ejemplos

- -

Delegando a otro generator

- -

En el siguiente código, los valores declarados con yield en g1() son devueltos por las llamadas a next() al igual que en g2().

- -
function* g1() {
-  yield 2;
-  yield 3;
-  yield 4;
-}
-
-function* g2() {
-  yield 1;
-  yield* g1();
-  yield 5;
-}
-
-var iterator = g2();
-
-console.log(iterator.next()); // { value: 1, done: false }
-console.log(iterator.next()); // { value: 2, done: false }
-console.log(iterator.next()); // { value: 3, done: false }
-console.log(iterator.next()); // { value: 4, done: false }
-console.log(iterator.next()); // { value: 5, done: false }
-console.log(iterator.next()); // { value: undefined, done: true }
-
- -

Otros objetos iterables

- -

Además de los objetos generator, yield* también se puede usar yield sobre otros tipos de iterables, ej. arrays, strings u objetos arguments.

- -
function* g3() {
-  yield* [1, 2];
-  yield* "34";
-  yield* Array.from(arguments);
-}
-
-var iterator = g3(5, 6);
-
-console.log(iterator.next()); // { value: 1, done: false }
-console.log(iterator.next()); // { value: 2, done: false }
-console.log(iterator.next()); // { value: "3", done: false }
-console.log(iterator.next()); // { value: "4", done: false }
-console.log(iterator.next()); // { value: 5, done: false }
-console.log(iterator.next()); // { value: 6, done: false }
-console.log(iterator.next()); // { value: undefined, done: true }
-
- -

El valor de la expresión yield*

- -

yield* es una expresión, no una declaración, por lo que se evalua como un valor.

- -
function* g4() {
-  yield* [1, 2, 3];
-  return "foo";
-}
-
-var result;
-
-function* g5() {
-  result = yield* g4();
-}
-
-var iterator = g5();
-
-console.log(iterator.next()); // { value: 1, done: false }
-console.log(iterator.next()); // { value: 2, done: false }
-console.log(iterator.next()); // { value: 3, done: false }
-console.log(iterator.next()); // { value: undefined, done: true },
-                              // g4() returned { value: "foo", done: true } at this point
-
-console.log(result);          // "foo"
-
- -

Especificaciones

- - - - - - - - - - - - - - - - - - - - - -
EspecificaciónEstadoComentarios
{{SpecName('ES6', '#', 'Yield')}}{{Spec2('ES6')}}Definición inical.
{{SpecName('ESDraft', '#', 'Yield')}}{{Spec2('ESDraft')}} 
- -

Compatibilidad con navegadores

- -

{{CompatibilityTable}}

- -
- - - - - - - - - - - - - - - - - - - -
CaracterísticaChromeFirefox (Gecko)Internet ExplorerOperaSafari (WebKit)
Soporte básico {{CompatVersionUnknown}}{{CompatGeckoDesktop("27.0")}}{{CompatUnknown}}{{CompatUnknown}}{{CompatUnknown}}
-
- -
- - - - - - - - - - - - - - - - - - - -
CaracterísticaAndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Soporte básico{{CompatVersionUnknown}}{{CompatGeckoMobile("27.0")}}{{CompatUnknown}}{{CompatUnknown}}{{CompatUnknown}}
-
- -

Notas específicas de Firefox

- - - -

Ver también

- - -- cgit v1.2.3-54-g00ecf