From 27f2d4318206caff7c031f12497d87fd49aadad1 Mon Sep 17 00:00:00 2001 From: GrayWolf Date: Wed, 31 Aug 2022 21:49:53 +0000 Subject: [PATCH 1/2] Convert /web/javascript/reference/global_objects/string folder to Markdown (es) --- .../global_objects/string/anchor/index.html | 57 --- .../global_objects/string/anchor/index.md | 55 +++ .../global_objects/string/big/index.html | 55 --- .../global_objects/string/big/index.md | 51 +++ .../global_objects/string/blink/index.html | 43 -- .../global_objects/string/blink/index.md | 58 +++ .../global_objects/string/bold/index.html | 44 -- .../global_objects/string/bold/index.md | 58 +++ .../global_objects/string/charat/index.html | 98 ----- .../global_objects/string/charat/index.md | 75 ++++ .../string/charcodeat/index.html | 66 --- .../global_objects/string/charcodeat/index.md | 57 +++ .../string/codepointat/index.html | 126 ------ .../string/codepointat/index.md | 105 +++++ .../global_objects/string/concat/index.html | 91 ----- .../global_objects/string/concat/index.md | 76 ++++ .../global_objects/string/endswith/index.html | 89 ---- .../global_objects/string/endswith/index.md | 80 ++++ .../global_objects/string/fixed/index.html | 36 -- .../global_objects/string/fixed/index.md | 51 +++ .../string/fontcolor/index.html | 75 ---- .../global_objects/string/fontcolor/index.md | 60 +++ .../global_objects/string/fontsize/index.html | 76 ---- .../global_objects/string/fontsize/index.md | 61 +++ .../string/fromcharcode/index.html | 83 ---- .../string/fromcharcode/index.md | 60 +++ .../string/fromcodepoint/index.html | 157 ------- .../string/fromcodepoint/index.md | 143 +++++++ .../global_objects/string/includes/index.html | 109 ----- .../global_objects/string/includes/index.md | 99 +++++ .../global_objects/string/index.html | 386 ------------------ .../reference/global_objects/string/index.md | 306 ++++++++++++++ .../global_objects/string/indexof/index.html | 105 ----- .../global_objects/string/indexof/index.md | 104 +++++ .../global_objects/string/italics/index.html | 50 --- .../global_objects/string/italics/index.md | 49 +++ .../string/lastindexof/index.html | 80 ---- .../string/lastindexof/index.md | 77 ++++ .../global_objects/string/length/index.html | 95 ----- .../global_objects/string/length/index.md | 73 ++++ .../global_objects/string/link/index.html | 57 --- .../global_objects/string/link/index.md | 55 +++ .../global_objects/string/match/index.html | 79 ---- .../global_objects/string/match/index.md | 75 ++++ .../global_objects/string/matchall/index.html | 135 ------ .../global_objects/string/matchall/index.md | 126 ++++++ .../string/normalize/index.html | 127 ------ .../global_objects/string/normalize/index.md | 101 +++++ .../global_objects/string/padstart/index.html | 53 --- .../global_objects/string/padstart/index.md | 50 +++ .../global_objects/string/raw/index.html | 111 ----- .../global_objects/string/raw/index.md | 89 ++++ .../global_objects/string/repeat/index.html | 129 ------ .../global_objects/string/repeat/index.md | 107 +++++ .../global_objects/string/search/index.html | 106 ----- .../global_objects/string/search/index.md | 78 ++++ .../global_objects/string/slice/index.html | 114 ------ .../global_objects/string/slice/index.md | 87 ++++ .../global_objects/string/small/index.html | 39 -- .../global_objects/string/small/index.md | 53 +++ .../string/startswith/index.html | 98 ----- .../global_objects/string/startswith/index.md | 87 ++++ .../global_objects/string/strike/index.html | 43 -- .../global_objects/string/strike/index.md | 58 +++ .../global_objects/string/sub/index.html | 36 -- .../global_objects/string/sub/index.md | 50 +++ .../global_objects/string/substr/index.html | 84 ---- .../global_objects/string/substr/index.md | 73 ++++ .../string/substring/index.html | 93 ----- .../global_objects/string/substring/index.md | 89 ++++ .../global_objects/string/sup/index.html | 36 -- .../global_objects/string/sup/index.md | 50 +++ .../string/tolocaleuppercase/index.html | 99 ----- .../string/tolocaleuppercase/index.md | 66 +++ .../string/tolowercase/index.html | 41 -- .../string/tolowercase/index.md | 38 ++ .../global_objects/string/tostring/index.html | 29 -- .../global_objects/string/tostring/index.md | 40 ++ .../string/touppercase/index.html | 40 -- .../string/touppercase/index.md | 39 ++ .../global_objects/string/trim/index.html | 86 ---- .../global_objects/string/trim/index.md | 69 ++++ .../global_objects/string/trimend/index.html | 81 ---- .../global_objects/string/trimend/index.md | 71 ++++ .../global_objects/string/valueof/index.html | 29 -- .../global_objects/string/valueof/index.md | 40 ++ 86 files changed, 3289 insertions(+), 3666 deletions(-) delete mode 100644 files/es/web/javascript/reference/global_objects/string/anchor/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/anchor/index.md delete mode 100644 files/es/web/javascript/reference/global_objects/string/big/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/big/index.md delete mode 100644 files/es/web/javascript/reference/global_objects/string/blink/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/blink/index.md delete mode 100644 files/es/web/javascript/reference/global_objects/string/bold/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/bold/index.md delete mode 100644 files/es/web/javascript/reference/global_objects/string/charat/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/charat/index.md delete mode 100644 files/es/web/javascript/reference/global_objects/string/charcodeat/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/charcodeat/index.md delete mode 100644 files/es/web/javascript/reference/global_objects/string/codepointat/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/codepointat/index.md delete mode 100644 files/es/web/javascript/reference/global_objects/string/concat/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/concat/index.md delete mode 100644 files/es/web/javascript/reference/global_objects/string/endswith/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/endswith/index.md delete mode 100644 files/es/web/javascript/reference/global_objects/string/fixed/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/fixed/index.md delete mode 100644 files/es/web/javascript/reference/global_objects/string/fontcolor/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/fontcolor/index.md delete mode 100644 files/es/web/javascript/reference/global_objects/string/fontsize/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/fontsize/index.md delete mode 100644 files/es/web/javascript/reference/global_objects/string/fromcharcode/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/fromcharcode/index.md delete mode 100644 files/es/web/javascript/reference/global_objects/string/fromcodepoint/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/fromcodepoint/index.md delete mode 100644 files/es/web/javascript/reference/global_objects/string/includes/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/includes/index.md delete mode 100644 files/es/web/javascript/reference/global_objects/string/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/index.md delete mode 100644 files/es/web/javascript/reference/global_objects/string/indexof/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/indexof/index.md delete mode 100644 files/es/web/javascript/reference/global_objects/string/italics/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/italics/index.md delete mode 100644 files/es/web/javascript/reference/global_objects/string/lastindexof/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/lastindexof/index.md delete mode 100644 files/es/web/javascript/reference/global_objects/string/length/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/length/index.md delete mode 100644 files/es/web/javascript/reference/global_objects/string/link/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/link/index.md delete mode 100644 files/es/web/javascript/reference/global_objects/string/match/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/match/index.md delete mode 100644 files/es/web/javascript/reference/global_objects/string/matchall/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/matchall/index.md delete mode 100644 files/es/web/javascript/reference/global_objects/string/normalize/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/normalize/index.md delete mode 100644 files/es/web/javascript/reference/global_objects/string/padstart/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/padstart/index.md delete mode 100644 files/es/web/javascript/reference/global_objects/string/raw/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/raw/index.md delete mode 100644 files/es/web/javascript/reference/global_objects/string/repeat/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/repeat/index.md delete mode 100644 files/es/web/javascript/reference/global_objects/string/search/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/search/index.md delete mode 100644 files/es/web/javascript/reference/global_objects/string/slice/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/slice/index.md delete mode 100644 files/es/web/javascript/reference/global_objects/string/small/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/small/index.md delete mode 100644 files/es/web/javascript/reference/global_objects/string/startswith/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/startswith/index.md delete mode 100644 files/es/web/javascript/reference/global_objects/string/strike/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/strike/index.md delete mode 100644 files/es/web/javascript/reference/global_objects/string/sub/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/sub/index.md delete mode 100644 files/es/web/javascript/reference/global_objects/string/substr/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/substr/index.md delete mode 100644 files/es/web/javascript/reference/global_objects/string/substring/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/substring/index.md delete mode 100644 files/es/web/javascript/reference/global_objects/string/sup/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/sup/index.md delete mode 100644 files/es/web/javascript/reference/global_objects/string/tolocaleuppercase/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/tolocaleuppercase/index.md delete mode 100644 files/es/web/javascript/reference/global_objects/string/tolowercase/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/tolowercase/index.md delete mode 100644 files/es/web/javascript/reference/global_objects/string/tostring/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/tostring/index.md delete mode 100644 files/es/web/javascript/reference/global_objects/string/touppercase/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/touppercase/index.md delete mode 100644 files/es/web/javascript/reference/global_objects/string/trim/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/trim/index.md delete mode 100644 files/es/web/javascript/reference/global_objects/string/trimend/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/trimend/index.md delete mode 100644 files/es/web/javascript/reference/global_objects/string/valueof/index.html create mode 100644 files/es/web/javascript/reference/global_objects/string/valueof/index.md 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 deleted file mode 100644 index 2a63c56bc6544c..00000000000000 --- a/files/es/web/javascript/reference/global_objects/string/anchor/index.html +++ /dev/null @@ -1,57 +0,0 @@ ---- -title: String.prototype.anchor() -slug: Web/JavaScript/Reference/Global_Objects/String/anchor -tags: - - HTML wrapper methods - - JavaScript - - Method - - Prototype - - String -translation_of: Web/JavaScript/Reference/Global_Objects/String/anchor -original_slug: Web/JavaScript/Referencia/Objetos_globales/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/anchor/index.md b/files/es/web/javascript/reference/global_objects/string/anchor/index.md new file mode 100644 index 00000000000000..1dc54a731c2a7b --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/anchor/index.md @@ -0,0 +1,55 @@ +--- +title: String.prototype.anchor() +slug: Web/JavaScript/Reference/Global_Objects/String/anchor +tags: + - HTML wrapper methods + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/anchor +original_slug: Web/JavaScript/Referencia/Objetos_globales/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`: + +```js +var miCadena = "Tabla de Contenidos"; +document.body.innerHTML = miCadena.anchor("ancla_contenidos"); +``` + +obtendrá el siguiente HTML: + +```html +Tabla de Contenidos +``` + +### Vea También + +- {{jsxref("String.prototype.link()")}} 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 deleted file mode 100644 index ad13429a094717..00000000000000 --- a/files/es/web/javascript/reference/global_objects/string/big/index.html +++ /dev/null @@ -1,55 +0,0 @@ ---- -title: String.prototype.big() -slug: Web/JavaScript/Reference/Global_Objects/String/big -tags: - - Deprecated - - HTML wrapper methods - - JavaScript - - Method - - Prototype - - String -translation_of: Web/JavaScript/Reference/Global_Objects/String/big -original_slug: Web/JavaScript/Referencia/Objetos_globales/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/big/index.md b/files/es/web/javascript/reference/global_objects/string/big/index.md new file mode 100644 index 00000000000000..07bddfee66688c --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/big/index.md @@ -0,0 +1,51 @@ +--- +title: String.prototype.big() +slug: Web/JavaScript/Reference/Global_Objects/String/big +tags: + - Deprecated + - HTML wrapper methods + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/big +original_slug: Web/JavaScript/Referencia/Objetos_globales/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("

" + cadenaMundo.big()); + console.log("

" + cadenaMundo.fontsize(7)); + +Este ejemplo produce el mismo resultado que el siguiente HTML: + + ¡Hola Mundo! +

¡Hola Mundo! +

¡Hola Mundo! + +### Vea También + +- {{jsxref("String.prototype.fontsize()")}} +- {{jsxref("String.prototype.small()")}} 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 deleted file mode 100644 index 390b4157770666..00000000000000 --- a/files/es/web/javascript/reference/global_objects/string/blink/index.html +++ /dev/null @@ -1,43 +0,0 @@ ---- -title: String.prototype.blink() -slug: Web/JavaScript/Reference/Global_Objects/String/blink -tags: - - Deprecated - - HTML wrapper methods - - JavaScript - - Method - - Prototype - - String -translation_of: Web/JavaScript/Reference/Global_Objects/String/blink -original_slug: Web/JavaScript/Referencia/Objetos_globales/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/blink/index.md b/files/es/web/javascript/reference/global_objects/string/blink/index.md new file mode 100644 index 00000000000000..6cba3cadafb4f3 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/blink/index.md @@ -0,0 +1,58 @@ +--- +title: String.prototype.blink() +slug: Web/JavaScript/Reference/Global_Objects/String/blink +tags: + - Deprecated + - HTML wrapper methods + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/blink +original_slug: Web/JavaScript/Referencia/Objetos_globales/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: + +```js +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: + +```html +¡Hola mundo! +¡Hola mundo! +¡Hola mundo! +¡Hola mundo! +``` + +## Vea también + +- {{jsxref("String.prototype.bold()")}} +- {{jsxref("String.prototype.italics()")}} +- {{jsxref("String.prototype.strike()")}} 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 deleted file mode 100644 index 130e23b0013cb4..00000000000000 --- a/files/es/web/javascript/reference/global_objects/string/bold/index.html +++ /dev/null @@ -1,44 +0,0 @@ ---- -title: String.prototype.bold() -slug: Web/JavaScript/Reference/Global_Objects/String/bold -tags: - - Deprecated - - HTML wrapper methods - - JavaScript - - Method - - Prototype - - String -translation_of: Web/JavaScript/Reference/Global_Objects/String/bold -original_slug: Web/JavaScript/Referencia/Objetos_globales/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/bold/index.md b/files/es/web/javascript/reference/global_objects/string/bold/index.md new file mode 100644 index 00000000000000..f020088ae14b77 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/bold/index.md @@ -0,0 +1,58 @@ +--- +title: String.prototype.bold() +slug: Web/JavaScript/Reference/Global_Objects/String/bold +tags: + - Deprecated + - HTML wrapper methods + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/bold +original_slug: Web/JavaScript/Referencia/Objetos_globales/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: + +```js +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: + +```html +¡Hola mundo! +¡Hola mundo! +¡Hola mundo! +¡Hola mundo! +``` + +### Vea También + +- {{jsxref("String.prototype.blink()")}} +- {{jsxref("String.prototype.italics()")}} +- {{jsxref("String.prototype.strike()")}} 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 deleted file mode 100644 index abd4d0d6c8fb9f..00000000000000 --- a/files/es/web/javascript/reference/global_objects/string/charat/index.html +++ /dev/null @@ -1,98 +0,0 @@ ---- -title: String.prototype.charAt() -slug: Web/JavaScript/Reference/Global_Objects/String/charAt -tags: - - JavaScript - - Method - - Prototype - - String -translation_of: Web/JavaScript/Reference/Global_Objects/String/charAt -original_slug: Web/JavaScript/Referencia/Objetos_globales/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

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

Vea También

- - diff --git a/files/es/web/javascript/reference/global_objects/string/charat/index.md b/files/es/web/javascript/reference/global_objects/string/charat/index.md new file mode 100644 index 00000000000000..46f96cb73e5c12 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/charat/index.md @@ -0,0 +1,75 @@ +--- +title: String.prototype.charAt() +slug: Web/JavaScript/Reference/Global_Objects/String/charAt +tags: + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/charAt +original_slug: Web/JavaScript/Referencia/Objetos_globales/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`": + +```js +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ón | Estado | Comentario | +| -------------------------------------------------------------------------------------------------------- | ------------------------ | ------------------ | +| ECMAScript 1st Edition. | Estándar | Primera 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 + +{{Compat("javascript.builtins.String.charAt")}} + +## Vea También + +- {{jsxref("String.prototype.indexOf()")}}, {{jsxref("String.prototype.lastIndexOf()")}} +- {{jsxref("String.prototype.split()")}} +- {{jsxref("String.prototype.charCodeAt()")}} +- {{jsxref("String.fromCodePoint()")}} +- {{jsxref("String.prototype.codePointAt()")}} 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 deleted file mode 100644 index cd0e1b478363a5..00000000000000 --- a/files/es/web/javascript/reference/global_objects/string/charcodeat/index.html +++ /dev/null @@ -1,66 +0,0 @@ ---- -title: String.prototype.charCodeAt() -slug: Web/JavaScript/Reference/Global_Objects/String/charCodeAt -tags: - - JavaScript - - Method - - Prototype - - String - - Unicode -translation_of: Web/JavaScript/Reference/Global_Objects/String/charCodeAt -original_slug: Web/JavaScript/Referencia/Objetos_globales/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/charcodeat/index.md b/files/es/web/javascript/reference/global_objects/string/charcodeat/index.md new file mode 100644 index 00000000000000..37cc7d42ec1a75 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/charcodeat/index.md @@ -0,0 +1,57 @@ +--- +title: String.prototype.charCodeAt() +slug: Web/JavaScript/Reference/Global_Objects/String/charCodeAt +tags: + - JavaScript + - Method + - Prototype + - String + - Unicode +translation_of: Web/JavaScript/Reference/Global_Objects/String/charCodeAt +original_slug: Web/JavaScript/Referencia/Objetos_globales/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](/es/docs/Web/JavaScript/Guide/Valores,_variables_y_literales#Unicode). 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 + +- {{jsxref("String.fromCharCode()")}} +- {{jsxref("String.prototype.charAt()")}} +- {{jsxref("String.fromCodePoint()")}} +- {{jsxref("String.prototype.codePointAt()")}} 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 deleted file mode 100644 index 09286167fa1b2a..00000000000000 --- a/files/es/web/javascript/reference/global_objects/string/codepointat/index.html +++ /dev/null @@ -1,126 +0,0 @@ ---- -title: String.prototype.codePointAt() -slug: Web/JavaScript/Reference/Global_Objects/String/codePointAt -translation_of: Web/JavaScript/Reference/Global_Objects/String/codePointAt -original_slug: Web/JavaScript/Referencia/Objetos_globales/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/codepointat/index.md b/files/es/web/javascript/reference/global_objects/string/codepointat/index.md new file mode 100644 index 00000000000000..f1effaef85e407 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/codepointat/index.md @@ -0,0 +1,105 @@ +--- +title: String.prototype.codePointAt() +slug: Web/JavaScript/Reference/Global_Objects/String/codePointAt +translation_of: Web/JavaScript/Reference/Global_Objects/String/codePointAt +original_slug: Web/JavaScript/Referencia/Objetos_globales/String/codePointAt +--- +{{JSRef}}El método **`codePointAt() `**`d`evuelve 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()` + +```js +'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. + +```js +/*! 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 + +| Specification | Status | Comment | +| ---------------------------------------------------------------------------------------------------------------------------- | ---------------------------- | ------------------- | +| {{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 + +- {{jsxref("String.fromCodePoint()")}} +- {{jsxref("String.fromCharCode()")}} +- {{jsxref("String.prototype.charCodeAt()")}} +- {{jsxref("String.prototype.charAt()")}} 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 deleted file mode 100644 index 8d96516f1949db..00000000000000 --- a/files/es/web/javascript/reference/global_objects/string/concat/index.html +++ /dev/null @@ -1,91 +0,0 @@ ---- -title: String.prototype.concat() -slug: Web/JavaScript/Reference/Global_Objects/String/concat -tags: - - JavaScript - - Prototipo - - Referencia - - String - - metodo -translation_of: Web/JavaScript/Reference/Global_Objects/String/concat -original_slug: Web/JavaScript/Referencia/Objetos_globales/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/concat/index.md b/files/es/web/javascript/reference/global_objects/string/concat/index.md new file mode 100644 index 00000000000000..16a7a660c2b062 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/concat/index.md @@ -0,0 +1,76 @@ +--- +title: String.prototype.concat() +slug: Web/JavaScript/Reference/Global_Objects/String/concat +tags: + - JavaScript + - Prototipo + - Referencia + - String + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/String/concat +original_slug: Web/JavaScript/Referencia/Objetos_globales/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. + +```js +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 + +- {{jsxref("Array.prototype.concat()")}} +- {{jsxref("Operators/Assignment_Operators", "Operadores de asignación", "", 1)}} 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 deleted file mode 100644 index a8a2d9d568a9bf..00000000000000 --- a/files/es/web/javascript/reference/global_objects/string/endswith/index.html +++ /dev/null @@ -1,89 +0,0 @@ ---- -title: String.prototype.endsWith() -slug: Web/JavaScript/Reference/Global_Objects/String/endsWith -tags: - - JavaScript - - Prototipo - - Referencia - - String - - metodo -translation_of: Web/JavaScript/Reference/Global_Objects/String/endsWith -original_slug: Web/JavaScript/Referencia/Objetos_globales/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/endswith/index.md b/files/es/web/javascript/reference/global_objects/string/endswith/index.md new file mode 100644 index 00000000000000..b62b55db609f8f --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/endswith/index.md @@ -0,0 +1,80 @@ +--- +title: String.prototype.endsWith() +slug: Web/JavaScript/Reference/Global_Objects/String/endsWith +tags: + - JavaScript + - Prototipo + - Referencia + - String + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/String/endsWith +original_slug: Web/JavaScript/Referencia/Objetos_globales/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: + +```js +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()` + +```js +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 + +- {{jsxref("String.prototype.startsWith()")}} +- {{jsxref("String.prototype.includes()")}} +- {{jsxref("String.prototype.indexOf()")}} +- {{jsxref("String.prototype.lastIndexOf()")}} 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 deleted file mode 100644 index dc9638944b3d73..00000000000000 --- a/files/es/web/javascript/reference/global_objects/string/fixed/index.html +++ /dev/null @@ -1,36 +0,0 @@ ---- -title: String.prototype.fixed() -slug: Web/JavaScript/Reference/Global_Objects/String/fixed -tags: - - Deprecated - - HTML wrapper methods - - JavaScript - - Method - - Prototype - - String -translation_of: Web/JavaScript/Reference/Global_Objects/String/fixed -original_slug: Web/JavaScript/Referencia/Objetos_globales/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/fixed/index.md b/files/es/web/javascript/reference/global_objects/string/fixed/index.md new file mode 100644 index 00000000000000..2a26272679f414 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/fixed/index.md @@ -0,0 +1,51 @@ +--- +title: String.prototype.fixed() +slug: Web/JavaScript/Reference/Global_Objects/String/fixed +tags: + - Deprecated + - HTML wrapper methods + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/fixed +original_slug: Web/JavaScript/Referencia/Objetos_globales/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: + +```js +var cadenaMundo="¡Hola Mundo!" +console.log(cadenaMundo.fixed()) +``` + +Este ejemplo produce el mismo resultado que el siguiente código HTML: + +```html +¡Hola Mundo! +``` + +### Vea También + +- {{jsxref("String.prototype.bold()")}} +- {{jsxref("String.prototype.italics()")}} +- {{jsxref("String.prototype.strike()")}} 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 deleted file mode 100644 index 0140591796b74a..00000000000000 --- a/files/es/web/javascript/reference/global_objects/string/fontcolor/index.html +++ /dev/null @@ -1,75 +0,0 @@ ---- -title: String.prototype.fontcolor() -slug: Web/JavaScript/Reference/Global_Objects/String/fontcolor -translation_of: Web/JavaScript/Reference/Global_Objects/String/fontcolor -original_slug: Web/JavaScript/Referencia/Objetos_globales/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

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

Ver también

- - diff --git a/files/es/web/javascript/reference/global_objects/string/fontcolor/index.md b/files/es/web/javascript/reference/global_objects/string/fontcolor/index.md new file mode 100644 index 00000000000000..289370c7c08225 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/fontcolor/index.md @@ -0,0 +1,60 @@ +--- +title: String.prototype.fontcolor() +slug: Web/JavaScript/Reference/Global_Objects/String/fontcolor +translation_of: Web/JavaScript/Reference/Global_Objects/String/fontcolor +original_slug: Web/JavaScript/Referencia/Objetos_globales/String/fontcolor +--- +{{JSRef}} {{deprecated_header}} + +`El método `**`fontcolor()`** crea {{HTMLElement("font")}} elemento HTML que cambia el color de la cadena. + +> **Nota:** **Usage note:** La etiqueta \ fue eliminada en [HTML5](/es/docs/Web/Guide/HTML/HTML5) y no debe ser usada. En lugar de es, es necesario aplicar propiedades [CSS](/es/docs/Web/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](/es/docs/Web/CSS/color_value). + +## 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. + +```js +var worldString = 'Hello, world'; + +console.log(worldString.fontcolor('red') + ' en rojo'); +// 'Hello, world en rojo' + +console.log(worldString.fontcolor('FF00') + ' es rojo en hexadecimal'); +// 'Hello, world es rojo en hexadecimal' +``` + +Con el objeto {{domxref("HTMLElement.style", "element.style")}} obtienes el atributo `style` y manipularlo: + +```js +document.getElementById('yourElemId').style.color = 'red'; +``` + +## Especificaciones + +| Especificación | Estatus | Comentario | +| ---------------------------------------------------------------------------------------------------------------- | -------------------- | ------------------------------------------------------------------------------------------------------------------------------------------ | +| {{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 + +{{Compat("javascript.builtins.String.fontcolor")}} + +## Ver también + +- {{jsxref("String.prototype.fontsize()")}} 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 deleted file mode 100644 index cb687b4309c8e6..00000000000000 --- a/files/es/web/javascript/reference/global_objects/string/fontsize/index.html +++ /dev/null @@ -1,76 +0,0 @@ ---- -title: String.prototype.fontsize() -slug: Web/JavaScript/Reference/Global_Objects/String/fontsize -translation_of: Web/JavaScript/Reference/Global_Objects/String/fontsize -original_slug: Web/JavaScript/Referencia/Objetos_globales/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

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

See also

- -
    -
  • {{jsxref("String.prototype.big()")}}
    • -
  • {{jsxref("String.prototype.small()")}}
    • -
diff --git a/files/es/web/javascript/reference/global_objects/string/fontsize/index.md b/files/es/web/javascript/reference/global_objects/string/fontsize/index.md new file mode 100644 index 00000000000000..ef95ee8070441d --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/fontsize/index.md @@ -0,0 +1,61 @@ +--- +title: String.prototype.fontsize() +slug: Web/JavaScript/Reference/Global_Objects/String/fontsize +translation_of: Web/JavaScript/Reference/Global_Objects/String/fontsize +original_slug: Web/JavaScript/Referencia/Objetos_globales/String/fontsize +--- +{{JSRef}} {{deprecated_header}} + +`El método `**`fontsize()`** crea {{HTMLElement("font")}} elemento HTML que muestra una cadena con el tamaño especificado. + +> **Nota:** **Usage note:** El elemento \ ha sido eliminado [HTML5](/es/docs/Web/Guide/HTML/HTML5) y no se debe usar. Los desarrolladores web deben usar propiedades [CSS](/es/docs/Web/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: + +```js +var worldString = 'Hello, world'; + +console.log(worldString.small()); // Hello, world +console.log(worldString.big()); // Hello, world +console.log(worldString.fontsize(7)); // Hello, world +``` + +With the {{domxref("HTMLElement.style", "element.style")}} object you can get the element's `style` attribute and manipulate it more generically, for example: + +```js +document.getElementById('yourElemId').style.fontSize = '0.7em'; +``` + +## Specifications + +| Specification | Status | Comment | +| ------------------------------------------------------------------------------------------------------------ | -------------------- | ------------------------------------------------------------------------------------------------------------------------------------------ | +| {{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 + +{{Compat("javascript.builtins.String.fontsize")}} + +## See also + +- {{jsxref("String.prototype.big()")}} +- {{jsxref("String.prototype.small()")}} 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 deleted file mode 100644 index e2bc7922c035b9..00000000000000 --- a/files/es/web/javascript/reference/global_objects/string/fromcharcode/index.html +++ /dev/null @@ -1,83 +0,0 @@ ---- -title: String.fromCharCode() -slug: Web/JavaScript/Reference/Global_Objects/String/fromCharCode -tags: - - JavaScript - - Method - - String - - Unicode -translation_of: Web/JavaScript/Reference/Global_Objects/String/fromCharCode -original_slug: Web/JavaScript/Referencia/Objetos_globales/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

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

Vea También

- -
    -
  • {{jsxref("String.prototype.charCodeAt()")}}
    • -
  • {{jsxref("String.prototype.charAt()")}}
    • -
  • {{jsxref("String.fromCodePoint()")}}
    • -
  • {{jsxref("String.prototype.codePointAt()")}}
    • -
diff --git a/files/es/web/javascript/reference/global_objects/string/fromcharcode/index.md b/files/es/web/javascript/reference/global_objects/string/fromcharcode/index.md new file mode 100644 index 00000000000000..5f7442fb75424a --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/fromcharcode/index.md @@ -0,0 +1,60 @@ +--- +title: String.fromCharCode() +slug: Web/JavaScript/Reference/Global_Objects/String/fromCharCode +tags: + - JavaScript + - Method + - String + - Unicode +translation_of: Web/JavaScript/Reference/Global_Objects/String/fromCharCode +original_slug: Web/JavaScript/Referencia/Objetos_globales/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". + +```js +String.fromCharCode(65,66,67) +``` + +## Especificaciónes + +| Especificación | Estatus | Comentario | +| ------------------------------------------------------------------------------------------------ | ------------------------ | ------------------------------------------------- | +| ECMAScript 1st Edition. | Estándar | Primera 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 + +{{Compat("javascript.builtins.String.fromCharCode")}} + +## Vea También + +- {{jsxref("String.prototype.charCodeAt()")}} +- {{jsxref("String.prototype.charAt()")}} +- {{jsxref("String.fromCodePoint()")}} +- {{jsxref("String.prototype.codePointAt()")}} 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 deleted file mode 100644 index 4a1b4386573182..00000000000000 --- a/files/es/web/javascript/reference/global_objects/string/fromcodepoint/index.html +++ /dev/null @@ -1,157 +0,0 @@ ---- -title: String.fromCodePoint() -slug: Web/JavaScript/Reference/Global_Objects/String/fromCodePoint -translation_of: Web/JavaScript/Reference/Global_Objects/String/fromCodePoint -original_slug: Web/JavaScript/Referencia/Objetos_globales/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

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

See also

- -
    -
  • {{jsxref("String.fromCharCode()")}}
    • -
  • {{jsxref("String.prototype.charAt()")}}
    • -
  • {{jsxref("String.prototype.codePointAt()")}}
    • -
  • {{jsxref("String.prototype.charCodeAt()")}}
    • -
diff --git a/files/es/web/javascript/reference/global_objects/string/fromcodepoint/index.md b/files/es/web/javascript/reference/global_objects/string/fromcodepoint/index.md new file mode 100644 index 00000000000000..61aa741f86dbc9 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/fromcodepoint/index.md @@ -0,0 +1,143 @@ +--- +title: String.fromCodePoint() +slug: Web/JavaScript/Reference/Global_Objects/String/fromCodePoint +translation_of: Web/JavaScript/Reference/Global_Objects/String/fromCodePoint +original_slug: Web/JavaScript/Referencia/Objetos_globales/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()` + +```js +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 +``` + +```js +// 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: + +```js +/*! 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 + +| Specification | Status | Comment | +| ------------------------------------------------------------------------------------------------ | -------------------- | ------------------- | +| {{SpecName('ES6', '#sec-string.fromcodepoint', 'String.fromCodePoint')}} | {{Spec2('ES6')}} | Initial definition. | + +## Browser compatibility + +{{Compat("javascript.builtins.String.fromCodePoint")}} + +## See also + +- {{jsxref("String.fromCharCode()")}} +- {{jsxref("String.prototype.charAt()")}} +- {{jsxref("String.prototype.codePointAt()")}} +- {{jsxref("String.prototype.charCodeAt()")}} 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 deleted file mode 100644 index 6e7aaace11ef81..00000000000000 --- a/files/es/web/javascript/reference/global_objects/string/includes/index.html +++ /dev/null @@ -1,109 +0,0 @@ ---- -title: String.prototype.includes() -slug: Web/JavaScript/Reference/Global_Objects/String/includes -tags: - - Cadena de texto - - JavaScript - - Prototipo - - Referencia - - String - - metodo -translation_of: Web/JavaScript/Reference/Global_Objects/String/includes -original_slug: Web/JavaScript/Referencia/Objetos_globales/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

- -
    -
  • {{jsxref("Array.prototype.includes()")}}
    • -
  • {{jsxref("TypedArray.prototype.includes()")}}
    • -
  • {{jsxref("String.prototype.indexOf()")}}
    • -
  • {{jsxref("String.prototype.lastIndexOf()")}}
    • -
  • {{jsxref("String.prototype.startsWith()")}}
    • -
  • {{jsxref("String.prototype.endsWith()")}}
    • -
diff --git a/files/es/web/javascript/reference/global_objects/string/includes/index.md b/files/es/web/javascript/reference/global_objects/string/includes/index.md new file mode 100644 index 00000000000000..afb4f071b6e047 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/includes/index.md @@ -0,0 +1,99 @@ +--- +title: String.prototype.includes() +slug: Web/JavaScript/Reference/Global_Objects/String/includes +tags: + - Cadena de texto + - JavaScript + - Prototipo + - Referencia + - String + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/String/includes +original_slug: Web/JavaScript/Referencia/Objetos_globales/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`: + +```js +'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: + +```js +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()` + +```js +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 + +- {{jsxref("Array.prototype.includes()")}} +- {{jsxref("TypedArray.prototype.includes()")}} +- {{jsxref("String.prototype.indexOf()")}} +- {{jsxref("String.prototype.lastIndexOf()")}} +- {{jsxref("String.prototype.startsWith()")}} +- {{jsxref("String.prototype.endsWith()")}} diff --git a/files/es/web/javascript/reference/global_objects/string/index.html b/files/es/web/javascript/reference/global_objects/string/index.html deleted file mode 100644 index 5efe7d3a0a73f4..00000000000000 --- a/files/es/web/javascript/reference/global_objects/string/index.html +++ /dev/null @@ -1,386 +0,0 @@ ---- -title: String — Cadena de caracteres -slug: Web/JavaScript/Reference/Global_Objects/String -tags: - - Clase - - Class - - ECMAScript 2015 - - JavaScript - - Referencia - - String -translation_of: Web/JavaScript/Reference/Global_Objects/String -original_slug: Web/JavaScript/Referencia/Objetos_globales/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/index.md b/files/es/web/javascript/reference/global_objects/string/index.md new file mode 100644 index 00000000000000..8b1fe76ebbba42 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/index.md @@ -0,0 +1,306 @@ +--- +title: String — Cadena de caracteres +slug: Web/JavaScript/Reference/Global_Objects/String +tags: + - Clase + - Class + - ECMAScript 2015 + - JavaScript + - Referencia + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String +original_slug: Web/JavaScript/Referencia/Objetos_globales/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 +=](/es/docs/Web/JavaScript/Reference/Operators/String_Operators), 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 `string`s primitivas y los objetos `string` se pueden usar indistintamente en la mayoría de las situaciones. Consulta "[Primitivas `String` y objetos `String`](#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](/es/docs/Web/JavaScript/Reference/Template_literals): 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()")}}: + +```js +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: + +```js +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](/es/docs/Web/JavaScript/Reference/Operators/Comparison_Operators): + +```js +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. + +```js +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: + +```js +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()")}}. + +```js +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ódigo | Salida | +| -------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------- | +| `\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 | +| `\n` | Nueva línea | +| `\r` | Retorno de carro | +| `\v` | Tabulación vertical | +| `\t` | Tabulación | +| `\b` | Retroceso | +| `\f` | Avance 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 [+](/es/docs/Web/JavaScript/Reference/Operators/Addition) para agregar varias cadenas juntas, así: + +```js +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í: + +```js +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 + +> **Nota:** **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: + +```js +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 + +- [Formato de texto en la Guía de JavaScript](/es/docs/Web/JavaScript/Guide/Text_formatting) +- {{jsxref("RegExp")}} +- {{domxref("DOMString")}} +- [`StringView` — una representación similar a C de cadenas basada en arreglos tipados](/es/Add-ons/Code_snippets/StringView) +- [Cadenas binarias](/es/docs/Web/API/DOMString/Binary) 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 deleted file mode 100644 index 7711332977a3cd..00000000000000 --- a/files/es/web/javascript/reference/global_objects/string/indexof/index.html +++ /dev/null @@ -1,105 +0,0 @@ ---- -title: String.prototype.indexOf() -slug: Web/JavaScript/Reference/Global_Objects/String/indexOf -tags: - - JavaScript - - Method - - Prototype - - String -translation_of: Web/JavaScript/Reference/Global_Objects/String/indexOf -original_slug: Web/JavaScript/Referencia/Objetos_globales/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

- -
    -
  • {{jsxref("String.prototype.charAt()")}}
    • -
  • {{jsxref("String.prototype.lastIndexOf()")}}
    • -
  • {{jsxref("String.prototype.split()")}}
    • -
  • {{jsxref("Array.prototype.indexOf()")}}
    • -
diff --git a/files/es/web/javascript/reference/global_objects/string/indexof/index.md b/files/es/web/javascript/reference/global_objects/string/indexof/index.md new file mode 100644 index 00000000000000..6bc27f85a71502 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/indexof/index.md @@ -0,0 +1,104 @@ +--- +title: String.prototype.indexOf() +slug: Web/JavaScript/Reference/Global_Objects/String/indexOf +tags: + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/indexOf +original_slug: Web/JavaScript/Referencia/Objetos_globales/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`. + +```js +"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: + +```js +"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`". + +```js +var cualquierCadena="Brave new world" + + +document.write("

The index of the first w from the beginning is " + + cualquierCadena.indexOf("w")) // Muestra 8 + +document.write("

The index of the first w from the end is " + + cualquierCadena.lastIndexOf("w")) // Muestra 10 + +document.write("

The index of 'new' from the beginning is " + + cualquierCadena.indexOf("new")) // Muestra 6 + +document.write("

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. + +```js +miCadena="brie, pepper jack, cheddar" +miCadenaMayusculas="Brie, Pepper Jack, Cheddar" +document.writeln('miCadena.indexOf("cheddar") is ' + + miCadena.indexOf("cheddar")) +document.writeln('

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`: + +```js +cuenta = 0; +posicion = miCadena.indexOf("x"); +while ( posicion != -1 ) { + cuenta++; + posicion = miCadena.indexOf("x",posicion+1); +} +``` + +## Vea También + +- {{jsxref("String.prototype.charAt()")}} +- {{jsxref("String.prototype.lastIndexOf()")}} +- {{jsxref("String.prototype.split()")}} +- {{jsxref("Array.prototype.indexOf()")}} 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 deleted file mode 100644 index 858e66df91cdf8..00000000000000 --- a/files/es/web/javascript/reference/global_objects/string/italics/index.html +++ /dev/null @@ -1,50 +0,0 @@ ---- -title: String.prototype.italics() -slug: Web/JavaScript/Reference/Global_Objects/String/italics -tags: - - Deprecated - - HTML wrapper methods - - JavaScript - - Method - - Prototype - - String -translation_of: Web/JavaScript/Reference/Global_Objects/String/italics -original_slug: Web/JavaScript/Referencia/Objetos_globales/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

- -
    -
  • {{jsxref("String.prototype.blink()")}}
    • -
  • {{jsxref("String.prototype.bold()")}}
    • -
  • {{jsxref("String.prototype.strike()")}}
    • -
diff --git a/files/es/web/javascript/reference/global_objects/string/italics/index.md b/files/es/web/javascript/reference/global_objects/string/italics/index.md new file mode 100644 index 00000000000000..e1f96f0863e7e5 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/italics/index.md @@ -0,0 +1,49 @@ +--- +title: String.prototype.italics() +slug: Web/JavaScript/Reference/Global_Objects/String/italics +tags: + - Deprecated + - HTML wrapper methods + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/italics +original_slug: Web/JavaScript/Referencia/Objetos_globales/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: + +```js +var cadenaMundo="¡Hola mundo!"; + +console.log(cadenaMundo.blink()); +console.log(cadenaMundo.bold()); +console.log(cadenaMundo.italics()); +console.log(cadenaMundo.strike()); +``` + +## Vea También + +- {{jsxref("String.prototype.blink()")}} +- {{jsxref("String.prototype.bold()")}} +- {{jsxref("String.prototype.strike()")}} 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 deleted file mode 100644 index 99afb18a5d46b9..00000000000000 --- a/files/es/web/javascript/reference/global_objects/string/lastindexof/index.html +++ /dev/null @@ -1,80 +0,0 @@ ---- -title: String.prototype.lastIndexOf() -slug: Web/JavaScript/Reference/Global_Objects/String/lastIndexOf -tags: - - Cadena - - JavaScript - - Prototipo - - Referencia - - metodo -translation_of: Web/JavaScript/Reference/Global_Objects/String/lastIndexOf -original_slug: Web/JavaScript/Referencia/Objetos_globales/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

- -

El siguiente ejemplo utiliza indexOf y lastIndexOf para localizar valores en la cadena "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

- -
    -
  • {{jsxref("String.prototype.charAt()")}}
    • -
  • {{jsxref("String.prototype.indexOf()")}}
    • -
  • {{jsxref("String.prototype.split()")}}
    • -
  • {{jsxref("Array.prototype.indexOf()")}}
    • -
  • {{jsxref("Array.prototype.lastIndexOf()")}}
    • -
diff --git a/files/es/web/javascript/reference/global_objects/string/lastindexof/index.md b/files/es/web/javascript/reference/global_objects/string/lastindexof/index.md new file mode 100644 index 00000000000000..b3b98d2d638b27 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/lastindexof/index.md @@ -0,0 +1,77 @@ +--- +title: String.prototype.lastIndexOf() +slug: Web/JavaScript/Reference/Global_Objects/String/lastIndexOf +tags: + - Cadena + - JavaScript + - Prototipo + - Referencia + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/String/lastIndexOf +original_slug: Web/JavaScript/Referencia/Objetos_globales/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`. + +```js +"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: + +```js +"Ballena Azul, Ballena Asesina".lastIndexOf("azul") +``` + +## Ejemplos + +### Ejemplo: Usando `indexOf` y `lastIndexOf` + +El siguiente ejemplo utiliza `indexOf` y `lastIndexOf` para localizar valores en la cadena "`Brave new world`". + +```js +var anyString="Brave new world" + +// Displays 8 +document.write("

The index of the first w from the beginning is " + + anyString.indexOf("w")) +// Displays 10 +document.write("

The index of the first w from the end is " + + anyString.lastIndexOf("w")) +// Displays 6 +document.write("

The index of 'new' from the beginning is " + + anyString.indexOf("new")) +// Displays 6 +document.write("

The index of 'new' from the end is " + + anyString.lastIndexOf("new")) +``` + +## Vea También + +- {{jsxref("String.prototype.charAt()")}} +- {{jsxref("String.prototype.indexOf()")}} +- {{jsxref("String.prototype.split()")}} +- {{jsxref("Array.prototype.indexOf()")}} +- {{jsxref("Array.prototype.lastIndexOf()")}} 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 deleted file mode 100644 index 6052e2289e65fd..00000000000000 --- a/files/es/web/javascript/reference/global_objects/string/length/index.html +++ /dev/null @@ -1,95 +0,0 @@ ---- -title: String.length -slug: Web/JavaScript/Reference/Global_Objects/String/length -tags: - - JavaScript - - Propiedad - - Prototipo - - Referencia - - String - - length -translation_of: Web/JavaScript/Reference/Global_Objects/String/length -original_slug: Web/JavaScript/Referencia/Objetos_globales/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/length/index.md b/files/es/web/javascript/reference/global_objects/string/length/index.md new file mode 100644 index 00000000000000..c74f734faf11ed --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/length/index.md @@ -0,0 +1,73 @@ +--- +title: String.length +slug: Web/JavaScript/Reference/Global_Objects/String/length +tags: + - JavaScript + - Propiedad + - Prototipo + - Referencia + - String + - length +translation_of: Web/JavaScript/Reference/Global_Objects/String/length +original_slug: Web/JavaScript/Referencia/Objetos_globales/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 + +```js +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 + +```js +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ón | Estatus | Comentario | +| -------------------------------------------------------------------------------------------------------------------------------- | ---------------------------- | --------------------------------------------------- | +| ECMAScript 1st Edition. | Estándar | Primera 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 + +- [JavaScript String.length and Internationalizing Web Applications](http://developer.teradata.com/blog/jasonstrimpel/2011/11/javascript-string-length-and-internationalizing-web-applications) 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 deleted file mode 100644 index 5cab4dd8e6fc03..00000000000000 --- a/files/es/web/javascript/reference/global_objects/string/link/index.html +++ /dev/null @@ -1,57 +0,0 @@ ---- -title: String.prototype.link() -slug: Web/JavaScript/Reference/Global_Objects/String/link -tags: - - HTML wrapper methods - - JavaScript - - Method - - Prototype - - String -translation_of: Web/JavaScript/Reference/Global_Objects/String/link -original_slug: Web/JavaScript/Referencia/Objetos_globales/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

- -
    -
  • {{jsxref("String.prototype.anchor()")}}
    • -
diff --git a/files/es/web/javascript/reference/global_objects/string/link/index.md b/files/es/web/javascript/reference/global_objects/string/link/index.md new file mode 100644 index 00000000000000..6c80215156b51c --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/link/index.md @@ -0,0 +1,55 @@ +--- +title: String.prototype.link() +slug: Web/JavaScript/Reference/Global_Objects/String/link +tags: + - HTML wrapper methods + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/link +original_slug: Web/JavaScript/Referencia/Objetos_globales/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 + +### Ejemplo: Usando `link` + +El siguiente ejemplo muestra la palabra "Netscape" como un enlace de hipertexto que devuelve al usuario a la página inicial de Netscape: + +```js +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: + +```html +Haga click para volver a MDN +``` + +## Vea También + +- {{jsxref("String.prototype.anchor()")}} 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 deleted file mode 100644 index 4fc95a5678e3e8..00000000000000 --- a/files/es/web/javascript/reference/global_objects/string/match/index.html +++ /dev/null @@ -1,79 +0,0 @@ ---- -title: String.prototype.match() -slug: Web/JavaScript/Reference/Global_Objects/String/match -tags: - - JavaScript - - Method - - Prototype - - RegExp - - Regular Expressions - - String -translation_of: Web/JavaScript/Reference/Global_Objects/String/match -original_slug: Web/JavaScript/Referencia/Objetos_globales/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

- -
    -
  • Si necesita conocer si una cadena se empareja con una expresión regular regexp, use {{jsxref("Regexp.test()")}}.
    • -
  • Si sólo quiere el primer emparejamiento hallado, podría querer usar {{jsxref("Regexp.exec()")}} a cambio.
    • -
- -

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

- -
    -
  • {{jsxref("RegExp.prototype.exec()")}}
    • -
  • {{jsxref("RegExp.prototype.test()")}}
    • -
diff --git a/files/es/web/javascript/reference/global_objects/string/match/index.md b/files/es/web/javascript/reference/global_objects/string/match/index.md new file mode 100644 index 00000000000000..a95b128b3852ae --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/match/index.md @@ -0,0 +1,75 @@ +--- +title: String.prototype.match() +slug: Web/JavaScript/Reference/Global_Objects/String/match +tags: + - JavaScript + - Method + - Prototype + - RegExp + - Regular Expressions + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/match +original_slug: Web/JavaScript/Referencia/Objetos_globales/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](/es/docs/Web/JavaScript/Referencia/Objetos_globales/RegExp). 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 + +- Si necesita conocer si una cadena se empareja con una expresión regular `regexp`, use {{jsxref("Regexp.test()")}}. +- Si sólo quiere el primer emparejamiento hallado, podría querer usar {{jsxref("Regexp.exec()")}} a cambio. + +## 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. + +```js +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. + +```js +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 + +- {{jsxref("RegExp.prototype.exec()")}} +- {{jsxref("RegExp.prototype.test()")}} 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 deleted file mode 100644 index 74141952fea288..00000000000000 --- a/files/es/web/javascript/reference/global_objects/string/matchall/index.html +++ /dev/null @@ -1,135 +0,0 @@ ---- -title: String.prototype.matchAll() -slug: Web/JavaScript/Reference/Global_Objects/String/matchAll -tags: - - Cadena - - Expresiones Regulares - - JavaScript - - Prototipo - - Referencia - - metodo -translation_of: Web/JavaScript/Reference/Global_Objects/String/matchAll -original_slug: Web/JavaScript/Referencia/Objetos_globales/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

- -
    -
  • {{jsxref("RegExp")}}
    • -
  • {{jsxref("RegExp.prototype.exec()")}}
    • -
  • {{jsxref("RegExp.prototype.test()")}}
    • -
diff --git a/files/es/web/javascript/reference/global_objects/string/matchall/index.md b/files/es/web/javascript/reference/global_objects/string/matchall/index.md new file mode 100644 index 00000000000000..ce368348fb223f --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/matchall/index.md @@ -0,0 +1,126 @@ +--- +title: String.prototype.matchAll() +slug: Web/JavaScript/Reference/Global_Objects/String/matchAll +tags: + - Cadena + - Expresiones Regulares + - JavaScript + - Prototipo + - Referencia + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/String/matchAll +original_slug: Web/JavaScript/Referencia/Objetos_globales/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](/es/docs/Web/JavaScript/Guide/Iterators_and_Generators) (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](/es/docs/Web/JavaScript/Reference/Global_Objects/RegExp/exec) (y usar expresiones regulares con la bandera `/g`) en un ciclo para obtener las ocurrencias: + +```js +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`](/en-US/docs/Web/JavaScript/Reference/Statements/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`](/en-US/docs/Web/JavaScript/Reference/Statements/for...of), [array spread](/es/docs/Web/JavaScript/Reference/Operators/Spread_syntax), o {{jsxref("Array.from()")}}: + +```js +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. + +```js +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](/es/docs/Web/JavaScript/Reference/Global_Objects/RegExp/exec), `lastIndex` no cambia a medida que la cadena es escaneada. + +```js +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()`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/match) con la bandera global `/g`: + +```js +var regexp = /t(e)(st(\d?))/g; +var cadena = 'test1test2'; + +cadena.match(regexp); +// Array ['test1', 'test2'] +``` + +Con `matchAll` puedes acceder a ellos: + +```js +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ón | Estado | Comentario | +| -------------------------------------------------------------------------------------------------------------------- | ---------------------------- | ---------- | +| {{SpecName('ESDraft', '#sec-string.prototype.matchall', 'String.prototype.matchAll')}} | {{Spec2('ESDraft')}} | | + +## Compatibilidad de navegadores + +{{Compat("javascript.builtins.String.matchAll")}} + +## Ver también + +- {{jsxref("RegExp")}} +- {{jsxref("RegExp.prototype.exec()")}} +- {{jsxref("RegExp.prototype.test()")}} 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 deleted file mode 100644 index 662df8ee2b4cb4..00000000000000 --- a/files/es/web/javascript/reference/global_objects/string/normalize/index.html +++ /dev/null @@ -1,127 +0,0 @@ ---- -title: String.prototype.normalize() -slug: Web/JavaScript/Reference/Global_Objects/String/normalize -tags: - - Cadena - - ECMAScript 2015 - - JavaScript - - Prototipo - - Referencia - - String - - Unicode - - metodo -translation_of: Web/JavaScript/Reference/Global_Objects/String/normalize -original_slug: Web/JavaScript/Referencia/Objetos_globales/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/normalize/index.md b/files/es/web/javascript/reference/global_objects/string/normalize/index.md new file mode 100644 index 00000000000000..d5b32b96b28d71 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/normalize/index.md @@ -0,0 +1,101 @@ +--- +title: String.prototype.normalize() +slug: Web/JavaScript/Reference/Global_Objects/String/normalize +tags: + - Cadena + - ECMAScript 2015 + - JavaScript + - Prototipo + - Referencia + - String + - Unicode + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/String/normalize +original_slug: Web/JavaScript/Referencia/Objetos_globales/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()` + +```js +// 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ón | Estado | Comentario | +| -------------------------------------------------------------------------------------------------------------------- | ---------------------------- | ------------------- | +| {{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 + +- [Anexo del Estándar Unicode #15, Formas de Normalización Unicode](http://www.unicode.org/reports/tr15/) +- [Equivalencia Unicode](http://en.wikipedia.org/wiki/Unicode_equivalence) 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 deleted file mode 100644 index 5440d3e8298e5e..00000000000000 --- a/files/es/web/javascript/reference/global_objects/string/padstart/index.html +++ /dev/null @@ -1,53 +0,0 @@ ---- -title: String.prototype.padStart() -slug: Web/JavaScript/Reference/Global_Objects/String/padStart -tags: - - Cadena - - Experimental - - JavaScript - - Método(2) - - Referencia -translation_of: Web/JavaScript/Reference/Global_Objects/String/padStart -original_slug: Web/JavaScript/Referencia/Objetos_globales/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

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

Ver también

- -
    -
  • {{jsxref("String.padEnd()")}}
    • -
diff --git a/files/es/web/javascript/reference/global_objects/string/padstart/index.md b/files/es/web/javascript/reference/global_objects/string/padstart/index.md new file mode 100644 index 00000000000000..e139159c6cd7f1 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/padstart/index.md @@ -0,0 +1,50 @@ +--- +title: String.prototype.padStart() +slug: Web/JavaScript/Reference/Global_Objects/String/padStart +tags: + - Cadena + - Experimental + - JavaScript + - Método(2) + - Referencia +translation_of: Web/JavaScript/Reference/Global_Objects/String/padStart +original_slug: Web/JavaScript/Referencia/Objetos_globales/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 + +```js +'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](https://github.com/tc39/proposal-string-pad-start-end). + +## Compatibilidad con navegadores + +{{Compat("javascript.builtins.String.padStart")}} + +## Ver también + +- {{jsxref("String.padEnd()")}} 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 deleted file mode 100644 index 4187edebd40466..00000000000000 --- a/files/es/web/javascript/reference/global_objects/string/raw/index.html +++ /dev/null @@ -1,111 +0,0 @@ ---- -title: String.raw() -slug: Web/JavaScript/Reference/Global_Objects/String/raw -translation_of: Web/JavaScript/Reference/Global_Objects/String/raw -original_slug: Web/JavaScript/Referencia/Objetos_globales/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/raw/index.md b/files/es/web/javascript/reference/global_objects/string/raw/index.md new file mode 100644 index 00000000000000..f0dc349b7d2d48 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/raw/index.md @@ -0,0 +1,89 @@ +--- +title: String.raw() +slug: Web/JavaScript/Reference/Global_Objects/String/raw +translation_of: Web/JavaScript/Reference/Global_Objects/String/raw +original_slug: Web/JavaScript/Referencia/Objetos_globales/String/raw +--- +{{JSRef}} + +El método estatico **`String.raw()` **es una función de [plantilla de literales](/es/docs/Web/JavaScript/Reference/template_strings), similar al prefijo `r` en Python o al prefijo `@` en C# para strings literales (con ciertas diferencias: ver la explicación en [este problema](https://bugs.chromium.org/p/v8/issues/detail?id=5016)). 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_](/es/docs/Web/JavaScript/Reference/template_strings), 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](/es/docs/Web/JavaScript/Reference/template_strings#Tagged_template_literals). + +`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()` + +```js +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ón | Estado | Comentario | +| ---------------------------------------------------------------------------- | ---------------------------- | ------------------- | +| {{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 + +- [Template strings](/es/docs/Web/JavaScript/Reference/template_strings) +- {{jsxref("String")}} +- [Lexical grammar](/es/docs/Web/JavaScript/Reference/Lexical_grammar) 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 deleted file mode 100644 index f49b45876d13b7..00000000000000 --- a/files/es/web/javascript/reference/global_objects/string/repeat/index.html +++ /dev/null @@ -1,129 +0,0 @@ ---- -title: String.prototype.repeat() -slug: Web/JavaScript/Reference/Global_Objects/String/repeat -tags: - - ECMAScript2015 - - JavaScript - - Prototype - - Referencia - - String - - metodo -translation_of: Web/JavaScript/Reference/Global_Objects/String/repeat -original_slug: Web/JavaScript/Referencia/Objetos_globales/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

- -
    -
  • {{jsxref("Errors/Negative_repetition_count", "RangeError")}}: El número de repeticiones no debe ser negativo.
    • -
  • {{jsxref("Errors/Resulting_string_too_large", "RangeError")}}: El número de repeticiones debe ser menor que infinito y no desbordar el tamaño máximo para un string.
    • -
- -
-
- -

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/repeat/index.md b/files/es/web/javascript/reference/global_objects/string/repeat/index.md new file mode 100644 index 00000000000000..80323e137d61de --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/repeat/index.md @@ -0,0 +1,107 @@ +--- +title: String.prototype.repeat() +slug: Web/JavaScript/Reference/Global_Objects/String/repeat +tags: + - ECMAScript2015 + - JavaScript + - Prototype + - Referencia + - String + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/String/repeat +original_slug: Web/JavaScript/Referencia/Objetos_globales/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 + +- {{jsxref("Errors/Negative_repetition_count", "RangeError")}}: El número de repeticiones no debe ser negativo. +- {{jsxref("Errors/Resulting_string_too_large", "RangeError")}}: El número de repeticiones debe ser menor que infinito y no desbordar el tamaño máximo para un string. + +## Ejemplos + +```js +'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: + +```js +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ón | Estado | Comentarios | +| ------------------------------------------------------------------------------------------------------------ | ---------------------------- | ------------------- | +| {{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/search/index.html b/files/es/web/javascript/reference/global_objects/string/search/index.html deleted file mode 100644 index 6e2a9b4e96f778..00000000000000 --- a/files/es/web/javascript/reference/global_objects/string/search/index.html +++ /dev/null @@ -1,106 +0,0 @@ ---- -title: String.prototype.search() -slug: Web/JavaScript/Reference/Global_Objects/String/search -tags: - - JavaScript - - Method - - Prototype - - Reference - - Regular Expressions - - String -translation_of: Web/JavaScript/Reference/Global_Objects/String/search -original_slug: Web/JavaScript/Referencia/Objetos_globales/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

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

Notas específicas de Gecko

- -
    -
  • Antes de {{Gecko("8.0")}}, search() estaba mal implementado; cuando se invocaba sin parámetros o con {{jsxref("undefined")}}, buscaría coincidencias con la cadena 'undefined' en lugar de la cadena vacía. Esto está corregido; ahora 'a'.search() y 'a'.search(undefined) devuelven correctamente un 0.
    • -
  • Desde Gecko 39 {{geckoRelease(39)}}, el argumento no estándar flags está obsoleto y muestra un aviso en la consola ({{bug(1142351)}}).
    • -
  • Desde Gecko 47 {{geckoRelease(47)}}, el argumento no estándar flags no es soportado en compilaciones que no sean lanzamientos y pronto serán eliminadas por completo ({{bug(1245801)}}).
    • -
  • Desde Gecko 49 {{geckoRelease(49)}}, el argumento no estándar flags no es soportado ({{bug(1108382)}}).
    • -
- -

Vea también

- -
    -
  • {{jsxref("String.prototype.match()")}}
    • -
  • {{jsxref("RegExp.prototype.exec()")}}
    • -
diff --git a/files/es/web/javascript/reference/global_objects/string/search/index.md b/files/es/web/javascript/reference/global_objects/string/search/index.md new file mode 100644 index 00000000000000..1ef5289560ce35 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/search/index.md @@ -0,0 +1,78 @@ +--- +title: String.prototype.search() +slug: Web/JavaScript/Reference/Global_Objects/String/search +tags: + - JavaScript + - Method + - Prototype + - Reference + - Regular Expressions + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/search +original_slug: Web/JavaScript/Referencia/Objetos_globales/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](/es/docs/Web/JavaScript/Referencia/Objetos_globales/RegExp). 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 + +### Utilizando `search()` + +El siguiente ejemplo imprime un mensaje dependiendo de cuál sea el resultado de la evaluación. + +```js +function testinput(re, str) { + var midstring; + if (str.search(re) != -1) { + midstring = ' contains '; + } else { + midstring = ' does not contain '; + } + console.log(str + midstring + re); +} +``` + +## Especificaciones + +| Especificaciones | Estado | Comentario | +| ------------------------------------------------------------------------------------------------------------ | ---------------------------- | --------------------------------------------------- | +| {{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 + +{{Compat("javascript.builtins.String.search")}} + +## Notas específicas de Gecko + +- Antes de {{Gecko("8.0")}}, `search()` estaba mal implementado; cuando se invocaba sin parámetros o con {{jsxref("undefined")}}, buscaría coincidencias con la cadena 'undefined' en lugar de la cadena vacía. Esto está corregido; ahora `'a'.search()` y `'a'.search(undefined)` devuelven correctamente un 0. +- Desde Gecko 39 {{geckoRelease(39)}}, el argumento no estándar `flags `está obsoleto y muestra un aviso en la consola ({{bug(1142351)}}). +- Desde Gecko 47 {{geckoRelease(47)}}, el argumento no estándar `flags` no es soportado en compilaciones que no sean lanzamientos y pronto serán eliminadas por completo ({{bug(1245801)}}). +- Desde Gecko 49 {{geckoRelease(49)}}, el argumento no estándar `flags `no es soportado ({{bug(1108382)}}). + +## Vea también + +- {{jsxref("String.prototype.match()")}} +- {{jsxref("RegExp.prototype.exec()")}} 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 deleted file mode 100644 index c1de6241a02e91..00000000000000 --- a/files/es/web/javascript/reference/global_objects/string/slice/index.html +++ /dev/null @@ -1,114 +0,0 @@ ---- -title: String.prototype.slice() -slug: Web/JavaScript/Reference/Global_Objects/String/slice -tags: - - Cadena - - JavaScript - - Método(2) - - Prototipo - - String -translation_of: Web/JavaScript/Reference/Global_Objects/String/slice -original_slug: Web/JavaScript/Referencia/Objetos_globales/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

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

Vea También

- -
    -
  • {{jsxref("String.prototype.substr()")}}
    • -
  • {{jsxref("String.prototype.substring()")}}
    • -
  • {{jsxref("Array.prototype.slice()")}}
    • -
diff --git a/files/es/web/javascript/reference/global_objects/string/slice/index.md b/files/es/web/javascript/reference/global_objects/string/slice/index.md new file mode 100644 index 00000000000000..ede405527d7c2b --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/slice/index.md @@ -0,0 +1,87 @@ +--- +title: String.prototype.slice() +slug: Web/JavaScript/Reference/Global_Objects/String/slice +tags: + - Cadena + - JavaScript + - Método(2) + - Prototipo + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/slice +original_slug: Web/JavaScript/Referencia/Objetos_globales/String/slice +--- +{{JSRef("Objetos_globales", "String")}} + +## Resumen + +El método **`slice()`** extrae una sección de una cadena y devuelve una cadena nueva. + +## Sintaxis + +```html +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. + +```js +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ón | Estado | Comentario | +| ------------------------------------------------------------------------------------------------------------ | ---------------------------- | --------------------------------------------------- | +| {{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 + +{{Compat("javascript.builtins.String.slice")}} + +## Vea También + +- {{jsxref("String.prototype.substr()")}} +- {{jsxref("String.prototype.substring()")}} +- {{jsxref("Array.prototype.slice()")}} 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 deleted file mode 100644 index 4f31bd7a2bf220..00000000000000 --- a/files/es/web/javascript/reference/global_objects/string/small/index.html +++ /dev/null @@ -1,39 +0,0 @@ ---- -title: String.prototype.small() -slug: Web/JavaScript/Reference/Global_Objects/String/small -tags: - - Deprecated - - HTML wrapper methods - - JavaScript - - Method - - Prototype - - String -translation_of: Web/JavaScript/Reference/Global_Objects/String/small -original_slug: Web/JavaScript/Referencia/Objetos_globales/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

-
    -
  • {{jsxref("String.prototype.fontsize()")}}
    • -
  • {{jsxref("String.prototype.big()")}}
    • -
diff --git a/files/es/web/javascript/reference/global_objects/string/small/index.md b/files/es/web/javascript/reference/global_objects/string/small/index.md new file mode 100644 index 00000000000000..0e542dae5639e2 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/small/index.md @@ -0,0 +1,53 @@ +--- +title: String.prototype.small() +slug: Web/JavaScript/Reference/Global_Objects/String/small +tags: + - Deprecated + - HTML wrapper methods + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/small +original_slug: Web/JavaScript/Referencia/Objetos_globales/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 + +```js +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: + +```html +¡Hola mundo! +¡Hola mundo! +¡Hola mundo! +``` + +### Vea También + +- {{jsxref("String.prototype.fontsize()")}} +- {{jsxref("String.prototype.big()")}} 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 deleted file mode 100644 index 710f8ede316279..00000000000000 --- a/files/es/web/javascript/reference/global_objects/string/startswith/index.html +++ /dev/null @@ -1,98 +0,0 @@ ---- -title: String.prototype.startsWith() -slug: Web/JavaScript/Reference/Global_Objects/String/startsWith -tags: - - ECMAScript 2015 - - JavaScript - - Method - - Prototipo - - Prototype - - Reference - - Referencia - - String - - metodo -translation_of: Web/JavaScript/Reference/Global_Objects/String/startsWith -original_slug: Web/JavaScript/Referencia/Objetos_globales/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

- -
    -
  • {{jsxref("String.prototype.endsWith()")}}
    • -
  • {{jsxref("String.prototype.includes()")}}
    • -
  • {{jsxref("String.prototype.indexOf()")}}
    • -
  • {{jsxref("String.prototype.lastIndexOf()")}}
    • -
diff --git a/files/es/web/javascript/reference/global_objects/string/startswith/index.md b/files/es/web/javascript/reference/global_objects/string/startswith/index.md new file mode 100644 index 00000000000000..62d02adedbdd5b --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/startswith/index.md @@ -0,0 +1,87 @@ +--- +title: String.prototype.startsWith() +slug: Web/JavaScript/Reference/Global_Objects/String/startsWith +tags: + - ECMAScript 2015 + - JavaScript + - Method + - Prototipo + - Prototype + - Reference + - Referencia + - String + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/String/startsWith +original_slug: Web/JavaScript/Referencia/Objetos_globales/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: + +```js +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](https://github.com/mathiasbynens/String.prototype.startsWith). + +## Ejemplos + +### Usando `startsWith()` + +```js +//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 + +- {{jsxref("String.prototype.endsWith()")}} +- {{jsxref("String.prototype.includes()")}} +- {{jsxref("String.prototype.indexOf()")}} +- {{jsxref("String.prototype.lastIndexOf()")}} 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 deleted file mode 100644 index 2acdb238811fc9..00000000000000 --- a/files/es/web/javascript/reference/global_objects/string/strike/index.html +++ /dev/null @@ -1,43 +0,0 @@ ---- -title: String.prototype.strike() -slug: Web/JavaScript/Reference/Global_Objects/String/strike -tags: - - Deprecated - - HTML wrapper methods - - JavaScript - - Method - - Prototype - - String -translation_of: Web/JavaScript/Reference/Global_Objects/String/strike -original_slug: Web/JavaScript/Referencia/Objetos_globales/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

-
    -
  • {{jsxref("String.prototype.blink()")}}
    • -
  • {{jsxref("String.prototype.bold()")}}
    • -
  • {{jsxref("String.prototype.italics()")}}
    • -
diff --git a/files/es/web/javascript/reference/global_objects/string/strike/index.md b/files/es/web/javascript/reference/global_objects/string/strike/index.md new file mode 100644 index 00000000000000..89215646a39043 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/strike/index.md @@ -0,0 +1,58 @@ +--- +title: String.prototype.strike() +slug: Web/JavaScript/Reference/Global_Objects/String/strike +tags: + - Deprecated + - HTML wrapper methods + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/strike +original_slug: Web/JavaScript/Referencia/Objetos_globales/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: + +```js +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: + +```html +¡Hola mundo! +¡Hola mundo! +¡Hola mundo! +¡Hola mundo! +``` + +## Vea También + +- {{jsxref("String.prototype.blink()")}} +- {{jsxref("String.prototype.bold()")}} +- {{jsxref("String.prototype.italics()")}} 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 deleted file mode 100644 index 7d11d8612d2522..00000000000000 --- a/files/es/web/javascript/reference/global_objects/string/sub/index.html +++ /dev/null @@ -1,36 +0,0 @@ ---- -title: String.prototype.sub() -slug: Web/JavaScript/Reference/Global_Objects/String/sub -tags: - - HTML wrapper methods - - JavaScript - - Method - - Prototype - - String -translation_of: Web/JavaScript/Reference/Global_Objects/String/sub -original_slug: Web/JavaScript/Referencia/Objetos_globales/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

-
    -
  • {{jsxref("String.prototype.sup()")}}
    • -
diff --git a/files/es/web/javascript/reference/global_objects/string/sub/index.md b/files/es/web/javascript/reference/global_objects/string/sub/index.md new file mode 100644 index 00000000000000..4c8d021b50778a --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/sub/index.md @@ -0,0 +1,50 @@ +--- +title: String.prototype.sub() +slug: Web/JavaScript/Reference/Global_Objects/String/sub +tags: + - HTML wrapper methods + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/sub +original_slug: Web/JavaScript/Referencia/Objetos_globales/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: + +```js +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: + +```html +Esto es lo que superscript parece. +Esto es lo que subscript parece. +``` + +### Vea También + +- {{jsxref("String.prototype.sup()")}} 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 deleted file mode 100644 index aedee46f714a82..00000000000000 --- a/files/es/web/javascript/reference/global_objects/string/substr/index.html +++ /dev/null @@ -1,84 +0,0 @@ ---- -title: String.prototype.substr() -slug: Web/JavaScript/Reference/Global_Objects/String/substr -tags: - - JavaScript - - Método(2) - - Prototipo - - String -translation_of: Web/JavaScript/Reference/Global_Objects/String/substr -original_slug: Web/JavaScript/Referencia/Objetos_globales/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

- -
    -
  • {{jsxref("String.prototype.slice()")}}
    • -
  • {{jsxref("String.prototype.substring()")}}
    • -
diff --git a/files/es/web/javascript/reference/global_objects/string/substr/index.md b/files/es/web/javascript/reference/global_objects/string/substr/index.md new file mode 100644 index 00000000000000..521eff43371370 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/substr/index.md @@ -0,0 +1,73 @@ +--- +title: String.prototype.substr() +slug: Web/JavaScript/Reference/Global_Objects/String/substr +tags: + - JavaScript + - Método(2) + - Prototipo + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/substr +original_slug: Web/JavaScript/Referencia/Objetos_globales/String/substr +--- +{{JSRef("Objetos_globales", "String")}} + +> **Advertencia:** 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 [.](http://msdn2.microsoft.com/en-us/library/0esxc5wy.aspx) + +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()` + +```js +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 + +- {{jsxref("String.prototype.slice()")}} +- {{jsxref("String.prototype.substring()")}} 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 deleted file mode 100644 index 8c14c9fff03363..00000000000000 --- a/files/es/web/javascript/reference/global_objects/string/substring/index.html +++ /dev/null @@ -1,93 +0,0 @@ ---- -title: String.prototype.substring() -slug: Web/JavaScript/Reference/Global_Objects/String/substring -tags: - - JavaScript - - Method - - Prototype - - String -translation_of: Web/JavaScript/Reference/Global_Objects/String/substring -original_slug: Web/JavaScript/Referencia/Objetos_globales/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 igual a indiceB, substring devuelve una cadena vacía.
    • -
  • Si se omite el indiceB, substring extrae caracteres hasta el final de la cadena.
    • -
  • Si el argumento es menor que 0 o es NaN, se trata como si fuese 0.
    • -
  • Si el argumento es mayor que nombreCadena.length, se trata como si fuese nombreCadena.length.
    • -
- -

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

- -
    -
  • {{jsxref("String.prototype.substr()")}}
    • -
  • {{jsxref("String.prototype.slice()")}}
    • -
diff --git a/files/es/web/javascript/reference/global_objects/string/substring/index.md b/files/es/web/javascript/reference/global_objects/string/substring/index.md new file mode 100644 index 00000000000000..190d3170135cad --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/substring/index.md @@ -0,0 +1,89 @@ +--- +title: String.prototype.substring() +slug: Web/JavaScript/Reference/Global_Objects/String/substring +tags: + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/substring +original_slug: Web/JavaScript/Referencia/Objetos_globales/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 igual a `indiceB`, `substring` devuelve una cadena vacía. +- Si se omite el `indiceB`, `substring` extrae caracteres hasta el final de la cadena. +- Si el argumento es menor que 0 o es `NaN`, se trata como si fuese 0. +- Si el argumento es mayor que `nombreCadena.length`, se trata como si fuese `nombreCadena.length`. + +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`": + +```js +// 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`". + +```js +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 + +- {{jsxref("String.prototype.substr()")}} +- {{jsxref("String.prototype.slice()")}} 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 deleted file mode 100644 index cf9670f0640f53..00000000000000 --- a/files/es/web/javascript/reference/global_objects/string/sup/index.html +++ /dev/null @@ -1,36 +0,0 @@ ---- -title: String.prototype.sup() -slug: Web/JavaScript/Reference/Global_Objects/String/sup -tags: - - HTML wrapper methods - - JavaScript - - Method - - Prototype - - String -translation_of: Web/JavaScript/Reference/Global_Objects/String/sup -original_slug: Web/JavaScript/Referencia/Objetos_globales/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

-
    -
  • {{jsxref("String.prototype.sub()")}}
    • -
diff --git a/files/es/web/javascript/reference/global_objects/string/sup/index.md b/files/es/web/javascript/reference/global_objects/string/sup/index.md new file mode 100644 index 00000000000000..5fbf92c0ddf8f4 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/sup/index.md @@ -0,0 +1,50 @@ +--- +title: String.prototype.sup() +slug: Web/JavaScript/Reference/Global_Objects/String/sup +tags: + - HTML wrapper methods + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/sup +original_slug: Web/JavaScript/Referencia/Objetos_globales/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: + +```js +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: + +```html +Esto es lo que superscript parece. +Esto es lo que subscript parece. +``` + +### Vea También + +- {{jsxref("String.prototype.sub()")}} 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 deleted file mode 100644 index 6e08248a3058f7..00000000000000 --- a/files/es/web/javascript/reference/global_objects/string/tolocaleuppercase/index.html +++ /dev/null @@ -1,99 +0,0 @@ ---- -title: String.prototype.toLocaleUpperCase() -slug: Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase -translation_of: Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase -original_slug: Web/JavaScript/Referencia/Objetos_globales/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

- -
    -
  • Un {{jsxref("RangeError")}} ("invalid language tag: xx_yy") se arroja si un argumento de configuración regional no es una etiqueta de idioma válida.
    • -
  • Un {{jsxref("TypeError")}} ("invalid element in locales argument") se lanzará si un elemento de matriz no es de tipo cadena.
    • -
- -

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

- -
    -
  • {{jsxref("String.prototype.toLocaleLowerCase()")}}
    • -
  • {{jsxref("String.prototype.toLowerCase()")}}
    • -
  • {{jsxref("String.prototype.toUpperCase()")}}
    • -
diff --git a/files/es/web/javascript/reference/global_objects/string/tolocaleuppercase/index.md b/files/es/web/javascript/reference/global_objects/string/tolocaleuppercase/index.md new file mode 100644 index 00000000000000..295bc1d0327e66 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/tolocaleuppercase/index.md @@ -0,0 +1,66 @@ +--- +title: String.prototype.toLocaleUpperCase() +slug: Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase +translation_of: Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase +original_slug: Web/JavaScript/Referencia/Objetos_globales/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 + +- Un {{jsxref("RangeError")}} ("invalid language tag: xx_yy") se arroja si un argumento de configuración regional no es una etiqueta de idioma válida. +- Un {{jsxref("TypeError")}} ("invalid element in locales argument") se lanzará si un elemento de matriz no es de tipo cadena. + +## 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()` + +```js +'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ón | Status | Comentario | +| ------------------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------- | -------------------------------------------------- | +| {{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 + +- {{jsxref("String.prototype.toLocaleLowerCase()")}} +- {{jsxref("String.prototype.toLowerCase()")}} +- {{jsxref("String.prototype.toUpperCase()")}} 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 deleted file mode 100644 index 0b29db43392223..00000000000000 --- a/files/es/web/javascript/reference/global_objects/string/tolowercase/index.html +++ /dev/null @@ -1,41 +0,0 @@ ---- -title: String.prototype.toLowerCase() -slug: Web/JavaScript/Reference/Global_Objects/String/toLowerCase -tags: - - JavaScript - - Method - - Prototype - - String -translation_of: Web/JavaScript/Reference/Global_Objects/String/toLowerCase -original_slug: Web/JavaScript/Referencia/Objetos_globales/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

- -
    -
  • {{jsxref("String.prototype.toLocaleLowerCase()")}}
    • -
  • {{jsxref("String.prototype.toUpperCase()")}}
    • -
diff --git a/files/es/web/javascript/reference/global_objects/string/tolowercase/index.md b/files/es/web/javascript/reference/global_objects/string/tolowercase/index.md new file mode 100644 index 00000000000000..5689cb7e9fe459 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/tolowercase/index.md @@ -0,0 +1,38 @@ +--- +title: String.prototype.toLowerCase() +slug: Web/JavaScript/Reference/Global_Objects/String/toLowerCase +tags: + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/toLowerCase +original_slug: Web/JavaScript/Referencia/Objetos_globales/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 + +- {{jsxref("String.prototype.toLocaleLowerCase()")}} +- {{jsxref("String.prototype.toUpperCase()")}} 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 deleted file mode 100644 index 52f14051a0fe5d..00000000000000 --- a/files/es/web/javascript/reference/global_objects/string/tostring/index.html +++ /dev/null @@ -1,29 +0,0 @@ ---- -title: String.prototype.toString() -slug: Web/JavaScript/Reference/Global_Objects/String/toString -tags: - - JavaScript - - Method - - Prototype - - String -translation_of: Web/JavaScript/Reference/Global_Objects/String/toString -original_slug: Web/JavaScript/Referencia/Objetos_globales/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

-
    -
  • {{jsxref("Object.prototype.toSource()")}}
    • -
  • {{jsxref("String.prototype.valueOf()")}}
    • -
diff --git a/files/es/web/javascript/reference/global_objects/string/tostring/index.md b/files/es/web/javascript/reference/global_objects/string/tostring/index.md new file mode 100644 index 00000000000000..613333963df67e --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/tostring/index.md @@ -0,0 +1,40 @@ +--- +title: String.prototype.toString() +slug: Web/JavaScript/Reference/Global_Objects/String/toString +tags: + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/toString +original_slug: Web/JavaScript/Referencia/Objetos_globales/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: + +```js +cadena = new String("Hello world"); +alert(cadena.toString()) // Displays "Hello world" +``` + +## Vea También + +- {{jsxref("Object.prototype.toSource()")}} +- {{jsxref("String.prototype.valueOf()")}} 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 deleted file mode 100644 index 27eef892e53c63..00000000000000 --- a/files/es/web/javascript/reference/global_objects/string/touppercase/index.html +++ /dev/null @@ -1,40 +0,0 @@ ---- -title: String.prototype.toUpperCase() -slug: Web/JavaScript/Reference/Global_Objects/String/toUpperCase -tags: - - JavaScript - - Method - - Prototype - - String -translation_of: Web/JavaScript/Reference/Global_Objects/String/toUpperCase -original_slug: Web/JavaScript/Referencia/Objetos_globales/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

- -
    -
  • {{jsxref("String.prototype.toLocaleUpperCase()")}}
    • -
  • {{jsxref("String.prototype.toLowerCase()")}}
    • -
diff --git a/files/es/web/javascript/reference/global_objects/string/touppercase/index.md b/files/es/web/javascript/reference/global_objects/string/touppercase/index.md new file mode 100644 index 00000000000000..edee768b10a457 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/touppercase/index.md @@ -0,0 +1,39 @@ +--- +title: String.prototype.toUpperCase() +slug: Web/JavaScript/Reference/Global_Objects/String/toUpperCase +tags: + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/toUpperCase +original_slug: Web/JavaScript/Referencia/Objetos_globales/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`": + +```js +console.log( "alphabet".toUpperCase() ); // "ALPHABET" +``` + +### Vea También + +- {{jsxref("String.prototype.toLocaleUpperCase()")}} +- {{jsxref("String.prototype.toLowerCase()")}} 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 deleted file mode 100644 index 593e177bf481d5..00000000000000 --- a/files/es/web/javascript/reference/global_objects/string/trim/index.html +++ /dev/null @@ -1,86 +0,0 @@ ---- -title: String.prototype.trim() -slug: Web/JavaScript/Reference/Global_Objects/String/Trim -translation_of: Web/JavaScript/Reference/Global_Objects/String/Trim -original_slug: Web/JavaScript/Referencia/Objetos_globales/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

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

Ver también

- -
    -
  • {{jsxref("String.prototype.trimLeft()")}} {{non-standard_inline}}
    • -
  • {{jsxref("String.prototype.trimRight()")}} {{non-standard_inline}}
    • -
diff --git a/files/es/web/javascript/reference/global_objects/string/trim/index.md b/files/es/web/javascript/reference/global_objects/string/trim/index.md new file mode 100644 index 00000000000000..43134e52404594 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/trim/index.md @@ -0,0 +1,69 @@ +--- +title: String.prototype.trim() +slug: Web/JavaScript/Reference/Global_Objects/String/Trim +translation_of: Web/JavaScript/Reference/Global_Objects/String/Trim +original_slug: Web/JavaScript/Referencia/Objetos_globales/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': + +```js +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. + +```js +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ón | Estatus | Comentario | +| ---------------------------------------------------------------------------------------------------- | ------------------------ | ----------------------------------------------------- | +| {{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 + +{{Compat("javascript.builtins.String.trim")}} + +## Ver también + +- {{jsxref("String.prototype.trimLeft()")}} {{non-standard_inline}} +- {{jsxref("String.prototype.trimRight()")}} {{non-standard_inline}} 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 deleted file mode 100644 index 9a3aea74950abc..00000000000000 --- a/files/es/web/javascript/reference/global_objects/string/trimend/index.html +++ /dev/null @@ -1,81 +0,0 @@ ---- -title: String.prototype.trimEnd() -slug: Web/JavaScript/Reference/Global_Objects/String/trimEnd -tags: - - Espacios en blanco - - JavaScript - - Métodos - - Prototype - - String - - Texto - - cadenas de texto -translation_of: Web/JavaScript/Reference/Global_Objects/String/trimEnd -original_slug: Web/JavaScript/Referencia/Objetos_globales/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

- -
    -
  • {{jsxref("String.prototype.trim()")}}
    • -
  • {{jsxref("String.prototype.trimStart()")}}
    • -
diff --git a/files/es/web/javascript/reference/global_objects/string/trimend/index.md b/files/es/web/javascript/reference/global_objects/string/trimend/index.md new file mode 100644 index 00000000000000..77f73fe0c12363 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/trimend/index.md @@ -0,0 +1,71 @@ +--- +title: String.prototype.trimEnd() +slug: Web/JavaScript/Reference/Global_Objects/String/trimEnd +tags: + - Espacios en blanco + - JavaScript + - Métodos + - Prototype + - String + - Texto + - cadenas de texto +translation_of: Web/JavaScript/Reference/Global_Objects/String/trimEnd +original_slug: Web/JavaScript/Referencia/Objetos_globales/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: + +```js +String.prototype.trimRight.name === "trimEnd"; +``` + +## Ejemplo + +### Usando `trimEnd()` + +El siguiente ejemplo muestra la cadena de texto en minusculas `' foo'`: + +```js +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 + +- {{jsxref("String.prototype.trim()")}} +- {{jsxref("String.prototype.trimStart()")}} 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 deleted file mode 100644 index a744d783b0e303..00000000000000 --- a/files/es/web/javascript/reference/global_objects/string/valueof/index.html +++ /dev/null @@ -1,29 +0,0 @@ ---- -title: String.prototype.valueOf() -slug: Web/JavaScript/Reference/Global_Objects/String/valueOf -tags: - - JavaScript - - Method - - Prototype - - String -translation_of: Web/JavaScript/Reference/Global_Objects/String/valueOf -original_slug: Web/JavaScript/Referencia/Objetos_globales/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

-
    -
  • {{jsxref("String.prototype.toString()")}}
    • -
  • {{jsxref("Object.prototype.valueOf()")}}
    • -
diff --git a/files/es/web/javascript/reference/global_objects/string/valueof/index.md b/files/es/web/javascript/reference/global_objects/string/valueof/index.md new file mode 100644 index 00000000000000..eea925fef5a768 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/string/valueof/index.md @@ -0,0 +1,40 @@ +--- +title: String.prototype.valueOf() +slug: Web/JavaScript/Reference/Global_Objects/String/valueOf +tags: + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/valueOf +original_slug: Web/JavaScript/Referencia/Objetos_globales/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` + +```js +cadena = new String("Hello world"); +alert(cadena.valueOf()) // Displays "Hello world" +``` + +## Vea También + +- {{jsxref("String.prototype.toString()")}} +- {{jsxref("Object.prototype.valueOf()")}} From 09a1df2aa7217640531ea5e85138e91c2317387d Mon Sep 17 00:00:00 2001 From: Alexander Date: Mon, 26 Sep 2022 14:55:09 -0500 Subject: [PATCH 2/2] Apply suggestions from code review --- .../es/web/javascript/reference/global_objects/string/index.md | 2 +- .../reference/global_objects/string/indexof/index.md | 2 +- .../javascript/reference/global_objects/string/length/index.md | 2 +- .../reference/global_objects/string/normalize/index.md | 3 ++- .../javascript/reference/global_objects/string/raw/index.md | 2 +- .../javascript/reference/global_objects/string/search/index.md | 2 +- .../javascript/reference/global_objects/string/substr/index.md | 3 ++- 7 files changed, 9 insertions(+), 7 deletions(-) diff --git a/files/es/web/javascript/reference/global_objects/string/index.md b/files/es/web/javascript/reference/global_objects/string/index.md index 8b1fe76ebbba42..0a9653feff9b5a 100644 --- a/files/es/web/javascript/reference/global_objects/string/index.md +++ b/files/es/web/javascript/reference/global_objects/string/index.md @@ -245,7 +245,7 @@ Ambos métodos anteriores dan como resultado cadenas idénticas. ## Métodos de contenedor HTML -> **Nota:** **Desaprobado. Evita estos métodos.**Son de uso limitado, ya que proporcionan solo un subconjunto de las etiquetas y atributos HTML disponibles. +> **Nota:** **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) diff --git a/files/es/web/javascript/reference/global_objects/string/indexof/index.md b/files/es/web/javascript/reference/global_objects/string/indexof/index.md index 6bc27f85a71502..9b3f772eeca9d2 100644 --- a/files/es/web/javascript/reference/global_objects/string/indexof/index.md +++ b/files/es/web/javascript/reference/global_objects/string/indexof/index.md @@ -13,7 +13,7 @@ original_slug: Web/JavaScript/Referencia/Objetos_globales/String/indexOf ## 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. +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 diff --git a/files/es/web/javascript/reference/global_objects/string/length/index.md b/files/es/web/javascript/reference/global_objects/string/length/index.md index c74f734faf11ed..8a2d36faef2222 100644 --- a/files/es/web/javascript/reference/global_objects/string/length/index.md +++ b/files/es/web/javascript/reference/global_objects/string/length/index.md @@ -13,7 +13,7 @@ original_slug: Web/JavaScript/Referencia/Objetos_globales/String/length --- {{JSRef}} -La propiedad** **`length`** de un objeto {{jsxref("String")}} representa la longitud de una cadena, en unidades de código UTF-16. +La propiedad **`length`** de un objeto {{jsxref("String")}} representa la longitud de una cadena, en unidades de código UTF-16. ## Sintaxis diff --git a/files/es/web/javascript/reference/global_objects/string/normalize/index.md b/files/es/web/javascript/reference/global_objects/string/normalize/index.md index d5b32b96b28d71..2cea1fafe94f14 100644 --- a/files/es/web/javascript/reference/global_objects/string/normalize/index.md +++ b/files/es/web/javascript/reference/global_objects/string/normalize/index.md @@ -24,7 +24,8 @@ El método **`normalize()`** retorna la Forma de Normalización Unicode de la ca ### 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. + - : 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. diff --git a/files/es/web/javascript/reference/global_objects/string/raw/index.md b/files/es/web/javascript/reference/global_objects/string/raw/index.md index f0dc349b7d2d48..3e0aae994c04e2 100644 --- a/files/es/web/javascript/reference/global_objects/string/raw/index.md +++ b/files/es/web/javascript/reference/global_objects/string/raw/index.md @@ -6,7 +6,7 @@ original_slug: Web/JavaScript/Referencia/Objetos_globales/String/raw --- {{JSRef}} -El método estatico **`String.raw()` **es una función de [plantilla de literales](/es/docs/Web/JavaScript/Reference/template_strings), similar al prefijo `r` en Python o al prefijo `@` en C# para strings literales (con ciertas diferencias: ver la explicación en [este problema](https://bugs.chromium.org/p/v8/issues/detail?id=5016)). Se utiliza para obtener un _string_ crudo a partir de plantillas de _string_ (es decir, el original, texto no interpretado). +El método estatico **`String.raw()`** es una función de [plantilla de literales](/es/docs/Web/JavaScript/Reference/template_strings), similar al prefijo `r` en Python o al prefijo `@` en C# para strings literales (con ciertas diferencias: ver la explicación en [este problema](https://bugs.chromium.org/p/v8/issues/detail?id=5016)). Se utiliza para obtener un _string_ crudo a partir de plantillas de _string_ (es decir, el original, texto no interpretado). ## Sintaxis diff --git a/files/es/web/javascript/reference/global_objects/string/search/index.md b/files/es/web/javascript/reference/global_objects/string/search/index.md index 1ef5289560ce35..ea53a7b114d7c6 100644 --- a/files/es/web/javascript/reference/global_objects/string/search/index.md +++ b/files/es/web/javascript/reference/global_objects/string/search/index.md @@ -15,7 +15,7 @@ original_slug: Web/JavaScript/Referencia/Objetos_globales/String/search ## 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. +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 diff --git a/files/es/web/javascript/reference/global_objects/string/substr/index.md b/files/es/web/javascript/reference/global_objects/string/substr/index.md index 521eff43371370..da5964c3bf6dae 100644 --- a/files/es/web/javascript/reference/global_objects/string/substr/index.md +++ b/files/es/web/javascript/reference/global_objects/string/substr/index.md @@ -11,7 +11,8 @@ original_slug: Web/JavaScript/Referencia/Objetos_globales/String/substr --- {{JSRef("Objetos_globales", "String")}} -> **Advertencia:** 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. +> **Advertencia:** 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