From a55b575e8089ee6cab7c5c262a7e6db55d0e34d6 Mon Sep 17 00:00:00 2001 From: Florian Merz Date: Thu, 11 Feb 2021 14:46:50 +0100 Subject: unslug es: move --- .../global_objects/arraybuffer/index.html | 69 ++ .../reference/global_objects/date/index.html | 201 ++++++ .../reference/global_objects/error/index.html | 154 +++++ .../reference/global_objects/function/index.html | 65 ++ .../reference/global_objects/map/index.html | 135 ++++ .../reference/global_objects/number/index.html | 16 + .../reference/global_objects/object/index.html | 195 ++++++ .../reference/global_objects/promise/index.html | 69 ++ .../reference/global_objects/rangeerror/index.html | 131 ++++ .../reference/global_objects/string/index.html | 118 ++++ .../global_objects/syntaxerror/index.html | 133 ++++ .../reference/global_objects/weakmap/index.html | 143 ++++ .../reference/lexical_grammar/index.html | 99 +++ .../web/javascript/reference/operators/index.html | 315 +++++++++ .../reference/operators/spread_syntax/index.html | 220 +++++++ .../index.html | 262 ++++++++ .../index.html | 722 +++++++++++++++++++++ .../index.html | 462 +++++++++++++ .../index.html | 296 +++++++++ .../reference/statements/switch/index.html | 121 ++++ 20 files changed, 3926 insertions(+) create mode 100644 files/es/conflicting/web/javascript/reference/global_objects/arraybuffer/index.html create mode 100644 files/es/conflicting/web/javascript/reference/global_objects/date/index.html create mode 100644 files/es/conflicting/web/javascript/reference/global_objects/error/index.html create mode 100644 files/es/conflicting/web/javascript/reference/global_objects/function/index.html create mode 100644 files/es/conflicting/web/javascript/reference/global_objects/map/index.html create mode 100644 files/es/conflicting/web/javascript/reference/global_objects/number/index.html create mode 100644 files/es/conflicting/web/javascript/reference/global_objects/object/index.html create mode 100644 files/es/conflicting/web/javascript/reference/global_objects/promise/index.html create mode 100644 files/es/conflicting/web/javascript/reference/global_objects/rangeerror/index.html create mode 100644 files/es/conflicting/web/javascript/reference/global_objects/string/index.html create mode 100644 files/es/conflicting/web/javascript/reference/global_objects/syntaxerror/index.html create mode 100644 files/es/conflicting/web/javascript/reference/global_objects/weakmap/index.html create mode 100644 files/es/conflicting/web/javascript/reference/lexical_grammar/index.html create mode 100644 files/es/conflicting/web/javascript/reference/operators/index.html create mode 100644 files/es/conflicting/web/javascript/reference/operators/spread_syntax/index.html create mode 100644 files/es/conflicting/web/javascript/reference/operators_5a0acbbb60ea37d0fdc52e3bd4c3fae8/index.html create mode 100644 files/es/conflicting/web/javascript/reference/operators_5c44e7d07c463ff1a5a63654f4bda87b/index.html create mode 100644 files/es/conflicting/web/javascript/reference/operators_d3958587a3d3dd644852ad397eb5951b/index.html create mode 100644 files/es/conflicting/web/javascript/reference/operators_e72d8790e25513408a18a5826660f704/index.html create mode 100644 files/es/conflicting/web/javascript/reference/statements/switch/index.html (limited to 'files/es/conflicting/web/javascript/reference') 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 +--- +
{{JSRef}}
+ +

La propiedad ArrayBuffer.prototype representa el prototipo para el objeto {{jsxref("ArrayBuffer")}}.

+ +
{{js_property_attributes(0,0,0)}}
+ +

Descripción

+ +

Las instancias de ArrayBuffer heredan de ArrayBuffer.prototype. Como con todos los constructores, puedes modificar el prototipo del constructor para aplicar cambios sobre todas las instancias de ArrayBuffer.

+ +

Propiedades

+ +
+
ArrayBuffer.prototype.constructor
+
Especifica la función que se encarga de crear el prototipo del objeto. El valor inicial es el constructor incluido en el estándar ArrayBuffer.
+
{{jsxref("ArrayBuffer.prototype.byteLength")}} {{readonlyInline}}
+
El tamaño, en bytes, del array. Este valor se establece al construir el objeto y no se puede modificar. Sólo lectura.
+
+ +

Métodos

+ +
+
{{jsxref("ArrayBuffer.prototype.slice()")}}
+
Retorna un nuevo ArrayBuffer cuyo contenido es una copia los bytes de este ArrayBuffer desde begin, incluido, hasta  end, no incluido. Si begin o end son negativos, éstos hacen referencia a un índice que comienza a partir del final del array.
+
+ +

Especificaciones

+ + + + + + + + + + + + + + + + + + + +
EspecificaciónEstadoComentario
{{SpecName('ES6', '#sec-arraybuffer.prototype', 'ArrayBuffer.prototype')}}{{Spec2('ES6')}}Definición inicial.
{{SpecName('ESDraft', '#sec-arraybuffer.prototype', 'ArrayBuffer.prototype')}}{{Spec2('ESDraft')}} 
+ +

Compatibilidad con navegadores

+ +

{{Compat("javascript.builtins.ArrayBuffer.prototype")}}

+ +
 
+ +

Ver también

+ + 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 +--- +
+ {{JSRef("Objetos_globales", "Date")}}
+

Resumen

+

Representa el prototipo para esta clase. Puede utilizar el prototipo para añadir propiedades o métodos a todas las instancias de una clase.

+
+ {{js_property_attributes(0,0,1)}}
+

Propriedades

+
+
+ Date.prototype.constructor
+
+  
+
+
+ {{ jsOverrides("Object", "properties", "constructor") }}
+

Métodos

+
+
+ {{jsxref("Date.prototype.getDate()")}}
+
+ Devuelve el día del mes de la fecha especificada según la hora local.
+
+ {{jsxref("Date.prototype.getDay()")}}
+
+ Devuelve el día de la semana de la fecha especificada según la hora local.
+
+ {{jsxref("Date.prototype.getFullYear()")}}
+
+ Devuelve el año de la fecha especificada según la hora local.
+
+ {{jsxref("Date.prototype.getHours()")}}
+
+ Devuelve la hora de la fecha especificada según la hora local.
+
+ {{jsxref("Date.prototype.getMilliseconds()")}}
+
+ Devuelve los milisegundos de la fecha especificada según la hora local.
+
+ {{jsxref("Date.prototype.getMinutes()")}}
+
+ Devuelve los minutos de la fecha especificada según la hora local.
+
+ {{jsxref("Date.prototype.getMonth()")}}
+
+ Devuelve el mes de la fecha especificada según la hora local.
+
+ {{jsxref("Date.prototype.getSeconds()")}}
+
+ Devuelve los segundos de la fecha especificada según la hora local.
+
+ {{jsxref("Date.prototype.getTime()")}}
+
+ Devuelve el valor numérico correspondiente a la hora especificada según la hora universal.
+
+ {{jsxref("Date.prototype.getTimezoneOffset()")}}
+
+ Devuelve la diferencia horaria en minutos para la zona geográfica actual.
+
+ {{jsxref("Date.prototype.getUTCDate()")}}
+
+ Devuelve el día del mes de la fecha especificada según la hora universal.
+
+ {{jsxref("Date.prototype.getUTCDay()")}}
+
+ Devuelve el día de la semana de la fecha especificada según la hora universal.
+
+ {{jsxref("Date.prototype.getUTCFullYear()")}}
+
+ Devuelve el día el año de la fecha especificada según la hora universal.
+
+ {{jsxref("Date.prototype.getUTCHours()")}}
+
+ Devuelve las horas de la fecha especificada según la hora universal.
+
+ {{jsxref("Date.prototype.getUTCMilliseconds()")}}
+
+ Devuelve los milisegundos de la fecha especificada según la hora universal.
+
+ {{jsxref("Date.prototype.getUTCMinutes()")}}
+
+ Devuelve los minutos de la fecha especificada según la hora universal.
+
+ {{jsxref("Date.prototype.getUTCMonth()")}}
+
+ Devuelve el mes de la fecha especificada según la hora universal.
+
+ {{jsxref("Date.prototype.getUTCSeconds()")}}
+
+ Devuelve los segundos de la fecha especificada según la hora universal.
+
+ {{jsxref("Date.prototype.getYear()")}} {{ deprecated_inline() }}
+
+ Devuelve el año de la fecha especificada según la hora local. Use {{jsxref("Date.prototype.getFullYear()")}} a cambio.
+
+ {{jsxref("Date.prototype.setDate()")}}
+
+ Establece el día del mes de la fecha especificada según la hora local.
+
+ {{jsxref("Date.prototype.setFullYear()")}}
+
+ Establece el año completo de la fecha especificada según la hora local.
+
+ {{jsxref("Date.prototype.setHours()")}}
+
+ Establece las horas de la fecha especificada según la hora local.
+
+ {{jsxref("Date.prototype.setMilliseconds()")}}
+
+ Establece los milisegundos de la fecha especificada según la hora local.
+
+ {{jsxref("Date.prototype.setMinutes()")}}
+
+ Establece los minutos de la fecha especificada según la hora local.
+
+ {{jsxref("Date.prototype.setMonth()")}}
+
+ Establece el mes de la fecha especificada según la hora local.
+
+ {{jsxref("Date.prototype.setSeconds()")}}
+
+ Establece los segundos de la fecha especificada según la hora local.
+
+ {{jsxref("Date.prototype.setTime()")}}
+
+ Establece el valor del objeto Date según la hora local.
+
+ {{jsxref("Date.prototype.setUTCDate()")}}
+
+ Establece el día del mes de la fecha especificada según la hora universal.
+
+ {{jsxref("Date.prototype.setUTCFullYear()")}}
+
+ Establece el año completo de la fecha especificada según la hora universal.
+
+ {{jsxref("Date.prototype.setUTCHours()")}}
+
+ Establece la hora de la fecha especificada según la hora universal.
+
+ {{jsxref("Date.prototype.setUTCMilliseconds()")}}
+
+ Establece los milisegundos de la fecha especificada según la hora universal..
+
+ {{jsxref("Date.prototype.setUTCMinutes()")}}
+
+ Establece los minutos de la fecha especificada según la hora universal..
+
+ {{jsxref("Date.prototype.setUTCMonth()")}}
+
+ Establece el mes de la fecha especificada según la hora universal.
+
+ {{jsxref("Date.prototype.setUTCSeconds()")}}
+
+ Establece los segundos de la fecha especificada según la hora universal..
+
+ {{jsxref("Date.prototype.setYear ()")}}{{deprecated_inline}}
+
+ Establece el año de la fecha especificada según la hora local. Use {{jsxref("Date.prototype.setFullYear()")}} a cambio.
+
+ {{jsxref("Date.prototype.toGMTString()")}} {{ deprecated_inline}}
+
+ Convierte una fecha en una cadena, usando las convenciones de Internet GMT. Utilice {{jsxref("Date.prototype.toUTCString()")}} a cambio.
+
+ {{jsxref("Date.prototype.toLocaleString()")}}
+
+ Convierte una fecha en una cadena, usando las reglas de la localización actual. Sobreescribe el método {{jsxref("Object.toLocaleString()")}}.
+
+ {{jsxref("Date.prototype.toLocaleDateString()")}}
+
+ Devuelve la porción fecha (sin la hora) de una fecha como una cadena, usando las reglas de la localización actual.
+
+ {{jsxref("Date.prototype.toLocaleTimeString()")}}
+
+ Devuelve la porción hora (sin la fecha) de una fecha como una cadena, siguiendo las reglas de la localización actual.
+
+ {{jsxref("Date.prototype.toSource()")}}
+
+ Devuelve un literal que representa al objeto Date especificado; puede usar este valor para crear un nuevo objeto. Sobreescribe el método {{jsxref("Object.toSource()")}}.
+
+ {{jsxref("Date.prototype.toString()")}}
+
+ Devuelve una cadena representando el objeto Date especificado. Sobreescribe el método {{jsxref("Object.toString()")}}.
+
+ {{jsxref("Date.prototype.toUTCString()")}}
+
+ Convierte una fecha en una cadena, usando las reglas horarias universales.
+
+ {{jsxref("Date.prototype.valueOf()")}}
+
+ Devuelve el valor primitivo de un objeto Date. Sobreescribe el método {{jsxref("Object.valueOf()")}}.
+
+

{{ 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") }}

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 +--- +
{{JSRef}}
+ +

La propiedad Error.prototype representa el prototipo del constructor {{jsxref("Error")}}.

+ +
{{js_property_attributes(0, 0, 0)}}
+ +

Descripción

+ +

Todas las instancias de {{jsxref("Error")}} e instancias de {{jsxref("Global_Objects/Error", "errores no genéricos", "#Error_types", 1)}}, heredan de Error.prototype. 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.

+ +

Properties

+ +

Propiedades estándar

+ +
+
Error.prototype.constructor
+
Especifica la función que crea una instancia del prototipo.
+
{{jsxref("Error.prototype.message")}}
+
Mensaje de error.
+
{{jsxref("Error.prototype.name")}}
+
Nombre del error.
+
+ +

Extensiones específicas del proveedor

+ +
{{non-standard_header}}
+ +

Microsoft

+ +
+
{{jsxref("Error.prototype.description")}}
+
Descripción del error. Similar a {{jsxref("Error.prototype.message", "message")}}.
+
{{jsxref("Error.prototype.number")}}
+
Número de error.
+
+ +

Mozilla

+ +
+
{{jsxref("Error.prototype.fileName")}}
+
Ruta del archivo que lanzó el error.
+
{{jsxref("Error.prototype.lineNumber")}}
+
Número de fila en el archivo que lanzó el error.
+
{{jsxref("Error.prototype.columnNumber")}}
+
Número de columna en el archivo que lanzó el error.
+
{{jsxref("Error.prototype.stack")}}
+
Seguimiento de la pila.
+
+ +

Métodos

+ +
+
{{jsxref("Error.prototype.toSource()")}} {{non-standard_inline}}
+
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()")}}.
+
{{jsxref("Error.prototype.toString()")}}
+
Devuelve una cadena que representa el objeto. Sobreescribe el método {{jsxref("Object.prototype.toString()")}}.
+
+ +

Especificaciones

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
EspecificaciónEstadoComentario
{{SpecName('ES1')}}{{Spec2('ES1')}}Definición inicial. Implementado en JavaScript 1.1.
{{SpecName('ES5.1', '#sec-15.11.3.1', 'Error')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-error.prototype', 'Error')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-error.prototype', 'Error')}}{{Spec2('ESDraft')}} 
+ +

Compatibilidad con navegadores

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

Ver también

+ + 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 +--- +
{{JSRef("Objetos_globales", "Function")}}
+ +

Resumen

+ +

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.

+ +

Descripción

+ +

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.

+ +

Propiedades

+ +
+
{{jsxref("Function.arguments")}} {{Deprecated_inline}}
+
Una matriz correspondiente a los argumentos pasados a una función. Como propiedad de una Function, este uso está obsoleto. Se recomenda el uso del objeto {{jsxref("Functiones/arguments", "arguments")}}.
+
{{jsxref("Function.arity")}} {{obsolete_inline}}
+
Especifica el número de argumentos que espera la función. Se recomienda, no obstante, utilizar la función {{jsxref("Function.length", "length")}}.
+
{{jsxref("Function.caller")}}
+
Especifica la función que invoca la ejecución de la función actual (no estándar).
+
{{jsxref("Function.constructor")}}
+
Especifica la función que crea un prototipo de objeto.
+
{{jsxref("Function.length")}}
+
Specifica el número de argumentos esperados por la función.
+
{{jsxref("Function.name")}}
+
El nombre de la función (no forma parte del estándar).
+
{{jsxref("Function.prototype")}}
+
Permite añadir propiedades a los objetos función (ambos, los construidos usando Function y los declarados usando una declaración de función o una expresión de función).
+
+ +
{{ jsOverrides("Object", "properties", "arguments", "arity", "caller", "constructor", "length", "name", "displayName") }}
+ +

Métodos

+ +
+
{{jsxref("Function.prototype.apply()")}}
+
Le permite aplicar el método de otro objeto en el contexto de un objeto diferente (el objeto llamado).
+
{{jsxref("Function.prototype.call()")}}
+
Le Permite llamar (ejecutar) a un método de otro objeto en el contexto de un objeto diferente (el objeto que llama).
+
{{jsxref("Function.prototype.toSource()")}}
+
Devuelve una cadena que representa el código fuente de la función. Anula al método {{jsxref("Object.toSource")}}.
+
{{jsxref("Function.prototype.toString()")}}
+
Devuelve una cadena que representa el código fuente de la función. Anula al método {{jsxref("Object.toSource")}}.
+
+ +
{{ jsOverrides("Object", "methods", "apply", "call", "toSource", "toString") }}
+ +
+
 
+
+ +

Vea También

+ + 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 +--- +
{{JSRef}}
+ +

La propiedad Map.prototype  representa el prototipo del constructor {{jsxref("Map")}}.

+ +
{{js_property_attributes(0,0,0)}}
+ +

Descripción

+ +

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

+ +

Propiedades

+ +
+
Map.prototype.constructor
+
Devuelve la función que creó el prototipo de una instancia. Esta es la función de {{jsxref("Map")}} por defecto.
+
{{jsxref("Map.prototype.size")}}
+
Devuelve el número de conjuntos de llave/valor en el objeto Map.
+
+ +

Métodos

+ +
+
{{jsxref("Map.prototype.clear()")}}
+
Elimina todos los conjuntos de llave/valor del objeto Map.
+
{{jsxref("Map.delete", "Map.prototype.delete(key)")}}
+
Elimina cualquier valor asociado a la llave y devuelve el valor que  Map.prototype.has(key) tenía previamente. Después  Map.prototype.has(key) devolverá false.
+
{{jsxref("Map.prototype.entries()")}}
+
Devuelve un nuevo objeto  Iterador que contiene un array de [llave, valor] para cada elemento en el objeto  Map en orden de inserción.
+
{{jsxref("Map.forEach", "Map.prototype.forEach(callbackFn[, thisArg])")}}
+
Llama a la callbackFn una vez por cada conjunto llave/valor presentes en cada objeto  Map, en orden de inserción. Si se le proporciona un parámetro thisArg a forEach, se usará como valor "this" para cada callback.
+
{{jsxref("Map.get", "Map.prototype.get(key)")}}
+
Devuelve el valor asociado a la  llave, o undefined si no tiene ninguno.
+
{{jsxref("Map.has", "Map.prototype.has(key)")}}
+
Devuelve un booleano que indica si un valor se ha asociado a la llave en el objeto Map o no se ha asociado.
+
{{jsxref("Map.prototype.keys()")}}
+
Devuelve un nuevo objeto  Iterador que contiene las llaves para cada elemento en el objeto Map en orden de inserción.
+
{{jsxref("Map.set", "Map.prototype.set(key, value)")}}
+
Establece un valor para la llave en el objeto Map. Devuelve el objeto  Map.
+
{{jsxref("Map.prototype.values()")}}
+
Devuelve un nuevo objeto  Iterador que contiene los valores para cada elemento en el objeto  Map en orden de inserción.
+
{{jsxref("Map.@@iterator", "Map.prototype[@@iterator]()")}}
+
Devuelve un nuevo objeto  Iterador que contiene un array de [llave, valor] para cada elemento en el objeto Map en orden de inserción.
+
+ +

Especificaciones

+ + + + + + + + + + + + + + + + + + + +
EspecificaciónEstadoComentario
{{SpecName('ES2015', '#sec-map.prototype', 'Map.prototype')}}{{Spec2('ES2015')}}Definición inicial.
{{SpecName('ESDraft', '#sec-map.prototype', 'Map.prototype')}}{{Spec2('ESDraft')}} 
+ +

Compatibilidad entre navegadores

+ +

{{CompatibilityTable}}

+ +
+ + + + + + + + + + + + + + + + + + + + + +
CaracterísticaChromeEdgeFirefox (Gecko)Internet ExplorerOperaSafari
Soporte básico38{{CompatVersionUnknown}}{{ CompatGeckoDesktop("13") }}11257.1
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + +
CaracterísticaAndroidChrome for AndroidEdgeFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Soporte básico{{CompatNo}}38{{CompatVersionUnknown}}{{CompatGeckoMobile("13")}}{{CompatNo}}{{CompatNo}} +

8

+
+
+ +

Vea también

+ + 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 +--- +
+ {{JSRef("Objetos_globales", "Number")}}
+

Resumen

+

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.

+
+  
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 +--- +
{{JSRef("Objetos_globales", "Object")}}
+ +

Resumen

+ +

La propiedad Object.prototype representa al objeto prototipo de {{jsxref("Object")}}.

+ +

{{js_property_attributes(0,0,0)}}

+ +

Descripción

+ +

Todos los objetos en JavaScript provienen de {{jsxref("Global_Objects/Object", "Object")}}; todos los objetos heredan métodos y propiedades de Object.prototype, aunque pueden ser sobrecargados. Sin embargo, un Object  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")}}).

+ +

Cambios en el prototipo de {{jsxref("Object")}} son vistos por todos 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.

+ +

Propiedades

+ +
+
{{jsxref("Object.prototype.constructor")}}
+
Especifica la función que crea el prototipo de un objeto.
+
{{jsxref("Object.proto", "Object.prototype.__proto__")}} {{Non-standard_inline}}
+
Apunta al objeto que se usó como prototipo cuando fue instanciado.
+
{{jsxref("Object.noSuchMethod", "Object.prototype.__noSuchMethod__")}} {{Non-standard_inline}}
+
Permite a una función ser definida que sera ejecutada cuando un miembro del objeto es llamado como un metodo.
+
{{jsxref("Object.count", "Object.prototype.__count__")}} {{obsolete_inline()}}
+
Se utiliza para devolver el número de propiedades enumerables directamente en un objeto definido por el usuario, pero que ha sido eliminado.
+
{{jsxref("Object.parent", "Object.prototype.__parent__")}} {{obsolete_inline()}}
+
Apunta al contexto de un objeto. Ha sido borrado.
+
+ +

Métodos

+ +
+
{{jsxref("Object.defineGetter", "Object.prototype.__defineGetter__()")}} {{Non-standard_inline}} {{deprecated_inline()}}
+
Asocia una función con una propiedad que, cuando se accede a ella, ejecuta esa función y devuelve su valor de retorno.
+
{{jsxref("Object.defineSetter", "Object.prototype.__defineSetter__()")}} {{Non-standard_inline}} {{deprecated_inline()}}
+
Asocia una función con una propiedad que al establecerse ejecuta esa función que modifica la propiedad.
+
{{jsxref("Object.lookupGetter", "Object.prototype.__lookupGetter__()")}} {{Non-standard_inline}} {{deprecated_inline()}}
+
Devuelve la función asociada con la propiedad indicada por el método {{jsxref("Object.defineGetter", "__defineGetter__")}}.
+
{{jsxref("Object.lookupSetter", "Object.prototype.__lookupSetter__()")}} {{Non-standard_inline}} {{deprecated_inline()}}
+
Devuelve la función asociada con la propiedad indicada en el método {{jsxref("Object.defineSetter", "__defineSetter__")}}.
+
{{jsxref("Object.prototype.hasOwnProperty()")}}
+
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.
+
{{jsxref("Object.prototype.isPrototypeOf()")}}
+
Devuelve una indicación booleana cuando el objeto especificado está en la cadena de prototipos del objeto sobre el cuál éste método es llamado.
+
{{jsxref("Object.prototype.propertyIsEnumerable()")}}
+
Devuelve un valor lógico (boolean) indicando si el attributo ECMAScript [[Enumerable]] está definido.
+
{{jsxref("Object.prototype.toSource()")}} {{Non-standard_inline}}
+
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.
+
{{jsxref("Object.prototype.toLocaleString()")}}
+
Llama a {{jsxref("Object.toString", "toString()")}}.
+
{{jsxref("Object.prototype.toString()")}}
+
Devuelve la cadena de texto (string) que representa al objeto.
+
{{jsxref("Object.prototype.unwatch()")}} {{Non-standard_inline}}
+
Remueve un punto de mira de una propiedad del objeto.
+
{{jsxref("Object.prototype.valueOf()")}}
+
Devuelve el valor primitivo del objeto indicado.
+
{{jsxref("Object.prototype.watch()")}} {{Non-standard_inline}}
+
Agrega un punto de mira a una propiedad del objeto.
+
{{jsxref("Object.prototype.eval()")}} {{ obsolete_inline()}}
+
Se utiliza para evaluar una cadena de código JavaScript  en el contexto del objeto especificado, pero que ha sido removido.
+
+ +

Ejemplos

+ +

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.

+ +

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.

+ +
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);
+  }
+}
+ +

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:

+ +
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();
+ +

Especificaciones

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
EspecificaciónEstadoObservación
{{SpecName('ES1')}}{{Spec2('ES1')}} +

Definición inicial.Implementado en  JavaScript 1.0.

+
{{SpecName('ES5.1', '#sec-15.2.3.1', 'Object.prototype')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-object.prototype', 'Object.prototype')}}{{Spec2('ES6')}} +

 

+
{{SpecName('ESDraft', '#sec-object.prototype', 'Object.prototype')}}{{Spec2('ESDraft')}} 
+ +

Compatibilidad con navegadores

+ +

{{Compat("javascript.builtins.Object.prototype")}}

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 +--- +
{{JSRef}}
+ +

La propiedad Promise.prototype representa el prototipo del constructor de {{jsxref("Promise")}}

+ +
{{js_property_attributes(0,0,0)}}
+ +

Descripción

+ +

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

+ +

Propiedades

+ +
+
Promise.prototype.constructor
+
Retorna la función que creó el prototipo de una instancia. Esta es la función por defecto de {{jsxref("Promise")}}.
+
+ +

Métodos

+ +
+
{{jsxref("Promise.catch", "Promise.prototype.catch(alRechazarse)")}}
+
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.
+
{{jsxref("Promise.then", "Promise.prototype.then(alCumplirse, alRechazarse)")}}
+
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 determinación (settled) original si la promesa no fue manejada (p.ej. si el manejador relevante alCumplirse o alRechazarse no es una función).
+
+ +

Especificaciones

+ + + + + + + + + + + + + + + + + + + +
EspecificaciónEstatusComentario
{{SpecName('ES6', '#sec-promise.prototype', 'Promise.prototype')}}{{Spec2('ES6')}}Definición inicial.
{{SpecName('ESDraft', '#sec-promise.prototype', 'Promise.prototype')}}{{Spec2('ESDraft')}} 
+ +

Compatibilidad de navegadores

+ + + +

{{Compat("javascript/promise","Promise.prototype")}}

+ +

Ver también

+ + 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 +--- +
{{JSRef}}
+ +

La propiedad RangeError.prototype representa el prototipo de {{jsxref("RangeError")}}.

+ +
{{js_property_attributes(0, 0, 0)}}
+ +

Descripción

+ +

Todas las instancias de {{jsxref("RangeError")}} heredan de RangeError.prototype. Puede utilizar el prototipo para añadir propiedades o métodos a todas las instancias.

+ +

Propiedades

+ +
+
RangeError.prototype.constructor
+
Especifica la función que crea instancias del prototipo.
+
{{jsxref("Error.prototype.message", "RangeError.prototype.message")}}
+
Mensaje de error. Aunque ECMA-262 especifica que {{jsxref("RangeError")}} debe procurar su propio message, en SpiderMonkey, se hereda de {{jsxref("Error.prototype.message")}}.
+
{{jsxref("Error.prototype.name", "RangeError.prototype.name")}}
+
Nombre del error. Heredada de {{jsxref("Error")}}.
+
{{jsxref("Error.prototype.fileName", "RangeError.prototype.fileName")}}
+
Ruta al fichero en el que se produjo el error. Heredada de {{jsxref("Error")}}.
+
{{jsxref("Error.prototype.lineNumber", "RangeError.prototype.lineNumber")}}
+
Número de línea en el fichero en el que se produjo el error. Heredada de {{jsxref("Error")}}.
+
{{jsxref("Error.prototype.columnNumber", "RangeError.prototype.columnNumber")}}
+
Número de columna de la línea en la que se produjo. Heredada de {{jsxref("Error")}}.
+
{{jsxref("Error.prototype.stack", "RangeError.prototype.stack")}}
+
Pila de llamadas. Heredada de {{jsxref("Error")}}.
+
+ +

Métodos

+ +

Aunque el prototipo del objeto {{jsxref("RangeError")}} no contiene métodos propios, las instancias de {{jsxref("RangeError")}} heredan algunos a través de la cadena de prototipos.

+ +

Especificaciones

+ + + + + + + + + + + + + + + + + + + + + + + + +
EspecificaciónEstadoCommentario
{{SpecName('ES3')}}{{Spec2('ES3')}}Definición inicial.
{{SpecName('ES5.1', '#sec-15.11.7.6', 'NativeError.prototype')}}{{Spec2('ES5.1')}}Definido como NativeError.prototype.
{{SpecName('ES6', '#sec-nativeerror.prototype', 'NativeError.prototype')}}{{Spec2('ES6')}}Definido como NativeError.prototype.
+ +

Compatibilidad de navegadores

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

Vea también

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

{{JSRef("Objetos_globales", "String")}}

+ +

Resumen

+ +

The String.prototype 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.

+ +
{{js_property_attributes(0,0,0)}}
+ +

Propiedades

+ +
+
String.prototype.constructor
+
Especifica la función que crea un prototipo de objeto.
+
{{jsxref("String.prototype.length")}}
+
Refleja la longitud de la cadena.
+
+ +
{{ jsOverrides("Object", "properties", "constructor", "length") }}
+ +

Métodos

+ +

Métodos no relacionados con HTML

+ +
+
{{jsxref("String.prototype.charAt()")}}
+
Devuelve el carácter en el índice especificado.
+
{{jsxref("String.prototype.charCodeAt()")}}
+
Devuelve el número que indica el valor Unicode del carácter en el índice especificado.
+
{{jsxref("String.prototype.concat()")}}
+
Combina el texto de dos cadenas y devuelve una nueva cadena.
+
{{jsxref("String.prototype.indexOf()")}}
+
Devuelve el índice dentro del objeto String que realiza la llamada de la primera ocurrencia del valor especificado, o -1 si no lo encuentra.
+
{{jsxref("String.prototype.lastIndexOf()")}}
+
Devuelve el índice dentro del objeto String que realiza la llamada de la última ocurrencia del valor especificado, o -1 si no lo encuentra.
+
{{jsxref("String.prototype.match()")}}
+
Se usa para emparejar una expresión regular con una cadena.
+
{{jsxref("String.prototype.replace()")}}
+
Se usa para emparejar una expresión regular con una cadena, y reemplezar la subcadena emparejada con una nueva subcadena.
+
{{jsxref("String.prototype.search()")}}
+
Realiza una búsqueda de una expresión regular en una cadena especificada.
+
{{jsxref("String.prototype.slice()")}}
+
Extrae una sección de una cadena y devuelve una nueva cadena.
+
{{jsxref("String.prototype.split()")}}
+
Divide un objeto String en un arreglo de cadenas, separando la cadena en subcadenas.
+
{{jsxref("String.prototype.substr()")}}
+
Devuelve los caracteres de una cadena comenzando en la localización especificada y hasta el número de caracteres especificado.
+
{{jsxref("String.prototype.substring()")}}
+
Devuelve los caracteres de una cadena entre dos índices dentro de la cadena.
+
{{jsxref("String.prototype.toLowerCase()")}}
+
Devuelve el valor de la cadena que realiza la llamada en minúsculas.
+
{{jsxref("String.prototype.toSource()")}}
+
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()")}}.
+
{{jsxref("String.prototype.toString()")}}
+
Devuelve una cadena que representa el objeto especificado. Sobreescribe el método {{jsxref("Object.prototype.toString()")}}.
+
{{jsxref("String.prototype.toUpperCase()")}}
+
Devuelve el valor de la cadena que realiza la llamada en mayúsculas.
+
{{jsxref("String.prototype.valueOf()")}}
+
Devuelve el valor primitivo del objeto especificado. Sobreescribe el método {{jsxref("Object.prototype.valueOf()")}}.
+
+ +

Métodos de encapsulado HTML

+ +

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

+ +
+
{{jsxref("String.prototype.anchor()")}}
+
<a name="name"> (Ancha Hipertexto)
+
{{jsxref("String.prototype.big()")}}
+
{{HTMLElement("big")}}
+
{{jsxref("String.prototype.blink()")}}
+
{{HTMLElement("blink")}}
+
{{jsxref("String.prototype.bold()")}}
+
{{HTMLElement("b")}}
+
{{jsxref("String.prototype.fixed()")}}
+
{{HTMLElement("tt")}}
+
{{jsxref("String.prototype.fontcolor()")}}
+
<font color="color">
+
{{jsxref("String.prototype.fontsize()")}}
+
<font size="size">
+
{{jsxref("String.prototype.italics()")}}
+
{{HTMLElement("i")}}
+
{{jsxref("String.prototype.link()")}}
+
<a href="url"> (Enlace a URL)
+
{{jsxref("String.prototype.small()")}}
+
{{HTMLElement("small")}}
+
{{jsxref("String.prototype.strike()")}}
+
{{HTMLElement("strike")}}
+
{{jsxref("String.prototype.sub()")}}
+
{{HTMLElement("sub")}}
+
{{jsxref("String.prototype.sup()")}}
+
{{HTMLElement("sup")}}
+
+ +

Estos métodos son de uso limitado, ya que sólo están disponibles un subconjunto de etiquetas HTML y atributos.

+ +

{{ 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") }}

+ +

Vea también

+ + + +
+
 
+
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 +--- +
{{JSRef}}
+ +

La propiedad SyntaxError.prototype representa el prototipo para el constructor {{jsxref("SyntaxError")}}.

+ +

Descripción

+ +

Todas las instancias de {{jsxref("SyntaxError")}} son heredadas de SyntaxError.prototype. Puedes usar el prototipo para agregar propiedades o metodos a todas las instancias.

+ +

Propiedades

+ +
+
SyntaxError.prototype.constructor
+
Especifica la funcion que creó una instancia del prototipo.
+
{{jsxref("Error.prototype.message", "SyntaxError.prototype.message")}}
+
Mensaje de error. A pesar de que ECMA-262 especifica que {{jsxref("SyntaxError")}} debe proveer su propia propiedad message , en SpiderMonkey, es heredada de {{jsxref("Error.prototype.message")}}.
+
{{jsxref("Error.prototype.name", "SyntaxError.prototype.name")}}
+
Error name. Inherited from {{jsxref("Error")}}.
+
{{jsxref("Error.prototype.fileName", "SyntaxError.prototype.fileName")}}
+
Ruta al archivo que produjo el error. Heredada de {{jsxref("Error")}}.
+
{{jsxref("Error.prototype.lineNumber", "SyntaxError.prototype.lineNumber")}}
+
Numero de linea en el archivo que produjo el error. Heredada de {{jsxref("Error")}}.
+
{{jsxref("Error.prototype.columnNumber", "SyntaxError.prototype.columnNumber")}}
+
Numero de columna en la linea que produjo el error. Heredada de {{jsxref("Error")}}.
+
{{jsxref("Error.prototype.stack", "SyntaxError.prototype.stack")}}
+
Stack trace. Heredada de {{jsxref("Error")}}.
+
+ +

Metodos

+ +

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.

+ +

Especificaciones

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpecificationStatusComment
{{SpecName('ES3')}}{{Spec2('ES3')}}Initial definition.
{{SpecName('ES5.1', '#sec-15.11.7.6', 'NativeError.prototype')}}{{Spec2('ES5.1')}}Defined as NativeError.prototype.
{{SpecName('ES6', '#sec-nativeerror.prototype', 'NativeError.prototype')}}{{Spec2('ES6')}}Defined as NativeError.prototype.
{{SpecName('ESDraft', '#sec-nativeerror.prototype', 'NativeError.prototype')}}{{Spec2('ESDraft')}}Defined as NativeError.prototype.
+ +

Compatibilidad con navegadores

+ +

{{CompatibilityTable}}

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

Véase también

+ + 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 +--- +
{{JSRef}}
+ +

La propiedad WeakMap.prototype representa el prototipo para el constructor {{jsxref("WeakMap")}}.

+ +
{{js_property_attributes(0,0,0)}}
+ +

Descripción

+ +

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

+ +

WeakMap.prototype por si mismo es solamente un objeto ordinario:

+ +
Object.prototype.toString.call(WeakMap.prototype); // "[object Object]"
+ +

Propiedades

+ +
+
WeakMap.prototype.constructor
+
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.
+
+ +

Métodos

+ +
+
{{jsxref("WeakMap.delete", "WeakMap.prototype.delete(key)")}}
+
Remueve cualquier valor asociado a la clave. Después de esto WeakMap.prototype.has(key) retornará falso.
+
{{jsxref("WeakMap.get", "WeakMap.prototype.get(key)")}}
+
Retorna el valor asociado a la clave, o undefined si no hay ninguno.
+
{{jsxref("WeakMap.has", "WeakMap.prototype.has(key)")}}
+
Retorna un valor booleano indicando si hay un valor asociado a la clave en el objeto the WeakMap object o no.
+
{{jsxref("WeakMap.set", "WeakMap.prototype.set(key, value)")}}
+
Asigna el valor para la clave en el objeto WeakMap. Retorna el objeto WeakMap.
+
{{jsxref("WeakMap.prototype.clear()")}} {{obsolete_inline}}
+
Remueve todas los pares clave/valore del objeto WeakMap. Notese que es posible implementar un objeto parecido al WeakMap que posea un método .clear(), encapsulando el objeto WeakMap que no lo tiene (ver ejemplo en la página {{jsxref("WeakMap")}})
+
+ +

Especificaciones

+ + + + + + + + + + + + + + + + + + + +
EspecificaciónEstadoComentario
{{SpecName('ES6', '#sec-weakmap.prototype', 'WeakMap.prototype')}}{{Spec2('ES6')}}Definición inicial.
{{SpecName('ESDraft', '#sec-weakmap.prototype', 'WeakMap.prototype')}}{{Spec2('ESDraft')}} 
+ +

Compatibilidad de navegadores

+ +

{{CompatibilityTable}}

+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + +
CaracterísticaChromeFirefox (Gecko)Internet ExplorerOperaSafari
Soporte básico36{{CompatGeckoDesktop("6.0")}}11237.1
Objeto ordinario{{CompatUnknown}}{{CompatGeckoDesktop("40")}}{{CompatUnknown}}{{CompatUnknown}}{{CompatUnknown}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
CaracterísticaAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Soporte básico{{CompatNo}}{{CompatNo}}{{CompatGeckoMobile("6.0")}}{{CompatNo}}{{CompatNo}}8
Objeto ordinario{{CompatUnknown}}{{CompatUnknown}}{{CompatGeckoMobile("40")}}{{CompatUnknown}}{{CompatUnknown}}{{CompatUnknown}}
+
+ +

Ver también

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

 

+ +

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:

+ +

Reserved keywords as of ECMAScript 6

+ +
+ +
+ +

Las siguientes estan reservadas como palabras futuras por la especificación ECMAScript:

+ + + +

Las siguientes estan reservadas como palabras futuras cuando se encuentre el modo correcto para su estructura de codigo:

+ +
+ +
+ +

Futuras Palabras Reservadas en estandares antiguos

+ +

Las siguientes estan reservadas como palabras futuras por la antigua especificación ECMAScript (ECMAScript 1 hasta 3).

+ +
+ +
+ +

Adicionalmente, los literales "null", "true", y "false" estan reservadas en ECMAScript para usos normales.

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 +--- +
{{jsSidebar("Operators")}}
+ +

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

+ +

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

+ +

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

+ +

Suma o adición (+)

+ +

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

+ +

Sintaxis

+ +
Operador: x + y
+ +

Ejemplos:

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

Resta o sustracción (-)

+ +

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

+ +

Sintaxis

+ +
Operador: x - y
+ +

Ejemplos

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

División (/)

+ +

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

+ +

Sintaxis

+ +
Operador: x / y
+ +

Ejemplos

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

Multiplicación (*)

+ +

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

+ +

Sintaxis

+ +
Operador: x * y
+ +

Ejemplos

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

Resto o Residuo  (%)

+ +

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

+ +

Sintaxis

+ +
Operador: var1 % var2
+ +

Ejemplos

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

Exponenciación (**)

+ +

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

+ +

Sintaxis

+ +
Operador: var1 ** var2
+ +

 

+ +

Notas

+ +

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

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

Ejemplos

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

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

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

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

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

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

+
+ +

 

+ +

Incremento (++)

+ +

 

+ +

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

+ + + +

Sintaxis

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

Ejemplos

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

Decremento (--)

+ +

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

+ + + +

Sintaxis

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

Ejemplos

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

 

+ +

Negación unaria (-)

+ +

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

+ +

Sintaxis

+ +
Operador: -x
+ +

Ejemplos

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

Unario más (+)

+ +

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

+ +

Sintaxis

+ +
Operador: +x
+ +

Ejemplos

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

 

+ +

Especificaciones

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

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

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

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

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

Compatibilidad con navegadores

+ +

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

+ +

Ver también

+ + + +

 

diff --git a/files/es/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 +--- +
{{jsSidebar("Operators")}}
+ +

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

+ +

Sintaxis

+ +

Llamadas a funciones:

+ +
f(...iterableObj);
+
+ +

Arrays literales:

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

Desestructuración destructuring:

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

Ejemplos

+ +

Un mejor método apply

+ +

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

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

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

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

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

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

Un array literal mas poderoso

+ +

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

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

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

+ +

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

+ +

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

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

Un método push mejorado

+ +

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

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

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

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

Solo funciona para iterables

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

Operador Rest

+ +

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

+ +

Especificaciones

+ + + + + + + + + + + + + + + + +
EspecificaciónEstadoCommentario
+

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

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

Compatibilidad en navegadores

+ +

{{CompatibilityTable}}

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

Temas relacionados

+ + diff --git a/files/es/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 +--- +
{{jsSidebar("Operators")}}
+ +

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

+ +

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

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

Características de las comparaciones:

+ + + +

Operadores de igualdad

+ +

Igualdad (==)

+ +

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

+ +

Sintaxis

+ +
x == y
+
+ +

Ejemplos

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

Desigualdad (!=)

+ +

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

+ +

Sintaxis

+ +
x != y
+ +

Ejemplos

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

Identidad / igualdad estricta (===)

+ +

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

+ +

Sintaxis

+ +
x === y
+ +

Ejemplos

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

Sin identidad / desigualdad estricta (!==)

+ +

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

+ +

Sintaxis

+ +
x !== y
+ +

Ejemplos

+ +
3 !== '3' // true
+4 !== 3   // true
+
+ +

Operadores relacionales

+ +

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

+ +

Operador mayor que (>)

+ +

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

+ +

Sintaxis

+ +
x > y
+ +

Ejemplos

+ +
4 > 3 // true
+
+ +

Operador mayor o igual (>=)

+ +

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

+ +

Sintaxis

+ +
 x >= y
+ +

Ejemplos

+ +
4 >= 3 // true
+3 >= 3 // true
+
+ +

Operador menor que (<)

+ +

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

+ +

Sintaxis

+ +
 x < y
+ +

Ejemplos

+ +
3 < 4 // true
+
+ +

Operador menor o igual (<=)

+ +

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

+ +

Sintaxis

+ +
 x <= y
+ +

Ejemplos

+ +
3 <= 4 // true
+
+ +

Usando los operadores de igualdad

+ +

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

+ +

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

+ +

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

+ +

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

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

Especificaciones

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

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

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

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

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

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

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

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

+
+ +

Compatibilidad con navegadores

+ + + +

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

+ +

Ver también

+ + diff --git a/files/es/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 +--- +
{{jsSidebar("Operators")}}
+ +

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

+ +

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

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

Enteros con signo de 32 bits

+ +

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

+ +
00000000000000000000000100111010
+
+ +

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

+ +
11111111111111111111111011000101
+
+ +

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

+ +
11111111111111111111111011000110
+
+ +

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

+ +

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

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

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

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

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

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

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

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

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

+ +

Operadores lógicos a nivel de bit

+ +

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

+ + + +

& (Bitwise AND o AND a nivel de bits)

+ +

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

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

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

+ +

| (Bitwise OR o  OR a nivel de bits)

+ +

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

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

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

+ +

^ (Bitwise XOR o XOR a nivel de bits)

+ +

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

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

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

+ +

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

+ +

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

+ + + + + + + + + + + + + + + + +
aNOT a
01
10
+ +

 

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

 

+ +

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

+ +

Ejemplo con indexOf:

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

Operadores de desplazamiento a nivel de bit

+ +

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

+ +

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

+ +

<< (Desplazamiento a la izquierda)

+ +

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

+ +

Por ejemplo, 9 << 2 devuelve 36:

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

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

+ +

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

+ +

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

+ +

Por ejemplo, 9 >> 2 devuelve 2:

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

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

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

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

+ +

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

+ +


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

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

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

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

Ejemplos

+ +

Banderas y máscaras de bits

+ +

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

+ +

Supongamos que hay 4 banderas:

+ + + +

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

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

Este valor indica:

+ + + +

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

+ +

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Fragmentos de conversión

+ +

Convert a binary String to a decimal Number:

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

 

+ +

Convierte una cadena binaria a un número decimal:

+ +

 

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

Automatiza la creación de una máscara.

+ +

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

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

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

+ +

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

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

Puedes probar ambos algoritmos al mismo tiempo ...

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

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

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

Specifications

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

Compatibilidad del navegador

+ +

{{CompatibilityTable}}

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

Ver también

+ + diff --git a/files/es/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 +--- +
{{jsSidebar("Operators")}}
+ +

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

+ +

Visión general

+ +

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

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

Asignación

+ +

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

+ +

Sintaxis

+ +
Operador: x = y
+
+ +

Ejemplos

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

Asignación de Adición

+ +

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

+ +

Sintaxis

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

Ejemplos

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

Asignación de Sustracción

+ +

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

+ + + +

Sintaxis

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

Ejemplos

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

Asignación de Multiplicación 

+ +

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

+ +

Sintaxis

+ +
Operador: x *= y
+Significado:  x  = x * y
+
+ +

Ejemplos

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

Asignación de división

+ +

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

+ +

Sintaxis

+ +
Operador: x /= y
+Significado:  x  = x / y
+
+ +

Ejemplos

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

Asignación  de resto

+ +

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

+ +

Sintaxis

+ +
Operador: x %= y
+Significado:  x  = x % y
+
+ +

Ejemplos

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

Asignación de exponenciación

+ +

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

+ +

Sintaxis

+ +
Operador: x **= y
+Significado:  x  = x ** y
+
+ +

Ejemplos

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

Asignación de desplazamiento a la izquierda

+ +

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

+ +

Sintaxis

+ +
Operador: x <<= y
+Significado:  x   = x << y
+
+ +

Ejemplos

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

Asignación de desplazamiento a la derecha

+ +

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

+ +

Sintaxis

+ +
Operador: x >>= y
+Significado:  x   = x >> y
+
+ +

Ejemplos

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

Asignación sin signo de desplazamiento a la derecha

+ +

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

+ +

Sintaxis

+ +
Operador: x >>>= y
+Significado:  x    = x >>> y
+
+ +

Ejemplo

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

Asignación AND

+ +

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

+ +

Sintaxis

+ +
Operador: x &= y
+Significado:  x  = x & y
+
+ +

Ejemplo

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

Asignación XOR

+ +

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

+ +

Sintaxis

+ +
Operador: x ^= y
+Significado:  x  = x ^ y
+
+ +

Ejemplo

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

Asignación OR

+ +

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

+ +

Sintaxis

+ +
Operador: x |= y
+Significado:  x  = x | y
+
+ +

Ejemplo

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

Ejemplos

+ +

Operador izquierdo con otros operadores de asignación

+ +

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

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

Especificaciones

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

Definición inicial

+
+ +

Compatibilidad de Navegadores

+ +

{{CompatibilityTable}}

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

Vea tambien

+ + diff --git a/files/es/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 +--- +
{{jsSidebar("Operadores_lógicos")}}
+ +

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

+ +

Descripción

+ +

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

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

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

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

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

+
NOT (!) lógico!expr +

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

+
+ +

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

+ +

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

+ +

Evaluación contra "corto circuitos"

+ +

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

+ + + +

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

+ +

Por ejemplo, las siguientes dos expresiones son equivalentes.

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

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

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

AND (&&) lógico

+ +

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

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

OR (||) lógico

+ +

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

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

Logical NOT (!)

+ +

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

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

Reglas de conversión

+ +

Convertir de AND a OR

+ +

la siguiente operación que involucra Booleans:

+ +
bCondition1 && bCondition2
+ +

siempre es igual a:

+ +
!(!bCondition1 || !bCondition2)
+ +

Convertir de OR a AND

+ +

la siguiente operación que involucra Booleans:

+ +
bCondition1 || bCondition2
+ +

siempre es igual a:

+ +
!(!bCondition1 && !bCondition2)
+ +

Convertir entre operadores NOT

+ +

la siguiente operación que involucra Booleans:

+ +
!!bCondition
+ +

siempre es igual a:

+ +
bCondition
+ +

Eliminando paréntesis anidados

+ +

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

+ +

Eliminando operadores AND anidados

+ +

La siguiente operación compleja que involucra Booleans:

+ +
bCondition1 || (bCondition2 && bCondition3)
+ +

siempre es igual a:

+ +
bCondition1 || bCondition2 && bCondition3
+ +

Eliminando operadores OR anidados

+ +

La siguiente operación compleja que involucra Booleans:

+ +
bCondition1 && (bCondition2 || bCondition3)
+ +

siempre es igual a:

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

Especificaciones

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

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

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

Compatibilidad entre navegadores

+ +

{{CompatibilityTable}}

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

Ver también

+ + diff --git a/files/es/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 +--- +
{{jsSidebar("Sentencias")}}
+ +

La palabra clave default, en JavaScript puede ser usada en dos situaciones: dentro una sentencia {{jsxref("Sentencias/switch", "switch")}}, o con un sentencia{{jsxref("Sentencias/export", "export")}}.

+ +
{{EmbedInteractiveExample("pages/js/statement-default.html")}}
+ + + +

Sintaxis

+ +

Dentro de una sentencia {{jsxref("Sentencias/switch", "switch")}}:

+ +
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;]
+}
+ +

Con una sentencia {{jsxref("Sentencias/export", "export")}}:

+ +
export default nameN
+ +

Descripción

+ +

Para mas detalles vea las paginas:

+ + + +

Ejemplos

+ +

Usando default en una sentencia switch

+ +

En el siguiente ejemplo, si se evalua expr  como "Naranjas" o "Manzanas", el programa coincide los valores en cada caso: "Naranjas" o "Manzanas", y ejecuta la declaración correspondiente. La palabra clave default ayudara en algun otro caso y ejecuta la declaración asociada.

+ +
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 + '.');
+}
+ +

Usando default con export

+ +

Si queres exportar un solo valor o necesitas reservar un valor para un modulo, puedes usar una exportación por defecto:

+ +
// modulo "mi-modulo.js"
+let cube = function cube(x) {
+  return x * x * x;
+};
+export default cube;
+ +

Entonces, en otro script, sera sencillo de importar el valor del modulo:

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

Especificaciones

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpecificationStatusComment
{{SpecName('ES6', '#sec-switch-statement', 'switch statement')}}{{Spec2('ES6')}} 
{{SpecName('ES6', '#sec-exports', 'Exports')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-switch-statement', 'switch statement')}}{{Spec2('ESDraft')}} 
{{SpecName('ESDraft', '#sec-exports', 'Exports')}}{{Spec2('ESDraft')}} 
+ +

Compatibilidad con navegadores

+ + + +

{{Compat("javascript.statements.default")}}

+ +

Vea tambien

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