diff options
Diffstat (limited to 'files/es/conflicting/web/javascript/reference')
20 files changed, 3926 insertions, 0 deletions
diff --git a/files/es/conflicting/web/javascript/reference/global_objects/arraybuffer/index.html b/files/es/conflicting/web/javascript/reference/global_objects/arraybuffer/index.html new file mode 100644 index 0000000000..fef80071de --- /dev/null +++ b/files/es/conflicting/web/javascript/reference/global_objects/arraybuffer/index.html @@ -0,0 +1,69 @@ +--- +title: ArrayBuffer.prototype +slug: Web/JavaScript/Referencia/Objetos_globales/ArrayBuffer/prototype +tags: + - ArrayBuffer + - JavaScript + - Propiedad +translation_of: Web/JavaScript/Reference/Global_Objects/ArrayBuffer +translation_of_original: Web/JavaScript/Reference/Global_Objects/ArrayBuffer/prototype +--- +<div>{{JSRef}}</div> + +<p>La propiedad <strong><code>ArrayBuffer.prototype</code></strong> representa el prototipo para el objeto {{jsxref("ArrayBuffer")}}.</p> + +<div>{{js_property_attributes(0,0,0)}}</div> + +<h2 id="Descripción">Descripción</h2> + +<p>Las instancias de <code>ArrayBuffer</code> heredan de <code>ArrayBuffer.prototype</code>. Como con todos los constructores, puedes modificar el prototipo del constructor para aplicar cambios sobre todas las instancias de <code>ArrayBuffer</code>.</p> + +<h2 id="Propiedades">Propiedades</h2> + +<dl> + <dt>ArrayBuffer.prototype.constructor</dt> + <dd>Especifica la función que se encarga de crear el prototipo del objeto. El valor inicial es el constructor incluido en el estándar <code>ArrayBuffer</code>.</dd> + <dt>{{jsxref("ArrayBuffer.prototype.byteLength")}} {{readonlyInline}}</dt> + <dd>El tamaño, en bytes, del array. Este valor se establece al construir el objeto y no se puede modificar. <strong>Sólo lectura.</strong></dd> +</dl> + +<h2 id="Métodos">Métodos</h2> + +<dl> + <dt>{{jsxref("ArrayBuffer.prototype.slice()")}}</dt> + <dd>Retorna un nuevo <code>ArrayBuffer</code> cuyo contenido es una copia los bytes de este <code>ArrayBuffer</code> desde <code>begin</code>, incluido, hasta <code>end</code>, no incluido. Si <code>begin</code> o <code>end</code> son negativos, éstos hacen referencia a un índice que comienza a partir del final del array.</dd> +</dl> + +<h2 id="Especificaciones">Especificaciones</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificación</th> + <th scope="col">Estado</th> + <th scope="col">Comentario</th> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-arraybuffer.prototype', 'ArrayBuffer.prototype')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definición inicial.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-arraybuffer.prototype', 'ArrayBuffer.prototype')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidad_con_navegadores">Compatibilidad con navegadores</h2> + +<p>{{Compat("javascript.builtins.ArrayBuffer.prototype")}}</p> + +<div id="compat-mobile"> </div> + +<h2 id="Ver_también">Ver también</h2> + +<ul> + <li>{{jsxref("ArrayBuffer")}}</li> +</ul> diff --git a/files/es/conflicting/web/javascript/reference/global_objects/date/index.html b/files/es/conflicting/web/javascript/reference/global_objects/date/index.html new file mode 100644 index 0000000000..de92c8ee02 --- /dev/null +++ b/files/es/conflicting/web/javascript/reference/global_objects/date/index.html @@ -0,0 +1,201 @@ +--- +title: Date.prototype +slug: Web/JavaScript/Referencia/Objetos_globales/Date/prototype +tags: + - Date + - JavaScript + - Property +translation_of: Web/JavaScript/Reference/Global_Objects/Date +translation_of_original: Web/JavaScript/Reference/Global_Objects/Date/prototype +--- +<div> + {{JSRef("Objetos_globales", "Date")}}</div> +<h2 id="Resumen">Resumen</h2> +<p>Representa el prototipo para esta clase. Puede utilizar el prototipo para añadir propiedades o métodos a todas las instancias de una clase.</p> +<div> + {{js_property_attributes(0,0,1)}}</div> +<h2 class="noinclude" id="Propriedades">Propriedades</h2> +<dl> + <dt class="noinclude"> + <code>Date.prototype.constructor</code></dt> + <dd> + </dd> +</dl> +<div> + {{ jsOverrides("Object", "properties", "constructor") }}</div> +<h2 id="Métodos">Métodos</h2> +<dl> + <dt> + {{jsxref("Date.prototype.getDate()")}}</dt> + <dd> + Devuelve el día del mes de la fecha especificada según la hora local.</dd> + <dt> + {{jsxref("Date.prototype.getDay()")}}</dt> + <dd> + Devuelve el día de la semana de la fecha especificada según la hora local.</dd> + <dt> + {{jsxref("Date.prototype.getFullYear()")}}</dt> + <dd> + Devuelve el año de la fecha especificada según la hora local.</dd> + <dt> + {{jsxref("Date.prototype.getHours()")}}</dt> + <dd> + Devuelve la hora de la fecha especificada según la hora local.</dd> + <dt> + {{jsxref("Date.prototype.getMilliseconds()")}}</dt> + <dd> + Devuelve los milisegundos de la fecha especificada según la hora local.</dd> + <dt> + {{jsxref("Date.prototype.getMinutes()")}}</dt> + <dd> + Devuelve los minutos de la fecha especificada según la hora local.</dd> + <dt> + {{jsxref("Date.prototype.getMonth()")}}</dt> + <dd> + Devuelve el mes de la fecha especificada según la hora local.</dd> + <dt> + {{jsxref("Date.prototype.getSeconds()")}}</dt> + <dd> + Devuelve los segundos de la fecha especificada según la hora local.</dd> + <dt> + {{jsxref("Date.prototype.getTime()")}}</dt> + <dd> + Devuelve el valor numérico correspondiente a la hora especificada según la hora universal.</dd> + <dt> + {{jsxref("Date.prototype.getTimezoneOffset()")}}</dt> + <dd> + Devuelve la diferencia horaria en minutos para la zona geográfica actual.</dd> + <dt> + {{jsxref("Date.prototype.getUTCDate()")}}</dt> + <dd> + Devuelve el día del mes de la fecha especificada según la hora universal.</dd> + <dt> + {{jsxref("Date.prototype.getUTCDay()")}}</dt> + <dd> + Devuelve el día de la semana de la fecha especificada según la hora universal.</dd> + <dt> + {{jsxref("Date.prototype.getUTCFullYear()")}}</dt> + <dd> + Devuelve el día el año de la fecha especificada según la hora universal.</dd> + <dt> + {{jsxref("Date.prototype.getUTCHours()")}}</dt> + <dd> + Devuelve las horas de la fecha especificada según la hora universal.</dd> + <dt> + {{jsxref("Date.prototype.getUTCMilliseconds()")}}</dt> + <dd> + Devuelve los milisegundos de la fecha especificada según la hora universal.</dd> + <dt> + {{jsxref("Date.prototype.getUTCMinutes()")}}</dt> + <dd> + Devuelve los minutos de la fecha especificada según la hora universal.</dd> + <dt> + {{jsxref("Date.prototype.getUTCMonth()")}}</dt> + <dd> + Devuelve el mes de la fecha especificada según la hora universal.</dd> + <dt> + {{jsxref("Date.prototype.getUTCSeconds()")}}</dt> + <dd> + Devuelve los segundos de la fecha especificada según la hora universal.</dd> + <dt> + {{jsxref("Date.prototype.getYear()")}} {{ deprecated_inline() }}</dt> + <dd> + Devuelve el año de la fecha especificada según la hora local. Use {{jsxref("Date.prototype.getFullYear()")}} a cambio.</dd> + <dt> + {{jsxref("Date.prototype.setDate()")}}</dt> + <dd> + Establece el día del mes de la fecha especificada según la hora local.</dd> + <dt> + {{jsxref("Date.prototype.setFullYear()")}}</dt> + <dd> + Establece el año completo de la fecha especificada según la hora local.</dd> + <dt> + {{jsxref("Date.prototype.setHours()")}}</dt> + <dd> + Establece las horas de la fecha especificada según la hora local.</dd> + <dt> + {{jsxref("Date.prototype.setMilliseconds()")}}</dt> + <dd> + Establece los milisegundos de la fecha especificada según la hora local.</dd> + <dt> + {{jsxref("Date.prototype.setMinutes()")}}</dt> + <dd> + Establece los minutos de la fecha especificada según la hora local.</dd> + <dt> + {{jsxref("Date.prototype.setMonth()")}}</dt> + <dd> + Establece el mes de la fecha especificada según la hora local.</dd> + <dt> + {{jsxref("Date.prototype.setSeconds()")}}</dt> + <dd> + Establece los segundos de la fecha especificada según la hora local.</dd> + <dt> + {{jsxref("Date.prototype.setTime()")}}</dt> + <dd> + Establece el valor del objeto <code>Date</code> según la hora local.</dd> + <dt> + {{jsxref("Date.prototype.setUTCDate()")}}</dt> + <dd> + Establece el día del mes de la fecha especificada según la hora universal.</dd> + <dt> + {{jsxref("Date.prototype.setUTCFullYear()")}}</dt> + <dd> + Establece el año completo de la fecha especificada según la hora universal.</dd> + <dt> + {{jsxref("Date.prototype.setUTCHours()")}}</dt> + <dd> + Establece la hora de la fecha especificada según la hora universal.</dd> + <dt> + {{jsxref("Date.prototype.setUTCMilliseconds()")}}</dt> + <dd> + Establece los milisegundos de la fecha especificada según la hora universal..</dd> + <dt> + {{jsxref("Date.prototype.setUTCMinutes()")}}</dt> + <dd> + Establece los minutos de la fecha especificada según la hora universal..</dd> + <dt> + {{jsxref("Date.prototype.setUTCMonth()")}}</dt> + <dd> + Establece el mes de la fecha especificada según la hora universal.</dd> + <dt> + {{jsxref("Date.prototype.setUTCSeconds()")}}</dt> + <dd> + Establece los segundos de la fecha especificada según la hora universal..</dd> + <dt> + {{jsxref("Date.prototype.setYear ()")}}{{deprecated_inline}}</dt> + <dd> + Establece el año de la fecha especificada según la hora local. Use {{jsxref("Date.prototype.setFullYear()")}} a cambio.</dd> + <dt> + {{jsxref("Date.prototype.toGMTString()")}} {{ deprecated_inline}}</dt> + <dd> + Convierte una fecha en una cadena, usando las convenciones de Internet GMT. Utilice {{jsxref("Date.prototype.toUTCString()")}} a cambio.</dd> + <dt> + {{jsxref("Date.prototype.toLocaleString()")}}</dt> + <dd> + Convierte una fecha en una cadena, usando las reglas de la localización actual. Sobreescribe el método {{jsxref("Object.toLocaleString()")}}.</dd> + <dt> + {{jsxref("Date.prototype.toLocaleDateString()")}}</dt> + <dd> + Devuelve la porción fecha (sin la hora) de una fecha como una cadena, usando las reglas de la localización actual.</dd> + <dt> + {{jsxref("Date.prototype.toLocaleTimeString()")}}</dt> + <dd> + Devuelve la porción hora (sin la fecha) de una fecha como una cadena, siguiendo las reglas de la localización actual.</dd> + <dt> + {{jsxref("Date.prototype.toSource()")}}</dt> + <dd> + Devuelve un literal que representa al objeto <code>Date</code> especificado; puede usar este valor para crear un nuevo objeto. Sobreescribe el método {{jsxref("Object.toSource()")}}.</dd> + <dt> + {{jsxref("Date.prototype.toString()")}}</dt> + <dd> + Devuelve una cadena representando el objeto <code>Date</code> especificado. Sobreescribe el método {{jsxref("Object.toString()")}}.</dd> + <dt> + {{jsxref("Date.prototype.toUTCString()")}}</dt> + <dd> + Convierte una fecha en una cadena, usando las reglas horarias universales.</dd> + <dt> + {{jsxref("Date.prototype.valueOf()")}}</dt> + <dd> + Devuelve el valor primitivo de un objeto <code>Date</code>. Sobreescribe el método {{jsxref("Object.valueOf()")}}.</dd> +</dl> +<p>{{ jsOverrides("Object", "methods", "getDate", "getDay", "getFullYear", "getHours", "getMilliseconds", "getMinutes", "getMonth", "getSeconds", "getTime", "getTimezoneOffset", "getUTCDate", "getUTCDay", "getUTCFullYear", "getUTCHours", "getUTCMilliseconds", "getUTCMinutes", "getUTCMonth", "getUTCSeconds", "getYear", "setdate", "setFullYear", "setHours", "setMilliseconds", "setMinutes", "setMontth", "setSeconds", "setTime", "setUTCDate", "setUTCFullYear", "setUTCHours", "setUTCMilliseconds", "setUTCMinutes", "setUTCMonth", "setUTCSeconds", "setYear", "toDateString", "toGMTString", "toLocaleDateString", "toLocaleFormat", "toLocaleString", "toLocaleTimeString", "toSource", "toString", "toTimeString", "toUTCString", "valueOf") }}</p> diff --git a/files/es/conflicting/web/javascript/reference/global_objects/error/index.html b/files/es/conflicting/web/javascript/reference/global_objects/error/index.html new file mode 100644 index 0000000000..aac1516fc2 --- /dev/null +++ b/files/es/conflicting/web/javascript/reference/global_objects/error/index.html @@ -0,0 +1,154 @@ +--- +title: Error.prototype +slug: Web/JavaScript/Referencia/Objetos_globales/Error/prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Error +translation_of_original: Web/JavaScript/Reference/Global_Objects/Error/prototype +--- +<div>{{JSRef}}</div> + +<p>La propiedad <code><strong>Error.prototype</strong></code> representa el prototipo del constructor {{jsxref("Error")}}.</p> + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<h2 id="Descripción">Descripción</h2> + +<p>Todas las instancias de {{jsxref("Error")}} e instancias de {{jsxref("Global_Objects/Error", "errores no genéricos", "#Error_types", 1)}}, heredan de <code>Error.prototype</code>. Como todas las funciones constructoras, se puede usar el protoipo del constructor para añadir propiedades o métodos a todas las instancias creadas con este constructor.</p> + +<h2 id="Properties">Properties</h2> + +<h3 id="Propiedades_estándar">Propiedades estándar</h3> + +<dl> + <dt><code>Error.prototype.constructor</code></dt> + <dd>Especifica la función que crea una instancia del prototipo.</dd> + <dt>{{jsxref("Error.prototype.message")}}</dt> + <dd>Mensaje de error.</dd> + <dt>{{jsxref("Error.prototype.name")}}</dt> + <dd>Nombre del error.</dd> +</dl> + +<h3 id="Extensiones_específicas_del_proveedor">Extensiones específicas del proveedor</h3> + +<div>{{non-standard_header}}</div> + +<h4 id="Microsoft">Microsoft</h4> + +<dl> + <dt>{{jsxref("Error.prototype.description")}}</dt> + <dd>Descripción del error. Similar a {{jsxref("Error.prototype.message", "message")}}.</dd> + <dt>{{jsxref("Error.prototype.number")}}</dt> + <dd>Número de error.</dd> +</dl> + +<h4 id="Mozilla">Mozilla</h4> + +<dl> + <dt>{{jsxref("Error.prototype.fileName")}}</dt> + <dd>Ruta del archivo que lanzó el error.</dd> + <dt>{{jsxref("Error.prototype.lineNumber")}}</dt> + <dd>Número de fila en el archivo que lanzó el error.</dd> + <dt>{{jsxref("Error.prototype.columnNumber")}}</dt> + <dd>Número de columna en el archivo que lanzó el error.</dd> + <dt>{{jsxref("Error.prototype.stack")}}</dt> + <dd>Seguimiento de la pila.</dd> +</dl> + +<h2 id="Métodos">Métodos</h2> + +<dl> + <dt>{{jsxref("Error.prototype.toSource()")}} {{non-standard_inline}}</dt> + <dd>Devuelve una cadena que contiene el codígo del objeto {{jsxref("Error")}}; se puede usar este valor para crear un nuevo objeto. Sobreescribe el método {{jsxref("Object.prototype.toSource()")}}.</dd> + <dt>{{jsxref("Error.prototype.toString()")}}</dt> + <dd>Devuelve una cadena que representa el objeto. Sobreescribe el método {{jsxref("Object.prototype.toString()")}}.</dd> +</dl> + +<h2 id="Especificaciones">Especificaciones</h2> + +<table class="standard-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. Implementado en JavaScript 1.1.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.11.3.1', 'Error')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-error.prototype', 'Error')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-error.prototype', 'Error')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidad_con_navegadores">Compatibilidad con navegadores</h2> + +<div>{{CompatibilityTable}}</div> + +<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</th> + </tr> + <tr> + <td>Soporte básico</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Soporte básico</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Ver_también">Ver también</h2> + +<ul> + <li>{{jsxref("Error")}}</li> + <li>{{jsxref("Object.prototype")}}</li> +</ul> diff --git a/files/es/conflicting/web/javascript/reference/global_objects/function/index.html b/files/es/conflicting/web/javascript/reference/global_objects/function/index.html new file mode 100644 index 0000000000..9d8671c534 --- /dev/null +++ b/files/es/conflicting/web/javascript/reference/global_objects/function/index.html @@ -0,0 +1,65 @@ +--- +title: Function.prototype +slug: Web/JavaScript/Referencia/Objetos_globales/Function/prototype +tags: + - Function + - JavaScript + - Property +translation_of: Web/JavaScript/Reference/Global_Objects/Function +translation_of_original: Web/JavaScript/Reference/Global_Objects/Function/prototype +--- +<div>{{JSRef("Objetos_globales", "Function")}}</div> + +<h2 id="Resumen" name="Resumen">Resumen</h2> + +<p>Un valor desde cuyas instancias de una clase particular son creados. Cada objeto que puede ser creado por la invocación a la función constructora posee una propiedad prototype asociada.</p> + +<h2 id="Descripci.C3.B3n" name="Descripci.C3.B3n">Descripción</h2> + +<p>Puede añadir propiedades o métodos a una clase existente mediante la adición de ellos al prototipo asociado con la función constructora para esa clase.</p> + +<h2 id="Propiedades">Propiedades</h2> + +<dl> + <dt>{{jsxref("Function.arguments")}} {{Deprecated_inline}}</dt> + <dd>Una matriz correspondiente a los argumentos pasados a una función. Como propiedad de una <code>Function</code>, este uso está obsoleto. Se recomenda el uso del objeto {{jsxref("Functiones/arguments", "arguments")}}.</dd> + <dt>{{jsxref("Function.arity")}} {{obsolete_inline}}</dt> + <dd>Especifica el número de argumentos que espera la función. Se recomienda, no obstante, utilizar la función {{jsxref("Function.length", "length")}}.</dd> + <dt>{{jsxref("Function.caller")}}</dt> + <dd>Especifica la función que invoca la ejecución de la función actual (no estándar).</dd> + <dt>{{jsxref("Function.constructor")}}</dt> + <dd>Especifica la función que crea un prototipo de objeto.</dd> + <dt>{{jsxref("Function.length")}}</dt> + <dd>Specifica el número de argumentos esperados por la función.</dd> + <dt>{{jsxref("Function.name")}}</dt> + <dd>El nombre de la función (no forma parte del estándar).</dd> + <dt>{{jsxref("Function.prototype")}}</dt> + <dd>Permite añadir propiedades a los objetos función (ambos, los construidos usando <code>Function</code> y los declarados usando una declaración de función o una expresión de función).</dd> +</dl> + +<div>{{ jsOverrides("Object", "properties", "arguments", "arity", "caller", "constructor", "length", "name", "displayName") }}</div> + +<h2 id="Métodos">Métodos</h2> + +<dl> + <dt>{{jsxref("Function.prototype.apply()")}}</dt> + <dd>Le permite aplicar el método de otro objeto en el contexto de un objeto diferente (el objeto llamado).</dd> + <dt>{{jsxref("Function.prototype.call()")}}</dt> + <dd>Le Permite llamar (ejecutar) a un método de otro objeto en el contexto de un objeto diferente (el objeto que llama).</dd> + <dt>{{jsxref("Function.prototype.toSource()")}}</dt> + <dd>Devuelve una cadena que representa el código fuente de la función. Anula al método {{jsxref("Object.toSource")}}.</dd> + <dt>{{jsxref("Function.prototype.toString()")}}</dt> + <dd>Devuelve una cadena que representa el código fuente de la función. Anula al método {{jsxref("Object.toSource")}}.</dd> +</dl> + +<div>{{ jsOverrides("Object", "methods", "apply", "call", "toSource", "toString") }}</div> + +<dl> + <dt> </dt> +</dl> + +<h2 id="Vea_También">Vea También</h2> + +<ul> + <li>{{jsxref("Objetos_globales/Function", "Function")}}</li> +</ul> diff --git a/files/es/conflicting/web/javascript/reference/global_objects/map/index.html b/files/es/conflicting/web/javascript/reference/global_objects/map/index.html new file mode 100644 index 0000000000..b255e65b69 --- /dev/null +++ b/files/es/conflicting/web/javascript/reference/global_objects/map/index.html @@ -0,0 +1,135 @@ +--- +title: Map.prototype +slug: Web/JavaScript/Referencia/Objetos_globales/Map/prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Map +translation_of_original: Web/JavaScript/Reference/Global_Objects/Map/prototype +--- +<div>{{JSRef}}</div> + +<p>La propiedad <code><strong>Map</strong></code><strong><code>.prototype</code></strong> representa el prototipo del constructor {{jsxref("Map")}}.</p> + +<div>{{js_property_attributes(0,0,0)}}</div> + +<h2 id="Descripción">Descripción</h2> + +<p>La instancia de {{jsxref("Map")}} hereda de {{jsxref("Map.prototype")}}. Puedes utilizar el constructor del prototipo del objeto para agregar propiedades o métodos a todas las instancias de <code>Map</code>.</p> + +<h2 id="Propiedades">Propiedades</h2> + +<dl> + <dt><code>Map.prototype.constructor</code></dt> + <dd>Devuelve la función que creó el prototipo de una instancia. Esta es la función de {{jsxref("Map")}} por defecto.</dd> + <dt>{{jsxref("Map.prototype.size")}}</dt> + <dd>Devuelve el número de conjuntos de llave/valor en el objeto <code>Map</code>.</dd> +</dl> + +<h2 id="Métodos">Métodos</h2> + +<dl> + <dt>{{jsxref("Map.prototype.clear()")}}</dt> + <dd>Elimina todos los conjuntos de llave/valor del objeto <code>Map</code>.</dd> + <dt>{{jsxref("Map.delete", "Map.prototype.delete(key)")}}</dt> + <dd>Elimina cualquier valor asociado a la <code>llave</code> y devuelve el valor que <code>Map.prototype.has(key)</code> tenía previamente. Después <code>Map.prototype.has(key)</code> devolverá <code>false</code>.</dd> + <dt>{{jsxref("Map.prototype.entries()")}}</dt> + <dd>Devuelve un nuevo objeto <code>Iterador</code> que contiene<strong> un array de <code>[llave, valor]</code></strong> para cada elemento en el objeto <code>Map</code> en orden de inserción.</dd> + <dt>{{jsxref("Map.forEach", "Map.prototype.forEach(callbackFn[, thisArg])")}}</dt> + <dd>Llama a la callbackFn una vez por cada conjunto llave/valor presentes en cada objeto <code>Map</code>, en orden de inserción. Si se le proporciona un parámetro thisArg a forEach, se usará como valor "this" para cada callback.</dd> + <dt>{{jsxref("Map.get", "Map.prototype.get(key)")}}</dt> + <dd>Devuelve el valor asociado a la <code>llave</code>, o <code>undefined</code> si no tiene ninguno.</dd> + <dt>{{jsxref("Map.has", "Map.prototype.has(key)")}}</dt> + <dd>Devuelve un booleano que indica si un valor se ha asociado a la <font face="consolas, Liberation Mono, courier, monospace"><span style="background-color: #eeeeee;">llave</span></font> en el objeto <code>Map</code> o no se ha asociado.</dd> + <dt>{{jsxref("Map.prototype.keys()")}}</dt> + <dd>Devuelve un nuevo objeto <code>Iterador</code> que contiene las <strong>llaves</strong> para cada elemento en el objeto <code>Map</code> en orden de inserción.</dd> + <dt>{{jsxref("Map.set", "Map.prototype.set(key, value)")}}</dt> + <dd>Establece un valor para la <code>llave</code> en el objeto <code>Map</code>. Devuelve el objeto <code>Map</code>.</dd> + <dt>{{jsxref("Map.prototype.values()")}}</dt> + <dd>Devuelve un nuevo objeto <code>Iterador</code> que contiene los <strong>valores</strong> para cada elemento en el objeto <code>Map</code> en orden de inserción.</dd> + <dt>{{jsxref("Map.@@iterator", "Map.prototype[@@iterator]()")}}</dt> + <dd>Devuelve un nuevo objeto <code>Iterador</code> que contiene<strong> un array de <code>[llave, valor]</code></strong> para cada elemento en el objeto <code>Map</code> en orden de inserción.</dd> +</dl> + +<h2 id="Especificaciones">Especificaciones</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificación</th> + <th scope="col">Estado</th> + <th scope="col">Comentario</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-map.prototype', 'Map.prototype')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Definición inicial.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-map.prototype', 'Map.prototype')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidad_entre_navegadores">Compatibilidad entre navegadores</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Edge</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Soporte básico</td> + <td>38</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{ CompatGeckoDesktop("13") }}</td> + <td>11</td> + <td>25</td> + <td>7.1</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Edge</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Soporte básico</td> + <td>{{CompatNo}}</td> + <td>38</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoMobile("13")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td> + <p>8</p> + </td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vea_también">Vea también</h2> + +<ul> + <li>{{jsxref("Set.prototype")}}</li> +</ul> diff --git a/files/es/conflicting/web/javascript/reference/global_objects/number/index.html b/files/es/conflicting/web/javascript/reference/global_objects/number/index.html new file mode 100644 index 0000000000..c15b5b5fcb --- /dev/null +++ b/files/es/conflicting/web/javascript/reference/global_objects/number/index.html @@ -0,0 +1,16 @@ +--- +title: Number.prototype +slug: Web/JavaScript/Referencia/Objetos_globales/Number/prototype +tags: + - JavaScript + - Number + - Property +translation_of: Web/JavaScript/Reference/Global_Objects/Number +translation_of_original: Web/JavaScript/Reference/Global_Objects/Number/prototype +--- +<div> + {{JSRef("Objetos_globales", "Number")}}</div> +<h3 id="Resumen" name="Resumen">Resumen</h3> +<p>Representa el prototipo para esta clase. Puede utilizar el prototipo para añadir propiedades o métodos a todas las instancias de una clase. Para información acerca de prototipos.</p> +<div class="noinclude"> + </div> diff --git a/files/es/conflicting/web/javascript/reference/global_objects/object/index.html b/files/es/conflicting/web/javascript/reference/global_objects/object/index.html new file mode 100644 index 0000000000..9b55c9cccc --- /dev/null +++ b/files/es/conflicting/web/javascript/reference/global_objects/object/index.html @@ -0,0 +1,195 @@ +--- +title: Object.prototype +slug: Web/JavaScript/Referencia/Objetos_globales/Object/prototype +tags: + - JavaScript + - Objeto + - Propiedad +translation_of: Web/JavaScript/Reference/Global_Objects/Object +translation_of_original: Web/JavaScript/Reference/Global_Objects/Object/prototype +--- +<div>{{JSRef("Objetos_globales", "Object")}}</div> + +<h2 id="Summary" name="Summary">Resumen</h2> + +<p>La propiedad <code><strong>Object.prototype</strong></code> representa al objeto prototipo de {{jsxref("Object")}}.</p> + +<p>{{js_property_attributes(0,0,0)}}</p> + +<h2 id="Description" name="Description">Descripción</h2> + +<p>Todos los objetos en JavaScript provienen de {{jsxref("Global_Objects/Object", "Object")}}; todos los objetos heredan métodos y propiedades de<code> Object.prototype</code>, aunque pueden ser sobrecargados. Sin embargo, un <code>Object</code> puede ser deliberadamente creado para que esto no sea cierto (por ejemplo usando {{jsxref("Object.create", "Object.create(null)")}}), o bien alterado para que no cumpla esta propiedad (por ejemplo usando {{jsxref("Object.setPrototypeOf")}}).</p> + +<p>Cambios en el prototipo de {{jsxref("Object")}} son vistos por <strong>todos </strong>los objetos a traves de el encadenado de prototype, a no ser que las propiedades y los metodos sujetos a estos cambios sean sobreescritos en algun lugar de la cadena de prototype. Este poderoso y a la vez potencialmente peligroso mecanismo permite extender o sobreescribir el comportamiento de un objeto.</p> + +<h2 id="Propiedades">Propiedades</h2> + +<dl> + <dt>{{jsxref("Object.prototype.constructor")}}</dt> + <dd>Especifica la función que crea el prototipo de un objeto.</dd> + <dt>{{jsxref("Object.proto", "Object.prototype.__proto__")}} {{Non-standard_inline}}</dt> + <dd>Apunta al objeto que se usó como prototipo cuando fue instanciado.</dd> + <dt>{{jsxref("Object.noSuchMethod", "Object.prototype.__noSuchMethod__")}} {{Non-standard_inline}}</dt> + <dd>Permite a una función ser definida que sera ejecutada cuando un miembro del objeto es llamado como un metodo.</dd> + <dt><s class="obsoleteElement">{{jsxref("Object.count", "Object.prototype.__count__")}} {{obsolete_inline()}}</s></dt> + <dd>Se utiliza para devolver el número de propiedades enumerables directamente en un objeto definido por el usuario, pero que ha sido eliminado.</dd> + <dt><s class="obsoleteElement">{{jsxref("Object.parent", "Object.prototype.__parent__")}} {{obsolete_inline()}}</s></dt> + <dd><s class="obsoleteElement">Apunta al contexto de un objeto. Ha sido borrado.</s></dd> +</dl> + +<h2 id="Métodos">Métodos</h2> + +<dl> + <dt>{{jsxref("Object.defineGetter", "Object.prototype.__defineGetter__()")}} {{Non-standard_inline}} {{deprecated_inline()}}</dt> + <dd>Asocia una función con una propiedad que, cuando se accede a ella, ejecuta esa función y devuelve su valor de retorno.</dd> + <dt>{{jsxref("Object.defineSetter", "Object.prototype.__defineSetter__()")}} {{Non-standard_inline}} {{deprecated_inline()}}</dt> + <dd>Asocia una función con una propiedad que al establecerse ejecuta esa función que modifica la propiedad.</dd> + <dt>{{jsxref("Object.lookupGetter", "Object.prototype.__lookupGetter__()")}} {{Non-standard_inline}} {{deprecated_inline()}}</dt> + <dd>Devuelve la función asociada con la propiedad indicada por el método {{jsxref("Object.defineGetter", "__defineGetter__")}}.</dd> + <dt>{{jsxref("Object.lookupSetter", "Object.prototype.__lookupSetter__()")}} {{Non-standard_inline}} {{deprecated_inline()}}</dt> + <dd>Devuelve la función asociada con la propiedad indicada en el método {{jsxref("Object.defineSetter", "__defineSetter__")}}.</dd> + <dt>{{jsxref("Object.prototype.hasOwnProperty()")}}</dt> + <dd>Devuelve un valor lógico (boolean) que indica si el objeto contiene la propiedad indicada como una propiedad directa de ese objeto y no heredada por la cadena de prototipo.</dd> + <dt>{{jsxref("Object.prototype.isPrototypeOf()")}}</dt> + <dd>Devuelve una indicación <em>booleana</em> cuando el objeto especificado está en la cadena de prototipos del objeto sobre el cuál éste método es llamado.</dd> + <dt>{{jsxref("Object.prototype.propertyIsEnumerable()")}}</dt> + <dd>Devuelve un valor lógico (boolean) indicando si el attributo <a href="/es/docs/Web/JavaScript/Data_structures#Objetos">ECMAScript [[Enumerable]]</a> está definido.</dd> + <dt>{{jsxref("Object.prototype.toSource()")}} {{Non-standard_inline}}</dt> + <dd>Devuelve una cadena con el fuente de un literal de objeto que representa el objeto desde el que este método es llamado; se puede usar este valor para crear un nuevo objeto.</dd> + <dt>{{jsxref("Object.prototype.toLocaleString()")}}</dt> + <dd>Llama a {{jsxref("Object.toString", "toString()")}}.</dd> + <dt>{{jsxref("Object.prototype.toString()")}}</dt> + <dd>Devuelve la cadena de texto (string) que representa al objeto.</dd> + <dt>{{jsxref("Object.prototype.unwatch()")}} {{Non-standard_inline}}</dt> + <dd>Remueve un punto de mira de una propiedad del objeto.</dd> + <dt>{{jsxref("Object.prototype.valueOf()")}}</dt> + <dd>Devuelve el valor primitivo del objeto indicado.</dd> + <dt>{{jsxref("Object.prototype.watch()")}} {{Non-standard_inline}}</dt> + <dd>Agrega un punto de mira a una propiedad del objeto.</dd> + <dt><s class="obsoleteElement">{{jsxref("Object.prototype.eval()")}} {{ obsolete_inline()}}</s></dt> + <dd><s class="obsoleteElement">Se utiliza para evaluar una cadena de código JavaScript en el contexto del objeto especificado, pero que ha sido removido.</s></dd> +</dl> + +<h2 id="Ejemplos">Ejemplos</h2> + +<p>Al alterar el comportamiento de un método existente en Object.prototype, es oportuno considerar envolver el código de tu extensión antes o después de la existente lógica. Por ejemplo, este trozo de código (sin testear) ejecutara una determinada lógica antes de que la lógica existente o la de algún otro elemento sea ejecutada.</p> + +<p>Cuando una función es llamada, los parámetros de la llamada son mantenidos en el argumento parecido a una array llamado "arguments". Por ejemplo, en la llamada "myFn(a, b, c)", los parámetros dentro del cuerpo de la función myFn estarán contenidos en una variable llamada "arguments". Si se desea llamar al siguiente método de la cadena de prototype, simplemente añade this y arguments a la funcion apply(). Este patrón puede ser usado en cualquier prototype, por ejemplo Node.prototype, Function.prototype, etc.</p> + +<pre class="brush: js">var current = Object.prototype.valueOf; + +// Como mi propiedad "-prop-value" es un atajo y no se encuentra siempre +// en la cadena de prototype, queremos modificar Object.prototype: +Object.prototype.valueOf = function() { + if (this.hasOwnProperty('-prop-value')) { + return this['-prop-value']; + } else { + // No parece que este objeto sea uno de los mios, por lo que recaeeremos + // en el comportamiento por defecto lo mejor que podamos. + // La llamada apply se comporta como el "super" en otros lenguages de programación. + // A pesar de que valueOf() no tiene parametros, alguna otra llamada podria tenerlos. + return current.apply(this, arguments); + } +}</pre> + +<p>Como JavaScript no tiene objetos de tipo “subclase”, prototype es realmente útil para crear un objeto “base” donde ciertas funciones actúan como objetos. Por ejemplo:</p> + +<pre class="brush: js">var Person = function(name) { + this.name = name; + this.canTalk = true; +}; + +Person.prototype.greet = function() { + if (this.canTalk) { + console.log('Hi, I am ' + this.name); + } +}; + +var Employee = function(name, title) { + Person.call(this, name); + this.title = title; +}; + +Employee.prototype = Object.create(Person.prototype); +Employee.prototype.constructor = Employee; + +Employee.prototype.greet = function() { + if (this.canTalk) { + console.log('Hi, I am ' + this.name + ', the ' + this.title); + } +}; + +var Customer = function(name) { + Person.call(this, name); +}; + +Customer.prototype = Object.create(Person.prototype); +Customer.prototype.constructor = Customer; + +var Mime = function(name) { + Person.call(this, name); + this.canTalk = false; +}; + +Mime.prototype = Object.create(Person.prototype); +Mime.prototype.constructor = Mime; + +var bob = new Employee('Bob', 'Builder'); +var joe = new Customer('Joe'); +var rg = new Employee('Red Green', 'Handyman'); +var mike = new Customer('Mike'); +var mime = new Mime('Mime'); + +bob.greet(); +// Hi, I am Bob, the Builder + +joe.greet(); +// Hi, I am Joe + +rg.greet(); +// Hi, I am Red Green, the Handyman + +mike.greet(); +// Hi, I am Mike + +mime.greet();</pre> + +<h2 id="Especificaciones">Especificaciones</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificación</th> + <th scope="col">Estado</th> + <th scope="col">Observación</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td> + <p>Definición inicial.Implementado en JavaScript 1.0.</p> + </td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.2.3.1', 'Object.prototype')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-object.prototype', 'Object.prototype')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> + <p> </p> + </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-object.prototype', 'Object.prototype')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidad_con_navegadores">Compatibilidad con navegadores</h2> + +<p>{{Compat("javascript.builtins.Object.prototype")}}</p> diff --git a/files/es/conflicting/web/javascript/reference/global_objects/promise/index.html b/files/es/conflicting/web/javascript/reference/global_objects/promise/index.html new file mode 100644 index 0000000000..c15107912a --- /dev/null +++ b/files/es/conflicting/web/javascript/reference/global_objects/promise/index.html @@ -0,0 +1,69 @@ +--- +title: Promise.prototype +slug: Web/JavaScript/Referencia/Objetos_globales/Promise/prototype +tags: + - JavaScript + - Promesa + - Propiedad +translation_of: Web/JavaScript/Reference/Global_Objects/Promise +translation_of_original: Web/JavaScript/Reference/Global_Objects/Promise/prototype +--- +<div>{{JSRef}}</div> + +<p>La propiedad <code><strong>Promise.prototype</strong></code> representa el prototipo del constructor de {{jsxref("Promise")}}</p> + +<div>{{js_property_attributes(0,0,0)}}</div> + +<h2 id="Descripción">Descripción</h2> + +<p>Las instancias de {{jsxref("Promise")}} heredan de {{jsxref("Promise.prototype")}}. Se puede usar el objeto prototipo del constructor para agregar propiedades o métodos a todas las instancias de <code>Promise</code>.</p> + +<h2 id="Propiedades">Propiedades</h2> + +<dl> + <dt><code>Promise.prototype.constructor</code></dt> + <dd>Retorna la función que creó el prototipo de una instancia. Esta es la función por defecto de {{jsxref("Promise")}}.</dd> +</dl> + +<h2 id="Métodos">Métodos</h2> + +<dl> + <dt>{{jsxref("Promise.catch", "Promise.prototype.catch(alRechazarse)")}}</dt> + <dd>Anexa a la promesa un callback manejador de rechazo, y retorna una nueva promesa que resuelve al valor de retorno del callback si es llamado, o de lo contrario a su valor de cumplimiento original si la promesa es cumplida.</dd> + <dt>{{jsxref("Promise.then", "Promise.prototype.then(alCumplirse, alRechazarse)")}}</dt> + <dd>Anexa a la promesa manejadores de cumplimiento y rechazo, y retorna una nueva promesa que resuelve al valor de retorno del manejador llamado, o a su valor de <a href="/es/docs/Web/JavaScript/Referencia/Objetos_globales/Promise#settledNote">determinación (settled)</a> original si la promesa no fue manejada (p.ej. si el manejador relevante <code>alCumplirse</code> o <code>alRechazarse</code> no es una función).</dd> +</dl> + +<h2 id="Especificaciones">Especificaciones</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificación</th> + <th scope="col">Estatus</th> + <th scope="col">Comentario</th> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-promise.prototype', 'Promise.prototype')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definición inicial.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-promise.prototype', 'Promise.prototype')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidad_de_navegadores">Compatibilidad de navegadores</h2> + +<p class="hidden">To contribute to this compatibility data, please write a pull request against this file: <a href="https://github.com/mdn/browser-compat-data/blob/master/javascript/promise.json">https://github.com/mdn/browser-compat-data/blob/master/javascript/promise.json</a>.</p> + +<p>{{Compat("javascript/promise","Promise.prototype")}}</p> + +<h2 id="Ver_también">Ver también</h2> + +<ul> + <li>{{jsxref("Promise")}}</li> +</ul> diff --git a/files/es/conflicting/web/javascript/reference/global_objects/rangeerror/index.html b/files/es/conflicting/web/javascript/reference/global_objects/rangeerror/index.html new file mode 100644 index 0000000000..fa75157c9d --- /dev/null +++ b/files/es/conflicting/web/javascript/reference/global_objects/rangeerror/index.html @@ -0,0 +1,131 @@ +--- +title: RangeError.prototype +slug: Web/JavaScript/Reference/Global_Objects/RangeError/prototype +tags: + - Error + - JavaScript + - Propiedad + - Prototipo + - Prototype + - RangeError +translation_of: Web/JavaScript/Reference/Global_Objects/RangeError +translation_of_original: Web/JavaScript/Reference/Global_Objects/RangeError/prototype +--- +<div>{{JSRef}}</div> + +<p>La propiedad <code><strong>RangeError.prototype</strong></code> representa el prototipo de {{jsxref("RangeError")}}.</p> + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<h2 id="Descripción">Descripción</h2> + +<p>Todas las instancias de {{jsxref("RangeError")}} heredan de <code>RangeError.prototype</code>. Puede utilizar el prototipo para añadir propiedades o métodos a todas las instancias.</p> + +<h2 id="Propiedades">Propiedades</h2> + +<dl> + <dt><code>RangeError.prototype.constructor</code></dt> + <dd>Especifica la función que crea instancias del prototipo.</dd> + <dt>{{jsxref("Error.prototype.message", "RangeError.prototype.message")}}</dt> + <dd>Mensaje de error. Aunque ECMA-262 especifica que {{jsxref("RangeError")}} debe procurar su propio <code>message</code>, en <a href="/en-US/docs/Mozilla/Projects/SpiderMonkey">SpiderMonkey</a>, se hereda de {{jsxref("Error.prototype.message")}}.</dd> + <dt>{{jsxref("Error.prototype.name", "RangeError.prototype.name")}}</dt> + <dd>Nombre del error. Heredada de {{jsxref("Error")}}.</dd> + <dt>{{jsxref("Error.prototype.fileName", "RangeError.prototype.fileName")}}</dt> + <dd>Ruta al fichero en el que se produjo el error. Heredada de {{jsxref("Error")}}.</dd> + <dt>{{jsxref("Error.prototype.lineNumber", "RangeError.prototype.lineNumber")}}</dt> + <dd>Número de línea en el fichero en el que se produjo el error. Heredada de {{jsxref("Error")}}.</dd> + <dt>{{jsxref("Error.prototype.columnNumber", "RangeError.prototype.columnNumber")}}</dt> + <dd>Número de columna de la línea en la que se produjo. Heredada de {{jsxref("Error")}}.</dd> + <dt>{{jsxref("Error.prototype.stack", "RangeError.prototype.stack")}}</dt> + <dd>Pila de llamadas. Heredada de {{jsxref("Error")}}.</dd> +</dl> + +<h2 id="Métodos">Métodos</h2> + +<p>Aunque el prototipo del objeto {{jsxref("RangeError")}} no contiene métodos propios, las instancias de {{jsxref("RangeError")}} heredan algunos a través de la <a href="https://developer.mozilla.org/es/docs/Web/JavaScript/Herencia_y_la_cadena_de_protipos">cadena de prototipos</a>.</p> + +<h2 id="Especificaciones">Especificaciones</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificación</th> + <th scope="col">Estado</th> + <th scope="col">Commentario</th> + </tr> + <tr> + <td>{{SpecName('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Definición inicial.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.11.7.6', 'NativeError.prototype')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Definido como <code><em>NativeError</em>.prototype</code>.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-nativeerror.prototype', 'NativeError.prototype')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definido como <code><em>NativeError</em>.prototype</code>.</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidad_de_navegadores">Compatibilidad de navegadores</h2> + +<div>{{CompatibilityTable}}</div> + +<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</th> + </tr> + <tr> + <td>Soporte básico</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Soporte básico</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vea_también">Vea también</h2> + +<ul> + <li>{{jsxref("Error.prototype")}}</li> + <li>{{jsxref("Function.prototype")}}</li> +</ul> diff --git a/files/es/conflicting/web/javascript/reference/global_objects/string/index.html b/files/es/conflicting/web/javascript/reference/global_objects/string/index.html new file mode 100644 index 0000000000..89519b08d2 --- /dev/null +++ b/files/es/conflicting/web/javascript/reference/global_objects/string/index.html @@ -0,0 +1,118 @@ +--- +title: String.prototype +slug: Web/JavaScript/Referencia/Objetos_globales/String/prototype +tags: + - JavaScript + - Property + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String +translation_of_original: Web/JavaScript/Reference/Global_Objects/String/prototype +--- +<p>{{JSRef("Objetos_globales", "String")}}</p> + +<h2 id="Resumen" name="Resumen">Resumen</h2> + +<p>The <strong><code>String.prototype</code></strong> propiedad representa el prototipo de esta clase. Puede usar el prototipo para añadir propiedades o métodos a todas las instancias de una clase.</p> + +<div>{{js_property_attributes(0,0,0)}}</div> + +<h2 id="Propiedades">Propiedades</h2> + +<dl> + <dt><code>String.prototype.constructor</code></dt> + <dd>Especifica la función que crea un prototipo de objeto.</dd> + <dt>{{jsxref("String.prototype.length")}}</dt> + <dd>Refleja la longitud de la cadena.</dd> +</dl> + +<div>{{ jsOverrides("Object", "properties", "constructor", "length") }}</div> + +<h2 id="Métodos">Métodos</h2> + +<h3 id="M.C3.A9todos_no_relacionados_con_HTML" name="M.C3.A9todos_no_relacionados_con_HTML">Métodos no relacionados con HTML</h3> + +<dl> + <dt>{{jsxref("String.prototype.charAt()")}}</dt> + <dd>Devuelve el carácter en el índice especificado.</dd> + <dt>{{jsxref("String.prototype.charCodeAt()")}}</dt> + <dd>Devuelve el número que indica el valor Unicode del carácter en el índice especificado.</dd> + <dt>{{jsxref("String.prototype.concat()")}}</dt> + <dd>Combina el texto de dos cadenas y devuelve una nueva cadena.</dd> + <dt>{{jsxref("String.prototype.indexOf()")}}</dt> + <dd>Devuelve el índice dentro del objeto <code>String</code> que realiza la llamada de la primera ocurrencia del valor especificado, o -1 si no lo encuentra.</dd> + <dt>{{jsxref("String.prototype.lastIndexOf()")}}</dt> + <dd>Devuelve el índice dentro del objeto <code>String</code> que realiza la llamada de la última ocurrencia del valor especificado, o -1 si no lo encuentra.</dd> + <dt>{{jsxref("String.prototype.match()")}}</dt> + <dd>Se usa para emparejar una expresión regular con una cadena.</dd> + <dt>{{jsxref("String.prototype.replace()")}}</dt> + <dd>Se usa para emparejar una expresión regular con una cadena, y reemplezar la subcadena emparejada con una nueva subcadena.</dd> + <dt>{{jsxref("String.prototype.search()")}}</dt> + <dd>Realiza una búsqueda de una expresión regular en una cadena especificada.</dd> + <dt>{{jsxref("String.prototype.slice()")}}</dt> + <dd>Extrae una sección de una cadena y devuelve una nueva cadena.</dd> + <dt>{{jsxref("String.prototype.split()")}}</dt> + <dd>Divide un objeto <code>String</code> en un arreglo de cadenas, separando la cadena en subcadenas.</dd> + <dt>{{jsxref("String.prototype.substr()")}}</dt> + <dd>Devuelve los caracteres de una cadena comenzando en la localización especificada y hasta el número de caracteres especificado.</dd> + <dt>{{jsxref("String.prototype.substring()")}}</dt> + <dd>Devuelve los caracteres de una cadena entre dos índices dentro de la cadena.</dd> + <dt>{{jsxref("String.prototype.toLowerCase()")}}</dt> + <dd>Devuelve el valor de la cadena que realiza la llamada en minúsculas.</dd> + <dt>{{jsxref("String.prototype.toSource()")}}</dt> + <dd>Devuelve el objeto literal que representa el objeto especificado; puede usar este valor para crear un nuevo objeto. Sobreescribe el método {{jsxref("Object.prototype.toSource()")}}.</dd> + <dt>{{jsxref("String.prototype.toString()")}}</dt> + <dd>Devuelve una cadena que representa el objeto especificado. Sobreescribe el método {{jsxref("Object.prototype.toString()")}}.</dd> + <dt>{{jsxref("String.prototype.toUpperCase()")}}</dt> + <dd>Devuelve el valor de la cadena que realiza la llamada en mayúsculas.</dd> + <dt>{{jsxref("String.prototype.valueOf()")}}</dt> + <dd>Devuelve el valor primitivo del objeto especificado. Sobreescribe el método {{jsxref("Object.prototype.valueOf()")}}.</dd> +</dl> + +<h3 id="HTML_wrapper_methods" name="HTML_wrapper_methods">Métodos de encapsulado HTML</h3> + +<p>Cada uno de los métodos siguientes devuelve una copia de la cadena encapsulada dentro de una etiqueta HTML. Por ejemplo, "test".bold() devuelve "<b>test</b>".</p> + +<dl> + <dt>{{jsxref("String.prototype.anchor()")}}</dt> + <dd><a class="external" href="http://www.w3.org/TR/html401/struct/links.html#adef-name-A"><code><a name="<em>name</em>"></code></a> (Ancha Hipertexto)</dd> + <dt>{{jsxref("String.prototype.big()")}}</dt> + <dd>{{HTMLElement("big")}}</dd> + <dt>{{jsxref("String.prototype.blink()")}}</dt> + <dd>{{HTMLElement("blink")}}</dd> + <dt>{{jsxref("String.prototype.bold()")}}</dt> + <dd>{{HTMLElement("b")}}</dd> + <dt>{{jsxref("String.prototype.fixed()")}}</dt> + <dd>{{HTMLElement("tt")}}</dd> + <dt>{{jsxref("String.prototype.fontcolor()")}}</dt> + <dd><code><font color="<em>color</em>"></code></dd> + <dt>{{jsxref("String.prototype.fontsize()")}}</dt> + <dd><code><font size="<em>size</em>"></code></dd> + <dt>{{jsxref("String.prototype.italics()")}}</dt> + <dd>{{HTMLElement("i")}}</dd> + <dt>{{jsxref("String.prototype.link()")}}</dt> + <dd><a class="external" href="http://www.w3.org/TR/html401/struct/links.html#adef-href"><code><a href="<em>url</em>"></code></a> (Enlace a URL)</dd> + <dt>{{jsxref("String.prototype.small()")}}</dt> + <dd>{{HTMLElement("small")}}</dd> + <dt>{{jsxref("String.prototype.strike()")}}</dt> + <dd>{{HTMLElement("strike")}}</dd> + <dt>{{jsxref("String.prototype.sub()")}}</dt> + <dd>{{HTMLElement("sub")}}</dd> + <dt>{{jsxref("String.prototype.sup()")}}</dt> + <dd>{{HTMLElement("sup")}}</dd> +</dl> + +<p>Estos métodos son de uso limitado, ya que sólo están disponibles un subconjunto de etiquetas HTML y atributos.</p> + +<p>{{ jsOverrides("Object", "methods", "charAt", "charCodeAt", "concat", "indexOf", "lastIndexOf", "localeCompare", "match", "quote", "replace", "search", "slice", "split", "substr", "substring", "toLocaleLowerCase", "toLocaleUpperCase", "toLowerCase", "toSource", "toString", "toUpperCase", "trim", "trimLeft", "trimRight", "valueOf", "anchor", "big", "blink", "bold", "fixed", "fontcolor", "fontsize", "italics", "link", "small", "strike", "sub", "sup") }}</p> + +<h2 id="See_also" name="See_also">Vea también</h2> + +<ul> + <li>{{jsxref("String")}}</li> + <li>{{jsxref("Function.prototype")}}</li> +</ul> + +<dl> + <dt> </dt> +</dl> diff --git a/files/es/conflicting/web/javascript/reference/global_objects/syntaxerror/index.html b/files/es/conflicting/web/javascript/reference/global_objects/syntaxerror/index.html new file mode 100644 index 0000000000..2de491bc21 --- /dev/null +++ b/files/es/conflicting/web/javascript/reference/global_objects/syntaxerror/index.html @@ -0,0 +1,133 @@ +--- +title: SyntaxError.prototype +slug: Web/JavaScript/Referencia/Objetos_globales/SyntaxError/prototype +tags: + - Error + - JavaScript + - Property + - Prototype + - SyntaxError +translation_of: Web/JavaScript/Reference/Global_Objects/SyntaxError +translation_of_original: Web/JavaScript/Reference/Global_Objects/SyntaxError/prototype +--- +<div>{{JSRef}}</div> + +<p>La propiedad <code><strong>SyntaxError.prototype</strong></code> representa el prototipo para el constructor {{jsxref("SyntaxError")}}.</p> + +<h2 id="Descripción">Descripción</h2> + +<p>Todas las instancias de {{jsxref("SyntaxError")}} son heredadas de <code>SyntaxError.prototype</code>. Puedes usar el prototipo para agregar propiedades o metodos a todas las instancias.</p> + +<h2 id="Propiedades">Propiedades</h2> + +<dl> + <dt><code>SyntaxError.prototype.constructor</code></dt> + <dd>Especifica la funcion que creó una instancia del prototipo.</dd> + <dt>{{jsxref("Error.prototype.message", "SyntaxError.prototype.message")}}</dt> + <dd>Mensaje de error. A pesar de que ECMA-262 especifica que {{jsxref("SyntaxError")}} debe proveer su propia propiedad <code>message</code> , en <a href="/en-US/docs/Mozilla/Projects/SpiderMonkey">SpiderMonkey</a>, es heredada de {{jsxref("Error.prototype.message")}}.</dd> + <dt>{{jsxref("Error.prototype.name", "SyntaxError.prototype.name")}}</dt> + <dd>Error name. Inherited from {{jsxref("Error")}}.</dd> + <dt>{{jsxref("Error.prototype.fileName", "SyntaxError.prototype.fileName")}}</dt> + <dd>Ruta al archivo que produjo el error. Heredada de {{jsxref("Error")}}.</dd> + <dt>{{jsxref("Error.prototype.lineNumber", "SyntaxError.prototype.lineNumber")}}</dt> + <dd>Numero de linea en el archivo que produjo el error. Heredada de {{jsxref("Error")}}.</dd> + <dt>{{jsxref("Error.prototype.columnNumber", "SyntaxError.prototype.columnNumber")}}</dt> + <dd>Numero de columna en la linea que produjo el error. Heredada de {{jsxref("Error")}}.</dd> + <dt>{{jsxref("Error.prototype.stack", "SyntaxError.prototype.stack")}}</dt> + <dd>Stack trace. Heredada de {{jsxref("Error")}}.</dd> +</dl> + +<h2 id="Metodos">Metodos</h2> + +<p>A pesar de que el objeto prototipo de {{jsxref("SyntaxError")}} no contiene metodos propios, las instancias de {{jsxref("SyntaxError")}} heredan algunos metodos debido a la cadena de prototipos.</p> + +<h2 id="Especificaciones">Especificaciones</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Initial definition.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.11.7.6', 'NativeError.prototype')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Defined as <code><em>NativeError</em>.prototype</code>.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-nativeerror.prototype', 'NativeError.prototype')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Defined as <code><em>NativeError</em>.prototype</code>.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-nativeerror.prototype', 'NativeError.prototype')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td>Defined as <code><em>NativeError</em>.prototype</code>.</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidad_con_navegadores">Compatibilidad con navegadores</h2> + +<h2 id="CompatibilityTable"><span style="font-size: 14px; font-weight: normal; line-height: 1.5;">{{CompatibilityTable}}</span></h2> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Véase_también">Véase también</h2> + +<ul> + <li>{{jsxref("Error.prototype")}}</li> + <li>{{jsxref("Function.prototype")}}</li> +</ul> diff --git a/files/es/conflicting/web/javascript/reference/global_objects/weakmap/index.html b/files/es/conflicting/web/javascript/reference/global_objects/weakmap/index.html new file mode 100644 index 0000000000..41d501135d --- /dev/null +++ b/files/es/conflicting/web/javascript/reference/global_objects/weakmap/index.html @@ -0,0 +1,143 @@ +--- +title: WeakMap.prototype +slug: Web/JavaScript/Referencia/Objetos_globales/WeakMap/prototype +tags: + - ECMAScript6 + - JavaScript + - Property + - WeakMap +translation_of: Web/JavaScript/Reference/Global_Objects/WeakMap +translation_of_original: Web/JavaScript/Reference/Global_Objects/WeakMap/prototype +--- +<div>{{JSRef}}</div> + +<p>La propiedad <code><strong>WeakMap</strong></code><strong><code>.prototype</code></strong> representa el prototipo para el constructor {{jsxref("WeakMap")}}.</p> + +<div>{{js_property_attributes(0,0,0)}}</div> + +<h2 id="Descripción">Descripción</h2> + +<p>Las instancias de {{jsxref("WeakMap")}} heredan de {{jsxref("WeakMap.prototype")}}. Se puede usar el objeto prototipo del constructor para añadir propiedades o métodos para todas las instancias de <code>WeakMap</code>.</p> + +<p><code>WeakMap.prototype</code> por si mismo es solamente un objeto ordinario:</p> + +<pre class="brush: js">Object.prototype.toString.call(WeakMap.prototype); // "[object Object]"</pre> + +<h2 id="Propiedades">Propiedades</h2> + +<dl> + <dt><code>WeakMap.prototype.constructor</code></dt> + <dd>Retorna la función que creó el prototipo de la instanciaReturns the function that created an instance's prototype. Esta es la función {{jsxref("WeakMap")}} por defecto.</dd> +</dl> + +<h2 id="Métodos">Métodos</h2> + +<dl> + <dt>{{jsxref("WeakMap.delete", "WeakMap.prototype.delete(key)")}}</dt> + <dd>Remueve cualquier valor asociado a la clave. Después de esto <code>WeakMap.prototype.has(key)</code> retornará falso.</dd> + <dt>{{jsxref("WeakMap.get", "WeakMap.prototype.get(key)")}}</dt> + <dd>Retorna el valor asociado a la clave, o <code>undefined</code> si no hay ninguno.</dd> + <dt>{{jsxref("WeakMap.has", "WeakMap.prototype.has(key)")}}</dt> + <dd>Retorna un valor booleano indicando si hay un valor asociado a la clave en el objeto the <code>WeakMap</code> object o no.</dd> + <dt>{{jsxref("WeakMap.set", "WeakMap.prototype.set(key, value)")}}</dt> + <dd>Asigna el valor para la clave en el objeto <code>WeakMap</code>. Retorna el objeto <code>WeakMap</code>.</dd> + <dt><s class="obsoleteElement">{{jsxref("WeakMap.prototype.clear()")}} {{obsolete_inline}}</s></dt> + <dd><s class="obsoleteElement">Remueve todas los pares clave/valore del objeto <code>WeakMap</code>. Notese que es posible implementar un objeto parecido al <code>WeakMap</code> que posea un método <code>.clear()</code>, encapsulando el objeto <code>WeakMap</code> que no lo tiene (ver ejemplo en la página {{jsxref("WeakMap")}})</s></dd> +</dl> + +<h2 id="Especificaciones">Especificaciones</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificación</th> + <th scope="col">Estado</th> + <th scope="col">Comentario</th> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-weakmap.prototype', 'WeakMap.prototype')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definición inicial.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-weakmap.prototype', 'WeakMap.prototype')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidad_de_navegadores">Compatibilidad de 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</th> + </tr> + <tr> + <td>Soporte básico</td> + <td>36</td> + <td>{{CompatGeckoDesktop("6.0")}}</td> + <td>11</td> + <td>23</td> + <td>7.1</td> + </tr> + <tr> + <td>Objeto ordinario</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatGeckoDesktop("40")}}</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ística</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Soporte básico</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatGeckoMobile("6.0")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + </tr> + <tr> + <td>Objeto ordinario</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatGeckoMobile("40")}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Ver_también">Ver también</h2> + +<ul> + <li>{{jsxref("Map.prototype")}}</li> +</ul> diff --git a/files/es/conflicting/web/javascript/reference/lexical_grammar/index.html b/files/es/conflicting/web/javascript/reference/lexical_grammar/index.html new file mode 100644 index 0000000000..14010f37e3 --- /dev/null +++ b/files/es/conflicting/web/javascript/reference/lexical_grammar/index.html @@ -0,0 +1,99 @@ +--- +title: Palabras Reservadas +slug: Web/JavaScript/Referencia/Palabras_Reservadas +tags: + - JavaScript + - palabras reservadas +translation_of: Web/JavaScript/Reference/Lexical_grammar#Keywords +translation_of_original: Web/JavaScript/Reference/Reserved_Words +--- +<p> </p> + +<p>Las siguientes son palabras reservadas y no pueden ser utilizadas como variables, funciones, métodos o identificadores de objetos. Las siguientes son reservadas como palabras claves existentes por la especificación ECMAScript:</p> + +<h3 id="Reserved_keywords_as_of_ECMAScript_6">Reserved keywords as of ECMAScript 6</h3> + +<div class="threecolumns"> +<ul> + <li>{{jsxref("Sentencias/break", "break")}}</li> + <li>{{jsxref("Sentencias/switch", "case")}}</li> + <li><code>class</code></li> + <li>{{jsxref("Sentencias/try...catch", "catch")}}</li> + <li>{{jsxref("Sentencias/const", "const")}}</li> + <li>{{jsxref("Sentencias/continue", "continue")}}</li> + <li>{{jsxref("Sentencias/debugger", "debugger")}}</li> + <li>{{jsxref("Sentencias/switch", "default")}}</li> + <li>{{jsxref("Operadores/delete", "delete")}}</li> + <li>{{jsxref("Sentencias/while", "do")}}</li> + <li>{{jsxref("Sentencias/if...else", "else")}}</li> + <li>{{jsxref("Sentencias/export", "export")}}</li> + <li><code>extends</code></li> + <li>{{jsxref("Sentencias/try...catch", "finally")}}</li> + <li>{{jsxref("Sentencias/for", "for")}}</li> + <li>{{jsxref("Sentencias/function", "function")}}</li> + <li>{{jsxref("Sentencias/if...else", "if")}}</li> + <li>{{jsxref("Sentencias/import", "import")}}</li> + <li>{{jsxref("Sentencias/for...in", "in")}}</li> + <li>{{jsxref("Operadores/instanceof", "instanceof")}}</li> + <li>{{jsxref("Sentencias/let", "let")}}</li> + <li>{{jsxref("Operadores/new", "new")}}</li> + <li>{{jsxref("Sentencias/return", "return")}}</li> + <li>{{jsxref("Operadores/super", "super")}}</li> + <li>{{jsxref("Sentencias/switch", "switch")}}</li> + <li>{{jsxref("Operadores/this", "this")}}</li> + <li>{{jsxref("Sentencias/throw", "throw")}}</li> + <li>{{jsxref("Sentencias/try...catch", "try")}}</li> + <li>{{jsxref("Operadores/typeof", "typeof")}}</li> + <li>{{jsxref("Sentencias/var", "var")}}</li> + <li>{{jsxref("Operadores/void", "void")}}</li> + <li>{{jsxref("Sentencias/while", "while")}}</li> + <li>{{jsxref("Sentencias/with", "with")}}</li> + <li><code>yield</code></li> +</ul> +</div> + +<p>Las siguientes estan reservadas como palabras futuras por la especificación ECMAScript:</p> + +<ul> + <li><code>enum</code></li> +</ul> + +<p>Las siguientes estan reservadas como palabras futuras cuando se encuentre el modo correcto para su estructura de codigo:</p> + +<div class="threecolumns"> +<ul> + <li><code>implements</code></li> + <li><code>package</code></li> + <li><code>protected</code></li> + <li><code>static</code></li> + <li><code>interface</code></li> + <li><code>private</code></li> + <li><code>public</code></li> +</ul> +</div> + +<h4 id="Futuras_Palabras_Reservadas_en_estandares_antiguos">Futuras Palabras Reservadas en estandares antiguos</h4> + +<p>Las siguientes estan reservadas como palabras futuras por la antigua especificación ECMAScript (ECMAScript 1 hasta 3).</p> + +<div class="threecolumns"> +<ul> + <li><code>abstract</code></li> + <li><code>boolean</code></li> + <li><code>byte</code></li> + <li><code>char</code></li> + <li><code>double</code></li> + <li><code>final</code></li> + <li><code>float</code></li> + <li><code>goto</code></li> + <li><code>int</code></li> + <li><code>long</code></li> + <li><code>native</code></li> + <li><code>short</code></li> + <li><code>synchronized</code></li> + <li><code>transient</code></li> + <li><code>volatile</code></li> +</ul> +</div> + +<p>Adicionalmente, los literales "<code>null"</code>, "<code>true"</code>, y "<code>false"</code> estan reservadas en ECMAScript para usos normales.</p> 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..71968fda85 --- /dev/null +++ b/files/es/conflicting/web/javascript/reference/operators/index.html @@ -0,0 +1,315 @@ +--- +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 +--- +<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..050a2026f6 --- /dev/null +++ b/files/es/conflicting/web/javascript/reference/operators/spread_syntax/index.html @@ -0,0 +1,220 @@ +--- +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 +--- +<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> diff --git a/files/es/conflicting/web/javascript/reference/operators_5a0acbbb60ea37d0fdc52e3bd4c3fae8/index.html b/files/es/conflicting/web/javascript/reference/operators_5a0acbbb60ea37d0fdc52e3bd4c3fae8/index.html new file mode 100644 index 0000000000..8685790d2c --- /dev/null +++ b/files/es/conflicting/web/javascript/reference/operators_5a0acbbb60ea37d0fdc52e3bd4c3fae8/index.html @@ -0,0 +1,262 @@ +--- +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 +--- +<div>{{jsSidebar("Operators")}}</div> + +<p>JavaScript tiene comparaciones estrictas y de conversión de tipos. Una comparación estricta (por ejemplo, <code>===</code>) 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, <code>==</code>) convierte los operandos al mismo tipo antes de hacer la comparación. Para las comparaciones abstractas relacionales (p. Ej., <code><=</code>), Los operandos primero se convierten en primitivos, y luego en el mismo tipo, antes de la comparación.</p> + +<p>Las cadenas se comparan en base al orden lexicográfico estándar, utilizando valores Unicode.</p> + +<pre class="brush: js notranslate">console.log(1 == 1) +// Esperamos True + +console.log("1" == 1 ) +// Esperamos true + +console.log( 1 === 1) +// Esperamos true + +console.log( "1" === 1) +// Esperamos false +</pre> + +<p>Características de las comparaciones:</p> + +<ul> + <li>Dos cadenas son estrictamente iguales cuando tienen la misma secuencia de caracteres, la misma longitud y los mismos caracteres en las posiciones correspondientes.</li> + <li>Dos números son estrictamente iguales cuando son numéricamente iguales (tienen el mismo valor numérico). <a href="/es/docs/Web/JavaScript/Reference/Global_Objects/NaN">NaN</a> no es igual a nada, incluido NaN. Los ceros positivos y negativos son iguales entre sí. </li> + <li>Dos operandos booleanos son estrictamente iguales si ambos son <code>true</code> o ambos son <code>false</code>.</li> + <li>Dos objetos distintos nunca son iguales para comparaciones estrictas o abstractas.</li> + <li>Una expresión que compara objetos solo es verdadera si los operandos hacen referencia al mismo objeto.</li> + <li>Los tipos Null y Undefined son estrictamente iguales a ellos mismos y abstractivamente iguales entre sí.</li> +</ul> + +<h2 id="Operadores_de_igualdad">Operadores de igualdad</h2> + +<h3 id="Igualdad"><a name="Equality">Igualdad (==)</a></h3> + +<p>El operador de igualdad convierte los operandos si <strong>no son del mismo tipo</strong>, luego aplica una comparación estricta. Si <strong>ambos operandos son objetos</strong>, entonces JavaScript compara las referencias internas que son iguales cuando los operandos se refieren al mismo objeto en la memoria.</p> + +<h4 id="Sintaxis">Sintaxis</h4> + +<pre class="syntaxbox notranslate">x == y +</pre> + +<h4 id="Ejemplos">Ejemplos</h4> + +<pre class="brush: js notranslate">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 +</pre> + +<h3 id="Desigualdad_!"><a name="Inequality">Desigualdad (!=)</a></h3> + +<p>El operador de desigualdad devuelve verdadero si los operandos no son iguales. Si los dos operandos <strong>no son del mismo tipo</strong>, JavaScript intenta convertir los operandos a un tipo apropiado para la comparación. Si <strong>ambos operandos son objetos</strong>, entonces JavaScript compara las referencias internas que no son iguales cuando los operandos se refieren a diferentes objetos en la memoria.</p> + +<h4 id="Sintaxis_2">Sintaxis</h4> + +<pre class="syntaxbox notranslate">x != y</pre> + +<h4 id="Ejemplos_2">Ejemplos</h4> + +<pre class="brush: js notranslate">1 != 2 // true +1 != '1' // false +1 != "1" // false +1 != true // false +0 != false // false +</pre> + +<h3 id="Identidad_igualdad_estricta"><a name="Identity">Identidad / igualdad estricta (===)</a></h3> + +<p>El operador de identidad devuelve verdadero si los operandos son estrictamente iguales (ver arriba) <strong>sin conversión de tipo</strong>.</p> + +<h4 id="Sintaxis_3">Sintaxis</h4> + +<pre class="syntaxbox notranslate">x === y</pre> + +<h4 id="Ejemplos_3">Ejemplos</h4> + +<pre class="brush: js notranslate">3 === 3 // true +3 === '3' // false +var object1 = {'key': 'value'}, object2 = {'key': 'value'}; +object1 === object2 // false</pre> + + + +<h3 id="Sin_identidad_desigualdad_estricta_!"><a name="Nonidentity">Sin identidad / desigualdad estricta (!==)</a></h3> + +<p>El operador sin identidad devuelve verdadero si los operandos <strong>no son iguales y / o no del mismo tipo</strong>.</p> + +<h4 id="Sintaxis_4">Sintaxis</h4> + +<pre class="syntaxbox notranslate">x !== y</pre> + +<h4 id="Ejemplos_4">Ejemplos</h4> + +<pre class="brush: js notranslate">3 !== '3' // true +4 !== 3 // true +</pre> + +<h2 id="Operadores_relacionales">Operadores relacionales</h2> + +<p>Cada uno de estos operadores llamará a la función <code>valueOf()</code> en cada operando antes de realizar una comparación.</p> + +<h3 id="Operador_mayor_que_>"><a name="Greater_than_operator">Operador mayor que (>)</a></h3> + +<p>El operador mayor que, devuelve verdadero si el operando izquierdo es mayor que el operando derecho.</p> + +<h4 id="Sintaxis_5">Sintaxis</h4> + +<pre class="syntaxbox notranslate">x > y</pre> + +<h4 id="Ejemplos_5">Ejemplos</h4> + +<pre class="brush: js notranslate">4 > 3 // true +</pre> + +<h3 id="Operador_mayor_o_igual_>"><a name="Greater_than_or_equal_operator">Operador mayor o igual (>=)</a></h3> + +<p>El operador mayor o igual que, devuelve verdadero si el operando izquierdo es mayor o igual que el operando derecho.</p> + +<h4 id="Sintaxis_6">Sintaxis</h4> + +<pre class="syntaxbox notranslate"> x >= y</pre> + +<h4 id="Ejemplos_6">Ejemplos</h4> + +<pre class="brush: js notranslate">4 >= 3 // true +3 >= 3 // true +</pre> + +<h3 id="Operador_menor_que_<"><a name="Less_than_operator"> Operador menor que (<)</a></h3> + +<p>El operador menor que devuelve verdadero si el operando de la izquierda es menor que el operando de la derecha.</p> + +<h4 id="Sintaxis_7">Sintaxis</h4> + +<pre class="syntaxbox notranslate"> x < y</pre> + +<h4 id="Ejemplos_7">Ejemplos</h4> + +<pre class="brush: js notranslate">3 < 4 // true +</pre> + +<h3 id="Operador_menor_o_igual_<"><a id="Less_than_or_equal_operator" name="Less_than_or_equal_operator">Operador menor o igual (<=)</a></h3> + +<p>El operador menor o igual devuelve verdadero si el operando izquierdo es menor o igual que el operando derecho.</p> + +<h4 id="Sintaxis_8">Sintaxis</h4> + +<pre class="syntaxbox notranslate"> x <= y</pre> + +<h4 id="Ejemplos_8">Ejemplos</h4> + +<pre class="brush: js notranslate">3 <= 4 // true +</pre> + +<h2 id="Usando_los_operadores_de_igualdad">Usando los operadores de igualdad</h2> + +<p>Los operadores de igualdad estándar (<code>==</code> y <code>!=</code>) utilizan el <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.9.3">Algoritmo de Comparación de Igualdad Abstracta</a> 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 <code>5 == '5'</code>, la cadena de la derecha se convierte a {{jsxref("Number")}} antes de realizar la comparación.</p> + +<p>Los operadores de igualdad estricta (<code>===</code> y <code>!==</code>) usan el <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.9.6">Algoritmo de Comparación de Igualdad Estricta</a> 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 <code>false</code>, entonces <code>5 !== '5'</code>.</p> + +<p>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.</p> + +<p>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:</p> + +<ul> + <li>Al comparar un número y una cadena, la cadena se convierte en un valor numérico. JavaScript intenta convertir el literal numérico de cadena a un valor de tipo <code>Number</code>. Primero, un valor matemático se deriva del literal numérico de cadena. A continuación, este valor se redondea al valor de tipo <code>Number</code> más cercano.</li> + <li>Si uno de los operandos es <code>Boolean</code>, el operando <code>Boolean</code> se convierte en 1 si es <code>true</code> y +0 si es <code>false</code>.</li> + <li>Si un objeto se compara con un número o cadena, JavaScript intenta devolver el valor predeterminado para el objeto. Los operadores intentan convertir el objeto a un valor primitivo, un valor <code>String</code> o <code>Number</code>, utilizando los métodos <code>valueOf</code> y <code>toString</code> de los objetos. Si falla este intento de convertir el objeto, se genera un error de tiempo de ejecución.</li> + <li>Tenga en cuenta que un objeto se convierte en una primitiva si, y solo si, su comparando es una primitiva. Si ambos operandos son objetos, se comparan como objetos, y la prueba de igualdad es verdadera solo si ambos refieren el mismo objeto.</li> +</ul> + +<div class="note"><strong>Nota:</strong> 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:</div> + +<pre class="brush:js notranslate">// 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'</pre> + +<h2 id="Especificaciones">Especificaciones</h2> + +<table class="standard-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. Implementado en JavaScript 1.0</td> + </tr> + <tr> + <td>{{SpecName('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td> + <p>Agrega <code>===</code> y <code>!==</code> operadores. Implementado en JavaScript 1.3</p> + </td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-11.8')}}</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.8">Operadores Relacionales</a>, <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.9">Operadores de Igualdad</a></p> + </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-relational-operators')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> + <p>Definido en varias secciones de la especificación: <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-relational-operators">Operadores Relacionales</a>, <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-equality-operators">Operadores de Igualdad</a></p> + </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-relational-operators')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> + <p>Definido en varias secciones de la especificación: <a href="http://tc39.github.io/ecma262/#sec-relational-operators">Operadores Relacionales</a>, <a href="http://tc39.github.io/ecma262/#sec-equality-operators">Operadores de Igualdad</a></p> + </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidad_con_navegadores">Compatibilidad con navegadores</h2> + + + +<p>{{Compat("javascript.operators.comparison")}}</p> + +<h2 id="Ver_también">Ver también</h2> + +<ul> + <li>{{jsxref("Object.is()")}}</li> + <li>{{jsxref("Math.sign()")}}</li> + <li><a href="/es/docs/Web/JavaScript/Equality_comparisons_and_sameness">Comparaciones de igualdad y uniformidad</a></li> +</ul> diff --git a/files/es/conflicting/web/javascript/reference/operators_5c44e7d07c463ff1a5a63654f4bda87b/index.html b/files/es/conflicting/web/javascript/reference/operators_5c44e7d07c463ff1a5a63654f4bda87b/index.html new file mode 100644 index 0000000000..c4276c1c95 --- /dev/null +++ b/files/es/conflicting/web/javascript/reference/operators_5c44e7d07c463ff1a5a63654f4bda87b/index.html @@ -0,0 +1,722 @@ +--- +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 +--- +<div>{{jsSidebar("Operators")}}</div> + +<p><strong>Los operadores a nivel de bit </strong>tratan sus operandos como una secuencia de 32 bits (unos y ceros) en lugar de <a href="/es/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators">números</a> 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.</p> + +<p>La siguiente tabla resume los operadores a nivel de bit de JavaScript:</p> + +<table class="standard-table"> + <tbody> + <tr> + <th>Operador</th> + <th>Uso</th> + <th>Descripción</th> + </tr> + <tr> + <td><a href="#Bitwise_AND">AND binario</a></td> + <td><code>a & b</code></td> + <td>Devuelve un uno en cada posición en la que ambos operandos sea uno.</td> + </tr> + <tr> + <td><a href="#Bitwise_OR">OR binario </a></td> + <td><code>a | b</code></td> + <td>Devuelve un uno en cada posición en la que uno o ambos operandos sea uno.</td> + </tr> + <tr> + <td><a href="#Bitwise_XOR">Bitwise XOR</a></td> + <td><code>a ^ b</code></td> + <td>Devuelve un uno en cada posición en la que los bits correspondientes en cada uno de los operandos, pero no en ambos, es uno. </td> + </tr> + <tr> + <td><a href="#Bitwise_NOT">Bitwise NOT</a></td> + <td><code>~ a</code></td> + <td>Invierte los bits del operando.</td> + </tr> + <tr> + <td><a href="#Left_shift">Left shift</a></td> + <td><code>a << b</code></td> + <td>Desplaza en representación binaria <code>b</code> (< 32) bits a la izquierda, desplazando en ceros desde la derecha.</td> + </tr> + <tr> + <td><a href="#Right_shift">Sign-propagating right shift</a></td> + <td><code>a >> b</code></td> + <td>Desplaza en representación binaria <code>b</code> (< 32) bits a la derecha, descartando los bits desplazados fuera.</td> + </tr> + <tr> + <td><a href="#Unsigned_right_shift">Zero-fill right shift</a></td> + <td><code>a >>> b</code></td> + <td>Desplaza en representación binaria <code>b</code> (< 32) bits a la derecha, desplazando en ceros desde la izquierda.</td> + </tr> + </tbody> +</table> + +<h2 id="Enteros_con_signo_de_32_bits">Enteros con signo de 32 bits</h2> + +<p>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:</p> + +<pre>00000000000000000000000100111010 +</pre> + +<p>A continuación se codifica <code>~314</code> como complemento a uno de 314:</p> + +<pre>11111111111111111111111011000101 +</pre> + +<p>Por último, se codifica <code>-314 como complemento a dos de </code><code>314</code>:</p> + +<pre>11111111111111111111111011000110 +</pre> + +<p>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 <em>bit de signo.</em></p> + +<p>El número 0 es el entero compuesto íntegramente por bits en 0.</p> + +<pre>0 (base 10) = 00000000000000000000000000000000 (base 2) + +</pre> + +<p>El número -1 es el entero compuesto íntegramente por bits de 1.</p> + +<pre>-1 (base 10) = 11111111111111111111111111111111 (base 2) +</pre> + +<p>El número <code>-2147483648</code> (representación hexadecimal: <code>-0x80000000</code>) es el entero compuesto íntegramente por bits de 0 excepto el de más a la izquierda.</p> + +<pre>-2147483648 (base 10) = 10000000000000000000000000000000 (base 2) +</pre> + +<p>El número <code>2147483647</code> (representación hexadecimal: <code>0x7fffffff</code>) es el entero compuesto íntegramente por bits de 1 excepto el de más a la izquierda. </p> + +<pre>2147483647 (base 10) = 01111111111111111111111111111111 (base 2) +</pre> + +<p>Los números <code>-2147483648</code> and <code>2147483647</code> son el mínimo y el máximo entero que se pueden representar con signo de 32 bits.</p> + +<h2 id="Operadores_lógicos_a_nivel_de_bit">Operadores lógicos<strong> a nivel de bit</strong></h2> + +<p>Conceptualmente, los operadores lógicos bit a bit funcionan de la siguiente manera:</p> + +<ul> + <li>Los operandos son convertidos en enteros de 32 bits y representados por series de bits (ceros y unos). Los numeros con más de 32 bits se convierten para que sus bits más significativos sean descartados. Por ejemplo, el siguiente entero con más de 32 bits se convierte a un entero de 32 bits.</li> + <li> + <pre><code>Antes: 1100110111110100000000000000110000000000001 +Después: 10100000000000000110000000000001</code></pre> + </li> + <li>Cada bit del primer operando es emparejado con su bit correspondiente en el segundo operando: el primero con el primero, el segundo con el segundo, y así.</li> + <li>El operador se aplica a cada pareja de bits, y el resultado se construye bit a bit. </li> +</ul> + +<h3 id="(Bitwise_AND_o_AND_a_nivel_de_bits)"><a name="Bitwise_AND">& (Bitwise AND o AND a nivel de bits)</a></h3> + +<p>Corresponde al operador lógico & o "Y". Ejecuta la operación AND en cada par de bits, <code>a</code> AND <code>b</code> es 1 sólo si tanto a como b son 1. La tabla de verdad del operador AND es:</p> + +<table class="standard-table"> + <tbody> + <tr> + <td class="header">a</td> + <td class="header">b</td> + <td class="header">a AND b</td> + </tr> + <tr> + <td>0</td> + <td>0</td> + <td>0</td> + </tr> + <tr> + <td>0</td> + <td>1</td> + <td>0</td> + </tr> + <tr> + <td>1</td> + <td>0</td> + <td>0</td> + </tr> + <tr> + <td>1</td> + <td>1</td> + <td>1</td> + </tr> + </tbody> +</table> + +<pre> 9 (base 10) = 00000000000000000000000000001001 (base 2) + 14 (base 10) = 00000000000000000000000000001110 (base 2) + -------------------------------- +14 & 9 (base 10) = 00000000000000000000000000001000 (base 2) = 8 (base 10) +</pre> + +<p>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. </p> + +<h3 id="(Bitwise_OR_o_OR_a_nivel_de_bits)"><a name="Bitwise_OR">| (Bitwise OR o OR a nivel de bits)</a></h3> + +<p>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:</p> + +<table class="standard-table"> + <tbody> + <tr> + <td class="header">a</td> + <td class="header">b</td> + <td class="header">a OR b</td> + </tr> + <tr> + <td>0</td> + <td>0</td> + <td>0</td> + </tr> + <tr> + <td>0</td> + <td>1</td> + <td>1</td> + </tr> + <tr> + <td>1</td> + <td>0</td> + <td>1</td> + </tr> + <tr> + <td>1</td> + <td>1</td> + <td>1</td> + </tr> + </tbody> +</table> + +<pre> 9 (base 10) = 00000000000000000000000000001001 (base 2) + 14 (base 10) = 00000000000000000000000000001110 (base 2) + -------------------------------- +14 | 9 (base 10) = 00000000000000000000000000001111 (base 2) = 15 (base 10) +</pre> + +<p>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.</p> + +<h3 id="(Bitwise_XOR_o_XOR_a_nivel_de_bits)"><a name="Bitwise_XOR">^ (Bitwise XOR o XOR a nivel de bits)</a></h3> + +<p>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:</p> + +<table class="standard-table"> + <tbody> + <tr> + <td class="header">a</td> + <td class="header">b</td> + <td class="header">a XOR b</td> + </tr> + <tr> + <td>0</td> + <td>0</td> + <td>0</td> + </tr> + <tr> + <td>0</td> + <td>1</td> + <td>1</td> + </tr> + <tr> + <td>1</td> + <td>0</td> + <td>1</td> + </tr> + <tr> + <td>1</td> + <td>1</td> + <td>0</td> + </tr> + </tbody> +</table> + +<pre> 9 (base 10) = 00000000000000000000000000001001 (base 2) + 14 (base 10) = 00000000000000000000000000001110 (base 2) + -------------------------------- +14 ^ 9 (base 10) = 00000000000000000000000000000111 (base 2) = 7 (base 10) +</pre> + +<p>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</p> + +<h3 id="(Bitwise_NOT_o_Negación_a_nivel_de_bits)"><a name="Bitwise_NOT">~ (Bitwise NOT o Negación a nivel de bits)</a></h3> + +<p>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:</p> + +<table class="standard-table"> + <tbody> + <tr> + <td class="header">a</td> + <td class="header">NOT a</td> + </tr> + <tr> + <td>0</td> + <td>1</td> + </tr> + <tr> + <td>1</td> + <td>0</td> + </tr> + </tbody> +</table> + +<p> </p> + +<pre> 9 (base 10) = 00000000000000000000000000001001 (base 2) + -------------------------------- +~9 (base 10) = 11111111111111111111111111110110 (base 2) = -10 (base 10) +</pre> + +<p> </p> + +<p>Ejecutar la operación NOT sobre cualquier número x devuelve -(x+1). Por ejemplo -5 devuelve 4.</p> + +<p>Ejemplo con indexOf:</p> + +<pre class="brush: js">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 +</pre> + +<h2 id="Operadores_de_desplazamiento_a_nivel_de_bit">Operadores de desplazamiento <strong>a nivel de bit</strong></h2> + +<p>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.</p> + +<p>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.</p> + +<h3 id="<<_(Desplazamiento_a_la_izquierda)"><a name="Left_shift"><< (Desplazamiento a la izquierda)</a></h3> + +<p>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.</p> + +<p>Por ejemplo, 9 << 2 devuelve 36:</p> + +<pre> 9 (base 10): 00000000000000000000000000001001 (base 2) + -------------------------------- +9 << 2 (base 10): 00000000000000000000000000100100 (base 2) = 36 (base 10) +</pre> + +<p>Desplazar a la izquierda cualquier número <strong>x</strong> por <strong>y</strong> bits da por resultado <strong>x * 2^y</strong>.</p> + +<h3 id=">>_(Desplazamiento_a_la_derecha_con_propagación_de_signo_o_Desplazamiento_aritmético_a_la_derecha)"><a name="Right_shift">>> (Desplazamiento a la derecha con propagación de signo o </a><a name="Unsigned_right_shift">Desplazamiento aritmético a la derecha</a><a name="Right_shift">)</a></h3> + +<p>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".</p> + +<p>Por ejemplo, <code>9 >> 2</code> devuelve 2:</p> + +<pre> 9 (base 10): 00000000000000000000000000001001 (base 2) + -------------------------------- +9 >> 2 (base 10): 00000000000000000000000000000010 (base 2) = 2 (base 10) +</pre> + +<p>Igualmente, <code>-9 >> 2</code> devuelve-3, porque se mantiene el signo:</p> + +<pre> -9 (base 10): 11111111111111111111111111110111 (base 2) + -------------------------------- +-9 >> 2 (base 10): 11111111111111111111111111111101 (base 2) = -3 (base 10) +</pre> + +<h3 id=">>>_(Desplazamiento_a_la_derecha_con_relleno_de_ceros_o_Desplazamiento_lógico_)"><a name="Unsigned_right_shift">>>> (Desplazamiento a la derecha con relleno de ceros o Desplazamiento lógico )</a></h3> + +<p>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. </p> + +<p><br> + Para números no negativos, el desplazamiento lógico y arítmetico dan el mismo resultado. Por ejemplo, <code>9 >>> 2</code> da 2, al igual que <code>9 >> 2</code>:</p> + +<pre> 9 (base 10): 00000000000000000000000000001001 (base 2) + -------------------------------- +9 >>> 2 (base 10): 00000000000000000000000000000010 (base 2) = 2 (base 10) +</pre> + +<p>Sin embargo, no es el caso para números negativos. Por ejemplo, <code>-9 >>> 2</code> da 1073741821, que es diferente de <code>-9 >> 2</code> (que da -3):</p> + +<pre> -9 (base 10): 11111111111111111111111111110111 (base 2) + -------------------------------- +-9 >>> 2 (base 10): 00111111111111111111111111111101 (base 2) = 1073741821 (base 10) +</pre> + +<h2 id="Ejemplos">Ejemplos</h2> + +<h3 id="Banderas_y_máscaras_de_bits">Banderas y máscaras de bits</h3> + +<p>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).</p> + +<p>Supongamos que hay 4 banderas:</p> + +<ul> + <li>bandera A: tenemos un problema de hormigas</li> + <li>bandera B: somos dueños de un murciélago</li> + <li>bandera C: somos dueños de un gato</li> + <li>bandera D: somos dueños de un pato</li> +</ul> + +<p>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:</p> + +<pre class="brush: js">var flags = 5; // binary 0101 +</pre> + +<p>Este valor indica:</p> + +<ul> + <li>la bandera A es verdadera (tenemos un problema de hormigas);</li> + <li>la bandera B es falsa (no tenemos un murciélago);</li> + <li>la bandera C es verdadera (somos dueños de un gato);</li> + <li>la bandera D es falsa (no tenemos pato);</li> +</ul> + +<p>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.</p> + +<p>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:</p> + +<pre class="brush: js">var FLAG_A = 1; // 0001 +var FLAG_B = 2; // 0010 +var FLAG_C = 4; // 0100 +var FLAG_D = 8; // 1000 +</pre> + +<p>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:</p> + +<pre class="brush: js">var mask = FLAG_A | FLAG_B | FLAG_D; // 0001 | 0010 | 1000 => 1011 +</pre> + +<p>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:</p> + +<pre class="brush: js">// if we own a cat +if (flags & FLAG_C) { // 0101 & 0100 => 0100 => true + // do stuff +} +</pre> + +<p>Una máscara de bits con varios indicadores establecidos actúa como un "either/or". Por ejemplo, los siguientes dos son equivalentes:</p> + +<pre class="brush: js">// 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 +} +</pre> + +<pre class="brush: js">// 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 +} +</pre> + +<p>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:</p> + +<pre class="brush: js">// yes, we own a cat and a duck +var mask = FLAG_C | FLAG_D; // 0100 | 1000 => 1100 +flags |= mask; // 0101 | 1100 => 1101 +</pre> + +<p>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:</p> + +<pre class="brush: js">// 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 +</pre> + +<p>La máscara también podría haberse creado con ~ FLAG_A & ~ FLAG_C (ley de De Morgan):</p> + +<pre class="brush: js">// 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 +</pre> + +<p>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:</p> + +<pre class="brush: js">// 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 +</pre> + +<p>Finalmente, todas las banderas se pueden voltear con el operador NOT:</p> + +<pre class="brush: js">// entering parallel universe... +flags = ~flags; // ~1010 => 0101 +</pre> + +<h3 id="Fragmentos_de_conversión">Fragmentos de conversión</h3> + +<p>Convert a binary <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/String" title="/en-US/docs/JavaScript/Reference/Global_Objects/String">String</a></code> to a decimal <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number" title="/en-US/docs/JavaScript/Reference/Global_Objects/Number">Number</a></code>:</p> + +<pre class="brush: js">var sBinString = "1011"; +var nMyNumber = parseInt(sBinString, 2); +alert(nMyNumber); // prints 11, i.e. 1011 +</pre> + +<p> </p> + +<p>Convierte una cadena binaria a un número decimal:</p> + +<p> </p> + +<pre class="brush: js">var nMyNumber = 11; +var sBinString = nMyNumber.toString(2); +alert(sBinString); // prints 1011, i.e. 11 +</pre> + +<h3 id="Automatiza_la_creación_de_una_máscara.">Automatiza la creación de una máscara.</h3> + +<p>Si tiene que crear muchas máscaras a partir de algunos valores booleanos, puede automatizar el proceso:</p> + +<pre class="brush: js">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 +</pre> + +<h3 id="Algoritmo_inverso_una_matriz_de_valores_booleanos_de_una_máscara">Algoritmo inverso: una matriz de valores booleanos de una máscara</h3> + +<p>Si desea crear una matriz de valores booleanos a partir de una máscara, puede usar este código:</p> + +<pre class="brush: js">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 +</pre> + +<p>Puedes probar ambos algoritmos al mismo tiempo ...</p> + +<pre class="brush: js">var nTest = 19; // our custom mask +var nResult = createMask.apply(this, arrayFromMask(nTest)); + +alert(nResult); // 19 +</pre> + +<p>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:</p> + +<pre class="brush: js">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 +</pre> + +<h2 id="Specifications">Specifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Definicion inicial</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-11.7')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>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</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-bitwise-shift-operators')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>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</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidad_del_navegador">Compatibilidad del navegador</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td><a href="#Bitwise_NOT">Bitwise NOT (<code>~</code>)</a></td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + <tr> + <td><a href="#Bitwise_AND">Bitwise AND (<code>&</code>)</a></td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + <tr> + <td><a href="#Bitwise_OR">Bitwise OR (<code>|</code>)</a></td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + <tr> + <td><a href="#Bitwise_XOR">Bitwise XOR (<code>^</code>)</a></td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + <tr> + <td><a href="#Left_shift">Left shift (<code><<</code>)</a></td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + <tr> + <td><a href="#Right_shift">Right shift (<code>>></code>)</a></td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + <tr> + <td><a href="#Unsigned_right_shift">Unsigned right shift (<code>>>></code>)</a></td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td><a href="#Bitwise_NOT">Bitwise NOT (<code>~</code>)</a></td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + <tr> + <td><a href="#Bitwise_AND">Bitwise AND (<code>&</code>)</a></td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + <tr> + <td><a href="#Bitwise_OR">Bitwise OR (<code>|</code>)</a></td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + <tr> + <td><a href="#Bitwise_XOR">Bitwise XOR (<code>^</code>)</a></td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + <tr> + <td><a href="#Left_shift">Left shift (<code><<</code>)</a></td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + <tr> + <td><a href="#Right_shift">Right shift (<code>>></code>)</a></td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + <tr> + <td><a href="#Unsigned_right_shift">Unsigned right shift (<code>>>></code>)</a></td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Ver_también">Ver también</h2> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Logical_Operators">Operadores logicos</a></li> +</ul> diff --git a/files/es/conflicting/web/javascript/reference/operators_d3958587a3d3dd644852ad397eb5951b/index.html b/files/es/conflicting/web/javascript/reference/operators_d3958587a3d3dd644852ad397eb5951b/index.html new file mode 100644 index 0000000000..979eff63f2 --- /dev/null +++ b/files/es/conflicting/web/javascript/reference/operators_d3958587a3d3dd644852ad397eb5951b/index.html @@ -0,0 +1,462 @@ +--- +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 +--- +<div>{{jsSidebar("Operators")}}</div> + +<p>Un <strong>operador de asignacion</strong> asigna un valor al operando de la izquierda basado en el valor del operando de la derecha.</p> + +<h2 id="Visión_general"><span class="short_text" id="result_box" lang="es"><span>Visión general</span></span></h2> + +<p>El operador de asignación basico es el igual (<code>=</code>), 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.</p> + +<table class="standard-table"> + <tbody> + <tr> + <th>Nombres</th> + <th>Abreviaciones</th> + <th>Significado</th> + </tr> + <tr> + <td><a href="#Assignment">Asignación</a></td> + <td><code>x = y</code></td> + <td><code>x = y</code></td> + </tr> + <tr> + <td><a href="#Addition_assignment">Asignación de adición</a></td> + <td><code>x += y</code></td> + <td><code>x = x + y</code></td> + </tr> + <tr> + <td><a href="#Subtraction_assignment">Asignación de sustracción</a></td> + <td><code>x -= y</code></td> + <td><code>x = x - y</code></td> + </tr> + <tr> + <td><a href="#Subtraction_assignment">Asignación de multiplicación</a></td> + <td><code>x *= y</code></td> + <td><code>x = x * y</code></td> + </tr> + <tr> + <td><a href="#Subtraction_assignment">Asignación de división</a></td> + <td><code>x /= y</code></td> + <td><code>x = x / y</code></td> + </tr> + <tr> + <td><a href="#Remainder_assignment">Asignación de Resto</a></td> + <td><code>x %= y</code></td> + <td><code>x = x % y</code></td> + </tr> + <tr> + <td><a href="#Exponentiation_assignment">Asignación de exponenciación</a></td> + <td><code>x **= y</code></td> + <td><code>x = x ** y</code></td> + </tr> + <tr> + <td><a href="#Left_shift_assignment">Asignación de desplazamiento a la izquierda</a></td> + <td><code>x <<= y</code></td> + <td><code>x = x << y</code></td> + </tr> + <tr> + <td><a href="#Left_shift_assignment">Asignación de desplazamiento a la derecha</a></td> + <td><code>x >>= y</code></td> + <td><code>x = x >> y</code></td> + </tr> + <tr> + <td><a href="#Unsigned_right_shift_assignment">Asignación sin signo de desplazamiento a la derecha</a></td> + <td><code>x >>>= y</code></td> + <td><code>x = x >>> y</code></td> + </tr> + <tr> + <td><a href="#Bitwise_AND_assignment">Asignacion AND</a></td> + <td><code>x &= y</code></td> + <td><code>x = x & y</code></td> + </tr> + <tr> + <td><a href="#Bitwise_XOR_assignment">Asignacion XOR</a></td> + <td><code>x ^= y</code></td> + <td><code>x = x ^ y</code></td> + </tr> + <tr> + <td><a href="#Bitwise_XOR_assignment">Asignacion OR</a></td> + <td><code>x |= y</code></td> + <td><code>x = x | y</code></td> + </tr> + </tbody> +</table> + +<h2 id="Asignación"><a name="Assignment">Asignación</a></h2> + +<p>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.</p> + +<h3 id="Sintaxis">Sintaxis</h3> + +<pre class="syntaxbox notranslate"><strong>Operador:</strong> x = y +</pre> + +<h3 id="Ejemplos">Ejemplos</h3> + +<pre class="brush: js notranslate">// Asumiendo las siguientes variables +// x = 5 +// y = 10 +// z = 25 + + +x = y // x es 10 +x = y = z // x, y, z son todas 25 +</pre> + +<h2 id="Asignación_de_Adición"><a name="Addition_assignment">Asignación de Adición</a></h2> + +<p>El operador de asignación de suma <strong>agrega</strong> 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.</p> + +<h3 id="Sintaxis_2">Sintaxis</h3> + +<pre class="syntaxbox notranslate"><strong>Operador:</strong> x += y +<strong>Significado:</strong> x = x + y +</pre> + +<h3 id="Ejemplos_2">Ejemplos</h3> + +<pre class="brush: js notranslate">// 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" +</pre> + +<h2 id="Asignación_de_Sustracción"><a name="Subtraction_assignment">Asignación de Sustracción</a></h2> + +<p>El operador de asignación de sustracción <strong>sustrae </strong>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.</p> + + + +<h4 id="Sintaxis_3">Sintaxis</h4> + + + +<pre class="syntaxbox notranslate"><strong>Operador:</strong> x -= y +<strong>Significado:</strong> x = x - y +</pre> + +<h4 id="Ejemplos_3">Ejemplos</h4> + +<pre class="brush: js notranslate">// Asumiendo las siguientes variables +// bar = 5 + +bar -= 2 // 3 +bar -= "foo" // NaN +</pre> + +<h2 id="Asignación_de_Multiplicación">Asignación de Multiplicación </h2> + +<p>El operador de asignación de multiplicación <strong>multiplica </strong>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.</p> + +<h3 id="Sintaxis_4">Sintaxis</h3> + +<pre class="syntaxbox notranslate"><strong>Operador:</strong> x *= y +<strong>Significado:</strong> x = x * y +</pre> + +<h3 id="Ejemplos_4">Ejemplos</h3> + +<pre class="brush: js notranslate">// Asumiendo la siguiente variable +// bar = 5 + +bar *= 2 // 10 +bar *= "foo" // NaN +</pre> + +<h2 id="Asignación_de_división"><a name="Division_assignment">Asignación de división</a></h2> + +<p>El operador de asignación de división <strong>divide </strong>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.</p> + +<h3 id="Sintaxis_5">Sintaxis</h3> + +<pre class="syntaxbox notranslate"><strong>Operador:</strong> x /= y +<strong>Significado:</strong> x = x / y +</pre> + +<h3 id="Ejemplos_5">Ejemplos</h3> + +<pre class="brush: js notranslate">// Asumiendo la siguiente variable +// bar = 5 + +bar /= 2 // 2.5 +bar /= "foo" // NaN +bar /= 0 // Infinity +</pre> + +<h2 id="Asignación_de_resto"><a name="Remainder_assignment">Asignación de resto</a></h2> + +<p>El operador de asignación de resto <strong>divide </strong>la variable por el valor del operador derecho y asigna el <strong>resto </strong>a la variable. Vea el {{jsxref("Operators/Arithmetic_Operators", "Operador de resto", "#Remainder", 1)}} para mas detelles.</p> + +<h3 id="Sintaxis_6">Sintaxis</h3> + +<pre class="syntaxbox notranslate"><strong>Operador:</strong> x %= y +<strong>Significado:</strong> x = x % y +</pre> + +<h3 id="Ejemplos_6">Ejemplos</h3> + +<pre class="brush: js notranslate">// Asumiendo la siguiente variable +// bar = 5 + +bar %= 2 // 1 +bar %= "foo" // NaN +bar %= 0 // NaN +</pre> + +<h2 id="Asignación_de_exponenciación"><a id="Exponentiation_assignment" name="Exponentiation_assignment"></a>Asignación de <span id="result_box" lang="es"><span>exponenciación</span></span></h2> + +<p>El operador de asignación de exponente evalua el resultado de elevar primero el operando a la <strong>potencia </strong>del segundo operando. Vea el {{jsxref("Operators/Bitwise_Operators", "operador de exponenciación", "#Left_shift", 1)}}para mas detalles</p> + +<h3 id="Sintaxis_7">Sintaxis</h3> + +<pre class="syntaxbox notranslate"><strong>Operador:</strong> x **= y +<strong>Significado:</strong> x = x ** y +</pre> + +<h3 id="Ejemplos_7">Ejemplos</h3> + +<pre class="brush: js notranslate">// Asumiendo la siguiente variable +// bar = 5 + +bar **= 2 // 25 +bar **= "foo" // NaN</pre> + +<h2 id="Asignación_de_desplazamiento_a_la_izquierda"><a name="Left_shift_assignment">Asignación de desplazamiento a la izquierda</a></h2> + +<p>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.</p> + +<h3 id="Sintaxis_8">Sintaxis</h3> + +<pre class="syntaxbox notranslate"><strong>Operador:</strong> x <<= y +<strong>Significado:</strong> x = x << y +</pre> + +<h3 id="Ejemplos_8">Ejemplos</h3> + +<pre class="brush: js notranslate">var bar = 5; // (00000000000000000000000000000101) +bar <<= 2; // 20 (00000000000000000000000000010100) +</pre> + +<h2 id="Asignación_de_desplazamiento_a_la_derecha"><a name="Right_shift_assignment">Asignación de desplazamiento a la derecha</a></h2> + +<p>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.</p> + +<h3 id="Sintaxis_9">Sintaxis</h3> + +<pre class="syntaxbox notranslate"><strong>Operador:</strong> x >>= y +<strong>Significado:</strong> x = x >> y +</pre> + +<h3 id="Ejemplos_9">Ejemplos</h3> + +<pre class="brush: js notranslate">var bar = 5; // (00000000000000000000000000000101) +bar >>= 2; // 1 (00000000000000000000000000000001) + +var bar -5; // (-00000000000000000000000000000101) +bar >>= 2; // -2 (-00000000000000000000000000000010) +</pre> + +<h2 id="Asignación_sin_signo_de_desplazamiento_a_la_derecha"><a name="Unsigned_right_shift_assignment">Asignación sin signo de desplazamiento a la derecha</a></h2> + +<p>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.</p> + +<h3 id="Sintaxis_10">Sintaxis</h3> + +<pre class="syntaxbox notranslate"><strong>Operador:</strong> x >>>= y +<strong>Significado:</strong> x = x >>> y +</pre> + +<h3 id="Ejemplo">Ejemplo</h3> + +<pre class="brush: js notranslate">var bar = 5; // (00000000000000000000000000000101) +bar >>>= 2; // 1 (00000000000000000000000000000001) + +var bar = -5; // (-00000000000000000000000000000101) +bar >>>= 2; // 1073741822 (00111111111111111111111111111110)</pre> + +<h2 id="Asignación_AND"><a name="Bitwise_AND_assignment">Asignación AND</a></h2> + +<p>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.</p> + +<h3 id="Sintaxis_11">Sintaxis</h3> + +<pre class="syntaxbox notranslate"><strong>Operador:</strong> x &= y +<strong>Significado:</strong> x = x & y +</pre> + +<h3 id="Ejemplo_2">Ejemplo</h3> + +<pre class="brush: js notranslate">var bar = 5; +// 5: 00000000000000000000000000000101 +// 2: 00000000000000000000000000000010 +bar &= 2; // 0 +</pre> + +<h2 id="Asignación_XOR"><a name="Bitwise_XOR_assignment">Asignación XOR</a></h2> + +<p>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</p> + +<h3 id="Sintaxis_12">Sintaxis</h3> + +<pre class="syntaxbox notranslate"><strong>Operador:</strong> x ^= y +<strong>Significado:</strong> x = x ^ y +</pre> + +<h3 id="Ejemplo_3">Ejemplo</h3> + +<pre class="brush: js notranslate">var bar = 5; +bar ^= 2; // 7 +// 5: 00000000000000000000000000000101 +// 2: 00000000000000000000000000000010 +// ----------------------------------- +// 7: 00000000000000000000000000000111 +</pre> + +<h2 id="Asignación_OR"><a name="Bitwise_OR_assignment">Asignación OR</a></h2> + +<p>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</p> + +<h3 id="Sintaxis_13">Sintaxis</h3> + +<pre class="syntaxbox notranslate"><strong>Operador:</strong> x |= y +<strong>Significado:</strong> x = x | y +</pre> + +<h3 id="Ejemplo_4">Ejemplo</h3> + +<pre class="brush: js notranslate">var bar = 5; +bar |= 2; // 7 +// 5: 00000000000000000000000000000101 +// 2: 00000000000000000000000000000010 +// ----------------------------------- +// 7: 00000000000000000000000000000111 +</pre> + +<h2 id="Ejemplos_10">Ejemplos</h2> + +<h3 id="Operador_izquierdo_con_otros_operadores_de_asignación">Operador izquierdo con otros operadores de asignación</h3> + +<p>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:</p> + +<pre class="brush: js notranslate">a[i++] += 5 // i es evaluado una vez +a[i++] = a[i++] + 5 // i es evaluado dos veces +</pre> + +<h2 id="Especificaciones">Especificaciones</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificación</th> + <th scope="col">Estado</th> + <th scope="col">Comentario</th> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-assignment-operators', 'Operadores de asignación')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-assignment-operators', 'Operadores de asignación')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-11.13', 'Operadores de asignación')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES1', '#sec-11.13', 'Operadores de asignación')}}</td> + <td>{{Spec2('ES1')}}</td> + <td> + <p>Definición inicial</p> + </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidad_de_Navegadores">Compatibilidad de 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</th> + </tr> + <tr> + <td>Soporte basico</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome para Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Soporte basico</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vea_tambien">Vea tambien</h2> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators">Operadores Aritméticos</a></li> +</ul> diff --git a/files/es/conflicting/web/javascript/reference/operators_e72d8790e25513408a18a5826660f704/index.html b/files/es/conflicting/web/javascript/reference/operators_e72d8790e25513408a18a5826660f704/index.html new file mode 100644 index 0000000000..4c9cb860a9 --- /dev/null +++ b/files/es/conflicting/web/javascript/reference/operators_e72d8790e25513408a18a5826660f704/index.html @@ -0,0 +1,296 @@ +--- +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 +--- +<div>{{jsSidebar("Operadores_lógicos")}}</div> + +<p>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.</p> + +<h2 id="Descripción">Descripción</h2> + +<p>Los operadores lógicos se describen en la tabla siguiente:</p> + +<table class="fullwidth-table"> + <tbody> + <tr> + <th>Operador</th> + <th>Uso</th> + <th>Descripción</th> + </tr> + <tr> + <td>AND (<code>&&</code>) lógico</td> + <td><code><em>expr1</em> && <em>expr2</em></code></td> + <td> + <p>Regresa <code>expr1 </code>si tal puede convertirse a false; de lo contrario, regresa <code>expr2</code>. De esta forma, cuando se usa con valores Boolean, && regresa true si ambos operandos son verdaderos; de lo contrario regresa false.</p> + </td> + </tr> + <tr> + <td>OR (<code>||</code>) lógico</td> + <td><code><em>expr1</em> || <em>expr2</em></code></td> + <td> + <p>Regresa<code> expr1</code> si tal puede convertirse a true; de lo contrario, regresa <code>expr2</code>. De esta forma, cuando se usa con valores Boolean, || regresa true si cualquier operando es verdadero; pero si ambos son falsos, regresa "false".</p> + </td> + </tr> + <tr> + <td>NOT (<code>!</code>) lógico</td> + <td><code>!<em>expr</em></code></td> + <td> + <p>Regresa false si su único operando puede convertirse a true; de lo contrario, regresa true.</p> + </td> + </tr> + </tbody> +</table> + +<p>Algunos ejemplos de expresiones que pueden convertirse a false son aquellas que evalúan a null, 0, un string vacío (""), o undefined.</p> + +<p>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.</p> + +<h3 id="Evaluación_contra_corto_circuitos">Evaluación contra "corto circuitos"</h3> + +<p>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:</p> + +<ul> + <li><code>false && (<em>cualquier valor)</em></code> evalúa a "false".</li> + <li><code>true || (<em>cualquier valor)</em></code> evalúa a "true".</li> +</ul> + +<p>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).</p> + +<p>Por ejemplo, las siguientes dos expresiones son equivalentes.</p> + +<pre class="brush: js">function shortCircuitEvaluation() { + doSomething() || doSomethingElse() +} + +function equivalentEvaluation() { + var flag = doSomething(); + if (!flag) { + doSomethingElse(); + } +} +</pre> + +<p>Sin embargo, las siguientes expresiones no son equivalentes debido a la <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence">precedencia de operadores</a>, 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).</p> + +<pre class="brush: js">false && true || true // regresa true +false && (true || true) // regresa false</pre> + +<h3 id="AND_()_lógico"><a name="Logical_AND">AND (<code>&&</code>) lógico</a></h3> + +<p>El siguiente código muestra ejemplos del operador && (AND lógico).</p> + +<pre class="brush: js">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 +</pre> + +<h3 id="OR_()_lógico"><a name="Logical_OR">OR (<code>||</code>) lógico</a></h3> + +<p>El siguiente código muestra ejemplos del operador <code>||</code> (OR lógico).</p> + +<pre class="brush: js">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" +</pre> + +<h3 id="Logical_NOT_(!)"><a name="Logical_NOT">Logical NOT (<code>!</code>)</a></h3> + +<p>El siguiente código muestra ejemplos del operador <code>!</code> (NOT lógico).</p> + +<pre class="brush: js">n1 = !true // !t regresa false +n2 = !false // !f regresa true +n3 = !"Cat" // !t regresa false +</pre> + +<h3 id="Reglas_de_conversión">Reglas de conversión</h3> + +<h4 id="Convertir_de_AND_a_OR">Convertir de AND a OR</h4> + +<p>la siguiente operación que involucra Booleans:</p> + +<pre class="brush: js">bCondition1 && bCondition2</pre> + +<p>siempre es igual a:</p> + +<pre class="brush: js">!(!bCondition1 || !bCondition2)</pre> + +<h4 id="Convertir_de_OR_a_AND">Convertir de OR a AND</h4> + +<p>la siguiente operación que involucra Booleans:</p> + +<pre class="brush: js">bCondition1 || bCondition2</pre> + +<p>siempre es igual a:</p> + +<pre class="brush: js">!(!bCondition1 && !bCondition2)</pre> + +<h4 id="Convertir_entre_operadores_NOT">Convertir entre operadores NOT</h4> + +<p>la siguiente operación que involucra Booleans:</p> + +<pre class="brush: js">!!bCondition</pre> + +<p>siempre es igual a:</p> + +<pre class="brush: js">bCondition</pre> + +<h3 id="Eliminando_paréntesis_anidados">Eliminando paréntesis anidados</h3> + +<p>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.</p> + +<h4 id="Eliminando_operadores_AND_anidados">Eliminando operadores AND anidados</h4> + +<p>La siguiente operación compleja que involucra Booleans:</p> + +<pre class="brush: js">bCondition1 || (bCondition2 && bCondition3)</pre> + +<p>siempre es igual a:</p> + +<pre class="brush: js">bCondition1 || bCondition2 && bCondition3</pre> + +<h4 id="Eliminando_operadores_OR_anidados">Eliminando operadores OR anidados</h4> + +<p>La siguiente operación compleja que involucra Booleans:</p> + +<pre class="brush: js">bCondition1 && (bCondition2 || bCondition3)</pre> + +<p>siempre es igual a:</p> + +<pre class="brush: js">!(!bCondition1 || !bCondition2 && !bCondition3)</pre> + +<h2 id="Especificaciones">Especificaciones</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificación</th> + <th scope="col">Estado</th> + <th scope="col">Comentarios</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Definición inicial.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-11.11')}}</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.4.9">Logical NOT Operator</a>, <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.11">Binary Logical Operators</a></p> + </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-binary-logical-operators')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definido en varias secciones de la especificación: <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-logical-not-operator">Logical NOT Operator</a>, <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-binary-logical-operators">Binary Logical Operators</a></td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-binary-logical-operators')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td>Definido en varias secciones de la especificación: <a href="http://tc39.github.io/ecma262/#sec-logical-not-operator">Logical NOT Operator</a>, <a href="http://tc39.github.io/ecma262/#sec-binary-logical-operators">Binary Logical Operators</a></td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidad_entre_navegadores">Compatibilidad entre 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</th> + </tr> + <tr> + <td>AND (<code>&&</code>) lógico</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + <tr> + <td>OR (<code>||</code>) lógico</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + <tr> + <td>NOT (<code>!</code>) lógico</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>AND (<code>&&</code>) lógico</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + <tr> + <td>OR (<code>||</code>) lógico</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + <tr> + <td>NOT (<code>!</code>) lógico</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Ver_también">Ver también</h2> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators">Operaciones binarias</a></li> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean">Boolean</a></li> +</ul> diff --git a/files/es/conflicting/web/javascript/reference/statements/switch/index.html b/files/es/conflicting/web/javascript/reference/statements/switch/index.html new file mode 100644 index 0000000000..a25a5a5369 --- /dev/null +++ b/files/es/conflicting/web/javascript/reference/statements/switch/index.html @@ -0,0 +1,121 @@ +--- +title: default +slug: Web/JavaScript/Referencia/Sentencias/default +tags: + - JavaScript + - Palabra clave +translation_of: Web/JavaScript/Reference/Statements/switch +translation_of_original: Web/JavaScript/Reference/Statements/default +--- +<div>{{jsSidebar("Sentencias")}}</div> + +<p>La palabra clave<strong> default, </strong>en JavaScript puede ser usada en dos situaciones: dentro una sentencia {{jsxref("Sentencias/switch", "switch")}}, o con un sentencia{{jsxref("Sentencias/export", "export")}}.</p> + +<div>{{EmbedInteractiveExample("pages/js/statement-default.html")}}</div> + +<p class="hidden">El codigo fuente para este ejemplo interactivo esta almacenado en un repositorio de GitHub. Si quieres contribuir al proyecto de ejemplos interactivos, clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> y mandenos un pull request.</p> + +<h2 id="Sintaxis">Sintaxis</h2> + +<p>Dentro de una sentencia {{jsxref("Sentencias/switch", "switch")}}:</p> + +<pre class="syntaxbox">switch (expresion) { + case valor1: + //Declaración ejecutada cuando el resultado de la expresion conincida con valor1 + [break;] + default: + //Declaración ejecutada cuando ninguno de los valores conincida con algun valor de la expresion + [break;] +}</pre> + +<p>Con una sentencia {{jsxref("Sentencias/export", "export")}}:</p> + +<pre class="syntaxbox">export default <em>nameN</em> </pre> + +<h2 id="Descripción">Descripción</h2> + +<p>Para mas detalles vea las paginas:</p> + +<ul> + <li>Sentencia {{jsxref("Sentencias/switch", "switch")}} y</li> + <li>Sentencia {{jsxref("Sentencias/export", "export")}}.</li> +</ul> + +<h2 id="Ejemplos">Ejemplos</h2> + +<h3 id="Usando_default_en_una_sentencia_switch">Usando <code>default</code> en una sentencia <code>switch</code></h3> + +<p>En el siguiente ejemplo, si se evalua <code>expr</code> como "Naranjas" o "Manzanas", el programa coincide los valores en cada caso: "Naranjas" o "Manzanas", y ejecuta la declaración correspondiente. La palabra clave <code>default</code> ayudara en algun otro caso y ejecuta la declaración asociada.</p> + +<pre class="brush: js">switch (expr) { + case 'Naranjas': + console.log('Las Naranjas cuestan $0.59 el kilogramo.'); + break; + case 'Manzanas': + console.log('Las Manzanas cuestan $0.32 el kilogramo.'); + break; + default: + console.log('Lo esntimos, no tenemos ' + expr + '.'); +}</pre> + +<h3 id="Usando_default_con_export">Usando <code>default</code> con <code>export</code></h3> + +<p>Si queres exportar un solo valor o necesitas reservar un valor para un modulo, puedes usar una exportación por defecto:</p> + +<pre class="brush: js">// modulo "mi-modulo.js" +let cube = function cube(x) { + return x * x * x; +}; +export default cube;</pre> + +<p>Entonces, en otro script, sera sencillo de importar el valor del modulo:</p> + +<pre class="brush: js">// modulo "otro-modulo.js" +import cubeArea from 'mi-modulo'; //default export nos da la libertad de decir import cubeArea, en lugar de import cube from 'my-module' +console.log(cubeArea(3)); // 27 +</pre> + +<h2 id="Especificaciones">Especificaciones</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-switch-statement', 'switch statement')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-exports', 'Exports')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-switch-statement', 'switch statement')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-exports', 'Exports')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidad_con_navegadores">Compatibilidad con navegadores</h2> + +<div class="hidden">La tabla de compatibilidad en esta pagina es generada desde datos estruturados. si quieres contribuir con los datos, revisa <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> y envianos un pull request.</div> + +<p>{{Compat("javascript.statements.default")}}</p> + +<h2 id="Vea_tambien">Vea tambien</h2> + +<ul> + <li>{{jsxref("Sentencias/export", "export")}}</li> + <li>{{jsxref("Sentencias/switch", "switch")}}</li> +</ul> |