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/string/anchor/index.html | 56 +++ .../reference/global_objects/string/big/index.html | 54 +++ .../global_objects/string/blink/index.html | 42 +++ .../global_objects/string/bold/index.html | 43 +++ .../global_objects/string/charat/index.html | 143 ++++++++ .../global_objects/string/charcodeat/index.html | 65 ++++ .../global_objects/string/codepointat/index.html | 127 +++++++ .../global_objects/string/concat/index.html | 90 +++++ .../global_objects/string/endswith/index.html | 88 +++++ .../global_objects/string/fixed/index.html | 35 ++ .../global_objects/string/fontcolor/index.html | 122 +++++++ .../global_objects/string/fontsize/index.html | 123 +++++++ .../global_objects/string/fromcharcode/index.html | 130 +++++++ .../global_objects/string/fromcodepoint/index.html | 204 +++++++++++ .../global_objects/string/includes/index.html | 108 ++++++ .../reference/global_objects/string/index.html | 385 +++++++++++++++++++++ .../global_objects/string/indexof/index.html | 104 ++++++ .../global_objects/string/italics/index.html | 49 +++ .../global_objects/string/lastindexof/index.html | 79 +++++ .../global_objects/string/length/index.html | 94 +++++ .../global_objects/string/link/index.html | 56 +++ .../global_objects/string/localecompare/index.html | 159 +++++++++ .../global_objects/string/match/index.html | 78 +++++ .../global_objects/string/matchall/index.html | 134 +++++++ .../global_objects/string/normalize/index.html | 126 +++++++ .../global_objects/string/padstart/index.html | 100 ++++++ .../reference/global_objects/string/raw/index.html | 112 ++++++ .../global_objects/string/repeat/index.html | 128 +++++++ .../global_objects/string/replace/index.html | 202 +++++++++++ .../global_objects/string/search/index.html | 153 ++++++++ .../global_objects/string/slice/index.html | 161 +++++++++ .../global_objects/string/small/index.html | 38 ++ .../global_objects/string/split/index.html | 240 +++++++++++++ .../global_objects/string/startswith/index.html | 97 ++++++ .../global_objects/string/strike/index.html | 42 +++ .../reference/global_objects/string/sub/index.html | 35 ++ .../global_objects/string/substr/index.html | 83 +++++ .../global_objects/string/substring/index.html | 92 +++++ .../reference/global_objects/string/sup/index.html | 35 ++ .../string/tolocalelowercase/index.html | 113 ++++++ .../string/tolocaleuppercase/index.html | 100 ++++++ .../global_objects/string/tolowercase/index.html | 40 +++ .../global_objects/string/tosource/index.html | 56 +++ .../global_objects/string/tostring/index.html | 28 ++ .../global_objects/string/touppercase/index.html | 39 +++ .../global_objects/string/trim/index.html | 133 +++++++ .../global_objects/string/trimend/index.html | 82 +++++ .../global_objects/string/valueof/index.html | 28 ++ 48 files changed, 4831 insertions(+) create mode 100644 files/es/web/javascript/reference/global_objects/string/anchor/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/big/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/blink/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/bold/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/charat/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/charcodeat/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/codepointat/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/concat/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/endswith/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/fixed/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/fontcolor/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/fontsize/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/fromcharcode/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/fromcodepoint/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/includes/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/indexof/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/italics/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/lastindexof/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/length/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/link/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/localecompare/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/match/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/matchall/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/normalize/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/padstart/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/raw/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/repeat/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/replace/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/search/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/slice/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/small/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/split/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/startswith/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/strike/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/sub/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/substr/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/substring/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/sup/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/tolocalelowercase/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/tolocaleuppercase/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/tolowercase/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/tosource/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/tostring/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/touppercase/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/trim/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/trimend/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/valueof/index.html (limited to 'files/es/web/javascript/reference/global_objects/string') diff --git a/files/es/web/javascript/reference/global_objects/string/anchor/index.html b/files/es/web/javascript/reference/global_objects/string/anchor/index.html new file mode 100644 index 0000000000..c34abd62b1 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/anchor/index.html @@ -0,0 +1,56 @@ +--- +title: String.prototype.anchor() +slug: Web/JavaScript/Referencia/Objetos_globales/String/anchor +tags: + - HTML wrapper methods + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/anchor +--- +
{{JSRef("Objetos_globales", "String")}}
+ +

Resumen

+ +

El método anchor() crea un ancla HTML, {{HTMLElement("a")}}, que se usa como un enlace a hipertexto.

+ +

Sintaxis

+ +
cadena.anchor(nombreAtributo)
+ +

Parámetros

+ +
+
nombreAtributo
+
Una cadena.
+
+ +

Descripción

+ +

Usa el método anchor con los métodos document.write o document.writeln para crear y mostrar programando un ancla en un documento. Crea el ancla con el método anchor, y entonces llama a write o writeln para mostrar el ancla en el documento. En JavaScript en el lado Servidor, usa la función write para mostrar el ancla.

+ +

En la sintaxis, la cadena de texto representa el texto literal que usted quiere que el usuario vea. La cadena nombreAtributo representa el atributo NAME de la etiqueta A.

+ +

Los anclas creados con el método anchor serán elementos del arreglo {{domxref("document.anchors")}}

+ +

Ejemplos

+ +

Ejemplo: Usando anchor

+ +

El siguiente código de ejemplo dentro de un elemento HTML script:

+ +
var miCadena = "Tabla de Contenidos";
+document.body.innerHTML = miCadena.anchor("ancla_contenidos");
+
+ +

obtendrá el siguiente HTML:

+ +
<a name="ancla_contenidos">Tabla de Contenidos</A>
+
+ +

Vea También

+ + diff --git a/files/es/web/javascript/reference/global_objects/string/big/index.html b/files/es/web/javascript/reference/global_objects/string/big/index.html new file mode 100644 index 0000000000..0aa04e5b74 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/big/index.html @@ -0,0 +1,54 @@ +--- +title: String.prototype.big() +slug: Web/JavaScript/Referencia/Objetos_globales/String/big +tags: + - Deprecated + - HTML wrapper methods + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/big +--- +

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

+ +

{{deprecated_header}}

+ +

Resumen

+ +

Provoca que una cadena sea mostrada con un tamaño de fuente grade, como si estuviese en una etiqueta {{HTMLElement("big")}}.

+ +

Sintaxis

+ +
cadena.big()
+ +

Descripción

+ +

Usa el método big para formatear y mostrar una cadena en un documento.

+ +

Ejemplos

+ +

Ejemplo: Usando big

+ +

El siguiente ejemplo usa los métodos de string para cambiar el tamañó de una cadena:

+ +
var cadenaMundo="¡Hola Mundo!";
+
+console.log(cadenaMundo.small());
+console.log("<P>" + cadenaMundo.big());
+console.log("<P>" + cadenaMundo.fontsize(7));
+
+ +

Este ejemplo produce el mismo resultado que el siguiente HTML:

+ +
<small>¡Hola Mundo!</small>
+<p><big>¡Hola Mundo!</big>
+<p><fontsize=7>¡Hola Mundo!</fontsize>
+
+ +

Vea También

+ + diff --git a/files/es/web/javascript/reference/global_objects/string/blink/index.html b/files/es/web/javascript/reference/global_objects/string/blink/index.html new file mode 100644 index 0000000000..cf49f3d840 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/blink/index.html @@ -0,0 +1,42 @@ +--- +title: String.prototype.blink() +slug: Web/JavaScript/Referencia/Objetos_globales/String/blink +tags: + - Deprecated + - HTML wrapper methods + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/blink +--- +

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

+

{{deprecated_header}}

+

Resumen

+

Causa que una cadena parpadee como si estuviese en una etiqueta {{HTMLElement("blink")}}.

+

Sintaxis

+
cadena.blink()
+

Descripción

+

Usa el método blink para formatear y mostrar una cadena en un documento.

+

Ejemplos

+

Ejemplo: Usando métodos de string para cambiar el formateado de una cadena

+

El siguiente ejemplo usa métodos de string para cambiar el formateado de una cadena:

+
var cadenaMundo="¡Hola mundo!"
+
+console.log(cadenaMundo.blink())
+console.log(cadenaMundo.bold())
+console.log(cadenaMundo.italics())
+console.log(cadenaMundo.strike())
+
+

Este ejemplo produce el mismo resultado que el siguiente código HTML:

+
<blink>¡Hola mundo!</blink>
+<b>¡Hola mundo!</b>
+<i>¡Hola mundo!</b>
+<strike>¡Hola mundo!</strike>
+
+

Vea también

+ diff --git a/files/es/web/javascript/reference/global_objects/string/bold/index.html b/files/es/web/javascript/reference/global_objects/string/bold/index.html new file mode 100644 index 0000000000..cc7c841181 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/bold/index.html @@ -0,0 +1,43 @@ +--- +title: String.prototype.bold() +slug: Web/JavaScript/Referencia/Objetos_globales/String/bold +tags: + - Deprecated + - HTML wrapper methods + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/bold +--- +

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

+

Resumen

+

Provoca que una cadena se muestre en negrita como si estuviera en una etiqueta {{HTMLElement("b")}}.

+

Sintaxis

+
cadena.bold()
+

Descripción

+

Usa el método bold para formatear y mostrar una cadena en un documento.

+

Ejemplos

+

Ejemplo: Usando métodos de string para cambiar el formateado de una cadena

+

El siguiente ejemplo usa métodos de string para cambiar el formateado de una cadena:

+
var cadenaMundo="¡Hola mundo!"
+
+console.log(cadenaMundo.blink())
+console.log(cadenaMundo.bold())
+console.log(cadenaMundo.italics())
+console.log(cadenaMundo.strike())
+
+

Este ejemplo produce el mismo resultado que el siguiente código HTML:

+
<blink>¡Hola mundo!</blink>
+<b>¡Hola mundo!</b>
+<i>¡Hola mundo!</i>
+<strike>¡Hola mundo!</strike>
+
+

Vea También

+ diff --git a/files/es/web/javascript/reference/global_objects/string/charat/index.html b/files/es/web/javascript/reference/global_objects/string/charat/index.html new file mode 100644 index 0000000000..6ef6d46e37 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/charat/index.html @@ -0,0 +1,143 @@ +--- +title: String.prototype.charAt() +slug: Web/JavaScript/Referencia/Objetos_globales/String/charAt +tags: + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/charAt +--- +

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

+ +

Resumen

+ +

El método charAt() de {{jsxref("String")}} devuelve en un nuevo String el carácter UTF-16 de una cadena.

+ +

Sintaxis

+ +
str.charAt(indice)
+ +

Parámetros

+ +
+
indice
+
Un entero entre 0 y 1 menos que la longitud de la cadena. Si no se proporciona ningún indice charAt() utilizará 0.
+
+ +

Descripción

+ +

Los caracteres de una cadena se indexan de izquierda a derecha. El índice del primer caracter es 0, y el índice del último caracter en una cadena llamada nombreCadena es nombreCadena.length - 1. Si el indice que usted proporciona está fuera del rango, JavaScript devuelve una cadena vacía.

+ +

Ejemplos

+ +

Ejemplo: Mostrando caracteres de diferentes localizaciones en una cadena

+ +

El siguiente ejemplo muestra caracteres de diferentes localizaciones en la cadena "Brave new world":

+ +
var cualquierCadena="Brave new world";
+
+console.log("El carácter en el índice 0 es '" + cualquierCadena.charAt(0) + "'")
+console.log("El carácter en el índice 1 es '" + cualquierCadena.charAt(1) + "'")
+console.log("El carácter en el índice 2 es '" + cualquierCadena.charAt(2) + "'")
+console.log("El carácter en el índice 3 es '" + cualquierCadena.charAt(3) + "'")
+console.log("El carácter en el índice 4 es '" + cualquierCadena.charAt(4) + "'")
+console.log("El carácter en el índice 999 es '" + cualquierCadena.charAt(999) + "'")
+
+ +

Estas líneas muestran lo siguiente:

+ +
El carácter en el índice 0 es 'B'
+El carácter en el índice 1 es 'r'
+El carácter en el índice 2 es 'a'
+El carácter en el índice 3 es 'v'
+El carácter en el índice 4 es 'e'
+El carácter en el índice 999 es ''
+
+ +

Especificaciónes

+ + + + + + + + + + + + + + + + + + + + + + + + +
EspecificaciónEstadoComentario
ECMAScript 1st Edition.EstándarPrimera definición
{{SpecName('ES5.1', '#sec-15.5.4.4', 'String.prototype.charAt')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-string.prototype.charat', 'String.prototype.charAt')}}{{Spec2('ES6')}} 
+ +

Compatibilidad de 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() }}
+
+ +

Vea También

+ + diff --git a/files/es/web/javascript/reference/global_objects/string/charcodeat/index.html b/files/es/web/javascript/reference/global_objects/string/charcodeat/index.html new file mode 100644 index 0000000000..4eccf78f13 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/charcodeat/index.html @@ -0,0 +1,65 @@ +--- +title: String.prototype.charCodeAt() +slug: Web/JavaScript/Referencia/Objetos_globales/String/charCodeAt +tags: + - JavaScript + - Method + - Prototype + - String + - Unicode +translation_of: Web/JavaScript/Reference/Global_Objects/String/charCodeAt +--- +

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

+ +

Resumen

+ +

El charCodeAt() método devuelve un número indicando el valor Unicode del carácter en el índice proporcionado.

+ +

Sintaxis

+ +
cadena.charCodeAt(indice);
+
+ +

Parámetros

+ +
+
indice
+
Un entero entre 0 y 1 menos que la longitud de la cadena; si no se especifica, su valor predeterminado es 0.
+
+ +

Descripción

+ +

El rango del código Unicode va del 0 al 1,114,1110x10FFFF. Los primeros 128 códigos de Unicode encajan directamente con los códigos de caractéres de la codificación ASCII. Para información sobre Unicode, vea la Guía de JavaScript. Observe que charCodeAt siempre devolverá un valor menor de 65.536.

+ +

charCodeAt devuelve {{jsxref("NaN")}} si el indice proporcionado no está entre 0 y 1 menos de la longitud de la cadena.

+ +

En JavaScript 1.2 el método charCodeAt devuelve un número indicando el valor de la hoja de códigos ISO-Latin-1 del carácter correspondiente al índice proporcionado. El rango de la hoja de códigos ISO-Latin-1 va del 0 al 255. Del 0 al 127 encajan directamente con la hoja de códigos ASCII.

+ +

Ejemplos

+ +

Ejemplo: Usando charCodeAt

+ +

El siguiente ejemplo devuelve 65, el valor Unicode para A. 

+ +
"ABC".charCodeAt(0) // returns 65
+
+ +

El siguiente ejemplo devuelve 83.

+ +
"AaSdas".charCodeAt(2) // returns 83
+
+ +

teniendo en cuenta que 2 es la posicion de la letra. Si `S` fuera minuscula, el Unicode es diferente

+ +
"Aasdas".charCodeAt(2) // returns 115
+ +

 

+ +

Vea También

+ + diff --git a/files/es/web/javascript/reference/global_objects/string/codepointat/index.html b/files/es/web/javascript/reference/global_objects/string/codepointat/index.html new file mode 100644 index 0000000000..ae3fef3ec8 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/codepointat/index.html @@ -0,0 +1,127 @@ +--- +title: String.prototype.codePointAt() +slug: Web/JavaScript/Referencia/Objetos_globales/String/codePointAt +translation_of: Web/JavaScript/Reference/Global_Objects/String/codePointAt +--- +
{{JSRef}}
+ +
 
+ +
El método codePointAt() devuelve un entero no negativo que equivale al valor Unicode code point del carácter.
+ +

Sintaxis

+ +
str.codePointAt(indice)
+ +

Parámetros

+ +
+
indice
+
Índice del carácter en la cadena del que se quiere obtener el valor del Unicode code point.
+
+ +

Valor de retorno

+ +

Un número que equivale al valor code point del carácter especificado en el índice de la cadena; devuelve {{jsxref("undefined")}} si no se encuentra carácter en la posición especifica.

+ +

Description

+ +

If there is no element at the specified position, {{jsxref("undefined")}} is returned. If no UTF-16 surrogate pair begins at pos, the code unit at pos is returned.

+ +

Examples

+ +

Using codePointAt()

+ +
'ABC'.codePointAt(1);          // 66
+'\uD800\uDC00'.codePointAt(0); // 65536
+
+'XYZ'.codePointAt(42); // undefined
+
+ +

Polyfill

+ +

The following extends Strings to include the codePointAt() function as specified in ECMAScript 2015 for browsers not supporting it natively.

+ +
/*! http://mths.be/codepointat v0.1.0 by @mathias */
+if (!String.prototype.codePointAt) {
+  (function() {
+    'use strict'; // needed to support `apply`/`call` with `undefined`/`null`
+    var codePointAt = function(position) {
+      if (this == null) {
+        throw TypeError();
+      }
+      var string = String(this);
+      var size = string.length;
+      // `ToInteger`
+      var index = position ? Number(position) : 0;
+      if (index != index) { // better `isNaN`
+        index = 0;
+      }
+      // Account for out-of-bounds indices:
+      if (index < 0 || index >= size) {
+        return undefined;
+      }
+      // Get the first code unit
+      var first = string.charCodeAt(index);
+      var second;
+      if ( // check if it’s the start of a surrogate pair
+        first >= 0xD800 && first <= 0xDBFF && // high surrogate
+        size > index + 1 // there is a next code unit
+      ) {
+        second = string.charCodeAt(index + 1);
+        if (second >= 0xDC00 && second <= 0xDFFF) { // low surrogate
+          // http://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
+          return (first - 0xD800) * 0x400 + second - 0xDC00 + 0x10000;
+        }
+      }
+      return first;
+    };
+    if (Object.defineProperty) {
+      Object.defineProperty(String.prototype, 'codePointAt', {
+        'value': codePointAt,
+        'configurable': true,
+        'writable': true
+      });
+    } else {
+      String.prototype.codePointAt = codePointAt;
+    }
+  }());
+}
+
+ +

Specifications

+ + + + + + + + + + + + + + + + + + + +
SpecificationStatusComment
{{SpecName('ES2015', '#sec-string.prototype.codepointat', 'String.prototype.codePointAt')}}{{Spec2('ES2015')}}Initial definition.
{{SpecName('ESDraft', '#sec-string.prototype.codepointat', 'String.prototype.codePointAt')}}{{Spec2('ESDraft')}} 
+ +

Browser compatibility

+ + + +

{{Compat("javascript.builtins.String.codePointAt")}}

+ +

See also

+ + diff --git a/files/es/web/javascript/reference/global_objects/string/concat/index.html b/files/es/web/javascript/reference/global_objects/string/concat/index.html new file mode 100644 index 0000000000..d00ffce70e --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/concat/index.html @@ -0,0 +1,90 @@ +--- +title: String.prototype.concat() +slug: Web/JavaScript/Referencia/Objetos_globales/String/concat +tags: + - JavaScript + - Prototipo + - Referencia + - String + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/String/concat +--- +
{{JSRef}}
+ +

El método concat() combina dos o más cadenas de texto y devuelve una cadena de texto nueva.

+ +
{{EmbedInteractiveExample("pages/js/string-concat.html")}}
+ +

Sintaxis

+ +
str.concat(str2 [, ...strN])
+ +

Parámetros

+ +
+
str2 [, ...strN]
+
Cadenas que se concatenarán con str.
+
+ +

Valor devuelto

+ +

Una nueva cadena que contiene el texto combinado de las cadenas proporcionadas.

+ +

Descripción

+ +

La función concat() concatena los argumentos de tipo texto con la cadena de sobre la que se llama a la función y devuelve una nueva cadena de texto. Los cambios en la cadena original o la cadena devuelta no afectan al otro.

+ +

Si los argumentos no son de tipo texto, son convertidos a texto antes de concatenarlos

+ +

Rendimiento

+ +

Es altamente recomendado que se utilicen {{jsxref("Operators/Assignment_Operators", "operadores de asignación", "", 1)}} (+, +=) en lugar del método concat().

+ +

Ejemplos

+ +

Usando concat()

+ +

El siguiente ejemplo combina cadenas de texto en una nueva.

+ +
let hello = 'Hello, '
+console.log(hello.concat('Kevin', '. Have a nice day.'))
+// Hello, Kevin. Have a nice day.
+
+let greetList = ['Hello', ' ', 'Venkat', '!']
+"".concat(...greetList)  // "Hello Venkat!"
+
+"".concat({})    // [object Object]
+"".concat([])    // ""
+"".concat(null)  // "null"
+"".concat(true)  // "true"
+"".concat(4, 5)  // "45"
+
+
+ +

Especificaciones

+ + + + + + + + + + + + +
Especificación
{{SpecName('ESDraft', '#sec-string.prototype.concat', 'String.prototype.concat')}}
+ +

Compatibilidad con navegadores

+ + + +

{{Compat("javascript.builtins.String.concat")}}

+ +

Ver también

+ + diff --git a/files/es/web/javascript/reference/global_objects/string/endswith/index.html b/files/es/web/javascript/reference/global_objects/string/endswith/index.html new file mode 100644 index 0000000000..cbeac4f481 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/endswith/index.html @@ -0,0 +1,88 @@ +--- +title: String.prototype.endsWith() +slug: Web/JavaScript/Referencia/Objetos_globales/String/endsWith +tags: + - JavaScript + - Prototipo + - Referencia + - String + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/String/endsWith +--- +
{{JSRef}}
+ +

El método endsWith() determina si una cadena de texto termina con los caracteres de una cadena indicada, devolviendo true o false según corresponda.

+ +
{{EmbedInteractiveExample("pages/js/string-endswith.html")}}
+ +

Sintaxis

+ +
str.endsWith(searchString[, position])
+ +

Parámetros

+ +
+
searchString
+
Los caracteres a buscar hasta el final de la cadena str.
+
length {{optional_inline}}
+
Si se indica, se utiliza como el tamaño de str. Por defecto se usa str.length.
+
+ +

Valor devuelto

+ +

true si los caracteres proporcionados se encuentran al final de la cadena de texto; en caso contrario, false.

+ +

Descripción

+ +

Este método determina si una cadena de texto termina en otra cadena o no. Este método distingue entre mayúsculas y minúsculas.

+ +

Polyfill

+ +

Este método ha sido añadido a la especificación ECMAScript 6 y puede no estar disponible en todas las implementaciones de JavaScript. Sin embargo, puedes implementar el polyfill String.prototype.endsWith() con el siguiente fragmento de código:

+ +
if (!String.prototype.endsWith) {
+	String.prototype.endsWith = function(search, this_len) {
+		if (this_len === undefined || this_len > this.length) {
+			this_len = this.length;
+		}
+		return this.substring(this_len - search.length, this_len) === search;
+	};
+}
+
+ +

Ejemplos

+ +

Usando endsWith()

+ +
let str = 'To be, or not to be, that is the question.'
+
+console.log(str.endsWith('question.'))  // true
+console.log(str.endsWith('to be'))      // false
+console.log(str.endsWith('to be', 19))  // true
+
+ +

Especificaciones

+ + + + + + + + + + +
Specification
{{SpecName('ESDraft', '#sec-string.prototype.endswith', 'String.prototype.endsWith')}}
+ +

Compatibilidad en navegadores

+ +

{{Compat("javascript.builtins.String.endsWith")}}

+ +

Ver también

+ + diff --git a/files/es/web/javascript/reference/global_objects/string/fixed/index.html b/files/es/web/javascript/reference/global_objects/string/fixed/index.html new file mode 100644 index 0000000000..3d188bc39d --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/fixed/index.html @@ -0,0 +1,35 @@ +--- +title: String.prototype.fixed() +slug: Web/JavaScript/Referencia/Objetos_globales/String/fixed +tags: + - Deprecated + - HTML wrapper methods + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/fixed +--- +

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

+

{{deprecated_header}}

+

Resumen

+

Causa que una cadena se muestre con una fuente de ancho fijo, como si estuviesde dentro de una etiqueta {{HTMLElement("tt")}}.

+

Sintaxis

+
cadena.fixed()
+

Descripción

+

Usa el método fixed para formatear y mostrar unacadena en un documento.

+

Ejemplos

+

Ejemplo: Usando fixed para cambiar el formateado de una cadena

+

El siguiente ejemplo usa el método fixed para cambiar el formateado de una cadena:

+
var cadenaMundo="¡Hola Mundo!"
+console.log(cadenaMundo.fixed())
+
+

Este ejemplo produce el mismo resultado que el siguiente código HTML:

+
<tt>¡Hola Mundo!</tt>
+
+

Vea También

+ diff --git a/files/es/web/javascript/reference/global_objects/string/fontcolor/index.html b/files/es/web/javascript/reference/global_objects/string/fontcolor/index.html new file mode 100644 index 0000000000..135e805cb2 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/fontcolor/index.html @@ -0,0 +1,122 @@ +--- +title: String.prototype.fontcolor() +slug: Web/JavaScript/Referencia/Objetos_globales/String/fontcolor +translation_of: Web/JavaScript/Reference/Global_Objects/String/fontcolor +--- +
{{JSRef}} {{deprecated_header}}
+ +

El método fontcolor() crea {{HTMLElement("font")}} elemento HTML que cambia el color de la cadena.

+ +
+

Usage note: La etiqueta <font> fue eliminada en HTML5 y no debe ser usada. En lugar de es, es necesario aplicar propiedades CSS.

+
+ +

Sintaxis

+ +
str.fontcolor(color)
+ +

Parametros

+ +
+
color
+
A string expressing the color as a hexadecimal RGB triplet or as a string literal. String literals for color names are listed in the CSS color reference.
+
+ +

Descripción

+ +

Si expresas el color como hexadecimal, usa el formato rrggbb. Por ejemplo, el color hexadecimal para salmón es R=FA, G=80, B=72, así que el valor será "FA8072".

+ +

Ejemplos

+ +

Usos fontcolor()

+ +

Los siguientes ejemplos usan el método fontcolor() para cambiar el color de una cadena.

+ +
var worldString = 'Hello, world';
+
+console.log(worldString.fontcolor('red') +  ' en rojo');
+// '<font color="red">Hello, world</font> en rojo'
+
+console.log(worldString.fontcolor('FF00') + ' es rojo en hexadecimal');
+// '<font color="FF00">Hello, world</font> es rojo en hexadecimal'
+
+ +

Con el objeto {{domxref("HTMLElement.style", "element.style")}} obtienes el atributo style y manipularlo:

+ +
document.getElementById('yourElemId').style.color = 'red';
+
+ +

Especificaciones

+ + + + + + + + + + + + + + +
EspecificaciónEstatusComentario
{{SpecName('ES6', '#sec-string.prototype.fontcolor', 'String.prototype.fontcolor')}}{{Spec2('ES6')}}Initial definition. Implemented in JavaScript 1.0. Defined in the (normative) Annex B for Additional ECMAScript Features for Web Browsers.
+ +

Compatibilidad con navegadores

+ +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + +
CaracterísticaChromeFirefox (Gecko)Internet ExplorerOperaSafari
Soporte Basico{{CompatVersionUnknown}}{{CompatGeckoDesktop("1.0")}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
CaracterísticaAndroidChrome para AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Soporte Basico{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatGeckoMobile("1.0")}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +

Ver también

+ + diff --git a/files/es/web/javascript/reference/global_objects/string/fontsize/index.html b/files/es/web/javascript/reference/global_objects/string/fontsize/index.html new file mode 100644 index 0000000000..212c49d638 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/fontsize/index.html @@ -0,0 +1,123 @@ +--- +title: String.prototype.fontsize() +slug: Web/JavaScript/Referencia/Objetos_globales/String/fontsize +translation_of: Web/JavaScript/Reference/Global_Objects/String/fontsize +--- +
{{JSRef}} {{deprecated_header}}
+ +

El método fontsize() crea {{HTMLElement("font")}} elemento HTML que muestra una cadena con el tamaño especificado.

+ +
+

Usage note: El elemento <font> ha sido eliminado HTML5 y no se debe usar. Los desarrolladores web deben usar propiedades CSS.

+
+ +

Sintaxis

+ +
str.fontsize(size)
+ +

Parámetros

+ +
+
size
+
Un entero entre 1 y 7.
+
+ +

Descripción

+ +

Cuando especificas el tamaño como entero, estableces el tamaño de la fuente. Cuando especificas el tamaño como cadena tal como "-2", se ajusta el tamaño de la fuente al de la etiqueta {{HTMLElement("basefont")}}.

+ +

When you specify size as an integer, you set the font size of str to one of the 7 defined sizes. When you specify size as a string such as "-2", you adjust the font size of str relative to the size set in the {{HTMLElement("basefont")}} tag.

+ +

Ejemlpos

+ +

Usos fontsize()

+ +

The following example uses string methods to change the size of a string:

+ +
var worldString = 'Hello, world';
+
+console.log(worldString.small());     // <small>Hello, world</small>
+console.log(worldString.big());       // <big>Hello, world</big>
+console.log(worldString.fontsize(7)); // <font size="7">Hello, world</fontsize>
+
+ +

With the {{domxref("HTMLElement.style", "element.style")}} object you can get the element's style attribute and manipulate it more generically, for example:

+ +
document.getElementById('yourElemId').style.fontSize = '0.7em';
+
+ +

Specifications

+ + + + + + + + + + + + + + +
SpecificationStatusComment
{{SpecName('ES6', '#sec-string.prototype.fontsize', 'String.prototype.fontsize')}}{{Spec2('ES6')}}Initial definition. Implemented in JavaScript 1.0. Defined in the (normative) Annex B for Additional ECMAScript Features for Web Browsers.
+ +

Browser compatibility

+ +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Basic support{{CompatVersionUnknown}}{{CompatGeckoDesktop("1.0")}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Basic support{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatGeckoMobile("1.0")}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +

See also

+ + diff --git a/files/es/web/javascript/reference/global_objects/string/fromcharcode/index.html b/files/es/web/javascript/reference/global_objects/string/fromcharcode/index.html new file mode 100644 index 0000000000..7e87f3d90d --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/fromcharcode/index.html @@ -0,0 +1,130 @@ +--- +title: String.fromCharCode() +slug: Web/JavaScript/Referencia/Objetos_globales/String/fromCharCode +tags: + - JavaScript + - Method + - String + - Unicode +translation_of: Web/JavaScript/Reference/Global_Objects/String/fromCharCode +--- +

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

+ +

Resumen

+ +

El String.fromCharCode() método estático que devuelve una cadena creada mediante el uso de una secuencia de valores Unicode especificada.

+ +

Sintaxis

+ +
String.fromCharCode(num1, ..., numN)
+ +

Parámetros

+ +
+
num1, ..., numN
+
Secuencia de números con los valores Unicode.
+
+ +

Descripción

+ +

Este método devuelve una cadena y no un objeto String.

+ +

Debido a que fromCharCode es un método estático de String, usted siempre lo usará como String.fromCharCode(), en vez de un método de un objeto String creado por usted.

+ +

Ejemplos

+ +

Ejemplo: Usando fromCharCode

+ +

El siguiene ejemplo devuelve la cadena "ABC".

+ +
String.fromCharCode(65,66,67)
+
+ +

Especificaciónes

+ + + + + + + + + + + + + + + + + + + + + + + + +
EspecificaciónEstatusComentario
ECMAScript 1st Edition.EstándarPrimera definicíon
+ Implementada en JavaScript 1.2
{{SpecName('ES5.1', '#sec-15.5.3.2', 'StringfromCharCode')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-string.fromcharcodes', 'String.fromCharCode')}}{{Spec2('ES6')}} 
+ +

Compatibilidad de 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() }}
+
+ +

Vea También

+ + diff --git a/files/es/web/javascript/reference/global_objects/string/fromcodepoint/index.html b/files/es/web/javascript/reference/global_objects/string/fromcodepoint/index.html new file mode 100644 index 0000000000..39fe662b75 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/fromcodepoint/index.html @@ -0,0 +1,204 @@ +--- +title: String.fromCodePoint() +slug: Web/JavaScript/Referencia/Objetos_globales/String/fromCodePoint +translation_of: Web/JavaScript/Reference/Global_Objects/String/fromCodePoint +--- +
{{JSRef("Global_Objects", "String")}}
+ +

Resumen

+ +

El método estatico String.fromCodePoint() devuelve una cadena creada por una secuencia de puntos de codigo.

+ +

Sintaxis

+ +
String.fromCodePoint(num1[, ...[, numN]])
+ +

Parametros

+ +
+
num1, ..., numN
+
Una secuencia de puntos de código.
+
+ +

Throws

+ +
+
{{jsxref("Global_Objects/RangeError", "RangeError")}}
+
A {{jsxref("Global_Objects/RangeError", "RangeError")}} is thrown if an invalid Unicode code point is given (e.g. "RangeError: NaN is not a valid code point").
+
+ +

Descripción

+ +

Because fromCodePoint() is a static method of {{jsxref("Global_Objects/String", "String")}}, you always use it as String.fromCodePoint(), rather than as a method of a {{jsxref("Global_Objects/String", "String")}} object you created.

+ +

Ejemplos

+ +

Ejemplos: Usando fromCodePoint()

+ +
String.fromCodePoint(42);       // "*"
+String.fromCodePoint(65, 90);   // "AZ"
+String.fromCodePoint(0x404);    // "\u0404"
+String.fromCodePoint(0x2F804);  // "\uD87E\uDC04"
+String.fromCodePoint(194564);   // "\uD87E\uDC04"
+String.fromCodePoint(0x1D306, 0x61, 0x1D307) // "\uD834\uDF06a\uD834\uDF07"
+
+String.fromCodePoint('_');      // RangeError
+String.fromCodePoint(Infinity); // RangeError
+String.fromCodePoint(-1);       // RangeError
+String.fromCodePoint(3.14);     // RangeError
+String.fromCodePoint(3e-2);     // RangeError
+String.fromCodePoint(NaN);      // RangeError
+
+ +
// String.fromCharCode() alone cannot get the character at such a high code point
+// The following, on the other hand, can return a 4-byte character as well as the
+// usual 2-byte ones (i.e., it can return a single character which actually has
+// a string length of 2 instead of 1!)
+console.log(String.fromCodePoint(0x2F804)); // or 194564 in decimal
+
+ +

Polyfill

+ +

The String.fromCodePoint method has been added to the ECMAScript standard in version 6 and may not be supported in all web browsers or environments yet. Use the code below for a polyfill:

+ +
/*! http://mths.be/fromcodepoint v0.1.0 by @mathias */
+if (!String.fromCodePoint) {
+  (function() {
+    var defineProperty = (function() {
+      // IE 8 only supports `Object.defineProperty` on DOM elements
+      try {
+        var object = {};
+        var $defineProperty = Object.defineProperty;
+        var result = $defineProperty(object, object, object) && $defineProperty;
+      } catch(error) {}
+      return result;
+    }());
+    var stringFromCharCode = String.fromCharCode;
+    var floor = Math.floor;
+    var fromCodePoint = function() {
+      var MAX_SIZE = 0x4000;
+      var codeUnits = [];
+      var highSurrogate;
+      var lowSurrogate;
+      var index = -1;
+      var length = arguments.length;
+      if (!length) {
+        return '';
+      }
+      var result = '';
+      while (++index < length) {
+        var codePoint = Number(arguments[index]);
+        if (
+          !isFinite(codePoint) ||       // `NaN`, `+Infinity`, or `-Infinity`
+          codePoint < 0 ||              // not a valid Unicode code point
+          codePoint > 0x10FFFF ||       // not a valid Unicode code point
+          floor(codePoint) != codePoint // not an integer
+        ) {
+          throw RangeError('Invalid code point: ' + codePoint);
+        }
+        if (codePoint <= 0xFFFF) { // BMP code point
+          codeUnits.push(codePoint);
+        } else { // Astral code point; split in surrogate halves
+          // http://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
+          codePoint -= 0x10000;
+          highSurrogate = (codePoint >> 10) + 0xD800;
+          lowSurrogate = (codePoint % 0x400) + 0xDC00;
+          codeUnits.push(highSurrogate, lowSurrogate);
+        }
+        if (index + 1 == length || codeUnits.length > MAX_SIZE) {
+          result += stringFromCharCode.apply(null, codeUnits);
+          codeUnits.length = 0;
+        }
+      }
+      return result;
+    };
+    if (defineProperty) {
+      defineProperty(String, 'fromCodePoint', {
+        'value': fromCodePoint,
+        'configurable': true,
+        'writable': true
+      });
+    } else {
+      String.fromCodePoint = fromCodePoint;
+    }
+  }());
+}
+
+ +

Specifications

+ + + + + + + + + + + + + + +
SpecificationStatusComment
{{SpecName('ES6', '#sec-string.fromcodepoint', 'String.fromCodePoint')}}{{Spec2('ES6')}}Initial definition.
+ +

Browser compatibility

+ +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Basic support41{{CompatGeckoDesktop("29")}}{{CompatNo}}{{CompatNo}}{{CompatNo}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Basic support{{CompatNo}}{{CompatNo}}{{CompatGeckoMobile("29")}}{{CompatNo}}{{CompatNo}}{{CompatNo}}
+
+ +

See also

+ + diff --git a/files/es/web/javascript/reference/global_objects/string/includes/index.html b/files/es/web/javascript/reference/global_objects/string/includes/index.html new file mode 100644 index 0000000000..094a3fd648 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/includes/index.html @@ -0,0 +1,108 @@ +--- +title: String.prototype.includes() +slug: Web/JavaScript/Referencia/Objetos_globales/String/includes +tags: + - Cadena de texto + - JavaScript + - Prototipo + - Referencia + - String + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/String/includes +--- +
{{JSRef}}
+ +

El método includes() determina si una cadena de texto puede ser encontrada dentro de otra cadena de texto, devolviendo true o false según corresponda.

+ +
{{EmbedInteractiveExample("pages/js/string-includes.html", "shorter")}}
+ +

Sintaxis

+ +
str.includes(searchString[, position])
+ +

Parametros

+ +
+
searchString
+
Una cadena a buscar en el texto str.
+
position {{optional_inline}}
+
La posición dentro de la cadena en la cual empieza la búsqueda de searchString (Por defecto este valor es 0).
+
+ +

Valor devuelto

+ +

true si la cadena de texto contiene la cadena buscada; en caso contrario, false.

+ +

Descripción

+ +

Este método permite determinar si una cadena de texto se encuentra incluida dentro de la otra.

+ +

Sensibilidad a Mayúsculas/Minúsculas

+ +

El método includes() es "case sensitive" (tiene en cuenta mayúsculas y minúsculas). Por ejemplo, la siguiente expresión devolverá false:

+ +
'Ballena azul'.includes('ballena'); // devuelve false
+
+ +

Polyfill

+ +

Este método ha sido agregado a la especificación ECMAScript 2015 y puede no estar  disponible en toda las implementaciones de JavaScript.

+ +

Sin embargo, puedes usar este método como polyfill:

+ +
if (!String.prototype.includes) {
+  String.prototype.includes = function(search, start) {
+    'use strict';
+
+    if (search instanceof RegExp) {
+      throw TypeError('first argument must not be a RegExp');
+    }
+    if (start === undefined) { start = 0; }
+    return this.indexOf(search, start) !== -1;
+  };
+}
+
+ +

Ejemplos

+ +

Usando includes()

+ +
const str = 'To be, or not to be, that is the question.'
+
+console.log(str.includes('To be'))        // true
+console.log(str.includes('question'))     // true
+console.log(str.includes('nonexistent'))  // false
+console.log(str.includes('To be', 1))     // false
+console.log(str.includes('TO BE'))        // false
+console.log(str.includes(''))             // true
+
+ +

Especificaciones

+ + + + + + + + + + + + +
Specification
{{SpecName('ESDraft', '#sec-string.prototype.includes', 'String.prototype.includes')}}
+ +

Compatibilidad en navegadores

+ +

{{Compat("javascript.builtins.String.includes")}}

+ +

Ver también

+ + diff --git a/files/es/web/javascript/reference/global_objects/string/index.html b/files/es/web/javascript/reference/global_objects/string/index.html new file mode 100644 index 0000000000..a6c5aea8e3 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/index.html @@ -0,0 +1,385 @@ +--- +title: String — Cadena de caracteres +slug: Web/JavaScript/Referencia/Objetos_globales/String +tags: + - Clase + - Class + - ECMAScript 2015 + - JavaScript + - Referencia + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String +--- +
{{JSRef}}
+ +

El objeto String se utiliza para representar y manipular una secuencia de caracteres.

+ +

Descripción

+ +

Las cadenas son útiles para almacenar datos que se pueden representar en forma de texto. Algunas de las operaciones más utilizadas en cadenas son verificar su {{jsxref("String.length", "length")}}, para construirlas y concatenarlas usando operadores de cadena + y +=, verificando la existencia o ubicación de subcadenas con {{jsxref("String.prototype.indexOf()", "indexOf()")}} o extraer subcadenas con el método {{jsxref("String.prototype.substring()", "substring()")}}.

+ +

Crear cadenas

+ +

Las cadenas se pueden crear como primitivas, a partir de cadena literales o como objetos, usando el constructor {{jsxref("String/String", "String()")}}:

+ +
const string1 = "Una cadena primitiva";
+const string2 = 'También una cadena primitiva';
+const string3 = `Otra cadena primitiva más`;
+ +
const string4 = new String("Un objeto String");
+
+ +

Las strings primitivas y los objetos string se pueden usar indistintamente en la mayoría de las situaciones. Consulta "Primitivas String y objetos String" a continuación.

+ +

Los cadena literales se pueden especificar usando comillas simples o dobles, que se tratan de manera idéntica, o usando el carácter de comilla invertida `. Esta última forma especifica una Plantilla literal: con esta forma puedes interpolar expresiones.

+ +

Acceder a un caracter

+ +

Hay dos formas de acceder a un caracter individual en una cadena. La primera es con el método {{jsxref("String.prototype.charAt()", "charAt()")}}:

+ +
return 'cat'.charAt(1) // devuelve "a"
+
+ +

La otra forma (introducida en ECMAScript 5) es tratar a la cadena como un objeto similar a un arreglo, donde los caracteres individuales corresponden a un índice numérico:

+ +
return 'cat'[1] // devuelve "a"
+
+ +

Cuando se usa la notación entre corchetes para acceder a los caracteres, no se puede intentar eliminar o asignar un valor a estas propiedades. Las propiedades involucradas no se pueden escribir ni configurar. (Ve {{jsxref("Object.defineProperty()")}} para más información).

+ +

Comparar cadenas

+ +

En C, se usa la función strcmp() para comparar cadenas. En JavaScript, solo usas los operadores menor que y mayor que:

+ +
let a = 'a'
+let b = 'b'
+if (a < b) { // true
+  console.log(a + ' es menor que ' + b)
+} else if (a > b) {
+  console.log(a + ' es mayor que ' + b)
+} else {
+  console.log(a + ' y ' + b + ' son iguales.')
+}
+
+ +

Puedes lograr un resultado similar usando el método {{jsxref("String.prototype.localeCompare()", "localeCompare()")}} heredado por las instancias de String.

+ +

Ten en cuenta que a == b compara las cadenas en a y b por ser igual en la forma habitual que distingue entre mayúsculas y minúsculas. Si deseas comparar sin tener en cuenta los caracteres en mayúsculas o minúsculas, usa una función similar a esta:

+ +
function isEqual(str1, str2)
+{
+    return str1.toUpperCase() === str2.toUpperCase()
+} // isEqual
+
+ +

En esta función se utilizan mayúsculas en lugar de minúsculas, debido a problemas con ciertas conversiones de caracteres UTF-8.

+ +

Primitivas String y objetos String

+ +

Ten en cuenta que JavaScript distingue entre objetos String y valores de {{Glossary("Primitive", "primitivas string")}}. (Lo mismo ocurre con {{jsxref("Boolean", "Booleanos")}} y {{jsxref("Global_Objects/Number", "Números")}}).

+ +

Las cadenas literales (denotadas por comillas simples o dobles) y cadenas devueltas de llamadas a String en un contexto que no es de constructor (es decir, llamado sin usar la palabra clave {{jsxref("Operators/new", "new")}}) son cadenas primitivas. JavaScript automáticamente convierte las primitivas en objetos String, por lo que es posible utilizar métodos del objeto String en cadenas primitivas. En contextos donde se va a invocar a un método en una cadena primitiva o se produce una búsqueda de propiedad, JavaScript ajustará automáticamente la cadena primitiva y llamará al método o realizará la búsqueda de la propiedad.

+ +
let s_prim = 'foo'
+let s_obj = new String(s_prim)
+
+console.log(typeof s_prim) // Registra "string"
+console.log(typeof s_obj)  // Registra "object"
+
+ +

Las primitivas de String y los objetos String también dan diferente resultado cuando se usa {{jsxref("Global_Objects/eval", "eval()")}}. Las primitivas pasadas a eval se tratan como código fuente; Los objetos String se tratan como todos los demás objetos, devuelven el objeto. Por ejemplo:

+ +
let s1 = '2 + 2'              // crea una string primitiva
+let s2 = new String('2 + 2')  // crea un objeto String
+console.log(eval(s1))         // devuelve el número 4
+console.log(eval(s2))         // devuelve la cadena "2 + 2"
+
+ +

Por estas razones, el código se puede romper cuando encuentra objetos String y espera una string primitiva en su lugar, aunque generalmente los autores no necesitan preocuparse por la distinción.

+ +

Un objeto String siempre se puede convertir a su contraparte primitiva con el método {{jsxref("String.prototype.valueOf()", "valueOf()")}}.

+ +
console.log(eval(s2.valueOf()))  // devuelve el número 4
+
+ +

Notación de escape

+ +

Los caracteres especiales se pueden codificar mediante notación de escape:

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
CódigoSalida
\XXX
+ (donde XXX es de 1 a 3 dígitos octales; rango de 0-377)		Punto de código Unicode/carácter ISO-8859-1 entre U+0000 y U+00FF
\'Comilla sencilla
\"Comilla doble
\\Barra inversa
\nNueva línea
\rRetorno de carro
\vTabulación vertical
\tTabulación
\bRetroceso
\fAvance de página
\uXXXX (donde XXXX son 4 dígitos hexadecimales; rango de 0x0000-0xFFFF)Unidad de código UTF-16/punto de código Unicode entre U+0000 y U+FFFF
\u{X} ... \u{XXXXXX}
+ (donde X…XXXXXX es de 1 a 6 dígitos hexadecimales; rango de 0x0-0x10FFFF)		Unidad de código UTF-32/punto de código Unicode entre U+0000 y U+10FFFF
\xXX
+ (donde XX son 2 dígitos hexadecimales; rango de 0x00-0xFF)		Punto de código Unicode/carácter ISO-8859-1 entre U+0000 y U+00FF
+ +

Cadenas literales largas

+ +

A veces, tu código incluirá cadenas que son muy largas. En lugar de tener líneas que se prolongan interminablemente o que se ajustan según el capricho de tu editor, es posible que desees dividir específicamente la cadena en varias líneas en el código fuente sin afectar el contenido real de la cadena. hay dos maneras de conseguirlo.

+ +

Método 1

+ +

Puedes usar el operador + para agregar varias cadenas juntas, así:

+ +
let longString = "Esta es una cadena muy larga que necesita " +
+                 "que dividimos en varias líneas porque " +
+                 "de lo contrario, mi código es ilegible."
+
+ +

Método 2

+ +

Puedes usar el caracter de barra invertida (\) al final de cada línea para indicar que la cadena continúa en la siguiente línea. Asegúrate de que no haya ningún espacio ni ningún otro carácter después de la barra invertida (a excepción de un salto de línea) o como sangría; de lo contrario, no trabajará.

+ +

Esa forma se ve así:

+ +
let longString = "Esta es una cadena muy larga que necesita \
+que dividimos en varias líneas porque \
+de lo contrario, mi código es ilegible."
+
+ +

Ambos métodos anteriores dan como resultado cadenas idénticas.

+ +

Constructor

+ +
+
{{jsxref("String/String", "String()")}}
+
Crea un nuevo objeto String. Realiza la conversión de tipos cuando se llama como función, en lugar de como constructor, lo cual suele ser más útil.
+
+ +

Métodos estáticos

+ +
+
{{jsxref("String.fromCharCode()", "String.fromCharCode(num1 [, ...[, numN]])")}}
+
Devuelve una cadena creada utilizando la secuencia de valores Unicode especificada.
+
{{jsxref("String.fromCodePoint()", "String.fromCodePoint(num1 [, ...[, numN]])")}}
+
Devuelve una cadena creada utilizando la secuencia de puntos de código especificada.
+
{{jsxref("String.raw()")}}
+
Devuelve una cadena creada a partir de una plantilla literal sin formato.
+
+ +

Propiedades de la instancia

+ +
+
{{jsxref("String.prototype.length")}}
+
Refleja la length de la cadena. Solo lectura.
+
+ +

Métodos de instancia

+ +
+
{{jsxref("String.prototype.charAt()", "String.prototype.charAt(index)")}}
+
Devuelve el caracter (exactamente una unidad de código UTF-16) en el index especificado.
+
{{jsxref("String.prototype.charCodeAt()", "String.prototype.charCodeAt(index)")}}
+
Devuelve un número que es el valor de la unidad de código UTF-16 en el index dado.
+
{{jsxref("String.prototype.codePointAt()", "String.prototype.codePointAt(pos)")}}
+
Devuelve un número entero no negativo que es el valor del punto de código del punto de código codificado en UTF-16 que comienza en la pos especificada.
+
{{jsxref("String.prototype.concat()", "String.prototype.concat(str[, ...strN])")}}
+
Combina el texto de dos (o más) cadenas y devuelve una nueva cadena.
+
{{jsxref("String.prototype.includes()", "String.prototype.includes(searchString [, position])")}}
+
Determina si la cadena de la llamada contiene searchString.
+
{{jsxref("String.prototype.endsWith()", "String.prototype.endsWith(searchString[, length])")}}
+
Determina si una cadena termina con los caracteres de la cadena searchString.
+
{{jsxref("String.prototype.indexOf()", "String.prototype.indexOf(searchValue[, fromIndex])")}}
+
Devuelve el índice dentro del objeto {{jsxref("String")}} llamador de la primera aparición de searchValue, o -1 si no lo encontró.
+
{{jsxref("String.prototype.lastIndexOf()", "String.prototype.lastIndexOf(searchValue[, fromIndex])")}}
+
Devuelve el índice dentro del objeto {{jsxref("String")}} llamador de la última aparición de searchValue, o -1 si no lo encontró.
+
{{jsxref("String.prototype.localeCompare()", "String.prototype.localeCompare(compareString[, locales[, options]])")}}
+
Devuelve un número que indica si la cadena de referencia compareString viene antes, después o es equivalente a la cadena dada en el orden de clasificación.
+
{{jsxref("String.prototype.match()", "String.prototype.match(regexp)")}}
+
Se utiliza para hacer coincidir la expresión regular regexp con una cadena.
+
{{jsxref("String.prototype.matchAll()", "String.prototype.matchAll(regexp)")}}
+
Devuelve un iterador de todas las coincidencias de regexp.
+
{{jsxref("String.prototype.normalize()", "String.prototype.normalize([form])")}}
+
Devuelve la forma de normalización Unicode del valor de la cadena llamada.
+
{{jsxref("String.prototype.padEnd()", "String.prototype.padEnd(targetLength[, padString])")}}
+
Rellena la cadena actual desde el final con una cadena dada y devuelve una nueva cadena de longitud targetLength.
+
{{jsxref("String.prototype.padStart()", "String.prototype.padStart(targetLength[, padString])")}}
+
Rellena la cadena actual desde el principio con una determinada cadena y devuelve una nueva cadena de longitud targetLength.
+
{{jsxref("String.prototype.repeat()", "String.prototype.repeat(count)")}}
+
Devuelve una cadena que consta de los elementos del objeto repetidos count veces.
+
{{jsxref("String.prototype.replace()" , "String.prototype.replace(searchFor, replaceWith)")}}
+
Se usa para reemplazar ocurrencias de searchFor usando replaceWith. searchFor puede ser una cadena o expresión regular, y replaceWith puede ser una cadena o función.
+
{{jsxref("String.prototype.replaceAll()", "String.prototype.replaceAll(searchFor, replaceWith)")}}
+
Se utiliza para reemplazar todas las apariciones de searchFor usando replaceWith. searchFor puede ser una cadena o expresión regular, y replaceWith puede ser una cadena o función.
+
{{jsxref("String.prototype.search()", "String.prototype.search(regexp)")}}
+
Busca una coincidencia entre una expresión regular regexp y la cadena llamadora.
+
{{jsxref("String.prototype.slice()", "String.prototype.slice(beginIndex[, endIndex])")}}
+
Extrae una sección de una cadena y devuelve una nueva cadena.
+
{{jsxref("String.prototype.split()", "String.prototype.split([sep[, limit] ])")}}
+
Devuelve un arreglo de cadenas pobladas al dividir la cadena llamadora en las ocurrencias de la subcadena sep.
+
{{jsxref("String.prototype.startsWith()", "String.prototype.startsWith(searchString[, length])")}}
+
Determina si la cadena llamadora comienza con los caracteres de la cadena searchString.
+
{{jsxref("String.prototype.substr()")}}
+
Devuelve los caracteres en una cadena que comienza en la ubicación especificada hasta el número especificado de caracteres.
+
{{jsxref("String.prototype.substring()", "String.prototype.substring(indexStart[, indexEnd])")}}
+
Devuelve una nueva cadena que contiene caracteres de la cadena llamadora de (o entre) el índice (o indeces) especificados.
+
{{jsxref("String.prototype.toLocaleLowerCase()", "String.prototype.toLocaleLowerCase( [locale, ...locales])")}}
+
+

Los caracteres dentro de una cadena se convierten a minúsculas respetando la configuración regional actual.

+ +

Para la mayoría de los idiomas, devolverá lo mismo que {{jsxref("String.prototype.toLowerCase()", "toLowerCase()")}}.

+
+
{{jsxref("String.prototype.toLocaleUpperCase()", "String.prototype.toLocaleUpperCase( [locale, ...locales])")}}
+
+

Los caracteres dentro de una cadena se convierten a mayúsculas respetando la configuración regional actual.

+ +

Para la mayoría de los idiomas, devolverá lo mismo que {{jsxref("String.prototype.toUpperCase()", "toUpperCase()")}}.

+
+
{{jsxref("String.prototype.toLowerCase()")}}
+
Devuelve el valor de la cadena llamadora convertido a minúsculas.
+
{{jsxref("String.prototype.toString()")}}
+
Devuelve una cadena que representa el objeto especificado. Redefine el método {{jsxref("Object.prototype.toString()")}}.
+
{{jsxref("String.prototype.toUpperCase()")}}
+
Devuelve el valor de la cadena llamadora convertido a mayúsculas.
+
{{jsxref("String.prototype.trim()")}}
+
Recorta los espacios en blanco desde el principio y el final de la cadena. Parte del estándar ECMAScript 5.
+
{{jsxref("String.prototype.trimStart()")}}
+
Recorta los espacios en blanco desde el principio de la cadena.
+
{{jsxref("String.prototype.trimEnd()")}}
+
Recorta los espacios en blanco del final de la cadena.
+
{{jsxref("String.prototype.valueOf()")}}
+
Devuelve el valor primitivo del objeto especificado. Redefine el método {{jsxref("Object.prototype.valueOf()")}}.
+
{{jsxref("String.prototype.@@iterator()")}}
+
Devuelve un nuevo objeto Iterator que itera sobre los puntos de código de un valor de cadena, devolviendo cada punto de código como un valor de cadena.
+
+ +

Métodos de contenedor HTML

+ +
+
+

Desaprobado. Evita estos métodos.

+ +

Son de uso limitado, ya que proporcionan solo un subconjunto de las etiquetas y atributos HTML disponibles.

+
+ +
+
{{jsxref("String.prototype.anchor()")}}
+
{{htmlattrxref("name", "a", "<a name=\"name\">")}} (hipertexto destino)
+
{{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()")}}
+
{{htmlattrxref("color", "font", "<font color=\"color\">")}}
+
{{jsxref("String.prototype.fontsize()")}}
+
{{htmlattrxref("size", "font", "<font size=\"size\">")}}
+
{{jsxref("String.prototype.italics()")}}
+
{{HTMLElement("i")}}
+
{{jsxref("String.prototype.link()")}}
+
{{htmlattrxref("href", "a", "<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")}}
+
+
+ +

Ejemplos

+ +

Conversión de cadenas

+ +

Es posible usar String como una alternativa más confiable de {{jsxref("String.prototype.toString()", "toString()")}}, ya que funciona cuando se usa en {{jsxref( "null")}}, {{jsxref("undefined")}} y en {{jsxref("Symbol", "símbolos")}}. Por ejemplo:

+ +
let outputStrings = []
+for (let i = 0, n = inputValues.length; i < n; ++i) {
+  outputStrings.push(String(inputValues[i]));
+}
+
+ +

Especificaciones

+ + + + + + + + + + + + +
Especificación
{{SpecName('ESDraft', '#sec-string-objects', 'String')}}
+ +

Compatibilidad del navegador

+ + + +

{{Compat("javascript.builtins.String")}}

+ +

Ve también

+ + diff --git a/files/es/web/javascript/reference/global_objects/string/indexof/index.html b/files/es/web/javascript/reference/global_objects/string/indexof/index.html new file mode 100644 index 0000000000..14f7b01eb8 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/indexof/index.html @@ -0,0 +1,104 @@ +--- +title: String.prototype.indexOf() +slug: Web/JavaScript/Referencia/Objetos_globales/String/indexOf +tags: + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/indexOf +--- +

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

+ +

Resumen

+ +

El método indexOf()devuelve el índice, dentro del objeto String que realiza la llamada, de la primera ocurrencia del valor especificado, comenzando la búsqueda desde indiceDesde; o -1 si no se encuentra dicho valor.

+ +

Sintaxis

+ +
cadena.indexOf(valorBusqueda[, indiceDesde])
+ +

Parámetros

+ +
+
valorBusqueda
+
Una cadena que representa el valor de búsqueda.
+
+ +
+
indiceDesde
+
La localización dentro de la cadena llamada desde la que empezará la búsqueda. Puede ser un entero entre 0 y la longitud de la cadena. El valor predeterminado es 0.
+
+ +

Descripción

+ +

Los caracteres de una cadena se indexan de izquierda a derecha. El índice del primer carácter es 0, y el índice del último carácter de una cadena llamada nombreCadena es nombreCadena.length - 1.

+ +
"Blue Whale".indexOf("Blue")    // returns 0
+"Blue Whale".indexOf("Blute")   // returns -1
+"Blue Whale".indexOf("Whale",0) // returns 5
+"Blue Whale".indexOf("Whale",5) // returns 5
+"Blue Whale".indexOf("",9)      // returns 9
+"Blue Whale".indexOf("",10)     // returns 10
+"Blue Whale".indexOf("",11)     // returns 10
+
+ +

El método indexOf es sensible a mayúsculas. Por ejemplo, la siguiente expresión devuelve -1:

+ +
"Ballena Azul".indexOf("azul")
+
+ +

Ejemplos

+ +

Ejemplo: Usando indexOf y lastIndexOf

+ +

El siguiente ejemplo utiliza indexOf y lastIndexOf para localizar valores dentro de la cadena "Brave new world".

+ +
var cualquierCadena="Brave new world"
+
+
+document.write("<P>The index of the first w from the beginning is " +
+   cualquierCadena.indexOf("w"))         // Muestra 8
+
+document.write("<P>The index of the first w from the end is " +
+   cualquierCadena.lastIndexOf("w"))    // Muestra 10
+
+document.write("<P>The index of 'new' from the beginning is " +
+   cualquierCadena.indexOf("new"))      // Muestra 6
+
+document.write("<P>The index of 'new' from the end is " +
+   cualquierCadena.lastIndexOf("new"))  // Muestra 6
+
+ +

Ejemplo: indexOf y sensibilidad a mayúsculas

+ +

El siguiente ejemplo define dos variables de tipo cadena. Las variables contienen la misma cadena excepto que la segunda cadena contienen letras en mayúscula. El primer método writeln muestra 19. Pero a que el método indexOf es sensible a mayúsculas, no se encuentra la cadena "cheddar" en miCadenaMayusculas, así que el segundo método writeln muestra -1.

+ +
miCadena="brie, pepper jack, cheddar"
+miCadenaMayusculas="Brie, Pepper Jack, Cheddar"
+document.writeln('miCadena.indexOf("cheddar") is ' +
+   miCadena.indexOf("cheddar"))
+document.writeln('<P>miCadenaMayusculas.indexOf("cheddar") is ' +
+   miCadenaMayusculas.indexOf("cheddar"))
+
+ +

Ejemplo: Usando indexOf para contar ocurrencias de una letra en una cadena

+ +

El siguiente ejemplo establece cuenta como el número de ocurrencias de la letra x dentro de la cadena miCadena:

+ +
cuenta = 0;
+posicion = miCadena.indexOf("x");
+while ( posicion != -1 ) {
+   cuenta++;
+   posicion = miCadena.indexOf("x",posicion+1);
+}
+
+ +

Vea También

+ + diff --git a/files/es/web/javascript/reference/global_objects/string/italics/index.html b/files/es/web/javascript/reference/global_objects/string/italics/index.html new file mode 100644 index 0000000000..71897293bb --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/italics/index.html @@ -0,0 +1,49 @@ +--- +title: String.prototype.italics() +slug: Web/JavaScript/Referencia/Objetos_globales/String/italics +tags: + - Deprecated + - HTML wrapper methods + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/italics +--- +

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

+ +

{{deprecated_header}}

+ +

Resumen

+ +

Provoca que una cadena ponga en cursiva, como si estuviese dentro de una etiqueta {{HTMLElement("i")}}.

+ +

Sintaxis

+ +
cadena.italics()
+ +

Descripción

+ +

Usa el método italics para formatear y mostrar una cadena en un documento.

+ +

Ejemplos

+ +

Ejemplo: Usando métodos de italics()

+ +

El siguiente ejemplo usa métodos de string para cambiar el formateado de una cadena:

+ +
var cadenaMundo="¡Hola mundo!";
+
+console.log(cadenaMundo.blink());
+console.log(cadenaMundo.bold());
+console.log(cadenaMundo.italics());
+console.log(cadenaMundo.strike());
+
+ +

Vea También

+ + diff --git a/files/es/web/javascript/reference/global_objects/string/lastindexof/index.html b/files/es/web/javascript/reference/global_objects/string/lastindexof/index.html new file mode 100644 index 0000000000..ffde251071 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/lastindexof/index.html @@ -0,0 +1,79 @@ +--- +title: String.prototype.lastIndexOf() +slug: Web/JavaScript/Referencia/Objetos_globales/String/lastIndexOf +tags: + - Cadena + - JavaScript + - Prototipo + - Referencia + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/String/lastIndexOf +--- +

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

+ +

Resumen

+ +

El  método lastIndexOf() devuelve la posicion (indice) en la que se encuentra el valorBusqueda, dentro del objeto String que realiza la llamada, de la última ocurrencia del valor especificado; o -1 si no se halla. La búsqueda se realiza empezando por el final de la cadena que realiza la llamada, empezando en indiceDesde.

+ +

Sintaxis

+ +
cadena.lastIndexOf(valorBusqueda[, indiceDesde])
+ +

Parámetros

+ +
+
valorBusqueda
+
Una cadena que representa el valor que se desea buscar.
+
+ +
+
indiceDesde
+
La localización dentro de la cadena que realiza la llamada desde donde comenzará la búsqueda. Puede ser cualquier entero entre 0 y la longitud de la cadena. El valor predeterminado es la longitud de la cadena.
+
+ +

Descripción

+ +

Los caracteres de una cadena se indexan de izquierda a derecha. El índice del primer carácter es 0, y el índice del último carácter es nombreCadena.length - 1.

+ +
"canal".lastIndexOf("a")   // returns 3
+"canal".lastIndexOf("a",2) // returns 1
+"canal".lastIndexOf("a",0) // returns -1
+"canal".lastIndexOf("x")   // returns -1
+
+ +

El método lastIndexOf es sensible a mayúsculas. Por ejemplo, la siguiente expresión devuelve -1:

+ +
"Ballena Azul, Ballena Asesina".lastIndexOf("azul")
+
+ +

Ejemplos

+ +

Ejemplo: Usando indexOf y lastIndexOf

+ +

The following example uses indexOf and lastIndexOf to locate values in the string "Brave new world".

+ +
var anyString="Brave new world"
+
+// Displays 8
+document.write("<P>The index of the first w from the beginning is " +
+   anyString.indexOf("w"))
+// Displays 10
+document.write("<P>The index of the first w from the end is " +
+   anyString.lastIndexOf("w"))
+// Displays 6
+document.write("<P>The index of 'new' from the beginning is " +
+   anyString.indexOf("new"))
+// Displays 6
+document.write("<P>The index of 'new' from the end is " +
+   anyString.lastIndexOf("new"))
+
+ +

Vea También

+ + diff --git a/files/es/web/javascript/reference/global_objects/string/length/index.html b/files/es/web/javascript/reference/global_objects/string/length/index.html new file mode 100644 index 0000000000..9401b8898a --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/length/index.html @@ -0,0 +1,94 @@ +--- +title: String.length +slug: Web/JavaScript/Referencia/Objetos_globales/String/length +tags: + - JavaScript + - Propiedad + - Prototipo + - Referencia + - String + - length +translation_of: Web/JavaScript/Reference/Global_Objects/String/length +--- +
{{JSRef}}
+ +

La propiedad length de un objeto {{jsxref("String")}} representa la longitud de una cadena, en unidades de código UTF-16.

+ +

Sintaxis

+ +
str.length
+ +

Descripción

+ +

Esta propiedad devuelve el número de caracteres de una cadena. {{interwiki("wikipedia", "UTF-16")}}, el formato usado por JavaScript, usa 16-bit para representar los caracteres más comunes, pero necesita usar dos caracteres para otros menos usados, así que es posible que el valor devuelto por length no corresponda al número de caracteres de la cadena.

+ +

ECMASCript 2016 (ed. 7) estableció una longitud máxima de 2^53 - 1 elementos. Anteriormente, ninguna longitud máxima era especificada. 

+ +

Para una cadena vacía, length es 0.

+ +

La propiedad static String.length devuelve 1.

+ +

Ejemplos

+ +

Uso Básico

+ +
var x = 'Mozilla';
+var empty = '';
+
+console.log('Mozilla is ' + x.length + ' code units long');
+/* "Mozilla is 7 code units long" */
+
+console.log('The empty string has a length of ' + empty.length);
+/* "The empty string has a length of 0" */
+ +

Asignando a length

+ +
var myString = "bluebells";
+
+// Attempting to assign a value to a string's .length property has no observable effect.
+myString.length = 4;
+console.log(myString);
+/* "bluebells" */
+
+ +

Especificaciones

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
EspecificaciónEstatusComentario
ECMAScript 1st Edition.EstándarPrimera definicíon. Implementado en JavaScript 1.0.
{{SpecName('ES5.1', '#sec-15.5.5.1', 'String.prototype.length')}}{{Spec2('ES5.1')}}
{{SpecName('ES6', '#sec-properties-of-string-instances-length', 'String.prototype.length')}}{{Spec2('ES6')}}
{{SpecName('ESDraft', '#sec-properties-of-string-instances-length', 'String.prototype.length')}}{{Spec2('ESDraft')}}
+ +

Compatibilidad con navegadores

+ +

{{Compat("javascript.builtins.String.length")}}

+ +

Ver también

+ + diff --git a/files/es/web/javascript/reference/global_objects/string/link/index.html b/files/es/web/javascript/reference/global_objects/string/link/index.html new file mode 100644 index 0000000000..021c659f34 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/link/index.html @@ -0,0 +1,56 @@ +--- +title: String.prototype.link() +slug: Web/JavaScript/Referencia/Objetos_globales/String/link +tags: + - HTML wrapper methods + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/link +--- +

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

+ +

Resumen

+ +

Crea un enlace de hipertexto HTML, {{HTMLElement("a")}}, que solicita otra URL.

+ +

Sintaxis

+ +
cadena.link(atributoHref)
+ +

Parámetros

+ +
+
atributoHref
+
Cualquier cadena que especifique el atributo {{htmlattrxref("href", "a")}} de la etiqueta {{HTMLElement("a")}}; debería ser una URL válida (relativa o absoluta).
+
+ +

Descripción

+ +

Usa el método link para crear un atajo HTML para un enlace de hipertexto. La cadena devuelta puede ser añadida al documento vía {{domxref("element.innerHTML")}}.

+ +

Los enlaces creados con el método link serán elementos del array links del objeto document. Vea {{domxref("document.links")}}.

+ +

Ejemplos

+ + + +

El siguiente ejemplo muestra la palabra "Netscape" como un enlace de hipertexto que devuelve al usuario a la página inicial de Netscape:

+ +
var textoActivo="MDN"
+var URL="https://developer.mozilla.org/"
+
+console.log("Haga click para volver a " + textoActivo.link(URL))
+
+ +

Este ejemplo produce el mismo resultado que el siguiente código HTML:

+ +
Haga click para volver a <a href="http://developer.mozilla.org/">MDN</a>
+
+ +

Vea También

+ + diff --git a/files/es/web/javascript/reference/global_objects/string/localecompare/index.html b/files/es/web/javascript/reference/global_objects/string/localecompare/index.html new file mode 100644 index 0000000000..2bda296c61 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/localecompare/index.html @@ -0,0 +1,159 @@ +--- +title: String.prototype.localeCompare() +slug: Web/JavaScript/Referencia/Objetos_globales/String/localeCompare +translation_of: Web/JavaScript/Reference/Global_Objects/String/localeCompare +--- +
{{JSRef}}
+ +

El método localeCompare() devuelve un número que indica si la cadena de caracteres actual es anterior, posterior o igual a la cadena pasada como parámetro, en orden lexicográfico.

+ +

Los nuevos argumentos locales y options permiten a las aplicaciones especificar el idioma y el orden de clasificación que debe usarse y personalizar el comportamiento de la función. En las implementaciones más antiguas, que ignoran los argumentos locales y options, la configuración locale y el orden de clasificación utilizados dependen enteramente de la implementación

+ +

Sintaxis

+ +
referenceStr.localeCompare(compareString[, locales[, options]])
+ +

Parámetros

+ +

Comprueba la sección Compatibilidad con el navegador para ver que navegadores soportan los argumentos locales y options, and the Checking for support for locales and options arguments for feature detection.

+ +
+
compareString
+
La cadena con la que queremos comparar la cadena actual de caracteres.
+
+ +
{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/Collator', 'Parameters')}}
+ +

Valor devuelto

+ +

Un número negativo si la cadena de referencia ocurre antes de la cadena de comparación; positivo si la cadena de referencia ocurre después de la cadena de comparación; 0 si son equivalentes.

+ +

Descripción

+ +

Returns an integer indicating whether the referenceStr comes before, after or is equivalent to the compareStr.

+ + + +

NO CONFIAR en que los valores devueltos sean siempre -1 o 1. Los resultados de enteros negativos y positivos varían entre los navegadores (así como entre diferentes versiones de un mismo navegador) porque la especificación W3C solo exige valores negativos y positivos. Algunos navegadores pueden devolver -2 o 2 o incluso algún otro valor negativo o positivo.

+ +

Ejemplos

+ +

Uso de localeCompare()

+ +
// La letra "a" es anterior a la "c" produciendo un valor negativo
+'a'.localeCompare('c'); // -2 o -1 (u otro valor negativo)
+
+// Alfabeticamente la palabra "check" viene después de "against" produciendo un valor ppositivo
+'check'.localeCompare('against'); // 2 o 1 (u otro valor positivo)
+
+// "a" y "a" son equivalentes produciendo un valor neutro de 0
+'a'.localeCompare('a'); // 0
+
+ +

Ordenar un array

+ +

localeCompare enables a case-insensitive sort of an array.

+ +
var items = ['réservé', 'premier', 'cliché', 'communiqué', 'café', 'adieu'];
+items.sort((a, b) => a.localeCompare(b)); // ['adieu', 'café', 'cliché', 'communiqué', 'premier', 'réservé']
+
+ +

Verificar si el navegador soporta argumentos extendidos

+ +

The locales and options arguments are not supported in all browsers yet. To check whether an implementation supports them, use the "i" argument (a requirement that illegal language tags are rejected) and look for a {{jsxref("RangeError")}} exception:

+ +
function localeCompareSupportsLocales() {
+  try {
+    'foo'.localeCompare('bar', 'i');
+  } catch (e) {
+    return e.name === 'RangeError';
+  }
+  return false;
+}
+
+ +

Uso de locales

+ +

The results provided by localeCompare() vary between languages. In order to get the sort order of the language used in the user interface of your application, make sure to specify that language (and possibly some fallback languages) using the locales argument:

+ +
console.log('ä'.localeCompare('z', 'de')); // a negative value: in German, ä sorts before z
+console.log('ä'.localeCompare('z', 'sv')); // a positive value: in Swedish, ä sorts after z
+
+ +

Uso de options

+ +

The results provided by localeCompare() can be customized using the options argument:

+ +
// in German, ä has a as the base letter
+console.log('ä'.localeCompare('a', 'de', { sensitivity: 'base' })); // 0
+
+// in Swedish, ä and a are separate base letters
+console.log('ä'.localeCompare('a', 'sv', { sensitivity: 'base' })); // a positive value
+
+ +

Performance

+ +

When comparing large numbers of strings, such as in sorting large arrays, it is better to create an {{jsxref("Global_Objects/Collator", "Intl.Collator")}} object and use the function provided by its {{jsxref("Collator.prototype.compare", "compare")}} property.

+ +

Especificaciones

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
EspecificaciónEstadoComentario
{{SpecName('ES3')}}{{Spec2('ES3')}}Definición inicial. Implementado en JavaScript 1.2.
{{SpecName('ES5.1', '#sec-15.5.4.9', 'String.prototype.localeCompare')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-string.prototype.localecompare', 'String.prototype.localeCompare')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-string.prototype.localecompare', 'String.prototype.localeCompare')}}{{Spec2('ESDraft')}} 
{{SpecName('ES Int 1.0', '#sec-13.1.1', 'String.prototype.localeCompare')}}{{Spec2('ES Int 1.0')}}Definiciones de los parámetros locale y option.
{{SpecName('ES Int 2.0', '#sec-13.1.1', 'String.prototype.localeCompare')}}{{Spec2('ES Int 2.0')}} 
{{SpecName('ES Int Draft', '#sec-String.prototype.localeCompare', 'String.prototype.localeCompare')}}{{Spec2('ES Int Draft')}} 
+ +

Compatibilidad con el navegador

+ + + +

{{Compat("javascript.builtins.String.localeCompare")}}

+ +

Ver también

+ + diff --git a/files/es/web/javascript/reference/global_objects/string/match/index.html b/files/es/web/javascript/reference/global_objects/string/match/index.html new file mode 100644 index 0000000000..6403dbaf06 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/match/index.html @@ -0,0 +1,78 @@ +--- +title: String.prototype.match() +slug: Web/JavaScript/Referencia/Objetos_globales/String/match +tags: + - JavaScript + - Method + - Prototype + - RegExp + - Regular Expressions + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/match +--- +

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

+ +

Resumen

+ +

El método match() se usa para obtener todas las ocurrencias de una expresión regular dentro de una cadena.

+ +

Sintaxis

+ +
cadena.match(regexp)
+ +

Parámetros

+ +
+
regexp
+
Un objeto expresión regular. Si se pasa un objeto obj que no es expresión regular, se convierte implícitamente a RegExp usando new RegExp(obj).
+
+ +

Descripción

+ +

Si la expresión regular no incluye el flag g, devuelve el mismo resultado que {{jsxref("Regexp.exec()")}}.

+ +

Si la expresión regular incluye el flag g, el método devuelve un {{jsxref("Array")}} que contiene todos los emparejamientos.

+ +

Notas

+ + + +

Ejemplos

+ +

Ejemplo: Usando match

+ +

En el siguiente ejemplo, se usa match para hallar "Capítulo" seguido de 1 o más caracteres numéricos seguidos de un punto decimal y caracteres numéricos cero o más veces. La expresión regular incluye el flag i por lo que las mayúsculas serán ignoradas.

+ +
cadena = "Para más información, vea Capítulo 3.4.5.1";
+expresion = /(capítulo \d+(\.\d)*)/i;
+hallado = cadena.match(expresion);
+console.log(hallado);
+
+ +

Esto devuelve un array que contiene Capítulo 3.4.5.1,Capítulo 3.4.5.1,.1

+ +

"Capítulo 3.4.5.1" es el primer emparejamiento y el primer valor referenciado por (Chapter \d+(\.\d)*).

+ +

".1" es el segundo valor referenciado por (\.\d).

+ +

Ejemplo: Usando los flags global e ignorar mayúsculas con match

+ +

El siguiente ejemplo demuestra el uso de los flags global e ignorar mayúsculas con match. Todas las letras de A hasta E y de a hasta e son devueltas, en su propio elemento dentro del array.

+ +
var cadena = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+var expresion = /[A-E]/gi;
+var array_emparejamientos = cadena.match(expresion);
+console.log(array_emparejamientos);
+
+ +

array_emparejamientos será {{ mediawiki.external('\'A\', \'B\', \'C\', \'D\', \'E\', \'a\', \'b\', \'c\', \'d\', \'e\'') }}

+ +

Vea También

+ + diff --git a/files/es/web/javascript/reference/global_objects/string/matchall/index.html b/files/es/web/javascript/reference/global_objects/string/matchall/index.html new file mode 100644 index 0000000000..a536720dbd --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/matchall/index.html @@ -0,0 +1,134 @@ +--- +title: String.prototype.matchAll() +slug: Web/JavaScript/Referencia/Objetos_globales/String/matchAll +tags: + - Cadena + - Expresiones Regulares + - JavaScript + - Prototipo + - Referencia + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/String/matchAll +--- +
{{JSRef}}
+ +

El método matchAll() retorna un iterador de todos los resultados de ocurrencia en una cadena de texto contra una expresión regular, incluyendo grupos de captura.

+ +
{{EmbedInteractiveExample("pages/js/string-matchall.html")}}
+ + + +

Sintaxis

+ +
cadena.matchAll(expresionRegular)
+ +

Parámetros

+ +
+
expresionRegular
+
Un objeto expresión regular. Si se pasa un objeto no-RegExp obj, este es implícitamente convertido a {{jsxref("RegExp")}} vía new RegExp(obj).
+
+ +

Valor devuelto

+ +

Un iterador (el cual no es reiniciable).

+ +

Ejemplo

+ +

Regexp.exec() y matchAll()

+ +

Antes de la adición de  matchAll a JavaScript, fue posible hacer llamados a regexp.exec (y usar expresiones regulares con la bandera /g) en un ciclo para obtener las ocurrencias:

+ +
const regexp = RegExp('foo[a-z]*','g');
+const cadena = 'mesa football, foosball';
+let ocurrencia;
+
+while ((ocurrencia = regexp.exec(cadena)) !== null) {
+  console.log(`Encontrado ${ocurrencia[0]} inicio=${ocurrencia.index} final=${regexp.lastIndex}.`);
+  // salida esperada: "Encontrado football inicio=5 final=13."
+  // salida esperada: "Encontrado foosball inicio=15 final=23."
+}
+ +

Con matchAll disponible, puedes evitar el ciclo while y exec con /g. Por el contrario, usando matchAll, obtienes un iterador con el cual puedes usar con constructores más convenientes  for...of, array spread, o {{jsxref("Array.from()")}}:

+ +
const regexp = RegExp('foo[a-z]*','g');
+const cadena = 'mesa football, foosball';
+const ocurrencias = cadena.matchAll(regexp);
+
+for (const ocurrencia of ocurrencias) {
+  console.log(`Encontrado ${ocurrencia[0]} inicio=${ocurrencia.index} final=${ocurrencia.index + ocurrencia[0].length}.`);
+}
+// salida esperada: "Encontrado football start=5 end=13."
+// salida esperada: "Encontrado foosball start=15 end=23."
+
+// el iterador ocurrencias es agotado después de la iteración for..of
+// Llama matchAll de nuevo para crear un nuevo iterador
+Array.from(cadena.matchAll(regexp), m => m[0]);
+// Array [ "football", "foosball" ]
+ +

matchAll solo devuelve la primer ocurrencia si la bandera /g está ausente.

+ +
const regexp = RegExp('[a-c]','');
+const cadena = 'abc';
+Array.from(cadena.matchAll(regexp), m => m[0]);
+// Array [ "a" ]
+
+ +

matchAll internamente hace un clon de la expresión regular, entonces a diferencia de regexp.exec,  lastIndex no cambia a medida que la cadena es escaneada.

+ +
const regexp = RegExp('[a-c]','g');
+regexp.lastIndex = 1;
+const cadena = 'abc';
+Array.from(cadena.matchAll(regexp), m => `${regexp.lastIndex} ${m[0]}`);
+// Array [ "1 b", "1 c" ]
+ +

Mejor acceso para capturar grupos

+ +

Otra buena razón para matchAll es el mejorado acceso a los grupos de captura. Los grupos de captura son ignorados cuando se usa match() con la bandera global /g:

+ +
var regexp = /t(e)(st(\d?))/g;
+var cadena = 'test1test2';
+
+cadena.match(regexp);
+// Array ['test1', 'test2']
+ +

Con matchAll puedes acceder a ellos:

+ +
let array = [...str.matchAll(regexp)];
+
+array[0];
+// ['test1', 'e', 'st1', '1', index: 0, input: 'test1test2', length: 4]
+array[1];
+// ['test2', 'e', 'st2', '2', index: 5, input: 'test1test2', length: 4]
+
+ +

Especificaciones

+ + + + + + + + + + + + + + +
EspecificaciónEstadoComentario
{{SpecName('ESDraft', '#sec-string.prototype.matchall', 'String.prototype.matchAll')}}{{Spec2('ESDraft')}}
+ +

Compatibilidad de navegadores

+ + + +

{{Compat("javascript.builtins.String.matchAll")}}

+ +

Ver también

+ + diff --git a/files/es/web/javascript/reference/global_objects/string/normalize/index.html b/files/es/web/javascript/reference/global_objects/string/normalize/index.html new file mode 100644 index 0000000000..2794644f1c --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/normalize/index.html @@ -0,0 +1,126 @@ +--- +title: String.prototype.normalize() +slug: Web/JavaScript/Referencia/Objetos_globales/String/normalize +tags: + - Cadena + - ECMAScript 2015 + - JavaScript + - Prototipo + - Referencia + - String + - Unicode + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/String/normalize +--- +
{{JSRef}}
+ +

El método normalize() retorna la Forma de Normalización Unicode de la cadena dada (si el valor no es una cadena, primero será convertido a ese tipo).

+ +

Sintaxis

+ +
str.normalize([form])
+ +

Parámetros

+ +
+
form
+
Uno de"NFC", "NFD", "NFKC", o "NFKD", especificando la Forma de Normalización Unicode. Si es omitida o {{jsxref("undefined")}}, se utiliza "NFC". +
    +
  • NFC — Forma de Normalización de Composición Canónica.
    • +
  • NFD — Forma de Normalización de Descomposición Canónica.
    • +
  • NFKC — Forma de Normalización de Composición de Compatibilidad.
    • +
  • NFKD — Forma de Normalización de Descomposición de Compatibilidad.
    • +
+
+
+ +

Valor de retorno

+ +

Una cadena que contiene la Forma de Normalización Unicode de la cadena dada.

+ +

Errores lanzados

+ +
+
{{jsxref("RangeError")}}
+
Un error {{jsxref("RangeError")}} es lanzado si form no es uno de los valores especificados arriba.
+
+ +

Descripción

+ +

El método normalize() retorna la Forma de Normalización Unicode de una cadena. No afecta el valor de la cadena en sí misma.

+ +

Ejemplos

+ +

Uso de normalize()

+ +
// Cadena inicial
+
+// U+1E9B: LETRA S LATINA MINÚSCULA CON PUNTO ARRIBA
+// U+0323: COMBINACIÓN CON PUNTO ABAJO
+var str = '\u1E9B\u0323';
+
+
+// Forma compuesta canónicamente (NFC)
+
+// U+1E9B: LETRA S LATINA MINÚSCULA CON PUNTO ARRIBA
+// U+0323: COMBINACIÓN CON PUNTO ABAJO
+str.normalize('NFC'); // '\u1E9B\u0323'
+str.normalize();      // lo mismo que arriba
+
+
+// Forma canónicamente descompuesta (NFD)
+
+// U+017F: LETRA S LATINA MINÚSCULA
+// U+0323: COMBINACIÓN CON PUNTO ABAJO
+// U+0307: COMBINACIÓN CON PUNTO ARRIBA
+str.normalize('NFD'); // '\u017F\u0323\u0307'
+
+
+// Compuesta con compatibilidad (NFKC)
+
+// U+1E69: LETRA S LATINA MINÚSCULA CON PUNTO ARRIBA Y ABAJO
+str.normalize('NFKC'); // '\u1E69'
+
+
+// Descompuesta con compatibilidad (NFKD)
+
+// U+0073: LETRA S LATINA MINÚSCULA
+// U+0323: COMBINACIÓN CON PUNTO ABAJO
+// U+0307: COMBINACIÓN CON PUNTO ARRIBA
+str.normalize('NFKD'); // '\u0073\u0323\u0307'
+
+ +

Especificaciones

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

Compatibilidad de Navegadores

+ + + +

{{Compat("javascript.builtins.String.normalize")}}

+ +

Vea también

+ + diff --git a/files/es/web/javascript/reference/global_objects/string/padstart/index.html b/files/es/web/javascript/reference/global_objects/string/padstart/index.html new file mode 100644 index 0000000000..57abbd8f5c --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/padstart/index.html @@ -0,0 +1,100 @@ +--- +title: String.prototype.padStart() +slug: Web/JavaScript/Referencia/Objetos_globales/String/padStart +tags: + - Cadena + - Experimental + - JavaScript + - Método(2) + - Referencia +translation_of: Web/JavaScript/Reference/Global_Objects/String/padStart +--- +
{{JSRef}}{{SeeCompatTable}}
+ +

El método padStart() rellena la cadena actual con una cadena dada (repetida eventualmente) de modo que la cadena resultante alcance una longitud dada. El relleno es aplicado desde el inicio (izquierda) de la cadena actual.

+ +

Sintaxis

+ +
str.padStart(targetLength [, padString])
+ +

Parámetros

+ +
+
targetLength
+
La longitud de la cadena resultante una vez la cadena actual haya sido rellenada. Si este parámetro es más pequeño que la longitud de la cadena actual, la cadena actual será devuelta sin modificar.
+
padString {{optional_inline}}
+
La cadena para rellenar la cadena actual. Si esta cadena es muy larga, será recortada y la parte más a la izquierda será aplicada. El valor por defecto para este parámetro es " " (U+0020).
+
+ +

Valor devuelto

+ +

Un {{jsxref("String")}} de la longitud específicada con la cadena de relleno aplicada desde el inicio.

+ +

Ejemplos

+ +
'abc'.padStart(10);         // "       abc"
+'abc'.padStart(10, "foo");  // "foofoofabc"
+'abc'.padStart(6,"123465"); // "123abc"
+
+ +

Especificaciones

+ +

Este método aún no ha alcanzado el estándar ECMAScript. Actualmente es una propuesta para ECMAScript.

+ +

Compatibilidad con navegadores

+ +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Soporte básico{{CompatChrome("52")}} {{CompatGeckoDesktop(48)}}{{CompatNo}}{{CompatUnknown}}{{CompatUnknown}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Soporte básico{{CompatUnknown}}{{CompatUnknown}}{{CompatGeckoMobile(48)}}{{CompatUnknown}}{{CompatUnknown}}{{CompatUnknown}}
+
+ +

Ver también

+ + diff --git a/files/es/web/javascript/reference/global_objects/string/raw/index.html b/files/es/web/javascript/reference/global_objects/string/raw/index.html new file mode 100644 index 0000000000..3c8f3c1d55 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/raw/index.html @@ -0,0 +1,112 @@ +--- +title: String.raw() +slug: Web/JavaScript/Referencia/Objetos_globales/String/raw +translation_of: Web/JavaScript/Reference/Global_Objects/String/raw +--- +
{{JSRef}}
+ +

El método estatico String.raw()  es una función de  plantilla de literales, similar al prefijo r en Python o al prefijo @ en C# para strings literales (con ciertas diferencias: ver la explicación en este problema). Se utiliza para obtener un string crudo a partir de plantillas de string (es decir, el original, texto no interpretado).

+ +

Sintaxis

+ +
String.raw(callSite, ...substitutions)
+
+String.raw`templateString`
+
+ +

Parametros

+ +
+
callSite
+
Plantilla bien estructurada, similar a { raw: ['foo', 'bar', 'baz'] }.
+
...substitutions
+
Contiene valores de sustitución.
+
templateString
+
[opcional] Una plantilla string, con sustituciones (${...}).
+
+ +

Valor de regreso

+ +

La forma cruda del string de una plantilla string proporcionada.

+ +

Excepciones

+ +
+
{{jsxref("TypeError")}}
+
Un {{jsxref("TypeError")}} es arrojado si el primer argumento no es un objeto bien estructurado.
+
+ +

Descripción

+ +

En la mayoría de los casos, String.raw() es usado con plantillas string. La primera sintaxis mencionada arriba es raramente usada,  porque el motor de JavaScript hará la llamada por ti con los argumentos apropiados, al igual que otras funciones de etiqueta.

+ +

String.raw() es la unica función de etiqueta incorporada en las plantillas string; trabaja igual que la función de la plantilla por defecto y ejecuta la concatenación. Incluso puedes reimplementarlo con código normal de JavaScript.

+ +

Ejemplos

+ +

Usando String.raw()

+ +
String.raw`Hi\n${2+3}!`;
+// 'Hi\n5!', the character after 'Hi'
+// is not a newline character,
+// '\' and 'n' are two characters.
+
+String.raw`Hi\u000A!`;
+// 'Hi\u000A!', same here, this time we will get the
+//  \, u, 0, 0, 0, A, 6 characters.
+// All kinds of escape characters will be ineffective
+// and backslashes will be present in the output string.
+// You can confirm this by checking the .length property
+// of the string.
+
+let name = 'Bob';
+String.raw`Hi\n${name}!`;
+// 'Hi\nBob!', substitutions are processed.
+
+// Normally you would not call String.raw() as a function,
+// but to simulate `t${0}e${1}s${2}t` you can do:
+String.raw({ raw: 'test' }, 0, 1, 2); // 't0e1s2t'
+// Note that 'test', a string, is an array-like object
+// The following is equivalent to
+// `foo${2 + 3}bar${'Java' + 'Script'}baz`
+String.raw({
+  raw: ['foo', 'bar', 'baz']
+}, 2 + 3, 'Java' + 'Script'); // 'foo5barJavaScriptbaz'
+
+
+ +

Especificaciónes

+ + + + + + + + + + + + + + + + + + + +
EspecificaciónEstadoComentario
{{SpecName('ES2015', '#sec-string.raw', 'String.raw')}}{{Spec2('ES2015')}}Definicion inicial.
{{SpecName('ESDraft', '#sec-string.raw', 'String.raw')}}{{Spec2('ESDraft')}} 
+ +

Compatibilidad de navegador

+ + + +

{{Compat("javascript.builtins.String.raw")}}

+ +

Tambien ver

+ + diff --git a/files/es/web/javascript/reference/global_objects/string/repeat/index.html b/files/es/web/javascript/reference/global_objects/string/repeat/index.html new file mode 100644 index 0000000000..a449bdfb27 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/repeat/index.html @@ -0,0 +1,128 @@ +--- +title: String.prototype.repeat() +slug: Web/JavaScript/Referencia/Objetos_globales/String/repeat +tags: + - ECMAScript2015 + - JavaScript + - Prototype + - Referencia + - String + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/String/repeat +--- +
{{JSRef}}
+ +

El método repeat() construye y devuelve una nueva cadena que contiene el número especificado de copias de la cadena en la cual fue llamada, concatenados.

+ +

Sintáxis

+ +
str.repeat(count)
+ +

Parámetros

+ +
+
count
+
Un entero entre 0 y +∞: [0, +∞), indicando el número de veces a repetir la cadena en la nueva cadenada creada que será devuelta.
+
+ +

Valor devuelto

+ +

Un nuevo string que contiene el número especificado de copias del string original.

+ +

Excepciones

+ + + +
+
+ +

Ejemplos

+ +
'abc'.repeat(-1);   // RangeError
+'abc'.repeat(0);    // ''
+'abc'.repeat(1);    // 'abc'
+'abc'.repeat(2);    // 'abcabc'
+'abc'.repeat(3.5);  // 'abcabcabc' (count will be converted to integer)
+'abc'.repeat(1/0);  // RangeError
+
+({ toString: () => 'abc', repeat: String.prototype.repeat }).repeat(2);
+// 'abcabc' (repeat() is a generic method)
+
+ +

Polyfill

+ +

Este método ha sido añadido a la especificación ECMAScript 6 y tal vez aún no se encuentre disponible en todas las implementaciones de JavaScript. Sin embargo, usted puede establecer String.prototype.repeat() con el siguiente fragmento de código:

+ +
if (!String.prototype.repeat) {
+  String.prototype.repeat = function(count) {
+    'use strict';
+    if (this == null) {
+      throw new TypeError('can\'t convert ' + this + ' to object');
+    }
+    var str = '' + this;
+    count = +count;
+    if (count != count) {
+      count = 0;
+    }
+    if (count < 0) {
+      throw new RangeError('repeat count must be non-negative');
+    }
+    if (count == Infinity) {
+      throw new RangeError('repeat count must be less than infinity');
+    }
+    count = Math.floor(count);
+    if (str.length == 0 || count == 0) {
+      return '';
+    }
+    // Ensuring count is a 31-bit integer allows us to heavily optimize the
+    // main part. But anyway, most current (August 2014) browsers can't handle
+    // strings 1 << 28 chars or longer, so:
+    if (str.length * count >= 1 << 28) {
+      throw new RangeError('repeat count must not overflow maximum string size');
+    }
+    var rpt = '';
+    for (;;) {
+      if ((count & 1) == 1) {
+        rpt += str;
+      }
+      count >>>= 1;
+      if (count == 0) {
+        break;
+      }
+      str += str;
+    }
+    return rpt;
+  }
+}
+
+ +

Especificaciones

+ + + + + + + + + + + + + + + + + + + +
EspecificaciónEstadoComentarios
{{SpecName('ES6', '#sec-string.prototype.repeat', 'String.prototype.repeat')}}{{Spec2('ES2015')}}Definición inicial.
{{SpecName('ESDraft', '#sec-string.prototype.repeat', 'String.prototype.repeat')}}{{Spec2('ESDraft')}} 
+ +

Compatibilidad en Navegadores

+ +
{{Compat("javascript.builtins.String.repeat")}}
+ +
 
diff --git a/files/es/web/javascript/reference/global_objects/string/replace/index.html b/files/es/web/javascript/reference/global_objects/string/replace/index.html new file mode 100644 index 0000000000..680393ece1 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/replace/index.html @@ -0,0 +1,202 @@ +--- +title: String.prototype.replace() +slug: Web/JavaScript/Referencia/Objetos_globales/String/replace +tags: + - JavaScript + - Method + - Prototype + - Regular Expressions + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/replace +--- +

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

+ +

Resumen

+ +

El método replace() devuelve una nueva cadena con algunas o todas las coincidencias de un patrón, siendo cada una de estas coincidencias reemplazadas por remplazo. El patrón puede ser una cadena o una {{jsxref("RegExp")}}, y el reemplazo puede ser una cadena o una función que será llamada para cada coincidencia. Si el patrón es una cadena, sólo la primera coincidencia será reemplazada.

+ +

La cadena original permanecerá inalterada.

+ +
{{EmbedInteractiveExample("pages/js/string-replace.html")}}
+ +

Sintaxis

+ +
cadena.replace(regexp|substr, newSubStr|function[, {{ Non-standard_inline() }} flags]);
+
+ +

Parámetros

+ +
+
expresionregular
+
Un objeto {{jsxref("RegExp")}} o literal. Las coincidencias son reemplazadas por ewSubSt o el valor devuelto por la función especificada.
+
+ +
+
subcadena
+
Un objeto {{jsxref("String")}} que será reemplazado por nuevaSubcadena.
+
+ +
+
nuevaSubcadena
+
El objeto {{jsxref("String")}} que reemplaza la subcadena que recibida desde el primer parámetro.
+
+ +
+
funcion
+
Una función que será invocada para crear la nueva subcadena (para ponerla en lugar de la subcadena recibida por el primer parámetro).
+
+ +
+
flags {{ non-standard_inline() }}
+
Un objeto {{jsxref("String")}} que contiene cualquier combinación de flags de la clase RegExp: g - emparejamiento global, i - ignorar mayúsculas, m - emparejar multiples líneas. Este parámetro se usa sólo si el primer parámetro es una cadena.
+
+ +

Descripción

+ +

Este método no cambia el objeto String sobre el que se realiza la llamada. Simplemente devuelve una nueva cadena.

+ +

Para realizar una búsqueda global y reemplazarla, o se incluye el flag g en la expresión regular o si el primer parámetro es una cadena, se incluye g en el parámetro flags.

+ +

Especificando una cadena como un parámetro

+ +

La cadena de reemplazo puede incluir los siguientes patrones de reemplazo especiales:

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + +
PatrónInserta
$$Inserta una "$".
$&Inserta la subcadena emparejada.
$`Inserta la sección de cadena que precede a la subcadena emparejada.
$'Inserta la porción de subcadena que sigue a la subcadena emparejada.
$n o $nn Donde n o nn son dígitos decimales positivos menores a 100, inserta la subcadena emparejada de orden n del paréntesis, proporcionado por el primer argumento del objeto RegExp.
+ +

Especificando una función con un parámetro

+ +

Cuando se especifica una función en el segundo parámetro, la función es invocada después de que el emparejamiento se haya realizado. (El uso de una función de este modo se llama expresión lambda.)

+ +

En la función, puedes generar dinámicamente la cadena que reemplaza la subcadena emparejada. El resultado de la llamada de la función se usa como valor de reemplazo.

+ +

The nested function can use the matched substrings to determine the new string (newSubStr) that replaces the found substring. You get the matched substrings through the parameters of your function. The first parameter of your function holds the complete matched substring. If the first argument was a RegExp object, then the followingn parameters can be used for parenthetical matches, remembered submatch strings, wheren is the number of submatch strings in the regular expression. Finally, the last two parameters are the offset within the string where the match occurred and the string itself. For example, the following replace method returns XXzzzz - XX , zzzz.

+ +
function replacer(str, p1, p2, offset, s)
+{
+  return str + " - " + p1 + " , " + p2;
+}
+var newString = "XXzzzz".replace(/(X*)(z*)/, replacer);
+console.log(newString); // XXzzzz - XX , zzzz
+
+ +

Ejemplos

+ +

Ejemplo: Usando global e ignore con replace

+ +

En el siguiente ejemplo, la expresión regular incluye las banderas "global" e "ignore case", las cuales permiten al método replace reemplazar cada aparición de la cadena 'apples' por la cadena 'oranges'.

+ +
var re = /apples/gi;
+var str = "Apples are round, and apples are juicy.";
+var newstr = str.replace(re, "oranges");
+print(newstr);
+
+ +

In this version, a string is used as the first parameter and the global and ignore case flags are specified in the flags parameter.

+ +
var str = "Apples are round, and apples are juicy.";
+var newstr = str.replace("apples", "oranges", "gi");
+print(newstr);
+
+ +

Both of these examples print "oranges are round, and oranges are juicy."

+ +

Ejemplo: Definiendo la expresión regular en replace

+ +

En el siguiente ejemplo, se define la expresión regular en replace e incluye el flag de ignorar mayúsculas.

+ +
var cadena = "Twas the night before Xmas...";
+var nuevaCadena = cadena.replace(/xmas/i, "Christmas");
+print(nuevaCadena);
+
+ +

Esto muestra "Twas the night before Christmas..."

+ +

Ejemplo: Conectando palabras en una cadena

+ +

El siguiente código conecta las palabras dentro de la cadena. Para reemplazar el texto, el código usa $1 y $2 como patrones de reemplazo.

+ +
var expresion = /(\w+)\s(\w+)/;
+var cadena = "John Smith";
+var nuevaCadena = cadena.replace(expresion, "$2, $1");
+print(nuevaCadena);
+
+ +

Esto muestra "Smith, John".

+ +

Ejemplo: Using an inline function that modifies the matched characters

+ +

In this example, all occurrences of capital letters in the string are converted to lower case, and a hyphen is inserted just before the match location. The important thing here is that additional operations are needed on the matched item before it is given back as a replacement.

+ +

The replacement function accepts the matched snippet as its parameter, and uses it to transform the case and concatenate the hyphen before returning.

+ +
function styleHyphenFormat(propertyName)
+{
+  function upperToHyphenLower(match)
+  {
+    return '-' + match.toLowerCase();
+  }
+  return propertyName.replace(/[A-Z]/, upperToHyphenLower);
+}
+
+ +

Given styleHyphenFormat('borderTop'), this returns 'border-top'.

+ +

Because we want to further transform theresult of the match before the final substitution is made, we must use a function. This forces the evaluation of the match prior to the toLowerCase() method. If we had tried to do this using the match without a function, the toLowerCase() would have no effect.

+ +
var newString = propertyName.replace(/[A-Z]/, '-' + '$&'.toLowerCase());  // won't work
+
+ +

This is because '$&'.toLowerCase() would be evaluated first as a string literal (resulting in the same '$&') before using the characters as a pattern.

+ +

Ejemplo: Reemplazando grados Fahrenheit con su equivalente Celsius

+ +

El siguiente ejemplo reemplaza los grados Fahrenheit con su enquivalente en grados Celsius. Los grados Fahrenheit deberían ser un número acabado en F. La función devuelve el número Celsius acabado en C. Por ejemplo, si el número de entrada es 212F, la función devuelve 100C. Si el número es 0F, la función devuelve -17.77777777777778C.

+ +

La expresión regular test revisa si para un número termina en F. El número de grados Fahrenheit es accesible a la función a través de su segundo parámetro, p1. La función establece el número Celsius basado en los grados Fahrenheit pasados en una cadena a la función f2c. Entonces f2c devuelve el número Celsius. Esta función aproxima al flag de Perl s///e.

+ +
function f2c(x)
+{
+  function convert(str, p1, offset, s)
+  {
+    return ((p1-32) * 5/9) + "C";
+  }
+  var s = String(x);
+  var test = /(\d+(?:\.\d*)?)F\b/g;
+  return s.replace(test, convert);
+}
+
+ +

Vea También

+ + diff --git a/files/es/web/javascript/reference/global_objects/string/search/index.html b/files/es/web/javascript/reference/global_objects/string/search/index.html new file mode 100644 index 0000000000..23e37234d1 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/search/index.html @@ -0,0 +1,153 @@ +--- +title: String.prototype.search() +slug: Web/JavaScript/Referencia/Objetos_globales/String/search +tags: + - JavaScript + - Method + - Prototype + - Reference + - Regular Expressions + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/search +--- +

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

+ +

Resumen

+ +

El método search() ejecuta una búsqueda que encaje entre una expresión regular y el objeto String desde el que se llama.

+ +

Sintaxis

+ +
str.search(expresionregular)
+ +

Parámetros

+ +
+
regexp
+
Un objeto expresión regular. Si se pasa un objeto obj que no sea una expresión regular, se convierte implicitamente en una expresión regualar usando new RegExp(obj).
+
+ +

Valor devuelto

+ +

El índice de la primera coincidencia entre la expresión regular y la cadena de texto proporcionada, si no se encuentra devuelve -1.

+ +

Descripción

+ +

Cuando se desee saber en qué casos un patrón se encuentra en una cadena de texto utiliza search() (si sólo deseas saber si existe, utiliza el método {{jsxref("RegExp.prototype.test()", "test()")}} del prototipo de RegExp); para más información (pero de ejecución más lenta) utiliza {{jsxref("String.prototype.match()", "match()")}} (similar al método {{jsxref("RegExp.prototype.exec()", "exec()")}} de las expresiones regulares).

+ +

Ejemplos

+ + + +

El siguiente ejemplo imprime un mensaje dependiendo de cuál sea el resultado de la evaluación.

+ +
function testinput(re, str) {
+  var midstring;
+  if (str.search(re) != -1) {
+    midstring = ' contains ';
+  } else {
+    midstring = ' does not contain ';
+  }
+  console.log(str + midstring + re);
+}
+
+ +

Especificaciones

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
EspecificacionesEstadoComentario
{{SpecName('ES3')}}{{Spec2('ES3')}}Definición inicial. Implementado en JavaScript 1.2.
{{SpecName('ES5.1', '#sec-15.5.4.12', 'String.prototype.search')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-string.prototype.search', 'String.prototype.search')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-string.prototype.search', 'String.prototype.search')}}{{Spec2('ESDraft')}} 
+ +

Compatibilidad con navegadores

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

Notas específicas de Gecko

+ + + +

Vea también

+ + diff --git a/files/es/web/javascript/reference/global_objects/string/slice/index.html b/files/es/web/javascript/reference/global_objects/string/slice/index.html new file mode 100644 index 0000000000..cbfe5a716b --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/slice/index.html @@ -0,0 +1,161 @@ +--- +title: String.prototype.slice() +slug: Web/JavaScript/Referencia/Objetos_globales/String/slice +tags: + - Cadena + - JavaScript + - Método(2) + - Prototipo + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/slice +--- +

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

+ +

Resumen

+ +

El método slice() extrae una sección de una cadena y devuelve una cadena nueva.

+ +

Sintaxis

+ +
cadena.slice(inicioTrozo[, finTrozo])
+
+ +

Parameters

+ +
+
inicioTrozo
+
El índice basado en cero en el cual empieza la extracción.  Si es negativo, se trata como longCadena + inicioTrozo donde longCadena es la longitud de la cadena (por ejemplo, si inicioTrozo es -3 se trata como longCadena - 3)
+
+ +
+
finTrozo
+
Opcional. El índice basado en cero en el que termina la extracción. Si se omite, slice extrae hasta el final de la cadena.  Si es negativo, se trata como longCadena + finTrozo donde longCadena es la longitud de la cadena (por ejemplo, si finTrozo es -3 se trata como longCadena - 3).
+
+ +

Valor retornado

+ +

Una nueva cadena que contiene la sección de la cadena.

+ +

Descripción

+ +

slice extrae el texto de una cadena y devuelve una nueva cadena. Los cambios en el texto de una cadena no afectan a la otra cadena.

+ +

slice extrae hasta, pero sin incluir finalTrozo. string.slice(1,4) extrae del segundo carácter hasta el cuarto carácter (caracteres con índice 1, 2 y 3).

+ +

Si se usa un índice negativo, finalTrozo indica el punto desde el final de la cadena.string.slice(2, -1) extrae desde tercer carácter hasta el último carácter de la cadena.

+ +

Ejemplos

+ +

Ejemplo: Uso de slice() para crear una nueva cadena

+ +

El siguiente ejemplo usa slice() para crear una nueva cadena.

+ +
var cadena1 = "La mañana se nos echa encima.";
+var cadena2 = cadena1.slice(3, -2);
+console.log(cadena2);
+
+ +

Esto escribe:

+ +
mañana se nos echa encim
+ +

Uso de slice() con índices negativos

+ +

El siguiente ejemplo usa slice() con índices negativos.

+ +
var cad = "La mañana se nos echa encima.";
+cad.slice(-3);     // retorna 'ma.'
+cad.slice(-3, -1); // retorna 'ma'
+cad.slice(0, -1);  // retorna 'La mañana se nos echa encima'
+ +

Especificaciones

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
EspecificaciónEstadoComentario
{{SpecName('ES3')}}{{Spec2('ES3')}}Definición inicial. Implementado en JavaScript 1.2.
{{SpecName('ES5.1', '#sec-15.5.4.13', 'String.prototype.slice')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-string.prototype.slice', 'String.prototype.slice')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-string.prototype.slice', 'String.prototype.slice')}}{{Spec2('ESDraft')}} 
+ +

Compatibilidad en 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/web/javascript/reference/global_objects/string/small/index.html b/files/es/web/javascript/reference/global_objects/string/small/index.html new file mode 100644 index 0000000000..a8b2f302fd --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/small/index.html @@ -0,0 +1,38 @@ +--- +title: String.prototype.small() +slug: Web/JavaScript/Referencia/Objetos_globales/String/small +tags: + - Deprecated + - HTML wrapper methods + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/small +--- +

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

+

{{deprecated_header}}

+

Resumen

+

Causa que una cadena se muestra con una fuente pequeña, como si estuviese dentro de una etiqueta {{HTMLElement("small")}}.

+

Sintaxis

+
cadena.small()
+

Descripción

+

Usa el método small para formatear y mostrar una cadena en un documento.

+

Ejemplos

+

Ejemplo: Usando métodos de string para cambiar el tamaño de una cadena

+
var cadenaMundo="¡Hola mundo!"
+
+console.log(cadenaMundo.small())
+console.log(cadenaMundo.big())
+console.log(cadenaMundo.fontsize(7))
+
+

Este ejemplo produce el mismo resultado que el siguiente código HTML:

+
<small>¡Hola mundo!</small>
+<big>¡Hola mundo!</big>
+<fontsize=7>¡Hola mundo!</fontsize>
+
+

Vea También

+ diff --git a/files/es/web/javascript/reference/global_objects/string/split/index.html b/files/es/web/javascript/reference/global_objects/string/split/index.html new file mode 100644 index 0000000000..ade291da0f --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/split/index.html @@ -0,0 +1,240 @@ +--- +title: String.prototype.split() +slug: Web/JavaScript/Referencia/Objetos_globales/String/split +tags: + - JavaScript + - Method + - Prototype + - Regular Expressions + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/split +--- +

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

+ +

El método split() divide un objeto de tipo String en un array (vector) de cadenas mediante la separación de la cadena en subcadenas.

+ +

Sintaxis

+ +
cadena.split([separador][,limite])
+ +

Parámetros

+ +
+
separador
+
Especifica el carácter a usar para la separación de la cadena. El separador es tratado como una cadena o como una {{jsxref("Objetos_globales/RegExp", "expresión regular", "", 1)}}. Si se omite el separador, el array devuelto contendrá un sólo elemento con la cadena completa.
+
+ +
+
limite
+
Opcional. Entero que especifica un límite sobre el número de divisiones a realizar. El método split() todavía se divide en todas las concordancias del separador, pero divide la matriz devuelta en la cantidad de elementos impuesta por el limite.
+
+ +

Descripción

+ +

El método split() devuelve el nuevo array.

+ +

Cuando se encuentra, el separador es eliminado de la cadena y las subcadenas obtenidas se devuelven en un array. Si el separador no es encontrado o se omite, el array contendrá un único elemento con la cadena original completa. Si el separador es una cadena vacía la cadena es convertida en un array de carácteres.

+ +

Si el separador es una expresión regular que contiene paréntesis de captura, entonces cada vez que el separador concuerda, los resultados (incluído cualquier resultado indefinido) de los paréntesis de captura son divididos en el array resultante. Sin embargo no todos los navegadores soportan esta característica.

+ +

{{Note("Cuando la cadena está vacía, split() devuelve un array que contiene una cadena vacía, en lugar de un array vacío.")}}

+ +

Ejemplos

+ +

Usando split()

+ +

El siguiente ejemplo define una función que divide una cadena en un array de cadenas usando el separador especificado. Después de la división de la cadena, la función muestra mensajes indicando la cadena original (antes de la división), el separador usado, el número de elementos del array y los elementos individuales del array.

+ +
function dividirCadena(cadenaADividir,separador) {
+   var arrayDeCadenas = cadenaADividir.split(separador);
+   document.write('<p>La cadena original es: "' + cadenaADividir + '"');
+   document.write('<br>El separador es: "' + separador + '"');
+   document.write("<br>El array tiene " + arrayDeCadenas.length + " elementos: ");
+
+   for (var i=0; i < arrayDeCadenas.length; i++) {
+      document.write(arrayDeCadenas[i] + " / ");
+   }
+}
+
+var cadenaVerso = "Oh brave new world that has such people in it.";
+var cadenaMeses = "Jan,Feb,Mar,Apr,May,Jun,Jul,Aug,Sep,Oct,Nov,Dec";
+
+var espacio = " ";
+var coma = ",";
+
+dividirCadena(cadenaVerso, espacio);
+dividirCadena(cadenaVerso);
+dividirCadena(cadenaMeses, coma);
+
+ +

Este ejemplo produce el siguiente resultado:

+ +
La cadena original es: "Oh brave new world that has such people in it."
+El separador es: " "
+El array tiene 10 elementos: Oh / brave / new / world / that / has / such / people / in / it. /
+
+La cadena original es: "Oh brave new world that has such people in it."
+El separador es: "undefined"
+El array tiene 1 elementos: Oh brave new world that has such people in it. /
+
+La cadena original es: "Jan,Feb,Mar,Apr,May,Jun,Jul,Aug,Sep,Oct,Nov,Dec"
+El separador es: ","
+El array tiene 12 elementos: Jan / Feb / Mar / Apr / May / Jun / Jul / Aug / Sep / Oct / Nov / Dec /
+
+ +

Eliminar espacios de una cadena

+ +

En el siguiente ejemplo, split busca 0 o más espacios seguidos de un punto y coma seguido por 0 o más espacios y, cuando los halla, elimina los espacios de la cadena. listaNombres es el array devuelto como resultado de la llamada a split.

+ +
var nombres = "Harry Trump ;Fred Barney; Helen Rigby ; Bill Abel ;Chris Hand ";
+document.write(nombres + "<br>" + "<br>");
+var expresionRegular = /\s*;\s*/;
+var listaNombres = nombres.split(expresionRegular);
+document.write(listaNombres);
+
+ +

Esto imprime dos líneas; la primera línea imprime la cadena original, y la segunda línea imprime el array resultante.

+ +
Harry Trump ;Fred Barney; Helen Rigby ; Bill Abel ;Chris Hand
+Harry Trump,Fred Barney,Helen Rigby,Bill Abel,Chris Hand
+
+ +

Devolviendo un número limitado de divisiones

+ +

El el siguiente ejemplo, split busca 0 o más espacios en una cadena y devuelve las tres primeras divisiones que encuentra.

+ +
var miCadena = "Hola Mundo. Cómo estás hoy?";
+var divisiones = miCadena.split(" ", 3);
+
+print(divisiones);
+
+ +

Este script muestra lo siguiente:

+ +
Hola,Mundo.,Cómo
+
+ +

Paréntesis de captura

+ +

Si el separador contiene paréntesis de capturaI los resultados que concuerden son devueltos en el array.

+ +
var miCadena = 'Hola 1 mundo. Oración número 2.';
+var division = miCadena.split(/(\d)/);
+
+console.log(division);
+ +
 
+ +
 
+ +
 
+ +
 
+ +

Este script muestra lo siguiente:

+ +
Hola ,1, mundo. Oración número ,2,.
+ +
 
+ +

Dar la vuelta a una cadena usando split()

+ +
var str = 'asdfghjkl';
+var strReverse = str.split('').reverse().join(''); // 'lkjhgfdsa'
+// split() retorna un array en el cual reverse() y join() pueden ser aplicados
+ +
 
+ +
 
+ +
 
+ +

Extra: usar el operador === para verificar si la cadena anterior era un palíndromo.

+ +

Specifications

+ + + + + + + + + + + + + + + + + + + + + + + + +
EspecificaciónEstadoComentario
ECMAScript 3rd Edition.EstándarDefinición inicial. Implementado en JavaScript 1.1.
{{SpecName('ES5.1', '#sec-15.5.4.14', 'String.prototype.split')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-string.prototype.split', 'String.prototype.split')}}{{Spec2('ES6')}} 
+ +

Compatibilidad con los 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/web/javascript/reference/global_objects/string/startswith/index.html b/files/es/web/javascript/reference/global_objects/string/startswith/index.html new file mode 100644 index 0000000000..c658cc80da --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/startswith/index.html @@ -0,0 +1,97 @@ +--- +title: String.prototype.startsWith() +slug: Web/JavaScript/Referencia/Objetos_globales/String/startsWith +tags: + - ECMAScript 2015 + - JavaScript + - Method + - Prototipo + - Prototype + - Reference + - Referencia + - String + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/String/startsWith +--- +
{{JSRef}}
+ +

El método startsWith() indica si una cadena de texto comienza con los caracteres de una cadena de texto concreta, devolviendo true o false según corresponda.

+ +
{{EmbedInteractiveExample("pages/js/string-startswith.html")}}
+ +

Sintaxis

+ +
str.startsWith(stringBuscada[, posicion])
+ +

Parámetros

+ +
+
stringBuscada
+
Los caracteres a ser buscados al inicio de la cadena de texto.
+
posicion {{optional_inline}}
+
La posición de str en la cual debe comenzar la búsqueda de stringBuscada. El valor por defecto es 0.
+
+ +

Valor devuelto

+ +

true si los caracteres dados se encuentran al inicio de la cadena de texto; false en cualquier otro caso.

+ +

Descripción

+ +

Este método te permite saber si una cadena de texto comienza o no con otra cadena de texto. Este método distingue entre mayúsculas y minúsculas.

+ +

Polyfill

+ +

Este método se ha añadido a la especificación ECMAScript 2015 y podría no estar disponible aún en todas las implementaciones de JavaScript. Sin embargo, puedes utilizar un polyfill de String.prototype.startsWith() con el siguiente fragmento de código:

+ +
if (!String.prototype.startsWith) {
+    Object.defineProperty(String.prototype, 'startsWith', {
+        value: function(search, rawPos) {
+            var pos = rawPos > 0 ? rawPos|0 : 0;
+            return this.substring(pos, pos + search.length) === search;
+        }
+    });
+}
+
+ +

Un polyfill más robusto (totalmente compatible con la especificación ES2015), pero con menos rendimiento y menos compacto está disponible en GitHub, por Mathias Bynens.

+ +

Ejemplos

+ +

Usando startsWith()

+ +
//startswith
+var str = 'Ser, o no ser. ¡Esa es la cuestión!';
+
+console.log(str.startsWith('Ser'));           // true
+console.log(str.startsWith('no ser'));        // false
+console.log(str.startsWith('Esa es la', 16)); // true
+
+ +

Especificaciones

+ + + + + + + + + + + + +
Especificación
{{SpecName('ESDraft', '#sec-string.prototype.startswith', 'String.prototype.startsWith')}}
+ +

Compatibilidad en navegadores

+ +

{{Compat("javascript.builtins.String.startsWith")}}

+ +

Ver también

+ + diff --git a/files/es/web/javascript/reference/global_objects/string/strike/index.html b/files/es/web/javascript/reference/global_objects/string/strike/index.html new file mode 100644 index 0000000000..20ba5e9c90 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/strike/index.html @@ -0,0 +1,42 @@ +--- +title: String.prototype.strike() +slug: Web/JavaScript/Referencia/Objetos_globales/String/strike +tags: + - Deprecated + - HTML wrapper methods + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/strike +--- +

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

+

{{deprecated_header}}

+

Resumen

+

Causa que una cadena se muestre como texto tachado, como si estuviese dentro de una etiqueta {{HTMLElement("strike")}}.

+

Sintaxis

+
cadena.strike()
+

Descripción

+

Usa el método strike para formatear y mostrar una cadena en un documento.

+

Ejemplos

+

Ejemplo: Usando métodos de string para cambiar el formateado de una cadena

+

El siguiente ejemplo usa los métodos de string para cambiar el formateado de una cadena:

+
var cadenaMundo="¡Hola mundo!"
+
+console.log(cadenaMundo.blink())
+console.log(cadenaMundo.bold())
+console.log(cadenaMundo.italics())
+console.log(cadenaMundo.strike())
+
+

Este ejemplo produce el mismo resultado que el siguiente código HTML:

+
<blink>¡Hola mundo!</blink>
+<b>¡Hola mundo!</b>
+<i>¡Hola mundo!</i>
+<strike>¡Hola mundo!</strike>
+
+

Vea También

+ diff --git a/files/es/web/javascript/reference/global_objects/string/sub/index.html b/files/es/web/javascript/reference/global_objects/string/sub/index.html new file mode 100644 index 0000000000..195bca9d1e --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/sub/index.html @@ -0,0 +1,35 @@ +--- +title: String.prototype.sub() +slug: Web/JavaScript/Referencia/Objetos_globales/String/sub +tags: + - HTML wrapper methods + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/sub +--- +

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

+

Resumen

+

Causa que una cadena se muestre como subíndice, como si estuviese dentro de una etiqueta {{HTMLElement("sub")}}.

+

Sintaxis

+
cadena.sub()
+

Descripción

+

Usa el método sub junto para formatear y mostrar una cadena en un documento.

+

Ejemplos

+

Ejemplo: Usando los métodos sub y sup para formatear una cadena

+

El siguiente ejemplo usa los métodos sub y sup para formatear una cadena:

+
var superText="superscript"
+var subText="subscript"
+
+console.log("Esto es lo que un " + superText.sup() + " parece.")
+console.log("Esto es lo que un " + subText.sub() + " parece.")
+
+

Este ejemplo produce el mismo resultado que el siguiente código HTML:

+
Esto es lo que <sup>superscript</sup> parece.
+Esto es lo que <sub>subscript</sub> parece.
+
+

Vea También

+ diff --git a/files/es/web/javascript/reference/global_objects/string/substr/index.html b/files/es/web/javascript/reference/global_objects/string/substr/index.html new file mode 100644 index 0000000000..290d1292ab --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/substr/index.html @@ -0,0 +1,83 @@ +--- +title: String.prototype.substr() +slug: Web/JavaScript/Referencia/Objetos_globales/String/substr +tags: + - JavaScript + - Método(2) + - Prototipo + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/substr +--- +

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

+ +
Advertencia: Aunque String.prototype.substr(…) no está estrictamente obsoleto (como en "eliminado de los estándares web"), se define en el anexo B de la norma ECMA-262, cuya introducción establece: + +
... Todas las características y comportamientos del lenguaje especificados en este anexo tienen una o más características indeseables y, en ausencia de uso heredado, se eliminarían de esta especificación. ... ... Los programadores no deben usar ni asumir la existencia de estas características y comportamientos al escribir un nuevo código ECMAScript.
+
+ +

 

+ +

Resumen

+ +

El método substr() devuelve los caracteres de una cadena que comienzan en una localización especificada y de acuerdo al número de caracteres que se especifiquen.

+ +

Sintaxis

+ +
cadena.substr(inicio[, longitud])
+ +

Parámetros

+ +
+
inicio
+
Localización en la cual se empiezan a extraer caracteres. Si se da un número negativo, se trata como longCad + inicio donde  longCad es la longitud de la cadena (por ejemplo, si inicio es -3 se trata como longCad - 3).
+
+ +
+
longitud
+
Opcional. El número de caracteres a extraer. Si este argumento es {{jsxref("undefined")}}, todos los caracteres desde inicio hasta el final de la cadena serán extraidos.
+
+ +

Valor retornado

+ +

Una nueva cadena que contiende la sección extraída de la cadena dada. Sí la longitud es 0 o un número negativo, retorna la cadena vacía.

+ +

Descripción

+ +

inicio es el índice de un carácter. El índice del primer carácter es 0, y el índice del último carácter es la longitud de la cadena menos 1. substr comienza extrayendo caracteres a partir de inicio y recolecta longitud  caracteres (a menos que se alcance primero el final de la cadena, en cuyo caso devuelve menos).

+ +

Si inicio es positivo y es mayor o igual que la longitud de la cadena, substr() devuelve una cadena vacía.

+ +

Si inicio es negativo, substr() lo usa como un índice de carácter desde el final de la cadena. Si inicio es negativo y abs(inicio) es mayor que la longitud de la cadena, substr usa 0 como índice inical. Nota: el uso descrito de valores negativos del argumento inicio no es soportado por Microsoft JScript .

+ +

Si longitud es 0 o negativa, substr devuelve una cadena vacía. Si se omite longitud, inicio extrae caracteres hasta el final de la cadena.

+ +

Ejemplos

+ +

Ejemplo: Uso de substr()

+ +
var cadena = "abcdefghij";
+
+console.log("(1,2): "    + cadena.substr(1,2));   // '(1, 2): bc'
+console.log("(-3,2): "   + cadena.substr(-3,2));  // '(-3, 2): hi'
+console.log("(-3): "     + cadena.substr(-3));    // '(-3): hij'
+console.log("(1): "      + cadena.substr(1));     // '(1): bcdefghij'
+console.log("(-20, 2): " + cadena.substr(-20,2)); // '(-20, 2): ab'
+console.log("(20, 2): "  + cadena.substr(20,2));  // '(20, 2): '
+
+ +

Este script muestra:

+ +
(1,2): bc
+(-3,2): hi
+(-3): hij
+(1): bcdefghij
+(-20, 2): ab
+(20, 2):
+
+ +

Vea También

+ + diff --git a/files/es/web/javascript/reference/global_objects/string/substring/index.html b/files/es/web/javascript/reference/global_objects/string/substring/index.html new file mode 100644 index 0000000000..9918417f95 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/substring/index.html @@ -0,0 +1,92 @@ +--- +title: String.prototype.substring() +slug: Web/JavaScript/Referencia/Objetos_globales/String/substring +tags: + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/substring +--- +

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

+ +

Resumen

+ +

El substring() método devuelve un subconjunto de un objeto String.

+ +

Sintaxis

+ +
cadena.substring(indiceA[, indiceB'])
+ +

Parámetros

+ +
+
indiceA
+
Un entero entre 0 y la longitud de la cadena menos 1.
+
indiceB
+
(opcional) Un entero entre 0 y la longitud de la cadena.
+
+ +

Descripción

+ +

substring extrae caracteres desde indiceA hasta indiceB sin incluirlo. En particular:

+ + + +

Si indiceA es mayor que indiceB, entonces el efecto de substring es como si los dos argumentos se intercambiasen; por ejemplo, cadena.substring(1, 0) == cadena.substring(0, 1).

+ +

Ejemplos

+ +

Ejemplo: Usando substring

+ +

El siguiente ejemplo usa substring para mostrar caracteres de la cadena "Mozilla":

+ +
// asume una función print ya definida
+var cualquierCadena = "Mozilla";
+
+// Muestra "Moz"
+print(cualquierCadena.substring(0,3));
+print(cualquierCadena.substring(3,0));
+
+// Muestra "lla"
+print(cualquierCadena.substring(4,7));
+print(cualquierCadena.substring(7,4));
+
+// Muestra "Mozill"
+print(cualquierCadena.substring(0,6));
+print(cualquierCadena.substring(6,0));
+
+// Muestra "Mozilla"
+print(cualquierCadena.substring(0,7));
+print(cualquierCadena.substring(0,10));
+
+ +

Ejemplo: Reemplazar una subcadena dentro de una cadena

+ +

El siguiente ejemplo reemplaza una subcadena dentro de una cadena. Reemplazará tanto caracteres individuales como subcadenas. La llamada de la función al final del ejemplo cambia la cadena "Bravo Nuevo Mundo" por "Bravo Nueva Web".

+ +
function reemplazarCadena(cadenaVieja, cadenaNueva, cadenaCompleta) {
+// Reemplaza cadenaVieja por cadenaNueva en cadenaCompleta
+
+   for (var i = 0; i < cadenaCompleta.length; i++) {
+      if (cadenaCompleta.substring(i, i + cadenaVieja.length) == cadenaVieja) {
+         cadenaCompleta= cadenaCompleta.substring(0, i) + cadenaNueva + cadenaCompleta.substring(i + cadenaVieja.length, cadenaCompleta.length);
+      }
+   }
+   return cadenaCompleta;
+}
+
+reemplazarCadena("Mundo", "Web", "Bravo Nuevo Mundo");
+
+ +

Vea También

+ + diff --git a/files/es/web/javascript/reference/global_objects/string/sup/index.html b/files/es/web/javascript/reference/global_objects/string/sup/index.html new file mode 100644 index 0000000000..6b8db218b6 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/sup/index.html @@ -0,0 +1,35 @@ +--- +title: String.prototype.sup() +slug: Web/JavaScript/Referencia/Objetos_globales/String/sup +tags: + - HTML wrapper methods + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/sup +--- +

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

+

Resumen

+

Causa que una cadena se muestre como superíndice, como si estuviese dentro de una etiqueta {{HTMLElement("sup")}}.

+

Sintaxis

+
cadena.sup()
+

Descripción

+

Usa el método sup junto para formatear y mostrar una cadena en un documento.

+

Ejemplos

+

Ejemplo: Usando los métodos sub y sup para formatear una cadena

+

El siguiente ejemplo usa los métodos sub y sup para formatear una cadena:

+
var textoSuper="superscript"
+var textoSub="subscript"
+
+console.log("Esto es lo que un " + textoSuper.sup() + " parece.")
+console.log("Esto es lo que un " + textoSub.sub() + " parece.")
+
+

Este ejemplo produce el mismo resultado que el siguiente código HTML:

+
Esto es lo que <sup>superscript</sup> parece.
+Esto es lo que <sub>subscript</sub> parece.
+
+

Vea También

+ diff --git a/files/es/web/javascript/reference/global_objects/string/tolocalelowercase/index.html b/files/es/web/javascript/reference/global_objects/string/tolocalelowercase/index.html new file mode 100644 index 0000000000..5c1eae2144 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/tolocalelowercase/index.html @@ -0,0 +1,113 @@ +--- +title: String.prototype.toLocaleLowerCase() +slug: Web/JavaScript/Referencia/Objetos_globales/String/toLocaleLowerCase +tags: + - Cadena + - Internacionalizacion + - Prototipo + - Referencia + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase +--- +
{{JSRef}}
+ +
El método toLocaleLowerCase() retorna la cadena de texto desde la que se llama convertida en minúsculas, de acuerdo con cualquier localización específica de correspondencia de mayúsculas y minúsculas.
+ +
 
+ +
{{EmbedInteractiveExample("pages/js/string-tolocalelowercase.html")}}
+ + + +

Sintaxis

+ +
str.toLocaleLowerCase()
+str.toLocaleLowerCase(locale)
+str.toLocaleLowerCase([locale, locale, ...])
+
+ +

Parámetros

+ +
+
locale {{optional_inline}}
+
El parámetro locale indica la localización que se utilizará para convertir a minúsculas de acuerdo con culalquier correspondencia de mayúsculas y minúsculas. Si se proporcionan múltiples locales en un {{jsxref("Array")}}, se utiliza el mejor local disponible. La localización por defecto es la localización actual configurada en el host.
+
+ +

Valor retornado

+ +

Una nueva cadena que representa la cadena desde la que se llama convertida a minúsculas, de acuerdo con cualquier localización específica de correspondencia de mayúsculas y minúsculas.

+ +

Excepciones

+ + + +

Descripción

+ +

El método toLocaleLowerCase() retorna la cadena de texto desde la que se llama convertida en minúsculas, de acuerdo con cualquier localización específica de correspondencia de mayúsculas y minúsculas.  toLocaleLowerCase() no afecta el valor de la cadena desde la que se llama. En la mayoría de los casos, producirá el mismo resultado que {{jsxref("String.prototype.toLowerCase()", "toLowerCase()")}}, pero para algunos locales, como el turco, cuyas correspondencias de mayúsculas y minúsculas no siguen las correpsondencias por defecto de Unicode, podría producir de un resultado diferente.

+ +

Ejemplos

+ +

Utilizando toLocaleLowerCase()

+ +
'ALPHABET'.toLocaleLowerCase(); // 'alphabet'
+
+'\u0130'.toLocaleLowerCase('tr') === 'i';    // true
+'\u0130'.toLocaleLowerCase('en-US') === 'i'; // false
+
+let locales = ['tr', 'TR', 'tr-TR', 'tr-u-co-search', 'tr-x-turkish'];
+'\u0130'.toLocaleLowerCase(locales) === 'i'; // true
+
+ +

Especificaciones

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
EspecificaciónEstatusComentario
{{SpecName('ES3')}}{{Spec2('ES3')}}Initial definition. Implemented in JavaScript 1.2.
{{SpecName('ES5.1', '#sec-15.5.4.17', 'String.prototype.toLocaleLowerCase')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-string.prototype.tolocalelowercase', 'String.prototype.toLocaleLowerCase')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-string.prototype.tolocalelowercase', 'String.prototype.toLocaleLowerCase')}}{{Spec2('ESDraft')}} 
{{SpecName('ES Int Draft', '#sup-string.prototype.tolocalelowercase', 'String.prototype.toLocaleLowerCase')}}{{Spec2('ES Int Draft')}}ES Intl 2017 added the locale parameter.
+ +

Compatibilidad entre navegadores

+ + + +

{{Compat("javascript.builtins.String.toLocaleLowerCase")}}

+ +

Vea también

+ + diff --git a/files/es/web/javascript/reference/global_objects/string/tolocaleuppercase/index.html b/files/es/web/javascript/reference/global_objects/string/tolocaleuppercase/index.html new file mode 100644 index 0000000000..7199ca3ae5 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/tolocaleuppercase/index.html @@ -0,0 +1,100 @@ +--- +title: String.prototype.toLocaleUpperCase() +slug: Web/JavaScript/Referencia/Objetos_globales/String/toLocaleUpperCase +translation_of: Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase +--- +
{{JSRef}}
+ +

El método toLocaleUpperCase() devuelve el valor de la cadena que lo llama convertido en mayúsculas, de acuerdo con las asignaciones de casos específicos de la configuración regional.

+ +

Syntaxis

+ +
str.toLocaleUpperCase()
+str.toLocaleUpperCase(locale)
+str.toLocaleUpperCase([locale, locale, ...])
+
+ +

Parámetros

+ +
+
locale {{optional_inline}}
+
El parámetro locale indica la configuración regional que se va a utilizar para convertir en mayúsculas según las asignaciones de casos específicos de la configuración regional. Si se proporcionan varios locales en un {{jsxref ("Array")}}, se utiliza la mejor configuración regional disponible. La configuración regional predeterminada es la configuración regional actual del entorno de host.
+
+ +

Valor de retorno

+ +

Una nueva cadena que representa la cadena de llamada convertida en mayúsculas, de acuerdo con cualquier asignación de mayúsculas de idioma específico.

+ +

Exceciones

+ + + +

Descripción

+ +

El método toLocaleUpperCase() devuelve el valor de la cadena convertida en mayúsculas según las asignaciones de casos específicos de la configuración regional. toLocaleUpperCase() no afecta al valor de la cadena en sí. En la mayoría de los casos, esto producirá el mismo resultado que {{jsxref("String.prototype.toUpperCase()", "toUpperCase()")}}, pero para algunas localidades, como turco, cuyas asignaciones de mayúsculas y minúsculas no siguen la mayúsculas y minúsculas en Unicode, puede haber un resultado diferente.

+ +

Ejemplos

+ +

Usando toLocaleUpperCase()

+ +
'alphabet'.toLocaleUpperCase(); // 'ALPHABET'
+
+'i\u0307'.toLocaleUpperCase('lt-LT'); // 'I'
+
+let locales = ['lt', 'LT', 'lt-LT', 'lt-u-co-phonebk', 'lt-x-lietuva'];
+'i\u0307'.toLocaleUpperCase(locales); // 'I'
+
+ +

Especificaciones

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
EspecificaciónStatusComentario
{{SpecName('ES3')}}{{Spec2('ES3')}}Initial definition. Implemented in JavaScript 1.2.
{{SpecName('ES5.1', '#sec-15.5.4.19', 'String.prototype.toLocaleUpperCase')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-string.prototype.tolocaleuppercase', 'String.prototype.toLocaleUpperCase')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-string.prototype.tolocaleuppercase', 'String.prototype.toLocaleUpperCase')}}{{Spec2('ESDraft')}} 
{{SpecName('ES Int Draft', '#sup-string.prototype.tolocaleuppercase', 'String.prototype.toLocaleUpperCase')}}{{Spec2('ES Int Draft')}}ES Intl 2017 added the locale parameter.
+ +

Compatibilidad de navegadores

+ + + +

{{Compat("javascript.builtins.String.toLocaleUpperCase")}}

+ +

Ver también

+ + diff --git a/files/es/web/javascript/reference/global_objects/string/tolowercase/index.html b/files/es/web/javascript/reference/global_objects/string/tolowercase/index.html new file mode 100644 index 0000000000..8060f3dd1c --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/tolowercase/index.html @@ -0,0 +1,40 @@ +--- +title: String.prototype.toLowerCase() +slug: Web/JavaScript/Referencia/Objetos_globales/String/toLowerCase +tags: + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/toLowerCase +--- +

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

+ +

Resumen

+ +

El método toLowerCase() devuelve el valor en minúsculas de la cadena que realiza la llamada.

+ +

Sintaxis

+ +
cadena.toLowerCase()
+ +

Descripción

+ +

El método toLowerCase devuelve el valor de la cadena convertida a minúsculas. toLowerCase no afecta al valor de la cadena en sí misma.

+ +

Ejemplos

+ +

Ejemplo: Usando toLowerCase

+ +

El siguiente ejemplo muestra la cadena "alfabeto" en minúsculas:

+ +
var textoMayusculas="ALFABETO"
+document.write(textoMayusculas.toLowerCase())
+
+ +

Vea También

+ + diff --git a/files/es/web/javascript/reference/global_objects/string/tosource/index.html b/files/es/web/javascript/reference/global_objects/string/tosource/index.html new file mode 100644 index 0000000000..104738c22d --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/tosource/index.html @@ -0,0 +1,56 @@ +--- +title: String.prototype.toSource() +slug: Web/JavaScript/Referencia/Objetos_globales/String/toSource +tags: + - Cadena + - JavaScript + - No estandar + - Prototipo + - Referencia + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/String/toSource +--- +
{{JSRef}} {{non-standard_header}}
+ +

El método toSource() devuelve una cadena que representa el código fuente del objeto.

+ +

Sintaxis

+ +
String.toSource()
+str.toSource()
+
+ +

Valor devuelto

+ +

Una cadena que representa el código fuente del objeto.

+ +

Descripción

+ +

El método toSource() devuelve los siguientes valores:

+ +

Para el objeto incorporado {{jsxref("String")}}, toSource() devuelve la siguiente cadena indicando que el código fuente no está disponible:

+ +
function String() {
+    [native code]
+}
+
+ +

Para instancias de {{jsxref("String")}} o cadenas literales, toSource() devuelve una cadena representando el código fuente.

+ +

Este método usualmente es llamado internamente por JavaScript y no explícitamente en código.

+ +

Especificaciones

+ +

No es parte de ningún estándar. Implementado en JavaScript 1.3.

+ +

Compatibilidad entre navegadores

+ + + +

{{Compat("javascript.builtins.String.toSource")}}

+ +

Véase también

+ + diff --git a/files/es/web/javascript/reference/global_objects/string/tostring/index.html b/files/es/web/javascript/reference/global_objects/string/tostring/index.html new file mode 100644 index 0000000000..89f53666b1 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/tostring/index.html @@ -0,0 +1,28 @@ +--- +title: String.prototype.toString() +slug: Web/JavaScript/Referencia/Objetos_globales/String/toString +tags: + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/toString +--- +

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

+

Resumen

+

El toString() método devuelve una cadena que representa al objeto especificado.

+

Sintaxis

+
cadena.toString()
+

Descripción

+

El objeto String sobreescribe el método toString del objeto {{jsxref("Object")}} object; no hereda {{jsxref("Object.toString()")}}. Para objetos String, el método toString devuelve una cadena que representa al objeto.

+

Ejemplos

+

Ejemplo: Usando toString

+

El siguiente ejemplo muestra el valor cadena de un objeto String:

+
cadena = new String("Hello world");
+alert(cadena.toString())      // Displays "Hello world"
+
+

Vea También

+ diff --git a/files/es/web/javascript/reference/global_objects/string/touppercase/index.html b/files/es/web/javascript/reference/global_objects/string/touppercase/index.html new file mode 100644 index 0000000000..77b05b28b4 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/touppercase/index.html @@ -0,0 +1,39 @@ +--- +title: String.prototype.toUpperCase() +slug: Web/JavaScript/Referencia/Objetos_globales/String/toUpperCase +tags: + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/toUpperCase +--- +

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

+ +

Resumen

+ +

El toUpperCase() método devuelve el valor convertido en mayúsculas de la cadena que realiza la llamada.

+ +

Sintaxis

+ +
cadena.toUpperCase()
+ +

Descripción

+ +

El método toUpperCase devuelve el valor de la cadena convertida a mayúsculas. toUpperCase no afecta al valor de la cadena en sí mismo.

+ +

Ejemplos

+ +

Ejemplo: Usando toUpperCase

+ +

El siguiente ejemplo muestra la cadena "ALPHABET":

+ +
console.log( "alphabet".toUpperCase() ); // "ALPHABET"
+
+ +

Vea También

+ + diff --git a/files/es/web/javascript/reference/global_objects/string/trim/index.html b/files/es/web/javascript/reference/global_objects/string/trim/index.html new file mode 100644 index 0000000000..d958d713eb --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/trim/index.html @@ -0,0 +1,133 @@ +--- +title: String.prototype.trim() +slug: Web/JavaScript/Referencia/Objetos_globales/String/Trim +translation_of: Web/JavaScript/Reference/Global_Objects/String/Trim +--- +
{{JSRef("Global_Objects", "String")}}
+ +

Resumen

+ +

El método trim( ) elimina los espacios en blanco en ambos extremos del string. Los espacios en blanco en este contexto, son todos los caracteres sin contenido (espacio, tabulación, etc.) y todos los caracteres de nuevas lineas (LF,CR,etc.).

+ +

Sintaxis

+ +
str.trim()
+ +

Una nueva cadena que representa la cadena de llamada sin espacios en blanco de ambos extremos.

+ +

Descripción

+ +

El método trim( ) devuelve la cadena de texto despojada de los espacios en blanco en ambos extremos. El método no afecta al valor de la cadena de texto.

+ +

Ejemplos

+ +

Ejemplo: Uso de trim()

+ +

El siguiente ejemplo muestra la cadena de texto en minúsculas 'foo':

+ +
var orig = '   foo  ';
+console.log(orig.trim()); // 'foo'
+
+// Otro ejemplo de .trim() eliminando el espacio en blanco sólo de un lado.
+
+var orig = 'foo    ';
+console.log(orig.trim()); // 'foo'
+
+ +

Polyfill

+ +

Ejecutar el siguiente código antes de cualquier otro código creará un trim ( ) si este no está disponible de manera nativa.

+ +
if (!String.prototype.trim) {
+  (function() {
+    // Make sure we trim BOM and NBSP
+    var rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g;
+    String.prototype.trim = function() {
+      return this.replace(rtrim, '');
+    };
+  })();
+}
+
+ +

Especificaciones

+ + + + + + + + + + + + + + + + + + + +
EspecificaciónEstatusComentario
{{SpecName('ES5.1', '#sec-15.5.4.20', 'String.prototype.trim')}}{{Spec2('ES5.1')}} +

Definición inicial. Implementado en JavaScript 1.8.1.

+
{{SpecName('ES6', '#sec-string.prototype.trim', 'String.prototype.trim')}}{{Spec2('ES6')}} 
+ +

Compatibilidad en Navegadores

+ +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + +
CaracterísticaChromeFirefox (Gecko)Internet ExplorerOperaSafari
Soporte Básico{{CompatVersionUnknown}}{{CompatGeckoDesktop("1.9.1")}}{{CompatIE("9")}}{{CompatOpera("10.5")}}{{CompatSafari("5")}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
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/web/javascript/reference/global_objects/string/trimend/index.html b/files/es/web/javascript/reference/global_objects/string/trimend/index.html new file mode 100644 index 0000000000..6252141adf --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/trimend/index.html @@ -0,0 +1,82 @@ +--- +title: String.prototype.trimEnd() +slug: Web/JavaScript/Referencia/Objetos_globales/String/trimEnd +tags: + - Espacios en blanco + - JavaScript + - Métodos + - Prototype + - String + - Texto + - cadenas de texto +translation_of: Web/JavaScript/Reference/Global_Objects/String/trimEnd +--- +
{{JSRef}}
+ +

El método trimEnd() elimina los espacios en blanco al final de una cadena de carácteres. trimRight() es el alias de este método.

+ +
{{EmbedInteractiveExample("pages/js/string-trimend.html")}}
+ + + +

Sintaxis

+ +
str.trimEnd();
+str.trimRight();
+ +

Valor de retorno

+ +

Una nueva cadena de texto que representa la cadena de texto llamada sin espacios en blanco de su extremo (derecho).

+ +

Descripción

+ +

trimEnd() / trimRight() Los metodos devuelven una cadena de texto sin espacios en blanco desde su extremo derecho. trimEnd() ó trimRight() no afectan el valor de la cadena de texto en sí.

+ +

Superposición

+ +

Por coherencia de funciones como {{jsxref("String.prototype.padEnd")}} el nombre del método estandar es trimEnd. Sin embargo por compatibilidad web, trimRight permanece como un alias para trimEnd. En algunos motores esto significa: 

+ +
String.prototype.trimRight.name === "trimEnd";
+ +

Ejemplo

+ +

Usando trimEnd()

+ +

El siguiente ejemplo muestra la cadena de texto en minusculas '   foo':

+ +
var str = '   foo  ';
+
+console.log(str.length); // 8
+
+str = str.trimEnd();
+console.log(str.length); // 6
+console.log(str);        // '   foo'
+
+ +

Especificaciones

+ + + + + + + + + + + + +
Especificación
{{SpecName('ESDraft', '#sec-string.prototype.trimend', 'String.prototype.trimEnd')}}
+ +

Compatibilidad en Navegadores

+ + + +

{{Compat("javascript.builtins.String.trimEnd")}}

+ +

Ver también

+ + diff --git a/files/es/web/javascript/reference/global_objects/string/valueof/index.html b/files/es/web/javascript/reference/global_objects/string/valueof/index.html new file mode 100644 index 0000000000..b287c4d774 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/valueof/index.html @@ -0,0 +1,28 @@ +--- +title: String.prototype.valueOf() +slug: Web/JavaScript/Referencia/Objetos_globales/String/valueOf +tags: + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/valueOf +--- +

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

+

Resumen

+

The valueOf() método devuelve el valor primitivo de un objeto String.

+

Sintaxis

+
caneda.valueOf()
+

Descripción

+

El método valueOf de String devuelve el valor primitivo de un objeto String como un tipo de dato cadena. Este valor es equivalente a String.toString.

+

Normalmente este método es llamado internamente por JavaScript y no en el código.

+

Ejemplos

+

Ejemplo: Usando valueOf

+
cadena = new String("Hello world");
+alert(cadena.valueOf())          // Displays "Hello world"
+
+

Vea También

+ -- cgit v1.2.3-54-g00ecf