diff options
Diffstat (limited to 'files/es/conflicting/web/javascript/reference/operators')
| -rw-r--r-- | files/es/conflicting/web/javascript/reference/operators/index.html | 316 | ||||
| -rw-r--r-- | files/es/conflicting/web/javascript/reference/operators/spread_syntax/index.html | 221 |
2 files changed, 537 insertions, 0 deletions
diff --git a/files/es/conflicting/web/javascript/reference/operators/index.html b/files/es/conflicting/web/javascript/reference/operators/index.html new file mode 100644 index 0000000000..ef6c162b92 --- /dev/null +++ b/files/es/conflicting/web/javascript/reference/operators/index.html @@ -0,0 +1,316 @@ +--- +title: Operadores Aritméticos +slug: conflicting/Web/JavaScript/Reference/Operators +tags: + - JavaScript + - Operador +translation_of: Web/JavaScript/Reference/Operators +translation_of_original: Web/JavaScript/Reference/Operators/Arithmetic_Operators +original_slug: Web/JavaScript/Referencia/Operadores/Aritméticos +--- +<div>{{jsSidebar("Operators")}}</div> + +<p>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 (/).</p> + +<p>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:</p> + +<p>{{EmbedInteractiveExample("pages/js/expressions-arithmetic.html")}}</p> + +<h2 id="Suma_o_adición_()"><a name="Addition">Suma o adición (+)</a></h2> + +<p>La operación suma se produce mediante la suma de número o strings concatenados.</p> + +<h3 id="Sintaxis">Sintaxis</h3> + +<pre class="brush: js"><strong>Operador:</strong> x + y</pre> + +<h3 id="Ejemplos">Ejemplos:</h3> + +<pre class="brush: js">// 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" +</pre> + +<h2 id="Resta_o_sustracción_(-)"><a name="Subtraction">Resta o sustracción (-)</a></h2> + +<p>La resta se produce cuando se sutraen el resultado de los operadores, produciendo su diferencia.</p> + +<h3 id="Sintaxis_2">Sintaxis</h3> + +<pre class="brush: js"><strong>Operador:</strong> x - y</pre> + +<h3 id="Ejemplos_2">Ejemplos</h3> + +<pre class="brush: js">5 - 3 // 2 +3 - 5 // -2 +'foo' - 3 // NaN +</pre> + +<h2 id="División_()"><a name="Division">División (/)</a></h2> + +<p>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.</p> + +<h3 id="Sintaxis_3">Sintaxis</h3> + +<pre class="brush: js"><strong>Operador:</strong> x / y</pre> + +<h3 id="Ejemplos_3">Ejemplos</h3> + +<pre class="brush: js">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 +</pre> + +<h2 id="Multiplicación_(*)"><a name="Multiplication">Multiplicación (*)</a></h2> + +<p>El operador multiplicación produce el producto de la multiplicación de los operandos.</p> + +<h3 id="Sintaxis_4">Sintaxis</h3> + +<pre class="brush: js"><strong>Operador:</strong> x * y</pre> + +<h3 id="Ejemplos_4">Ejemplos</h3> + +<pre class="brush: js">2 * 2 // 4 +-2 * 2 // -4 +Infinito * 0 // NaN +Infinito * Infinito // Infinito +'foo' * 2 // NaN</pre> + +<h2 id=".25_.28modular.29" name=".25_.28modular.29">Resto o Residuo (%)</h2> + +<p>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 <code>modulo</code> incorporada para producir el resultado, que es el resto entero de dividir <code>var1</code> por <code>var2</code> - por ejemplo - <code>var1</code> modulo <code>var2</code>. <a href="http://wiki.ecmascript.org/doku.php?id=strawman:modulo_operator">Existe una propuesta para obtener un operador de módulo real en una versión futura de ECMAScript</a>, con la diferencia de que el resultado del operador de módulo tomaría el signo del divisor, no el dividendo.</p> + +<h3 id="Sintaxis_5">Sintaxis</h3> + +<pre class="brush: js"><strong>Operador:</strong> var1 % var2</pre> + +<h3 id="Ejemplos_5">Ejemplos</h3> + +<pre class="brush: js">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</pre> + +<h2 id="Exponenciación_(**)">Exponenciación (**)</h2> + +<p>El operador de exponenciación devuelve el resultado de elevar el primer operando al segundo operando de potencia. es decir, <code>var1<sup>var2</sup></code>, en la declaración anterior, donde <code>var1</code> y <code>var2</code> son variables. El operador de exponenciación es asociativo a la derecha. <code>a ** b ** c</code> es igual a <code>a ** (b ** c)</code>.</p> + +<h3 id="Sintaxis_6">Sintaxis</h3> + +<pre><strong>Operador:</strong> var1 ** var2</pre> + +<p> </p> + +<h3 id="Notas">Notas</h3> + +<p>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 (<code>+/-/~/!/delete/void/typeof</code>) inmediatamente antes del número de base.</p> + +<pre class="brush: js">-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.</pre> + +<h3 id="Ejemplos_6">Ejemplos</h3> + +<pre class="brush: js">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</pre> + +<p>Para invertir el signo del resultado de una expresión de exponenciación:</p> + +<pre class="brush: js">-(2 ** 2) // -4</pre> + +<p>Para forzar la base de una expresión de exponenciación a ser un número negativo:</p> + +<pre class="brush: js">(-2) ** 2 // 4</pre> + +<div class="note"> +<p><strong>Nota:</strong> JavaScript también tiene <a href="/es/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#Bitwise_XOR">un operador bit a bit ^ (logical XOR)</a>. <code>**</code> y <code>^</code> son diferentes (por ejemplo: <code>2 ** 3 === 8</code> cuando <code>2 ^ 3 === 1</code>.)</p> +</div> + +<p> </p> + +<h2 id=".2B.2B_.28incremento.29" name=".2B.2B_.28incremento.29">Incremento (++)</h2> + +<p> </p> + +<p>El operador de incremento incrementa (agrega uno a) su operando y devuelve un valor.</p> + +<ul> + <li>Si se usa postfijo, con el operador después del operando (por ejemplo, x++), devuelve el valor antes de incrementar.</li> + <li>Si se usa prefijo, con el operador antes del operando (por ejemplo, ++x), devuelve el valor después de incrementar.</li> +</ul> + +<h3 id="Sintaxis_7">Sintaxis</h3> + +<pre><strong>Operador:</strong> x++ o ++x</pre> + +<h3 id="Ejemplos_7">Ejemplos</h3> + +<pre class="brush: js">// Postfijo +var x = 3; +y = x++; // y = 3, x = 4 + +// Prefijo +var a = 2; +b = ++a; // a = 3, b = 3 +</pre> + +<h2 id="--_.28decremento.29" name="--_.28decremento.29">Decremento (--)</h2> + +<p>El operador de decremento disminuye (resta uno de) su operando y devuelve un valor.</p> + +<ul> + <li>Si se usa postfijo (por ejemplo, x--), devuelve el valor antes de decrementar.</li> + <li>Si usa el prefijo (por ejemplo, --x), entonces devuelve el valor después de decrementar.</li> +</ul> + +<h3 id="Sintaxis_8">Sintaxis</h3> + +<pre><strong>Operador:</strong> x-- o --x</pre> + +<h3 id="Ejemplos_8">Ejemplos</h3> + +<pre class="brush: js">// Postfijo +var x = 3; +y = x--; // y = 3, x = 2 + +// Prefijo +var a = 2; +b = --a; // a = 1, b = 1</pre> + +<p> </p> + +<h2 id="-_.28negaci.C3.B3n_unitario.29" name="-_.28negaci.C3.B3n_unitario.29">Negación unaria (-)</h2> + +<p>El operador de negación unaria precede su operando y lo niega.</p> + +<h3 id="Sintaxis_9">Sintaxis</h3> + +<pre><strong>Operador:</strong> -x</pre> + +<h3 id="Ejemplos_9">Ejemplos</h3> + +<pre class="brush: js">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</pre> + +<h2 id="Unario_más_()">Unario más (+)</h2> + +<p>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 <code>true</code>, <code>false</code> y <code>null</code>. 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 <a href="/es/docs/Web/JavaScript/Reference/Global_Objects/NaN">NaN</a>.</p> + +<h3 id="Sintaxis_10">Sintaxis</h3> + +<pre><strong>Operador:</strong> +x</pre> + +<h3 id="Ejemplos_10">Ejemplos</h3> + +<pre class="brush: js">+3 // 3 ++'3' // 3 ++true // 1 ++false // 0 ++null // 0 ++function(val){ return val } // NaN</pre> + +<p> </p> + +<h2 id="Especificaciones">Especificaciones</h2> + +<table> + <tbody> + <tr> + <th scope="col">Especificación</th> + <th scope="col">Estado</th> + <th scope="col">Comentario</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Definición inicial.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-11.3')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> + <p>Definido en varias secciones de la especificación: <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.6">Operadores aditivos</a>, <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.5">Operadores multiplicativos</a>, <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.3">Expresiones Postfijas</a>, <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.4">Operadores unarios.</a></p> + </td> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-postfix-expressions')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td> + <p>Definido en varias secciones de la especificación: <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-additive-operators">Operadores aditivos</a>, <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-multiplicative-operators">Operadores multiplicativos</a>, <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-postfix-expressions">Expresiones Postfijas</a>, <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-unary-operators">Operadores unarios.</a></p> + </td> + </tr> + <tr> + <td>{{SpecName('ES2016', '#sec-postfix-expressions')}}</td> + <td>{{Spec2('ES2016')}}</td> + <td><a href="https://github.com/rwaldron/exponentiation-operator">Operador de exponenciación</a> agregado.</td> + </tr> + <tr> + <td>{{SpecName('ES2017', '#sec-postfix-expressions')}}</td> + <td>{{Spec2('ES2017')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-additive-operators')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidad_con_navegadores">Compatibilidad con navegadores</h2> + +<p>{{Compat("javascript.operators.arithmetic")}}</p> + +<h2 id="Ver_también">Ver también</h2> + +<ul> + <li><a href="/es/docs/Web/JavaScript/Reference/Operators/Assignment_Operators">Operadores de Asignación</a></li> +</ul> + +<p> </p> diff --git a/files/es/conflicting/web/javascript/reference/operators/spread_syntax/index.html b/files/es/conflicting/web/javascript/reference/operators/spread_syntax/index.html new file mode 100644 index 0000000000..f8d23e4eaa --- /dev/null +++ b/files/es/conflicting/web/javascript/reference/operators/spread_syntax/index.html @@ -0,0 +1,221 @@ +--- +title: Operador de propagación +slug: conflicting/Web/JavaScript/Reference/Operators/Spread_syntax +tags: + - Experimental + - Expérimental(2) + - JavaScript + - Operador +translation_of: Web/JavaScript/Reference/Operators/Spread_syntax +translation_of_original: Web/JavaScript/Reference/Operators/Spread_operator +original_slug: Web/JavaScript/Referencia/Operadores/Spread_operator +--- +<div>{{jsSidebar("Operators")}}</div> + +<p>El operador de propagación <em><strong>spread operator</strong></em> permite que una expresión sea expandida en situaciones donde se esperan múltiples argumentos (llamadas a funciones) o múltiples elementos (arrays literales).</p> + +<h2 id="Sintaxis">Sintaxis</h2> + +<p>Llamadas a funciones:</p> + +<pre class="brush: js">f(...iterableObj); +</pre> + +<p>Arrays literales:</p> + +<pre class="brush: js">[...iterableObj, 4, 5, 6]</pre> + +<p>Desestructuración <em>destructuring</em>:</p> + +<pre class="brush: js">[a, b, ...iterableObj] = [1, 2, 3, 4, 5];</pre> + +<h2 id="Ejemplos">Ejemplos</h2> + +<h3 id="Un_mejor_método_apply">Un mejor método apply</h3> + +<p><strong>Ejemplo:</strong> 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:</p> + +<pre class="brush: js">function f(x, y, z) { } +var args = [0, 1, 2]; +f.apply(null, args);</pre> + +<p>Con el operador spread de ES6, el ejemplo anterior se puede rescribir como:</p> + +<pre class="brush: js">function f(x, y, z) { } +var args = [0, 1, 2]; +f(...args);</pre> + +<p>Cualquier argumento en la lista de argumentos puede usar la sintaxis de propagación <em>spread, </em>donde además puede ser usada varias veces.</p> + +<pre class="brush: js">function f(v, w, x, y, z) { } +var args = [0, 1]; +f(-1, ...args, 2, ...[3]);</pre> + +<h3 id="Un_array_literal_mas_poderoso">Un array literal mas poderoso</h3> + +<p><strong>Ejemplo:</strong> 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 <code>push</code>, <code>splice</code>, <code>concat</code>, etc. Con la sintaxis de propagación <em>spread</em> esta tarea resulta mucho mas concisa:</p> + +<pre class="brush: js">var parts = ['shoulder', 'knees']; +var lyrics = ['head', ...parts, 'and', 'toes'];</pre> + +<p>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.</p> + +<h3 id="Combinación_del_método_apply_y_el_operador_new">Combinación del método apply y el operador new</h3> + +<p><strong>Ejemplo:</strong> En ES5 no es posible combinar <code>new</code> y <code>apply</code> (en ES5 el método <code>apply</code> crea un <code>[[Call]]</code> y no un <code>[[Construct]]</code>). En ES6 la sintaxis de propagación <em>spread</em> soporta esto de forma natural:</p> + +<pre class="brush: js">var dateFields = readDateFields(database); +var d = new Date(...dateFields);</pre> + +<h3 id="Un_método_push_mejorado">Un método push mejorado</h3> + +<p><strong>Ejemplo:</strong> {{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:</p> + +<pre class="brush: js">var arr1 = [0, 1, 2]; +var arr2 = [3, 4, 5]; +// Agregar todos los elementos de arr2 a arr1 +Array.prototype.push.apply(arr1, arr2);</pre> + +<p>Usando el operador de propagación <em>spread</em> de ES6, este sería el resultado:</p> + +<pre class="brush: js">var arr1 = [0, 1, 2]; +var arr2 = [3, 4, 5]; +arr1.push(...arr2);</pre> + +<h3 id="Solo_funciona_para_iterables">Solo funciona para iterables</h3> + +<pre class="brush: js">var obj = {"key1":"value1"}; +function myFunction(x) { + console.log(x); // undefined +} +myFunction(...obj); +var args = [...obj]; +console.log(args, args.length) //[] 0</pre> + +<h2 id="Operador_Rest">Operador Rest</h2> + +<p>El operador <em>Rest</em> es exactamente igual a la sintaxis del operador de propagación, y se utiliza para desestructurar arrays y objetos. En cierto modo, <em>Rest</em> es lo contrario de <em>spread</em>. <em>Spread</em> 'expande' un array en sus elementos, y <em>Rest</em> recoge múltiples elementos y los 'condensa' en uno solo.</p> + +<h2 id="Especificaciones">Especificaciones</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Especificación</th> + <th scope="col">Estado</th> + <th scope="col">Commentario</th> + </tr> + </thead> + <tbody> + <tr> + <td> + <p>{{SpecName('ES6', '#sec-array-initializer', 'Array Initializer')}}<br> + {{SpecName('ES6', '#sec-argument-lists', 'Argument Lists')}}</p> + </td> + <td>{{Spec2('ES6')}}</td> + <td> + <ul> + <li>12.2.4 Array Initializer</li> + <li>12.3.6 Argument Lists</li> + </ul> + </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidad_en_navegadores">Compatibilidad en navegadores</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari (WebKit)</th> + </tr> + <tr> + <td>Operación de spread en arrays literales</td> + <td>{{CompatNo}}<br> + <a href="https://code.google.com/p/v8/issues/detail?id=3018">v8 issue 3018</a></td> + <td>{{ CompatGeckoDesktop("16") }}<br> + {{ CompatGeckoDesktop("36") }} (Symbol.iterator)</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>7.1</td> + </tr> + <tr> + <td>Operación de spread en llamadas a funciones</td> + <td>{{CompatNo}}</td> + <td>{{ CompatGeckoDesktop("27") }}<br> + {{ CompatGeckoDesktop("36") }} (Symbol.iterator)</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>7.1</td> + </tr> + <tr> + <td>Operación de spread en desestructuración<br> + <em>destructuring</em></td> + <td>{{CompatUnknown}}</td> + <td>{{ CompatGeckoDesktop("34") }}<br> + {{ CompatGeckoDesktop("36") }} (Symbol.iterator)</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Características</th> + <th>Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td><span style="font-size: 12px; line-height: 18px;">Operación de spread en arrays literales</span></td> + <td>{{CompatNo}}</td> + <td>{{ CompatGeckoMobile("16") }}<br> + {{ CompatGeckoMobile("36") }} (Symbol.iterator)</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>iOS 8</td> + </tr> + <tr> + <td><span style="font-size: 12px; line-height: 18px;">Operación de spread en llamadas a funciones</span></td> + <td>{{CompatNo}}</td> + <td>{{ CompatGeckoMobile("27") }}<br> + {{ CompatGeckoMobile("36") }} (Symbol.iterator)</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>iOS 8</td> + </tr> + <tr> + <td><span style="font-size: 12px; line-height: 18px;">Operación de spread en desestructuración</span><br> + <em>destructuring</em></td> + <td>{{CompatUnknown}}</td> + <td>{{ CompatGeckoDesktop("34") }}<br> + {{ CompatGeckoMobile("36") }} (Symbol.iterator)</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Temas_relacionados">Temas relacionados</h2> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Functions_and_function_scope/rest_parameters">Parámetros rest</a></li> +</ul> |