diff options
Diffstat (limited to 'files/es/web/javascript/referencia/objetos_globales/string')
49 files changed, 4948 insertions, 0 deletions
diff --git a/files/es/web/javascript/referencia/objetos_globales/string/anchor/index.html b/files/es/web/javascript/referencia/objetos_globales/string/anchor/index.html new file mode 100644 index 0000000000..c34abd62b1 --- /dev/null +++ b/files/es/web/javascript/referencia/objetos_globales/string/anchor/index.html @@ -0,0 +1,56 @@ +--- +title: String.prototype.anchor() +slug: Web/JavaScript/Referencia/Objetos_globales/String/anchor +tags: + - HTML wrapper methods + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/anchor +--- +<div>{{JSRef("Objetos_globales", "String")}}</div> + +<h2 id="Resumen" name="Resumen">Resumen</h2> + +<p>El método <strong><code>anchor()</code></strong> crea un ancla HTML, {{HTMLElement("a")}}, que se usa como un enlace a hipertexto.</p> + +<h2 id="Sintaxis" name="Sintaxis">Sintaxis</h2> + +<pre class="syntaxbox"><em>cadena</em>.anchor(<em>nombreAtributo</em>)</pre> + +<h3 id="Par.C3.A1metros" name="Par.C3.A1metros">Parámetros</h3> + +<dl> + <dt><code>nombreAtributo</code></dt> + <dd>Una cadena.</dd> +</dl> + +<h2 id="Descripci.C3.B3n" name="Descripci.C3.B3n">Descripción</h2> + +<p>Usa el método <code>anchor</code> con los métodos <code>document.write</code> o <code>document.writeln</code> para crear y mostrar programando un ancla en un documento. Crea el ancla con el método <code>anchor</code>, y entonces llama a <code>write</code> o <code>writeln</code> para mostrar el ancla en el documento. En JavaScript en el lado Servidor, usa la función <code>write</code> para mostrar el ancla.</p> + +<p>En la sintaxis, la cadena de texto representa el texto literal que usted quiere que el usuario vea. La cadena <code>nombreAtributo</code> representa el atributo <code>NAME</code> de la etiqueta A.</p> + +<p>Los anclas creados con el método <code>anchor</code> serán elementos del arreglo {{domxref("document.anchors")}}</p> + +<h2 id="Ejemplos" name="Ejemplos">Ejemplos</h2> + +<h3 id="Ejemplo:_Usando_anchor" name="Ejemplo:_Usando_anchor">Ejemplo: Usando <code>anchor</code></h3> + +<p>El siguiente código de ejemplo dentro de un elemento HTML <code>script</code>:</p> + +<pre class="brush: js">var miCadena = "Tabla de Contenidos"; +document.body.innerHTML = miCadena.anchor("ancla_contenidos"); +</pre> + +<p>obtendrá el siguiente HTML:</p> + +<pre class="brush: html"><a name="ancla_contenidos">Tabla de Contenidos</A> +</pre> + +<h3 id="Vea_Tambi.C3.A9n" name="Vea_Tambi.C3.A9n">Vea También</h3> + +<ul> + <li>{{jsxref("String.prototype.link()")}}</li> +</ul> diff --git a/files/es/web/javascript/referencia/objetos_globales/string/big/index.html b/files/es/web/javascript/referencia/objetos_globales/string/big/index.html new file mode 100644 index 0000000000..0aa04e5b74 --- /dev/null +++ b/files/es/web/javascript/referencia/objetos_globales/string/big/index.html @@ -0,0 +1,54 @@ +--- +title: String.prototype.big() +slug: Web/JavaScript/Referencia/Objetos_globales/String/big +tags: + - Deprecated + - HTML wrapper methods + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/big +--- +<p>{{JSRef("Objetos_globales", "String")}}</p> + +<p>{{deprecated_header}}</p> + +<h2 id="Resumen" name="Resumen">Resumen</h2> + +<p>Provoca que una cadena sea mostrada con un tamaño de fuente grade, como si estuviese en una etiqueta {{HTMLElement("big")}}.</p> + +<h2 id="Sintaxis" name="Sintaxis">Sintaxis</h2> + +<pre class="syntaxbox"><em>cadena</em>.big()</pre> + +<h2 id="Descripci.C3.B3n" name="Descripci.C3.B3n">Descripción</h2> + +<p>Usa el método <code>big</code> para formatear y mostrar una cadena en un documento.</p> + +<h2 id="Ejemplos" name="Ejemplos">Ejemplos</h2> + +<h3 id="Ejemplo:_Usando_big" name="Ejemplo:_Usando_big">Ejemplo: Usando <code>big</code></h3> + +<p>El siguiente ejemplo usa los métodos de <code>string</code> para cambiar el tamañó de una cadena:</p> + +<pre>var cadenaMundo="¡Hola Mundo!"; + +console.log(cadenaMundo.small()); +console.log("<P>" + cadenaMundo.big()); +console.log("<P>" + cadenaMundo.fontsize(7)); +</pre> + +<p>Este ejemplo produce el mismo resultado que el siguiente HTML:</p> + +<pre><small>¡Hola Mundo!</small> +<p><big>¡Hola Mundo!</big> +<p><fontsize=7>¡Hola Mundo!</fontsize> +</pre> + +<h3 id="Vea_Tambi.C3.A9n" name="Vea_Tambi.C3.A9n">Vea También</h3> + +<ul> + <li>{{jsxref("String.prototype.fontsize()")}}</li> + <li>{{jsxref("String.prototype.small()")}}</li> +</ul> diff --git a/files/es/web/javascript/referencia/objetos_globales/string/blink/index.html b/files/es/web/javascript/referencia/objetos_globales/string/blink/index.html new file mode 100644 index 0000000000..cf49f3d840 --- /dev/null +++ b/files/es/web/javascript/referencia/objetos_globales/string/blink/index.html @@ -0,0 +1,42 @@ +--- +title: String.prototype.blink() +slug: Web/JavaScript/Referencia/Objetos_globales/String/blink +tags: + - Deprecated + - HTML wrapper methods + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/blink +--- +<p>{{JSRef("Objetos_globales", "String")}}</p> +<p>{{deprecated_header}}</p> +<h2 id="Resumen" name="Resumen">Resumen</h2> +<p>Causa que una cadena parpadee como si estuviese en una etiqueta {{HTMLElement("blink")}}.</p> +<h2 id="Sintaxis" name="Sintaxis">Sintaxis</h2> +<pre class="syntaxbox"><em>cadena</em>.blink()</pre> +<h2 id="Descripci.C3.B3n" name="Descripci.C3.B3n">Descripción</h2> +<p>Usa el método <code>blink</code> para formatear y mostrar una cadena en un documento.</p> +<h2 id="Ejemplos">Ejemplos</h2> +<h3 id="Ejemplo:_Usando_m.C3.A9todos_de_string_para_cambiar_el_formateado_de_una_cadena" name="Ejemplo:_Usando_m.C3.A9todos_de_string_para_cambiar_el_formateado_de_una_cadena">Ejemplo: Usando métodos de <code>string</code> para cambiar el formateado de una cadena</h3> +<p>El siguiente ejemplo usa métodos de <code>string</code> para cambiar el formateado de una cadena:</p> +<pre class="brush: js">var cadenaMundo="¡Hola mundo!" + +console.log(cadenaMundo.blink()) +console.log(cadenaMundo.bold()) +console.log(cadenaMundo.italics()) +console.log(cadenaMundo.strike()) +</pre> +<p>Este ejemplo produce el mismo resultado que el siguiente código HTML:</p> +<pre class="brush: html"><blink>¡Hola mundo!</blink> +<b>¡Hola mundo!</b> +<i>¡Hola mundo!</b> +<strike>¡Hola mundo!</strike> +</pre> +<h2 id="Vea_tambi.C3.A9n" name="Vea_tambi.C3.A9n">Vea también</h2> +<ul> + <li>{{jsxref("String.prototype.bold()")}}</li> + <li>{{jsxref("String.prototype.italics()")}}</li> + <li>{{jsxref("String.prototype.strike()")}}</li> +</ul> diff --git a/files/es/web/javascript/referencia/objetos_globales/string/bold/index.html b/files/es/web/javascript/referencia/objetos_globales/string/bold/index.html new file mode 100644 index 0000000000..cc7c841181 --- /dev/null +++ b/files/es/web/javascript/referencia/objetos_globales/string/bold/index.html @@ -0,0 +1,43 @@ +--- +title: String.prototype.bold() +slug: Web/JavaScript/Referencia/Objetos_globales/String/bold +tags: + - Deprecated + - HTML wrapper methods + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/bold +--- +<p>{{JSRef("Objetos_globales", "String")}}<br> + <br> + {{Deprecated_header}}</p> +<h2 id="Resumen" name="Resumen">Resumen</h2> +<p>Provoca que una cadena se muestre en negrita como si estuviera en una etiqueta {{HTMLElement("b")}}.</p> +<h2 id="Sintaxis" name="Sintaxis">Sintaxis</h2> +<pre class="syntaxbox"><em>cadena</em>.bold()</pre> +<h2 id="Descripci.C3.B3n" name="Descripci.C3.B3n">Descripción</h2> +<p>Usa el método <code>bold</code> para formatear y mostrar una cadena en un documento.</p> +<h2 id="Ejemplos" name="Ejemplos">Ejemplos</h2> +<h3 id="Ejemplo:_Usando_m.C3.A9todos_de_string_para_cambiar_el_formateado_de_una_cadena" name="Ejemplo:_Usando_m.C3.A9todos_de_string_para_cambiar_el_formateado_de_una_cadena">Ejemplo: Usando métodos de <code>string</code> para cambiar el formateado de una cadena</h3> +<p>El siguiente ejemplo usa métodos de <code>string</code> para cambiar el formateado de una cadena:</p> +<pre class="brush: js">var cadenaMundo="¡Hola mundo!" + +console.log(cadenaMundo.blink()) +console.log(cadenaMundo.bold()) +console.log(cadenaMundo.italics()) +console.log(cadenaMundo.strike()) +</pre> +<p>Este ejemplo produce el mismo resultado que el siguiente código HTML:</p> +<pre class="brush: html"><blink>¡Hola mundo!</blink> +<b>¡Hola mundo!</b> +<i>¡Hola mundo!</i> +<strike>¡Hola mundo!</strike> +</pre> +<h3 id="Vea_Tambi.C3.A9n" name="Vea_Tambi.C3.A9n">Vea También</h3> +<ul> + <li>{{jsxref("String.prototype.blink()")}}</li> + <li>{{jsxref("String.prototype.italics()")}}</li> + <li>{{jsxref("String.prototype.strike()")}}</li> +</ul> diff --git a/files/es/web/javascript/referencia/objetos_globales/string/charat/index.html b/files/es/web/javascript/referencia/objetos_globales/string/charat/index.html new file mode 100644 index 0000000000..6ef6d46e37 --- /dev/null +++ b/files/es/web/javascript/referencia/objetos_globales/string/charat/index.html @@ -0,0 +1,143 @@ +--- +title: String.prototype.charAt() +slug: Web/JavaScript/Referencia/Objetos_globales/String/charAt +tags: + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/charAt +--- +<p>{{JSRef("Objetos_globales", "String")}}</p> + +<h2 id="Resumen" name="Resumen">Resumen</h2> + +<p>El método <strong><code>charAt() </code></strong><code>de</code><strong><code> </code></strong>{{jsxref("String")}} devuelve en un nuevo String el carácter UTF-16 de una cadena.</p> + +<h2 id="Syntax" name="Syntax">Sintaxis</h2> + +<pre class="syntaxbox"><em>str</em>.charAt(<em>indice</em>)</pre> + +<h3 id="Par.C3.A1metros" name="Par.C3.A1metros">Parámetros</h3> + +<dl> + <dt><code>indice</code></dt> + <dd>Un entero entre 0 y 1 menos que la longitud de la cadena. Si no se proporciona ningún indice charAt() utilizará 0.</dd> +</dl> + +<h2 id="Descripci.C3.B3n" name="Descripci.C3.B3n">Descripción</h2> + +<p>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 <code>nombreCadena</code> es <code>nombreCadena.length - 1</code>. Si el <code>indice</code> que usted proporciona está fuera del rango, JavaScript devuelve una cadena vacía.</p> + +<h2 id="Ejemplos" name="Ejemplos">Ejemplos</h2> + +<h3 id="Ejemplo:_Mostrando_caracteres_de_diferentes_localizaciones_en_una_cadena" name="Ejemplo:_Mostrando_caracteres_de_diferentes_localizaciones_en_una_cadena">Ejemplo: Mostrando caracteres de diferentes localizaciones en una cadena</h3> + +<p>El siguiente ejemplo muestra caracteres de diferentes localizaciones en la cadena "<code>Brave new world</code>":</p> + +<pre class="brush: 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) + "'") +</pre> + +<p>Estas líneas muestran lo siguiente:</p> + +<pre>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 '' +</pre> + +<h2 id="Especificaciónes">Especificaciónes</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificación</th> + <th scope="col">Estado</th> + <th scope="col">Comentario</th> + </tr> + <tr> + <td>ECMAScript 1st Edition.</td> + <td>Estándar</td> + <td>Primera definición</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.4', 'String.prototype.charAt')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.charat', 'String.prototype.charAt')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidad_de_navegadores">Compatibilidad de navegadores</h2> + +<p>{{ CompatibilityTable() }}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vea_Tambi.C3.A9n" name="Vea_Tambi.C3.A9n">Vea También</h2> + +<ul> + <li>{{jsxref("String.prototype.indexOf()")}}, {{jsxref("String.prototype.lastIndexOf()")}}</li> + <li>{{jsxref("String.prototype.split()")}}</li> + <li>{{jsxref("String.prototype.charCodeAt()")}}</li> + <li>{{jsxref("String.fromCodePoint()")}}</li> + <li>{{jsxref("String.prototype.codePointAt()")}}</li> +</ul> diff --git a/files/es/web/javascript/referencia/objetos_globales/string/charcodeat/index.html b/files/es/web/javascript/referencia/objetos_globales/string/charcodeat/index.html new file mode 100644 index 0000000000..4eccf78f13 --- /dev/null +++ b/files/es/web/javascript/referencia/objetos_globales/string/charcodeat/index.html @@ -0,0 +1,65 @@ +--- +title: String.prototype.charCodeAt() +slug: Web/JavaScript/Referencia/Objetos_globales/String/charCodeAt +tags: + - JavaScript + - Method + - Prototype + - String + - Unicode +translation_of: Web/JavaScript/Reference/Global_Objects/String/charCodeAt +--- +<p>{{JSRef("Objetos_globales", "String")}}</p> + +<h2 id="Resumen" name="Resumen">Resumen</h2> + +<p>El <code><strong>charCodeAt()</strong></code> método devuelve un número indicando el valor Unicode del carácter en el índice proporcionado.</p> + +<h2 id="Sintaxis" name="Sintaxis">Sintaxis</h2> + +<pre class="syntaxbox"><em>cadena</em>.charCodeAt(<em>indice</em>); +</pre> + +<h3 id="Par.C3.A1metros" name="Par.C3.A1metros">Parámetros</h3> + +<dl> + <dt><code>indice</code></dt> + <dd>Un entero entre 0 y 1 menos que la longitud de la cadena; si no se especifica, su valor predeterminado es 0.</dd> +</dl> + +<h2 id="Descripci.C3.B3n" name="Descripci.C3.B3n">Descripción</h2> + +<p>El rango del código Unicode va del 0 al 1,114,111<span class="comment">0x10FFFF</span>. 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 <a href="/es/docs/Web/JavaScript/Guide/Valores,_variables_y_literales#Unicode">Guía de JavaScript</a>. Observe que <code>charCodeAt</code> siempre devolverá un valor menor de 65.536.</p> + +<p><code>charCodeAt</code> devuelve {{jsxref("NaN")}} si el indice proporcionado no está entre 0 y 1 menos de la longitud de la cadena.</p> + +<p>En JavaScript 1.2 el método <code>charCodeAt</code> 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.</p> + +<h2 id="Ejemplos" name="Ejemplos">Ejemplos</h2> + +<h3 id="Ejemplo:_Usando_charCodeAt" name="Ejemplo:_Usando_charCodeAt">Ejemplo: Usando <code>charCodeAt</code></h3> + +<p>El siguiente ejemplo devuelve 65, el valor Unicode para A. </p> + +<pre class="eval">"ABC".charCodeAt(0) // returns 65 +</pre> + +<p>El siguiente ejemplo devuelve 83.</p> + +<pre>"AaSdas".charCodeAt(2) // returns 83 +</pre> + +<p>teniendo en cuenta que 2 es la posicion de la letra. Si `S` fuera minuscula, el Unicode es diferente</p> + +<pre>"Aasdas".charCodeAt(2) // returns 115</pre> + +<p> </p> + +<h2 id="Vea_Tambi.C3.A9n" name="Vea_Tambi.C3.A9n">Vea También</h2> + +<ul> + <li>{{jsxref("String.fromCharCode()")}}</li> + <li>{{jsxref("String.prototype.charAt()")}}</li> + <li>{{jsxref("String.fromCodePoint()")}}</li> + <li>{{jsxref("String.prototype.codePointAt()")}}</li> +</ul> diff --git a/files/es/web/javascript/referencia/objetos_globales/string/codepointat/index.html b/files/es/web/javascript/referencia/objetos_globales/string/codepointat/index.html new file mode 100644 index 0000000000..ae3fef3ec8 --- /dev/null +++ b/files/es/web/javascript/referencia/objetos_globales/string/codepointat/index.html @@ -0,0 +1,127 @@ +--- +title: String.prototype.codePointAt() +slug: Web/JavaScript/Referencia/Objetos_globales/String/codePointAt +translation_of: Web/JavaScript/Reference/Global_Objects/String/codePointAt +--- +<div>{{JSRef}}</div> + +<div> </div> + +<div>El método <strong><code>codePointAt() </code></strong><code>d</code>evuelve un entero no negativo que equivale al valor Unicode code point del carácter.</div> + +<h2 id="Sintaxis">Sintaxis</h2> + +<pre class="syntaxbox"><code><var>str</var>.codePointAt(<var>indice</var>)</code></pre> + +<h3 id="Parámetros">Parámetros</h3> + +<dl> + <dt><code>indice</code></dt> + <dd>Índice del carácter en la cadena del que se quiere obtener el valor del Unicode code point.</dd> +</dl> + +<h3 id="Valor_de_retorno">Valor de retorno</h3> + +<p>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.</p> + +<h2 id="Description">Description</h2> + +<p>If there is no element at the specified position, {{jsxref("undefined")}} is returned. If no UTF-16 surrogate pair begins at <code>pos</code>, the code unit at <code>pos</code> is returned.</p> + +<h2 id="Examples">Examples</h2> + +<h3 id="Using_codePointAt()">Using <code>codePointAt()</code></h3> + +<pre class="brush: js">'ABC'.codePointAt(1); // 66 +'\uD800\uDC00'.codePointAt(0); // 65536 + +'XYZ'.codePointAt(42); // undefined +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>The following extends Strings to include the <code>codePointAt()</code> function as specified in ECMAScript 2015 for browsers not supporting it natively.</p> + +<pre class="brush: 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; + } + }()); +} +</pre> + +<h2 id="Specifications">Specifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-string.prototype.codepointat', 'String.prototype.codePointAt')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initial definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.codepointat', 'String.prototype.codePointAt')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility">Browser compatibility</h2> + +<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> + +<p>{{Compat("javascript.builtins.String.codePointAt")}}</p> + +<h2 id="See_also">See also</h2> + +<ul> + <li>{{jsxref("String.fromCodePoint()")}}</li> + <li>{{jsxref("String.fromCharCode()")}}</li> + <li>{{jsxref("String.prototype.charCodeAt()")}}</li> + <li>{{jsxref("String.prototype.charAt()")}}</li> +</ul> diff --git a/files/es/web/javascript/referencia/objetos_globales/string/concat/index.html b/files/es/web/javascript/referencia/objetos_globales/string/concat/index.html new file mode 100644 index 0000000000..d00ffce70e --- /dev/null +++ b/files/es/web/javascript/referencia/objetos_globales/string/concat/index.html @@ -0,0 +1,90 @@ +--- +title: String.prototype.concat() +slug: Web/JavaScript/Referencia/Objetos_globales/String/concat +tags: + - JavaScript + - Prototipo + - Referencia + - String + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/String/concat +--- +<div>{{JSRef}}</div> + +<p><span class="seoSummary">El método <strong><code>concat()</code></strong> combina dos o más cadenas de texto y devuelve una cadena de texto nueva.</span></p> + +<div>{{EmbedInteractiveExample("pages/js/string-concat.html")}}</div> + +<h2 id="Sintaxis">Sintaxis</h2> + +<pre class="syntaxbox notranslate"><var>str</var>.concat(<var>str2</var> [, ...<var>strN</var>])</pre> + +<h3 id="Parámetros">Parámetros</h3> + +<dl> + <dt><code><var>str2</var> [, ...<var>strN</var>]</code></dt> + <dd>Cadenas que se concatenarán con <code><var>str</var></code>.</dd> +</dl> + +<h3 id="Valor_devuelto">Valor devuelto</h3> + +<p>Una nueva cadena que contiene el texto combinado de las cadenas proporcionadas.</p> + +<h2 id="Descripción">Descripción</h2> + +<p>La función <code>concat()</code> 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.</p> + +<p>Si los argumentos no son de tipo texto, son convertidos a texto antes de concatenarlos</p> + +<h2 id="Rendimiento">Rendimiento</h2> + +<p>Es altamente recomendado que se utilicen {{jsxref("Operators/Assignment_Operators", "operadores de asignación", "", 1)}} (<code>+</code>, <code>+=</code>) en lugar del método <code>concat()</code>.</p> + +<h2 id="Ejemplos">Ejemplos</h2> + +<h3 id="Usando_concat">Usando concat()</h3> + +<p>El siguiente ejemplo combina cadenas de texto en una nueva.</p> + +<pre class="brush: js notranslate">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" + +</pre> + +<h2 id="Especificaciones">Especificaciones</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Especificación</th> + </tr> + </thead> + <tbody> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.concat', 'String.prototype.concat')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidad_con_navegadores">Compatibilidad con navegadores</h2> + + + +<p>{{Compat("javascript.builtins.String.concat")}}</p> + +<h2 id="Ver_también">Ver también</h2> + +<ul> + <li>{{jsxref("Array.prototype.concat()")}}</li> + <li>{{jsxref("Operators/Assignment_Operators", "Operadores de asignación", "", 1)}}</li> +</ul> diff --git a/files/es/web/javascript/referencia/objetos_globales/string/endswith/index.html b/files/es/web/javascript/referencia/objetos_globales/string/endswith/index.html new file mode 100644 index 0000000000..cbeac4f481 --- /dev/null +++ b/files/es/web/javascript/referencia/objetos_globales/string/endswith/index.html @@ -0,0 +1,88 @@ +--- +title: String.prototype.endsWith() +slug: Web/JavaScript/Referencia/Objetos_globales/String/endsWith +tags: + - JavaScript + - Prototipo + - Referencia + - String + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/String/endsWith +--- +<div>{{JSRef}}</div> + +<p>El método <strong><code>endsWith()</code></strong> determina si una cadena de texto termina con los caracteres de una cadena indicada, devolviendo <code>true</code> o <code>false</code> según corresponda.</p> + +<div>{{EmbedInteractiveExample("pages/js/string-endswith.html")}}</div> + +<h2 id="Sintaxis">Sintaxis</h2> + +<pre class="syntaxbox notranslate"><code><var>str</var>.endsWith(<var>searchString</var>[, <var>position</var>])</code></pre> + +<h3 id="Parámetros">Parámetros</h3> + +<dl> + <dt><code><var>searchString</var></code></dt> + <dd>Los caracteres a buscar hasta el final de la cadena <em><code>str</code></em>.</dd> + <dt><code><var>length</var></code> {{optional_inline}}</dt> + <dd>Si se indica, se utiliza como el tamaño de <em><code>str</code></em>. Por defecto se usa <code><em>str</em>.length</code>.</dd> +</dl> + +<h3 id="Valor_devuelto">Valor devuelto</h3> + +<p><strong><code>true</code></strong> si los caracteres proporcionados se encuentran al final de la cadena de texto; en caso contrario, <strong><code>false</code></strong>.</p> + +<h2 id="Descripción">Descripción</h2> + +<p>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.</p> + +<h2 id="Polyfill">Polyfill</h2> + +<p>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 <code>String.prototype.endsWith()</code> con el siguiente fragmento de código:</p> + +<pre class="brush: js notranslate">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; + }; +} +</pre> + +<h2 id="Ejemplos">Ejemplos</h2> + +<h3 id="Usando_endsWith">Usando <code>endsWith()</code></h3> + +<pre class="brush: js notranslate">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 +</pre> + +<h2 id="Especificaciones">Especificaciones</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.endswith', 'String.prototype.endsWith')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidad_en_navegadores">Compatibilidad en navegadores</h2> + +<p>{{Compat("javascript.builtins.String.endsWith")}}</p> + +<h2 id="Ver_también">Ver también</h2> + +<ul> + <li>{{jsxref("String.prototype.startsWith()")}}</li> + <li>{{jsxref("String.prototype.includes()")}}</li> + <li>{{jsxref("String.prototype.indexOf()")}}</li> + <li>{{jsxref("String.prototype.lastIndexOf()")}}</li> +</ul> diff --git a/files/es/web/javascript/referencia/objetos_globales/string/fixed/index.html b/files/es/web/javascript/referencia/objetos_globales/string/fixed/index.html new file mode 100644 index 0000000000..3d188bc39d --- /dev/null +++ b/files/es/web/javascript/referencia/objetos_globales/string/fixed/index.html @@ -0,0 +1,35 @@ +--- +title: String.prototype.fixed() +slug: Web/JavaScript/Referencia/Objetos_globales/String/fixed +tags: + - Deprecated + - HTML wrapper methods + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/fixed +--- +<p>{{JSRef("Objetos_globales", "String")}}</p> +<p>{{deprecated_header}}</p> +<h2 id="Resumen" name="Resumen">Resumen</h2> +<p>Causa que una cadena se muestre con una fuente de ancho fijo, como si estuviesde dentro de una <span class="external">etiqueta {{HTMLElement("tt")}}</span>.</p> +<h2 id="Sintaxis" name="Sintaxis">Sintaxis</h2> +<pre class="syntaxbox"><em>cadena</em>.fixed()</pre> +<h2 id="Descripci.C3.B3n" name="Descripci.C3.B3n">Descripción</h2> +<p>Usa el método <code>fixed</code> para formatear y mostrar unacadena en un documento.</p> +<h2 id="Ejemplos" name="Ejemplos">Ejemplos</h2> +<h3 id="Ejemplo:_Usando_fixed_para_cambiar_el_formateado_de_una_cadena" name="Ejemplo:_Usando_fixed_para_cambiar_el_formateado_de_una_cadena">Ejemplo: Usando <code>fixed</code> para cambiar el formateado de una cadena</h3> +<p>El siguiente ejemplo usa el método <code>fixed</code> para cambiar el formateado de una cadena:</p> +<pre class="brush: js">var cadenaMundo="¡Hola Mundo!" +console.log(cadenaMundo.fixed()) +</pre> +<p>Este ejemplo produce el mismo resultado que el siguiente código HTML:</p> +<pre class="brush: html"><tt>¡Hola Mundo!</tt> +</pre> +<h3 id="Vea_Tambi.C3.A9n" name="Vea_Tambi.C3.A9n">Vea También</h3> +<ul> + <li>{{jsxref("String.prototype.bold()")}}</li> + <li>{{jsxref("String.prototype.italics()")}}</li> + <li>{{jsxref("String.prototype.strike()")}}</li> +</ul> diff --git a/files/es/web/javascript/referencia/objetos_globales/string/fontcolor/index.html b/files/es/web/javascript/referencia/objetos_globales/string/fontcolor/index.html new file mode 100644 index 0000000000..135e805cb2 --- /dev/null +++ b/files/es/web/javascript/referencia/objetos_globales/string/fontcolor/index.html @@ -0,0 +1,122 @@ +--- +title: String.prototype.fontcolor() +slug: Web/JavaScript/Referencia/Objetos_globales/String/fontcolor +translation_of: Web/JavaScript/Reference/Global_Objects/String/fontcolor +--- +<div>{{JSRef}} {{deprecated_header}}</div> + +<p><code>El método </code><strong><code>fontcolor()</code></strong> crea {{HTMLElement("font")}} elemento HTML que cambia el color de la cadena.</p> + +<div class="note"> +<p><strong>Usage note:</strong> La etiqueta <font> fue eliminada en <a href="/en-US/docs/Web/Guide/HTML/HTML5">HTML5</a> y no debe ser usada. En lugar de es, es necesario aplicar propiedades <a href="/en-US/docs/Web/CSS">CSS</a>.</p> +</div> + +<h2 id="Sintaxis">Sintaxis</h2> + +<pre class="syntaxbox"><code><var>str</var>.fontcolor(<var>color</var>)</code></pre> + +<h3 id="Parametros">Parametros</h3> + +<dl> + <dt><code>color</code></dt> + <dd>A string expressing the color as a hexadecimal RGB triplet or as a string literal. String literals for color names are listed in the <a href="/en-US/docs/Web/CSS/color_value">CSS color reference</a>.</dd> +</dl> + +<h2 id="Descripción">Descripción</h2> + +<p>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á <code>"FA8072"</code>.</p> + +<h2 id="Ejemplos">Ejemplos</h2> + +<h3 id="Usos_fontcolor()"><code>Usos fontcolor()</code></h3> + +<p>Los siguientes ejemplos usan el método <code>fontcolor()</code> para cambiar el color de una cadena.</p> + +<pre class="brush: js">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' +</pre> + +<p>Con el objeto {{domxref("HTMLElement.style", "element.style")}} obtienes el atributo <code>style</code> y manipularlo:</p> + +<pre class="brush: js">document.getElementById('yourElemId').style.color = 'red'; +</pre> + +<h2 id="Especificaciones">Especificaciones</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificación</th> + <th scope="col">Estatus</th> + <th scope="col">Comentario</th> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.fontcolor', 'String.prototype.fontcolor')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Initial definition. Implemented in JavaScript 1.0. Defined in the (normative) Annex B for Additional ECMAScript Features for Web Browsers.</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidad_con_navegadores">Compatibilidad con navegadores</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Soporte Basico</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoDesktop("1.0")}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome para Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Soporte Basico</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoMobile("1.0")}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Ver_también">Ver también</h2> + +<ul> + <li>{{jsxref("String.prototype.fontsize()")}}</li> +</ul> diff --git a/files/es/web/javascript/referencia/objetos_globales/string/fontsize/index.html b/files/es/web/javascript/referencia/objetos_globales/string/fontsize/index.html new file mode 100644 index 0000000000..212c49d638 --- /dev/null +++ b/files/es/web/javascript/referencia/objetos_globales/string/fontsize/index.html @@ -0,0 +1,123 @@ +--- +title: String.prototype.fontsize() +slug: Web/JavaScript/Referencia/Objetos_globales/String/fontsize +translation_of: Web/JavaScript/Reference/Global_Objects/String/fontsize +--- +<div>{{JSRef}} {{deprecated_header}}</div> + +<p><code>El método </code><strong><code>fontsize()</code></strong> crea {{HTMLElement("font")}} elemento HTML que muestra una cadena con el tamaño especificado.</p> + +<div class="note"> +<p><strong>Usage note:</strong> El elemento <font> ha sido eliminado <a href="/en-US/docs/Web/Guide/HTML/HTML5">HTML5</a> y no se debe usar. Los desarrolladores web deben usar propiedades <a href="/en-US/docs/Web/CSS">CSS</a>.</p> +</div> + +<h2 id="Sintaxis">Sintaxis</h2> + +<pre class="syntaxbox"><code><var>str</var>.fontsize(<var>size</var>)</code></pre> + +<h3 id="Parámetros">Parámetros</h3> + +<dl> + <dt><code>size</code></dt> + <dd>Un entero entre 1 y 7.</dd> +</dl> + +<h2 id="Descripción">Descripción</h2> + +<p>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")}}.</p> + +<p>When you specify size as an integer, you set the font size of <code>str</code> to one of the 7 defined sizes. When you specify <code>size</code> as a string such as "-2", you adjust the font size of <code>str</code> relative to the size set in the {{HTMLElement("basefont")}} tag.</p> + +<h2 id="Ejemlpos">Ejemlpos</h2> + +<h3 id="Usos_fontsize()"><code>Usos fontsize()</code></h3> + +<p>The following example uses string methods to change the size of a string:</p> + +<pre class="brush: js">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> +</pre> + +<p>With the {{domxref("HTMLElement.style", "element.style")}} object you can get the element's <code>style</code> attribute and manipulate it more generically, for example:</p> + +<pre class="brush: js">document.getElementById('yourElemId').style.fontSize = '0.7em'; +</pre> + +<h2 id="Specifications">Specifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.fontsize', 'String.prototype.fontsize')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Initial definition. Implemented in JavaScript 1.0. Defined in the (normative) Annex B for Additional ECMAScript Features for Web Browsers.</td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility">Browser compatibility</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoDesktop("1.0")}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoMobile("1.0")}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also">See also</h2> + +<ul> + <li>{{jsxref("String.prototype.big()")}}</li> + <li>{{jsxref("String.prototype.small()")}}</li> +</ul> diff --git a/files/es/web/javascript/referencia/objetos_globales/string/fromcharcode/index.html b/files/es/web/javascript/referencia/objetos_globales/string/fromcharcode/index.html new file mode 100644 index 0000000000..7e87f3d90d --- /dev/null +++ b/files/es/web/javascript/referencia/objetos_globales/string/fromcharcode/index.html @@ -0,0 +1,130 @@ +--- +title: String.fromCharCode() +slug: Web/JavaScript/Referencia/Objetos_globales/String/fromCharCode +tags: + - JavaScript + - Method + - String + - Unicode +translation_of: Web/JavaScript/Reference/Global_Objects/String/fromCharCode +--- +<p>{{JSRef("Objetos_globales", "String")}}</p> + +<h2 id="Resumen" name="Resumen">Resumen</h2> + +<p>El <strong><code>String.fromCharCode()</code></strong> método estático que devuelve una cadena creada mediante el uso de una secuencia de valores Unicode especificada.</p> + +<h2 id="Sintaxis" name="Sintaxis">Sintaxis</h2> + +<pre class="syntaxbox">String.fromCharCode(<em>num1</em>,<em> ...</em>,<em> numN</em>) </pre> + +<h3 id="Par.C3.A1metros" name="Par.C3.A1metros">Parámetros</h3> + +<dl> + <dt><code>num1, ..., num<em>N</em> </code></dt> + <dd>Secuencia de números con los valores Unicode.</dd> +</dl> + +<h2 id="Descripci.C3.B3n" name="Descripci.C3.B3n">Descripción</h2> + +<p>Este método devuelve una cadena y no un objeto <code>String</code>.</p> + +<p>Debido a que <code>fromCharCode</code> es un método estático de <code>String</code>, usted siempre lo usará como <code>String.fromCharCode()</code>, en vez de un método de un objeto <code>String</code> creado por usted.</p> + +<h2 id="Ejemplos" name="Ejemplos">Ejemplos</h2> + +<h3 id="Ejemplo:_Usando_fromCharCode" name="Ejemplo:_Usando_fromCharCode">Ejemplo: Usando <code>fromCharCode</code></h3> + +<p>El siguiene ejemplo devuelve la cadena "ABC".</p> + +<pre class="brush: js">String.fromCharCode(65,66,67) +</pre> + +<h2 id="Especificaciónes">Especificaciónes</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificación</th> + <th scope="col">Estatus</th> + <th scope="col">Comentario</th> + </tr> + <tr> + <td>ECMAScript 1st Edition.</td> + <td>Estándar</td> + <td>Primera definicíon<br> + Implementada en JavaScript 1.2</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.3.2', 'StringfromCharCode')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.fromcharcodes', 'String.fromCharCode')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidad_de_navegadores">Compatibilidad de navegadores</h2> + +<p>{{ CompatibilityTable() }}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vea_Tambi.C3.A9n" name="Vea_Tambi.C3.A9n">Vea También</h2> + +<ul> + <li>{{jsxref("String.prototype.charCodeAt()")}}</li> + <li>{{jsxref("String.prototype.charAt()")}}</li> + <li>{{jsxref("String.fromCodePoint()")}}</li> + <li>{{jsxref("String.prototype.codePointAt()")}}</li> +</ul> diff --git a/files/es/web/javascript/referencia/objetos_globales/string/fromcodepoint/index.html b/files/es/web/javascript/referencia/objetos_globales/string/fromcodepoint/index.html new file mode 100644 index 0000000000..39fe662b75 --- /dev/null +++ b/files/es/web/javascript/referencia/objetos_globales/string/fromcodepoint/index.html @@ -0,0 +1,204 @@ +--- +title: String.fromCodePoint() +slug: Web/JavaScript/Referencia/Objetos_globales/String/fromCodePoint +translation_of: Web/JavaScript/Reference/Global_Objects/String/fromCodePoint +--- +<div>{{JSRef("Global_Objects", "String")}}</div> + +<h2 id="Summary" name="Summary">Resumen</h2> + +<p>El método estatico <strong><code>String.fromCodePoint()</code></strong> devuelve una cadena creada por una secuencia de puntos de codigo.</p> + +<h2 id="Syntax" name="Syntax">Sintaxis</h2> + +<pre class="syntaxbox"><code>String.fromCodePoint(<var>num1</var>[, ...[, <var>numN</var>]])</code></pre> + +<h3 id="Parameters" name="Parameters">Parametros</h3> + +<dl> + <dt><code>num1, ..., num<em>N</em></code></dt> + <dd>Una secuencia de puntos de código.</dd> +</dl> + +<h3 id="Throws">Throws</h3> + +<dl> + <dt>{{jsxref("Global_Objects/RangeError", "RangeError")}}</dt> + <dd>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").</dd> +</dl> + +<h2 id="Description" name="Description">Descripción</h2> + +<p>Because <code>fromCodePoint()</code> is a static method of {{jsxref("Global_Objects/String", "String")}}, you always use it as <code>String.fromCodePoint()</code>, rather than as a method of a {{jsxref("Global_Objects/String", "String")}} object you created.</p> + +<h2 id="Examples" name="Examples">Ejemplos</h2> + +<h3 id="Example:_Using_fromCharCode" name="Example:_Using_fromCharCode">Ejemplos: Usando <code>fromCodePoint()</code></h3> + +<pre class="brush: 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 +</pre> + +<pre class="brush: 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 +</pre> + +<h2 id="Polyfill" name="Polyfill">Polyfill</h2> + +<p>The <code>String.fromCodePoint</code> 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:</p> + +<pre class="brush: 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; + } + }()); +} +</pre> + +<h2 id="Specifications">Specifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.fromcodepoint', 'String.fromCodePoint')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Initial definition.</td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility">Browser compatibility</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>41</td> + <td>{{CompatGeckoDesktop("29")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatGeckoMobile("29")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">See also</h2> + +<ul> + <li>{{jsxref("String.fromCharCode()")}}</li> + <li>{{jsxref("String.prototype.charAt()")}}</li> + <li>{{jsxref("String.prototype.codePointAt()")}}</li> + <li>{{jsxref("String.prototype.charCodeAt()")}}</li> +</ul> diff --git a/files/es/web/javascript/referencia/objetos_globales/string/includes/index.html b/files/es/web/javascript/referencia/objetos_globales/string/includes/index.html new file mode 100644 index 0000000000..094a3fd648 --- /dev/null +++ b/files/es/web/javascript/referencia/objetos_globales/string/includes/index.html @@ -0,0 +1,108 @@ +--- +title: String.prototype.includes() +slug: Web/JavaScript/Referencia/Objetos_globales/String/includes +tags: + - Cadena de texto + - JavaScript + - Prototipo + - Referencia + - String + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/String/includes +--- +<div>{{JSRef}}</div> + +<p>El método <strong><code>includes()</code></strong> determina si una cadena de texto puede ser encontrada dentro de otra cadena de texto, devolviendo <code><strong>true</strong></code> o <strong><code>false</code></strong> según corresponda.</p> + +<div>{{EmbedInteractiveExample("pages/js/string-includes.html", "shorter")}}</div> + +<h2 id="Sintaxis">Sintaxis</h2> + +<pre class="syntaxbox notranslate"><code><var>str</var>.includes(<var>searchString</var>[, <var>position</var>])</code></pre> + +<h3 id="Parametros">Parametros</h3> + +<dl> + <dt><code><var>searchString</var></code></dt> + <dd>Una cadena a buscar en el texto <em><code>str</code></em>.</dd> + <dt><code><var>position</var></code> {{optional_inline}}</dt> + <dd>La posición dentro de la cadena en la cual empieza la búsqueda de <code>searchString</code> (Por defecto este valor es 0).</dd> +</dl> + +<h3 id="Valor_devuelto">Valor devuelto</h3> + +<p><strong><code>true</code></strong> si la cadena de texto contiene la cadena buscada; en caso contrario, <strong><code>false</code></strong>.</p> + +<h2 id="Descripción">Descripción</h2> + +<p>Este método permite determinar si una cadena de texto se encuentra incluida dentro de la otra.</p> + +<h3 id="Sensibilidad_a_MayúsculasMinúsculas">Sensibilidad a Mayúsculas/Minúsculas</h3> + +<p>El método <code>includes()</code> es "case sensitive" (tiene en cuenta mayúsculas y minúsculas). Por ejemplo, la siguiente expresión devolverá <code>false</code>:</p> + +<pre class="brush: js notranslate">'Ballena azul'.includes('ballena'); // devuelve false +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Este método ha sido agregado a la especificación ECMAScript 2015 y puede no estar disponible en toda las implementaciones de JavaScript.</p> + +<p>Sin embargo, puedes usar este método como polyfill:</p> + +<pre class="brush: js notranslate">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; + }; +} +</pre> + +<h2 id="Ejemplos">Ejemplos</h2> + +<h3 id="Usando_includes">Usando <code>includes()</code></h3> + +<pre class="brush: js notranslate">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 +</pre> + +<h2 id="Especificaciones">Especificaciones</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Specification</th> + </tr> + </thead> + <tbody> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.includes', 'String.prototype.includes')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidad_en_navegadores">Compatibilidad en navegadores</h2> + +<p>{{Compat("javascript.builtins.String.includes")}}</p> + +<h2 id="Ver_también">Ver también</h2> + +<ul> + <li>{{jsxref("Array.prototype.includes()")}}</li> + <li>{{jsxref("TypedArray.prototype.includes()")}}</li> + <li>{{jsxref("String.prototype.indexOf()")}}</li> + <li>{{jsxref("String.prototype.lastIndexOf()")}}</li> + <li>{{jsxref("String.prototype.startsWith()")}}</li> + <li>{{jsxref("String.prototype.endsWith()")}}</li> +</ul> diff --git a/files/es/web/javascript/referencia/objetos_globales/string/index.html b/files/es/web/javascript/referencia/objetos_globales/string/index.html new file mode 100644 index 0000000000..a6c5aea8e3 --- /dev/null +++ b/files/es/web/javascript/referencia/objetos_globales/string/index.html @@ -0,0 +1,385 @@ +--- +title: String — Cadena de caracteres +slug: Web/JavaScript/Referencia/Objetos_globales/String +tags: + - Clase + - Class + - ECMAScript 2015 + - JavaScript + - Referencia + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String +--- +<div>{{JSRef}}</div> + +<p>El objeto <strong><code>String</code></strong> se utiliza para representar y manipular una secuencia de caracteres.</p> + +<h2 id="Descripción">Descripción</h2> + +<p>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 <a href="/es/docs/Web/JavaScript/Reference/Operators/String_Operators">operadores de cadena + y +=</a>, 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()")}}.</p> + +<h3 id="Crear_cadenas">Crear cadenas</h3> + +<p>Las cadenas se pueden crear como primitivas, a partir de cadena literales o como objetos, usando el constructor {{jsxref("String/String", "String()")}}:</p> + +<pre class="syntaxbox notranslate">const string1 = "Una cadena primitiva"; +const string2 = 'También una cadena primitiva'; +const string3 = `Otra cadena primitiva más`;</pre> + +<pre class="syntaxbox notranslate">const string4 = new String("Un objeto String"); +</pre> + +<p>Las <code>string</code>s primitivas y los objetos <code>string</code> se pueden usar indistintamente en la mayoría de las situaciones. Consulta "<a href="#Primitivas_string_y_objetos_string">Primitivas <code>String</code> y objetos <code>String</code></a>" a continuación.</p> + +<p>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 <kbd>`</kbd>. Esta última forma especifica una <a href="/es/docs/Web/JavaScript/Reference/Template_literals">Plantilla literal</a>: con esta forma puedes interpolar expresiones.</p> + +<h3 id="Acceder_a_un_caracter">Acceder a un caracter</h3> + +<p>Hay dos formas de acceder a un caracter individual en una cadena. La primera es con el método {{jsxref("String.prototype.charAt()", "charAt()")}}:</p> + +<pre class="brush: js notranslate">return 'cat'.charAt(1) // devuelve "a" +</pre> + +<p>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:</p> + +<pre class="brush: js notranslate">return 'cat'[1] // devuelve "a" +</pre> + +<p>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).</p> + +<h3 id="Comparar_cadenas">Comparar cadenas</h3> + +<p>En C, se usa la función <code>strcmp()</code> para comparar cadenas. En JavaScript, solo usas los <a href="/es/docs/Web/JavaScript/Reference/Operators/Comparison_Operators">operadores menor que y mayor que</a>:</p> + +<pre class="brush: js notranslate">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.') +} +</pre> + +<p>Puedes lograr un resultado similar usando el método {{jsxref("String.prototype.localeCompare()", "localeCompare()")}} heredado por las instancias de <code>String</code>.</p> + +<p>Ten en cuenta que <code>a == b</code> compara las cadenas en <code><var>a</var></code> y <code><var>b</var></code> 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:</p> + +<pre class="notranslate">function isEqual(str1, str2) +{ + return str1.toUpperCase() === str2.toUpperCase() +} // isEqual +</pre> + +<p>En esta función se utilizan mayúsculas en lugar de minúsculas, debido a problemas con ciertas conversiones de caracteres UTF-8.</p> + +<h3 id="Primitivas_String_y_objetos_String">Primitivas <code>String</code> y objetos <code>String</code></h3> + +<p>Ten en cuenta que JavaScript distingue entre objetos <code>String</code> y valores de {{Glossary("Primitive", "primitivas string")}}. (Lo mismo ocurre con {{jsxref("Boolean", "Booleanos")}} y {{jsxref("Global_Objects/Number", "Números")}}).</p> + +<p>Las cadenas literales (denotadas por comillas simples o dobles) y cadenas devueltas de llamadas a <code>String</code> 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 <code>String</code>, por lo que es posible utilizar métodos del objeto <code>String</code> 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.</p> + +<pre class="brush: js notranslate">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" +</pre> + +<p>Las primitivas de <code>String</code> y los objetos <code>String</code> también dan diferente resultado cuando se usa {{jsxref("Global_Objects/eval", "eval()")}}. Las primitivas pasadas a <code>eval</code> se tratan como código fuente; Los objetos <code>String</code> se tratan como todos los demás objetos, devuelven el objeto. Por ejemplo:</p> + +<pre class="brush: js notranslate">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" +</pre> + +<p>Por estas razones, el código se puede romper cuando encuentra objetos <code>String</code> y espera una <code>string</code> primitiva en su lugar, aunque generalmente los autores no necesitan preocuparse por la distinción.</p> + +<p>Un objeto <code>String</code> siempre se puede convertir a su contraparte primitiva con el método {{jsxref("String.prototype.valueOf()", "valueOf()")}}.</p> + +<pre class="brush: js notranslate">console.log(eval(s2.valueOf())) // devuelve el número 4 +</pre> + +<h3 id="Notación_de_escape">Notación de escape</h3> + +<p>Los caracteres especiales se pueden codificar mediante notación de escape:</p> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Código</th> + <th scope="col">Salida</th> + </tr> + </thead> + <tbody> + <tr> + <td><code>\<var>XXX</var></code><br> + (donde <code><var>XXX</var></code> es de 1 a 3 dígitos octales; rango de <code>0</code>-<code>377</code>)</td> + <td>Punto de código Unicode/carácter ISO-8859-1 entre <code>U+0000</code> y <code>U+00FF</code></td> + </tr> + <tr> + <td><code>\'</code></td> + <td>Comilla sencilla</td> + </tr> + <tr> + <td><code>\"</code></td> + <td>Comilla doble</td> + </tr> + <tr> + <td><code>\\</code></td> + <td>Barra inversa</td> + </tr> + <tr> + <td><code>\n</code></td> + <td>Nueva línea</td> + </tr> + <tr> + <td><code>\r</code></td> + <td>Retorno de carro</td> + </tr> + <tr> + <td><code>\v</code></td> + <td>Tabulación vertical</td> + </tr> + <tr> + <td><code>\t</code></td> + <td>Tabulación</td> + </tr> + <tr> + <td><code>\b</code></td> + <td>Retroceso</td> + </tr> + <tr> + <td><code>\f</code></td> + <td>Avance de página</td> + </tr> + <tr> + <td><code>\u<var>XXXX</var></code> (donde <code><var>XXXX</var></code> son 4 dígitos hexadecimales; rango de <code>0x0000</code>-<code>0xFFFF</code>)</td> + <td>Unidad de código UTF-16/punto de código Unicode entre <code>U+0000</code> y <code>U+FFFF</code></td> + </tr> + <tr> + <td><code>\u{<var>X</var>}</code> ... <code>\u{<var>XXXXXX</var>}</code><br> + (donde <code><var>X</var>…<var>XXXXXX</var></code> es de 1 a 6 dígitos hexadecimales; rango de <code>0x0</code>-<code>0x10FFFF</code>)</td> + <td>Unidad de código UTF-32/punto de código Unicode entre <code>U+0000</code> y <code>U+10FFFF</code></td> + </tr> + <tr> + <td><code>\x<var>XX</var></code><br> + (donde <code><var>XX</var></code> son 2 dígitos hexadecimales; rango de <code>0x00</code>-<code>0xFF</code>)</td> + <td>Punto de código Unicode/carácter ISO-8859-1 entre <code>U+0000</code> y <code>U+00FF</code></td> + </tr> + </tbody> +</table> + +<h3 id="Cadenas_literales_largas">Cadenas literales largas</h3> + +<p>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.</p> + +<h4 id="Método_1">Método 1</h4> + +<p>Puedes usar el operador <a href="/es/docs/Web/JavaScript/Reference/Operators/Addition">+</a> para agregar varias cadenas juntas, así:</p> + +<pre class="brush: js notranslate">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." +</pre> + +<h4 id="Método_2">Método 2</h4> + +<p>Puedes usar el caracter de barra invertida (<code>\</code>) 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á.</p> + +<p>Esa forma se ve así:</p> + +<pre class="brush: js notranslate">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." +</pre> + +<p>Ambos métodos anteriores dan como resultado cadenas idénticas.</p> + +<h2 id="Constructor">Constructor</h2> + +<dl> + <dt>{{jsxref("String/String", "String()")}}</dt> + <dd>Crea un nuevo objeto <code>String</code>. Realiza la conversión de tipos cuando se llama como función, en lugar de como constructor, lo cual suele ser más útil.</dd> +</dl> + +<h2 id="Métodos_estáticos">Métodos estáticos</h2> + +<dl> + <dt>{{jsxref("String.fromCharCode()", "String.fromCharCode(<var>num1</var> [, ...[, <var>numN</var>]])")}}</dt> + <dd>Devuelve una cadena creada utilizando la secuencia de valores Unicode especificada.</dd> + <dt>{{jsxref("String.fromCodePoint()", "String.fromCodePoint(<var>num1</var> [, ...[, <var>numN</var>]])")}}</dt> + <dd>Devuelve una cadena creada utilizando la secuencia de puntos de código especificada.</dd> + <dt>{{jsxref("String.raw()")}}</dt> + <dd>Devuelve una cadena creada a partir de una plantilla literal sin formato.</dd> +</dl> + +<h2 id="Propiedades_de_la_instancia">Propiedades de la instancia</h2> + +<dl> + <dt>{{jsxref("String.prototype.length")}}</dt> + <dd>Refleja la <code>length</code> de la cadena. Solo lectura.</dd> +</dl> + +<h2 id="Métodos_de_instancia">Métodos de instancia</h2> + +<dl> + <dt>{{jsxref("String.prototype.charAt()", "String.prototype.charAt(<var>index</var>)")}}</dt> + <dd>Devuelve el caracter (exactamente una unidad de código UTF-16) en el <code><var>index</var></code> especificado.</dd> + <dt>{{jsxref("String.prototype.charCodeAt()", "String.prototype.charCodeAt(<var>index</var>)")}}</dt> + <dd>Devuelve un número que es el valor de la unidad de código UTF-16 en el <code><var>index</var></code> dado.</dd> + <dt>{{jsxref("String.prototype.codePointAt()", "String.prototype.codePointAt(<var>pos</var>)")}}</dt> + <dd>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 <code><var>pos</var></code> especificada.</dd> + <dt>{{jsxref("String.prototype.concat()", "String.prototype.concat(<var>str</var>[, ...<var>strN</var>])")}}</dt> + <dd>Combina el texto de dos (o más) cadenas y devuelve una nueva cadena.</dd> + <dt>{{jsxref("String.prototype.includes()", "String.prototype.includes(<var>searchString</var> [, <var>position</var>])")}}</dt> + <dd>Determina si la cadena de la llamada contiene <code><var>searchString</var></code>.</dd> + <dt>{{jsxref("String.prototype.endsWith()", "String.prototype.endsWith(<var>searchString</var>[, <var>length</var>])")}}</dt> + <dd>Determina si una cadena termina con los caracteres de la cadena <code><var>searchString</var></code>.</dd> + <dt>{{jsxref("String.prototype.indexOf()", "String.prototype.indexOf(<var>searchValue</var>[, <var>fromIndex</var>])")}}</dt> + <dd>Devuelve el índice dentro del objeto {{jsxref("String")}} llamador de la primera aparición de <code><var>searchValue</var></code>, o <code>-1</code> si no lo encontró.</dd> + <dt>{{jsxref("String.prototype.lastIndexOf()", "String.prototype.lastIndexOf(<var>searchValue</var>[, <var>fromIndex</var>])")}}</dt> + <dd>Devuelve el índice dentro del objeto {{jsxref("String")}} llamador de la última aparición de <code><var>searchValue</var></code>, o <code>-1</code> si no lo encontró.</dd> + <dt>{{jsxref("String.prototype.localeCompare()", "String.prototype.localeCompare(<var>compareString</var>[, <var>locales</var>[, <var>options</var>]])")}}</dt> + <dd>Devuelve un número que indica si la cadena de referencia <code><var>compareString</var></code> viene antes, después o es equivalente a la cadena dada en el orden de clasificación.</dd> + <dt>{{jsxref("String.prototype.match()", "String.prototype.match(<var>regexp</var>)")}}</dt> + <dd>Se utiliza para hacer coincidir la expresión regular <code><var>regexp</var></code> con una cadena.</dd> + <dt>{{jsxref("String.prototype.matchAll()", "String.prototype.matchAll(<var>regexp</var>)")}}</dt> + <dd>Devuelve un iterador de todas las coincidencias de <code><var>regexp</var></code>.</dd> + <dt>{{jsxref("String.prototype.normalize()", "String.prototype.normalize([<var>form</var>])")}}</dt> + <dd>Devuelve la forma de normalización Unicode del valor de la cadena llamada.</dd> + <dt>{{jsxref("String.prototype.padEnd()", "String.prototype.padEnd(<var>targetLength</var>[, <var>padString</var>])")}}</dt> + <dd>Rellena la cadena actual desde el final con una cadena dada y devuelve una nueva cadena de longitud <code><var>targetLength</var></code>.</dd> + <dt>{{jsxref("String.prototype.padStart()", "String.prototype.padStart(<var>targetLength</var>[, <var>padString</var>])")}}</dt> + <dd>Rellena la cadena actual desde el principio con una determinada cadena y devuelve una nueva cadena de longitud <code><var>targetLength</var></code>.</dd> + <dt>{{jsxref("String.prototype.repeat()", "String.prototype.repeat(<var>count</var>)")}}</dt> + <dd>Devuelve una cadena que consta de los elementos del objeto repetidos <code><var>count</var></code> veces.</dd> + <dt>{{jsxref("String.prototype.replace()" , "String.prototype.replace(<var>searchFor</var>, <var>replaceWith</var>)")}}</dt> + <dd>Se usa para reemplazar ocurrencias de <code><var>searchFor</var></code> usando <code><var>replaceWith</var></code>. <code><var>searchFor</var></code> puede ser una cadena o expresión regular, y <code><var>replaceWith</var></code> puede ser una cadena o función.</dd> + <dt>{{jsxref("String.prototype.replaceAll()", "String.prototype.replaceAll(<var>searchFor</var>, <var>replaceWith</var>)")}}</dt> + <dd>Se utiliza para reemplazar todas las apariciones de <code><var>searchFor</var></code> usando <code><var>replaceWith</var></code>. <code><var>searchFor</var></code> puede ser una cadena o expresión regular, y <code><var>replaceWith</var></code> puede ser una cadena o función.</dd> + <dt>{{jsxref("String.prototype.search()", "String.prototype.search(<var>regexp</var>)")}}</dt> + <dd>Busca una coincidencia entre una expresión regular <code><var>regexp</var></code> y la cadena llamadora.</dd> + <dt>{{jsxref("String.prototype.slice()", "String.prototype.slice(<var>beginIndex</var>[, <var>endIndex</var>])")}}</dt> + <dd>Extrae una sección de una cadena y devuelve una nueva cadena.</dd> + <dt>{{jsxref("String.prototype.split()", "String.prototype.split([<var>sep</var>[, <var>limit</var>] ])")}}</dt> + <dd>Devuelve un arreglo de cadenas pobladas al dividir la cadena llamadora en las ocurrencias de la subcadena <code><var>sep</var></code>.</dd> + <dt>{{jsxref("String.prototype.startsWith()", "String.prototype.startsWith(<var>searchString</var>[, <var>length</var>])")}}</dt> + <dd>Determina si la cadena llamadora comienza con los caracteres de la cadena <code><var>searchString</var></code>.</dd> + <dt>{{jsxref("String.prototype.substr()")}}</dt> + <dd>Devuelve los caracteres en una cadena que comienza en la ubicación especificada hasta el número especificado de caracteres.</dd> + <dt>{{jsxref("String.prototype.substring()", "String.prototype.substring(<var>indexStart</var>[, <var>indexEnd</var>])")}}</dt> + <dd>Devuelve una nueva cadena que contiene caracteres de la cadena llamadora de (o entre) el índice (o indeces) especificados.</dd> + <dt>{{jsxref("String.prototype.toLocaleLowerCase()", "String.prototype.toLocaleLowerCase( [<var>locale</var>, ...<var>locales</var>])")}}</dt> + <dd> + <p>Los caracteres dentro de una cadena se convierten a minúsculas respetando la configuración regional actual.</p> + + <p>Para la mayoría de los idiomas, devolverá lo mismo que {{jsxref("String.prototype.toLowerCase()", "toLowerCase()")}}.</p> + </dd> + <dt>{{jsxref("String.prototype.toLocaleUpperCase()", "String.prototype.toLocaleUpperCase( [<var>locale</var>, ...<var>locales</var>])")}}</dt> + <dd> + <p>Los caracteres dentro de una cadena se convierten a mayúsculas respetando la configuración regional actual.</p> + + <p>Para la mayoría de los idiomas, devolverá lo mismo que {{jsxref("String.prototype.toUpperCase()", "toUpperCase()")}}.</p> + </dd> + <dt>{{jsxref("String.prototype.toLowerCase()")}}</dt> + <dd>Devuelve el valor de la cadena llamadora convertido a minúsculas.</dd> + <dt>{{jsxref("String.prototype.toString()")}}</dt> + <dd>Devuelve una cadena que representa el objeto especificado. Redefine el método {{jsxref("Object.prototype.toString()")}}.</dd> + <dt>{{jsxref("String.prototype.toUpperCase()")}}</dt> + <dd>Devuelve el valor de la cadena llamadora convertido a mayúsculas.</dd> + <dt>{{jsxref("String.prototype.trim()")}}</dt> + <dd>Recorta los espacios en blanco desde el principio y el final de la cadena. Parte del estándar ECMAScript 5.</dd> + <dt>{{jsxref("String.prototype.trimStart()")}}</dt> + <dd>Recorta los espacios en blanco desde el principio de la cadena.</dd> + <dt>{{jsxref("String.prototype.trimEnd()")}}</dt> + <dd>Recorta los espacios en blanco del final de la cadena.</dd> + <dt>{{jsxref("String.prototype.valueOf()")}}</dt> + <dd>Devuelve el valor primitivo del objeto especificado. Redefine el método {{jsxref("Object.prototype.valueOf()")}}.</dd> + <dt>{{jsxref("String.prototype.@@iterator()")}}</dt> + <dd>Devuelve un nuevo objeto <code>Iterator</code> que itera sobre los puntos de código de un valor de cadena, devolviendo cada punto de código como un valor de cadena.</dd> +</dl> + +<h2 id="Métodos_de_contenedor_HTML">Métodos de contenedor HTML</h2> + +<div> +<div class="blockIndicator note"> +<p><strong>Desaprobado. Evita estos métodos.</strong></p> + +<p>Son de uso limitado, ya que proporcionan solo un subconjunto de las etiquetas y atributos HTML disponibles.</p> +</div> + +<dl> + <dt>{{jsxref("String.prototype.anchor()")}}</dt> + <dd>{{htmlattrxref("name", "a", "<a name=\"name\">")}} (hipertexto destino)</dd> + <dt>{{jsxref("String.prototype.big()")}}</dt> + <dd>{{HTMLElement("big")}}</dd> + <dt>{{jsxref("String.prototype.blink()")}}</dt> + <dd>{{HTMLElement("blink")}}</dd> + <dt>{{jsxref("String.prototype.bold()")}}</dt> + <dd>{{HTMLElement("b")}}</dd> + <dt>{{jsxref("String.prototype.fixed()")}}</dt> + <dd>{{HTMLElement("tt")}}</dd> + <dt>{{jsxref("String.prototype.fontcolor()")}}</dt> + <dd>{{htmlattrxref("color", "font", "<font color=\"color\">")}}</dd> + <dt>{{jsxref("String.prototype.fontsize()")}}</dt> + <dd>{{htmlattrxref("size", "font", "<font size=\"size\">")}}</dd> + <dt>{{jsxref("String.prototype.italics()")}}</dt> + <dd>{{HTMLElement("i")}}</dd> + <dt>{{jsxref("String.prototype.link()")}}</dt> + <dd>{{htmlattrxref("href", "a", "<a href=\"url\">")}} (enlace a URL)</dd> + <dt>{{jsxref("String.prototype.small()")}}</dt> + <dd>{{HTMLElement("small")}}</dd> + <dt>{{jsxref("String.prototype.strike()")}}</dt> + <dd>{{HTMLElement("strike")}}</dd> + <dt>{{jsxref("String.prototype.sub()")}}</dt> + <dd>{{HTMLElement("sub")}}</dd> + <dt>{{jsxref("String.prototype.sup()")}}</dt> + <dd>{{HTMLElement("sup")}}</dd> +</dl> +</div> + +<h2 id="Ejemplos">Ejemplos</h2> + +<h3 id="Conversión_de_cadenas">Conversión de cadenas</h3> + +<p>Es posible usar <code>String</code> 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:</p> + +<pre class="brush: js notranslate">let outputStrings = [] +for (let i = 0, n = inputValues.length; i < n; ++i) { + outputStrings.push(String(inputValues[i])); +} +</pre> + +<h2 id="Especificaciones">Especificaciones</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Especificación</th> + </tr> + </thead> + <tbody> + <tr> + <td>{{SpecName('ESDraft', '#sec-string-objects', 'String')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidad_del_navegador">Compatibilidad del navegador</h2> + +<div class="hidden">La tabla de compatibilidad de esta página se genera a partir de datos estructurados. Si deseas contribuir con los datos, consulta <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> y envíanos una solicitud de extracción.</div> + +<p>{{Compat("javascript.builtins.String")}}</p> + +<h2 id="Ve_también">Ve también</h2> + +<ul> + <li><a href="/es/docs/Web/JavaScript/Guide/Text_formatting">Formato de texto en la Guía de JavaScript</a></li> + <li>{{jsxref("RegExp")}}</li> + <li>{{domxref("DOMString")}}</li> + <li><a href="/es/Add-ons/Code_snippets/StringView"><code>StringView</code> — una representación similar a C de cadenas basada en arreglos tipados</a></li> + <li><a href="/es/docs/Web/API/DOMString/Binary">Cadenas binarias</a></li> +</ul> diff --git a/files/es/web/javascript/referencia/objetos_globales/string/indexof/index.html b/files/es/web/javascript/referencia/objetos_globales/string/indexof/index.html new file mode 100644 index 0000000000..14f7b01eb8 --- /dev/null +++ b/files/es/web/javascript/referencia/objetos_globales/string/indexof/index.html @@ -0,0 +1,104 @@ +--- +title: String.prototype.indexOf() +slug: Web/JavaScript/Referencia/Objetos_globales/String/indexOf +tags: + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/indexOf +--- +<p>{{JSRef("Objetos_globales", "String")}}</p> + +<h2 id="Resumen" name="Resumen">Resumen</h2> + +<p>El método <code><strong>indexOf()</strong></code>devuelve el índice, dentro del objeto <code>String</code> que realiza la llamada, de la primera ocurrencia del valor especificado, comenzando la búsqueda desde <code>indiceDesde</code>; o -1 si no se encuentra dicho valor.</p> + +<h2 id="Sintaxis" name="Sintaxis">Sintaxis</h2> + +<pre class="syntaxbox"><em>cadena</em>.indexOf(<em>valorBusqueda</em>[,<em> indiceDesde</em>])</pre> + +<h3 id="Par.C3.A1metros" name="Par.C3.A1metros">Parámetros</h3> + +<dl> + <dt><code>valorBusqueda</code></dt> + <dd>Una cadena que representa el valor de búsqueda.</dd> +</dl> + +<dl> + <dt><code>indiceDesde</code></dt> + <dd>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.</dd> +</dl> + +<h2 id="Descripci.C3.B3n" name="Descripci.C3.B3n">Descripción</h2> + +<p>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 <code>nombreCadena</code> es <code>nombreCadena.length - 1</code>.</p> + +<pre class="brush: 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 +</pre> + +<p>El método <code>indexOf</code> es sensible a mayúsculas. Por ejemplo, la siguiente expresión devuelve -1:</p> + +<pre class="brush: js">"Ballena Azul".indexOf("azul") +</pre> + +<h2 id="Ejemplos" name="Ejemplos">Ejemplos</h2> + +<h3 id="Ejemplo:_Usando_indexOf_y_lastIndexOf" name="Ejemplo:_Usando_indexOf_y_lastIndexOf">Ejemplo: Usando <code>indexOf</code> y <code>lastIndexOf</code></h3> + +<p>El siguiente ejemplo utiliza <code>indexOf</code> y <code>lastIndexOf</code> para localizar valores dentro de la cadena "<code>Brave new world</code>".</p> + +<pre class="brush: js">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 +</pre> + +<h3 id="Ejemplo:_indexOf_y_sensibilidad_a_may.C3.BAsculas" name="Ejemplo:_indexOf_y_sensibilidad_a_may.C3.BAsculas">Ejemplo: <code>indexOf</code> y sensibilidad a mayúsculas</h3> + +<p>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 <code>writeln</code> muestra 19. Pero a que el método <code>indexOf</code> es sensible a mayúsculas, no se encuentra la cadena "<code>cheddar</code>" en <code>miCadenaMayusculas</code>, así que el segundo método <code>writeln</code> muestra -1.</p> + +<pre class="brush: js">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")) +</pre> + +<h3 id="Ejemplo:_Usando_indexOf_para_contar_ocurrencias_de_una_letra_en_una_cadena" name="Ejemplo:_Usando_indexOf_para_contar_ocurrencias_de_una_letra_en_una_cadena">Ejemplo: Usando <code>indexOf</code> para contar ocurrencias de una letra en una cadena</h3> + +<p>El siguiente ejemplo establece <code>cuenta</code> como el número de ocurrencias de la letra <code>x</code> dentro de la cadena <code>miCadena</code>:</p> + +<pre class="brush: js">cuenta = 0; +posicion = miCadena.indexOf("x"); +while ( posicion != -1 ) { + cuenta++; + posicion = miCadena.indexOf("x",posicion+1); +} +</pre> + +<h2 id="Vea_Tambi.C3.A9n" name="Vea_Tambi.C3.A9n">Vea También</h2> + +<ul> + <li>{{jsxref("String.prototype.charAt()")}}</li> + <li>{{jsxref("String.prototype.lastIndexOf()")}}</li> + <li>{{jsxref("String.prototype.split()")}}</li> + <li>{{jsxref("Array.prototype.indexOf()")}}</li> +</ul> diff --git a/files/es/web/javascript/referencia/objetos_globales/string/italics/index.html b/files/es/web/javascript/referencia/objetos_globales/string/italics/index.html new file mode 100644 index 0000000000..71897293bb --- /dev/null +++ b/files/es/web/javascript/referencia/objetos_globales/string/italics/index.html @@ -0,0 +1,49 @@ +--- +title: String.prototype.italics() +slug: Web/JavaScript/Referencia/Objetos_globales/String/italics +tags: + - Deprecated + - HTML wrapper methods + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/italics +--- +<p>{{JSRef("Objetos_globales", "String")}}</p> + +<p>{{deprecated_header}}</p> + +<h2 id="Resumen" name="Resumen">Resumen</h2> + +<p>Provoca que una cadena ponga en cursiva, como si estuviese dentro de una etiqueta {{HTMLElement("i")}}.</p> + +<h2 id="Sintaxis" name="Sintaxis">Sintaxis</h2> + +<pre class="syntaxbox"><em>cadena</em>.italics()</pre> + +<h2 id="Descripci.C3.B3n" name="Descripci.C3.B3n">Descripción</h2> + +<p>Usa el método <code>italics</code> para formatear y mostrar una cadena en un documento.</p> + +<h2 id="Ejemplos" name="Ejemplos">Ejemplos</h2> + +<h3 id="Ejemplo:_Usando_m.C3.A9todos_de_string_para_cambiar_el_formateado_de_una_cadena" name="Ejemplo:_Usando_m.C3.A9todos_de_string_para_cambiar_el_formateado_de_una_cadena">Ejemplo: Usando métodos de <code>italics()</code></h3> + +<p>El siguiente ejemplo usa métodos de <code>string</code> para cambiar el formateado de una cadena:</p> + +<pre class="brush: js">var cadenaMundo="¡Hola mundo!"; + +console.log(cadenaMundo.blink()); +console.log(cadenaMundo.bold()); +console.log(cadenaMundo.italics()); +console.log(cadenaMundo.strike()); +</pre> + +<h2 id="Vea_Tambi.C3.A9n" name="Vea_Tambi.C3.A9n">Vea También</h2> + +<ul> + <li>{{jsxref("String.prototype.blink()")}}</li> + <li>{{jsxref("String.prototype.bold()")}}</li> + <li>{{jsxref("String.prototype.strike()")}}</li> +</ul> diff --git a/files/es/web/javascript/referencia/objetos_globales/string/lastindexof/index.html b/files/es/web/javascript/referencia/objetos_globales/string/lastindexof/index.html new file mode 100644 index 0000000000..ffde251071 --- /dev/null +++ b/files/es/web/javascript/referencia/objetos_globales/string/lastindexof/index.html @@ -0,0 +1,79 @@ +--- +title: String.prototype.lastIndexOf() +slug: Web/JavaScript/Referencia/Objetos_globales/String/lastIndexOf +tags: + - Cadena + - JavaScript + - Prototipo + - Referencia + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/String/lastIndexOf +--- +<p>{{JSRef("Objetos_globales", "String")}}</p> + +<h2 id="Resumen" name="Resumen">Resumen</h2> + +<p>El método <strong><code>lastIndexOf() </code></strong><code>devuelve </code>la posicion (indice) en la que se encuentra el <strong>valorBusqueda</strong>, dentro del objeto <code>String</code> 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 <strong><code>indiceDesde</code></strong>.</p> + +<h2 id="Sintaxis" name="Sintaxis">Sintaxis</h2> + +<pre class="syntaxbox"><em>cadena</em>.lastIndexOf(<em>valorBusqueda</em>[,<em> indiceDesde</em>]<em>)</em></pre> + +<h3 id="Par.C3.A1metros" name="Par.C3.A1metros">Parámetros</h3> + +<dl> + <dt><code>valorBusqueda</code></dt> + <dd>Una cadena que representa el valor que se desea buscar.</dd> +</dl> + +<dl> + <dt><code>indiceDesde</code></dt> + <dd>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.</dd> +</dl> + +<h2 id="Descripci.C3.B3n" name="Descripci.C3.B3n">Descripción</h2> + +<p>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 <code>nombreCadena.length - 1</code>.</p> + +<pre class="brush: js">"canal".lastIndexOf("a") // returns 3 +"canal".lastIndexOf("a",2) // returns 1 +"canal".lastIndexOf("a",0) // returns -1 +"canal".lastIndexOf("x") // returns -1 +</pre> + +<p>El método <code>lastIndexOf</code> es sensible a mayúsculas. Por ejemplo, la siguiente expresión devuelve -1:</p> + +<pre class="brush: js">"Ballena Azul, Ballena Asesina".lastIndexOf("azul") +</pre> + +<h2 id="Ejemplos" name="Ejemplos">Ejemplos</h2> + +<h3 id="Ejemplo:_Usando_indexOf_y_lastIndexOf" name="Ejemplo:_Usando_indexOf_y_lastIndexOf">Ejemplo: Usando <code>indexOf</code> y <code>lastIndexOf</code></h3> + +<p>The following example uses <code>indexOf</code> and <code>lastIndexOf</code> to locate values in the string "<code>Brave new world</code>".</p> + +<pre class="brush: js">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")) +</pre> + +<h2 id="Vea_Tambi.C3.A9n" name="Vea_Tambi.C3.A9n">Vea También</h2> + +<ul> + <li>{{jsxref("String.prototype.charAt()")}}</li> + <li>{{jsxref("String.prototype.indexOf()")}}</li> + <li>{{jsxref("String.prototype.split()")}}</li> + <li>{{jsxref("Array.prototype.indexOf()")}}</li> + <li>{{jsxref("Array.prototype.lastIndexOf()")}}</li> +</ul> diff --git a/files/es/web/javascript/referencia/objetos_globales/string/length/index.html b/files/es/web/javascript/referencia/objetos_globales/string/length/index.html new file mode 100644 index 0000000000..9401b8898a --- /dev/null +++ b/files/es/web/javascript/referencia/objetos_globales/string/length/index.html @@ -0,0 +1,94 @@ +--- +title: String.length +slug: Web/JavaScript/Referencia/Objetos_globales/String/length +tags: + - JavaScript + - Propiedad + - Prototipo + - Referencia + - String + - length +translation_of: Web/JavaScript/Reference/Global_Objects/String/length +--- +<div>{{JSRef}}</div> + +<p>La propiedad<strong> </strong><code><strong>length</strong></code> de un objeto {{jsxref("String")}} representa la longitud de una cadena, en unidades de código UTF-16.</p> + +<h2 id="Sintaxis">Sintaxis</h2> + +<pre class="syntaxbox notranslate"><var>str</var>.length</pre> + +<h2 id="Descripción">Descripción</h2> + +<p>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 <code>length</code> no corresponda al número de caracteres de la cadena.</p> + +<p>ECMASCript 2016 (ed. 7) estableció una longitud máxima de <code>2^53 - 1</code> elementos. Anteriormente, ninguna longitud máxima era especificada. </p> + +<p>Para una cadena vacía, <code>length</code> es 0.</p> + +<p>La propiedad static <code>String.length</code> devuelve 1.</p> + +<h2 id="Ejemplos" name="Ejemplos">Ejemplos</h2> + +<h3 id="Uso_Básico">Uso Básico</h3> + +<pre class="brush: js notranslate">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" */</pre> + +<h3 id="Asignando_a_length">Asignando a length</h3> + +<pre class="brush: js notranslate">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" */ +</pre> + +<h2 id="Especificaciones">Especificaciones</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificación</th> + <th scope="col">Estatus</th> + <th scope="col">Comentario</th> + </tr> + <tr> + <td>ECMAScript 1st Edition.</td> + <td>Estándar</td> + <td>Primera definicíon. Implementado en JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.5.1', 'String.prototype.length')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-properties-of-string-instances-length', 'String.prototype.length')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-properties-of-string-instances-length', 'String.prototype.length')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidad_con_navegadores">Compatibilidad con navegadores</h2> + +<p>{{Compat("javascript.builtins.String.length")}}</p> + +<h2 id="See_also" name="See_also">Ver también</h2> + +<ul> + <li><a class="external" href="http://developer.teradata.com/blog/jasonstrimpel/2011/11/javascript-string-length-and-internationalizing-web-applications">JavaScript String.length and Internationalizing Web Applications</a></li> +</ul> diff --git a/files/es/web/javascript/referencia/objetos_globales/string/link/index.html b/files/es/web/javascript/referencia/objetos_globales/string/link/index.html new file mode 100644 index 0000000000..021c659f34 --- /dev/null +++ b/files/es/web/javascript/referencia/objetos_globales/string/link/index.html @@ -0,0 +1,56 @@ +--- +title: String.prototype.link() +slug: Web/JavaScript/Referencia/Objetos_globales/String/link +tags: + - HTML wrapper methods + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/link +--- +<p>{{JSRef("Objetos_globales", "String")}}</p> + +<h2 id="Resumen" name="Resumen">Resumen</h2> + +<p>Crea un enlace de hipertexto HTML, {{HTMLElement("a")}}, que solicita otra URL.</p> + +<h2 id="Sintaxis" name="Sintaxis">Sintaxis</h2> + +<pre class="syntaxbox"><em>cadena</em>.link(<em>atributoHref</em>)</pre> + +<h3 id="Par.C3.A1metros" name="Par.C3.A1metros">Parámetros</h3> + +<dl> + <dt><code>atributoHref</code></dt> + <dd>Cualquier cadena que especifique el atributo {{htmlattrxref("href", "a")}} de la etiqueta {{HTMLElement("a")}}; debería ser una URL válida (relativa o absoluta).</dd> +</dl> + +<h2 id="Descripci.C3.B3n" name="Descripci.C3.B3n">Descripción</h2> + +<p>Usa el método <code>link</code> para crear un atajo HTML para un enlace de hipertexto. La cadena devuelta puede ser añadida al documento vía {{domxref("element.innerHTML")}}.</p> + +<p>Los enlaces creados con el método <code>link</code> serán elementos del array <code>links</code> del objeto <code>document</code>. Vea {{domxref("document.links")}}.</p> + +<h2 id="Ejemplos" name="Ejemplos">Ejemplos</h2> + +<h3 id="Ejemplo:_Usando_link" name="Ejemplo:_Usando_link">Ejemplo: Usando <code>link</code></h3> + +<p>El siguiente ejemplo muestra la palabra "Netscape" como un enlace de hipertexto que devuelve al usuario a la página inicial de Netscape:</p> + +<pre>var textoActivo="MDN" +var URL="<code class="language-js"><span class="brush: js">https://developer.mozilla.org/</span></code>" + +console.log("Haga click para volver a " + textoActivo.link(URL)) +</pre> + +<p>Este ejemplo produce el mismo resultado que el siguiente código HTML:</p> + +<pre class="brush: html">Haga click para volver a <a href="http://<code class="language-js"><span class="brush: js">developer.mozilla.org/</span></code>">MDN</a> +</pre> + +<h2 id="Vea_También">Vea También</h2> + +<ul> + <li>{{jsxref("String.prototype.anchor()")}}</li> +</ul> diff --git a/files/es/web/javascript/referencia/objetos_globales/string/localecompare/index.html b/files/es/web/javascript/referencia/objetos_globales/string/localecompare/index.html new file mode 100644 index 0000000000..2bda296c61 --- /dev/null +++ b/files/es/web/javascript/referencia/objetos_globales/string/localecompare/index.html @@ -0,0 +1,159 @@ +--- +title: String.prototype.localeCompare() +slug: Web/JavaScript/Referencia/Objetos_globales/String/localeCompare +translation_of: Web/JavaScript/Reference/Global_Objects/String/localeCompare +--- +<div>{{JSRef}}</div> + +<p>El método <strong><code>localeCompare()</code></strong> devuelve un número que indica si la cadena de caracteres actual es anterior, posterior o igual a la cadena pasada como parámetro, en orden lexicográfico.</p> + +<p>Los nuevos argumentos <code>locales</code> y <code>options</code> permiten a las aplicaciones especificar el idioma y el orden de clasificación que debe usarse y personalizar el comportamiento de la función. En las implementaciones más antiguas, que ignoran los argumentos <code>locales</code> y <code>options</code>, la configuración <code>locale</code> y el orden de clasificación utilizados dependen enteramente de la implementación</p> + +<h2 id="Sintaxis">Sintaxis</h2> + +<pre class="syntaxbox"><code><var>referenceStr</var>.localeCompare(<var>compareString</var>[, <var>locales</var>[, <var>options</var>]])</code></pre> + +<h3 id="Parámetros">Parámetros</h3> + +<p>Comprueba la sección <a href="#Compatibilidad_con_el_navegador">Compatibilidad con el navegador</a> para ver que navegadores soportan los argumentos <code>locales</code> y <code>options</code>, and the <a href="#Checking_for_support_for_locales_and_options_arguments">Checking for support for <code>locales</code> and <code>options</code> arguments</a> for feature detection.</p> + +<dl> + <dt><code>compareString</code></dt> + <dd>La cadena con la que queremos comparar la cadena actual de caracteres.</dd> +</dl> + +<div>{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/Collator', 'Parameters')}}</div> + +<h3 id="Valor_devuelto">Valor devuelto</h3> + +<p>Un número <strong>negativo</strong> si la cadena de referencia ocurre antes de la cadena de comparación; <strong>positivo</strong> si la cadena de referencia ocurre después de la cadena de comparación; <strong>0</strong> si son equivalentes.</p> + +<h2 id="Descripción">Descripción</h2> + +<p>Returns an integer indicating whether the <strong>referenceStr</strong> comes before, after or is equivalent to the <strong>compareStr</strong>.</p> + +<ul> + <li>Negative when the <strong>referenceStr</strong> occurs before <strong>compareStr</strong></li> + <li>Positive when the <strong>referenceStr</strong> occurs after <strong>compareStr</strong></li> + <li>Returns 0 if they are equivalent</li> +</ul> + +<p><strong>NO CONFIAR en que los valores devueltos sean siempre -1 o 1. </strong>Los resultados de enteros negativos y positivos varían entre los navegadores (así como entre diferentes versiones de un mismo navegador) porque la especificación W3C solo exige valores negativos y positivos. Algunos navegadores pueden devolver -2 o 2 o incluso algún otro valor negativo o positivo.</p> + +<h2 id="Ejemplos">Ejemplos</h2> + +<h3 id="Uso_de_localeCompare()">Uso de <code>localeCompare()</code></h3> + +<pre class="brush: js">// La letra "a" es anterior a la "c" produciendo un valor negativo +'a'.localeCompare('c'); // -2 o -1 (u otro valor negativo) + +// Alfabeticamente la palabra "check" viene después de "against" produciendo un valor ppositivo +'check'.localeCompare('against'); // 2 o 1 (u otro valor positivo) + +// "a" y "a" son equivalentes produciendo un valor neutro de 0 +'a'.localeCompare('a'); // 0 +</pre> + +<h3 id="Ordenar_un_array">Ordenar un array</h3> + +<p><code>localeCompare</code> enables a case-insensitive sort of an array.</p> + +<pre class="brush: js">var items = ['réservé', 'premier', 'cliché', 'communiqué', 'café', 'adieu']; +items.sort((a, b) => a.localeCompare(b)); // ['adieu', 'café', 'cliché', 'communiqué', 'premier', 'réservé'] +</pre> + +<h3 id="Verificar_si_el_navegador_soporta_argumentos_extendidos">Verificar si el navegador soporta argumentos extendidos</h3> + +<p>The <code>locales</code> and <code>options</code> arguments are not supported in all browsers yet. To check whether an implementation supports them, use the "i" argument (a requirement that illegal language tags are rejected) and look for a {{jsxref("RangeError")}} exception:</p> + +<pre class="brush: js">function localeCompareSupportsLocales() { + try { + 'foo'.localeCompare('bar', 'i'); + } catch (e) { + return e.name === 'RangeError'; + } + return false; +} +</pre> + +<h3 id="Uso_de_locales">Uso de <code>locales</code></h3> + +<p>The results provided by <code>localeCompare()</code> vary between languages. In order to get the sort order of the language used in the user interface of your application, make sure to specify that language (and possibly some fallback languages) using the <code>locales</code> argument:</p> + +<pre class="brush: js">console.log('ä'.localeCompare('z', 'de')); // a negative value: in German, ä sorts before z +console.log('ä'.localeCompare('z', 'sv')); // a positive value: in Swedish, ä sorts after z +</pre> + +<h3 id="Uso_de_options">Uso de <code>options</code></h3> + +<p>The results provided by <code>localeCompare()</code> can be customized using the <code>options</code> argument:</p> + +<pre class="brush: js">// in German, ä has a as the base letter +console.log('ä'.localeCompare('a', 'de', { sensitivity: 'base' })); // 0 + +// in Swedish, ä and a are separate base letters +console.log('ä'.localeCompare('a', 'sv', { sensitivity: 'base' })); // a positive value +</pre> + +<h2 id="Performance">Performance</h2> + +<p>When comparing large numbers of strings, such as in sorting large arrays, it is better to create an {{jsxref("Global_Objects/Collator", "Intl.Collator")}} object and use the function provided by its {{jsxref("Collator.prototype.compare", "compare")}} property.</p> + +<h2 id="Especificaciones">Especificaciones</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificación</th> + <th scope="col">Estado</th> + <th scope="col">Comentario</th> + </tr> + <tr> + <td>{{SpecName('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Definición inicial. Implementado en JavaScript 1.2.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.9', 'String.prototype.localeCompare')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.localecompare', 'String.prototype.localeCompare')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.localecompare', 'String.prototype.localeCompare')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES Int 1.0', '#sec-13.1.1', 'String.prototype.localeCompare')}}</td> + <td>{{Spec2('ES Int 1.0')}}</td> + <td>Definiciones de los parámetros <code>locale</code> y <code>option</code>.</td> + </tr> + <tr> + <td>{{SpecName('ES Int 2.0', '#sec-13.1.1', 'String.prototype.localeCompare')}}</td> + <td>{{Spec2('ES Int 2.0')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES Int Draft', '#sec-String.prototype.localeCompare', 'String.prototype.localeCompare')}}</td> + <td>{{Spec2('ES Int Draft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidad_con_el_navegador">Compatibilidad con el navegador</h2> + +<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> + +<p>{{Compat("javascript.builtins.String.localeCompare")}}</p> + +<h2 id="Ver_también">Ver también</h2> + +<ul> + <li>{{jsxref("Global_Objects/Collator", "Intl.Collator")}}</li> +</ul> diff --git a/files/es/web/javascript/referencia/objetos_globales/string/match/index.html b/files/es/web/javascript/referencia/objetos_globales/string/match/index.html new file mode 100644 index 0000000000..6403dbaf06 --- /dev/null +++ b/files/es/web/javascript/referencia/objetos_globales/string/match/index.html @@ -0,0 +1,78 @@ +--- +title: String.prototype.match() +slug: Web/JavaScript/Referencia/Objetos_globales/String/match +tags: + - JavaScript + - Method + - Prototype + - RegExp + - Regular Expressions + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/match +--- +<p>{{JSRef("Objetos_globales", "String")}}</p> + +<h2 id="Resumen" name="Resumen">Resumen</h2> + +<p>El método <strong><code>match()</code></strong> se usa para obtener todas las ocurrencias de una <em>expresión regular</em> dentro de una <em>cadena</em>.</p> + +<h2 id="Sintaxis" name="Sintaxis">Sintaxis</h2> + +<pre class="syntaxbox"><em>cadena</em>.match(<em>regexp</em>)</pre> + +<h3 id="Par.C3.A1metros" name="Par.C3.A1metros">Parámetros</h3> + +<dl> + <dt><code>regexp</code></dt> + <dd>Un objeto <a href="/es/docs/Web/JavaScript/Referencia/Objetos_globales/RegExp"> expresión regular</a>. Si se pasa un objeto <code>obj</code> que no es expresión regular, se convierte implícitamente a RegExp usando <code>new RegExp(obj)</code>.</dd> +</dl> + +<h2 id="Descripci.C3.B3n" name="Descripci.C3.B3n">Descripción</h2> + +<p>Si la expresión regular no incluye el flag <code>g</code>, devuelve el mismo resultado que {{jsxref("Regexp.exec()")}}.</p> + +<p>Si la expresión regular incluye el flag <code>g</code>, el método devuelve un {{jsxref("Array")}} que contiene todos los emparejamientos.</p> + +<h3 id="Notas" name="Notas">Notas</h3> + +<ul> + <li>Si necesita conocer si una cadena se empareja con una expresión regular <code>regexp</code>, use {{jsxref("Regexp.test()")}}.</li> + <li>Si sólo quiere el primer emparejamiento hallado, podría querer usar {{jsxref("Regexp.exec()")}} a cambio.</li> +</ul> + +<h2 id="Ejemplos" name="Ejemplos">Ejemplos</h2> + +<h3 id="Ejemplo:_Usando_match" name="Ejemplo:_Usando_match">Ejemplo: Usando <code>match</code></h3> + +<p>En el siguiente ejemplo, se usa <code>match</code> para hallar "<code>Capítulo</code>" 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 <code>i</code> por lo que las mayúsculas serán ignoradas.</p> + +<pre class="brush: 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); +</pre> + +<p>Esto devuelve un array que contiene Capítulo 3.4.5.1,Capítulo 3.4.5.1,.1</p> + +<p>"<code>Capítulo 3.4.5.1</code>" es el primer emparejamiento y el primer valor referenciado por <code>(Chapter \d+(\.\d)*)</code>.</p> + +<p>"<code>.1</code>" es el segundo valor referenciado por <code>(\.\d)</code>.</p> + +<h3 id="Ejemplo:_Usando_los_flags_global_e_ignorar_may.C3.BAsculas_con_match" name="Ejemplo:_Usando_los_flags_global_e_ignorar_may.C3.BAsculas_con_match">Ejemplo: Usando los flags global e ignorar mayúsculas con <code>match</code></h3> + +<p>El siguiente ejemplo demuestra el uso de los flags global e ignorar mayúsculas con <code>match</code>. Todas las letras de A hasta E y de a hasta e son devueltas, en su propio elemento dentro del array.</p> + +<pre class="brush: js">var cadena = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"; +var expresion = /[A-E]/gi; +var array_emparejamientos = cadena.match(expresion); +console.log(array_emparejamientos); +</pre> + +<p><code>array_emparejamientos</code> será <code>{{ mediawiki.external('\'A\', \'B\', \'C\', \'D\', \'E\', \'a\', \'b\', \'c\', \'d\', \'e\'') }}</code></p> + +<h2 id="Vea_También">Vea También</h2> + +<ul> + <li>{{jsxref("RegExp.prototype.exec()")}}</li> + <li>{{jsxref("RegExp.prototype.test()")}}</li> +</ul> diff --git a/files/es/web/javascript/referencia/objetos_globales/string/matchall/index.html b/files/es/web/javascript/referencia/objetos_globales/string/matchall/index.html new file mode 100644 index 0000000000..a536720dbd --- /dev/null +++ b/files/es/web/javascript/referencia/objetos_globales/string/matchall/index.html @@ -0,0 +1,134 @@ +--- +title: String.prototype.matchAll() +slug: Web/JavaScript/Referencia/Objetos_globales/String/matchAll +tags: + - Cadena + - Expresiones Regulares + - JavaScript + - Prototipo + - Referencia + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/String/matchAll +--- +<div>{{JSRef}}</div> + +<p>El método <strong><code>matchAll()</code></strong> retorna un iterador de todos los resultados de ocurrencia en una <em>cadena de texto</em> contra una expresión regular, incluyendo grupos de captura.</p> + +<div>{{EmbedInteractiveExample("pages/js/string-matchall.html")}}</div> + + + +<h2 id="Sintaxis">Sintaxis</h2> + +<pre class="syntaxbox"><var>cadena</var>.matchAll(<var>expresionRegular</var>)</pre> + +<h3 id="Parámetros">Parámetros</h3> + +<dl> + <dt><var>expresionRegular</var></dt> + <dd>Un objeto expresión regular. Si se pasa un objeto no-RegExp <code>obj</code>, este es implícitamente convertido a {{jsxref("RegExp")}} vía <code>new RegExp(obj)</code>.</dd> +</dl> + +<h3 id="Valor_devuelto">Valor devuelto</h3> + +<p>Un <a href="/en-US/docs/Web/JavaScript/Guide/Iterators_and_Generators">iterador</a> (el cual no es reiniciable).</p> + +<h2 id="Ejemplo">Ejemplo</h2> + +<h3 id="Regexp.exec()_y_matchAll()">Regexp.exec() y matchAll()</h3> + +<p>Antes de la adición de <code>matchAll</code> a JavaScript, fue posible hacer llamados a <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/exec">regexp.exec</a> (y usar expresiones regulares con la bandera <code>/g</code>) en un ciclo para obtener las ocurrencias:</p> + +<pre class="brush: 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." +}</pre> + +<p>Con <code>matchAll</code> disponible, puedes evitar el ciclo <code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/while">while</a></code> y <code>exec</code> con <code>/g</code>. Por el contrario, usando <code>matchAll</code>, obtienes un iterador con el cual puedes usar con constructores más convenientes <code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/for...of">for...of</a></code>, <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Spread_syntax">array spread</a>, o {{jsxref("Array.from()")}}:</p> + +<pre class="brush: 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" ]</pre> + +<p><code>matchAll</code> solo devuelve la primer ocurrencia si la bandera <code>/g</code> está ausente.</p> + +<pre class="brush: js">const regexp = RegExp('[a-c]',''); +const cadena = 'abc'; +Array.from(cadena.matchAll(regexp), m => m[0]); +// Array [ "a" ] +</pre> + +<p><code>matchAll</code> internamente hace un clon de la expresión regular, entonces a diferencia de <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/exec">regexp.exec</a>, <code>lastIndex</code> no cambia a medida que la cadena es escaneada.</p> + +<pre class="brush: 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" ]</pre> + +<h3 id="Mejor_acceso_para_capturar_grupos">Mejor acceso para capturar grupos</h3> + +<p>Otra buena razón para <code>matchAll</code> es el mejorado acceso a los grupos de captura. Los grupos de captura son ignorados cuando se usa <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/match">match()</a></code> con la bandera global <code>/g</code>:</p> + +<pre class="brush: js">var regexp = /t(e)(st(\d?))/g; +var cadena = 'test1test2'; + +cadena.match(regexp); +// Array ['test1', 'test2']</pre> + +<p>Con <code>matchAll</code> puedes acceder a ellos:</p> + +<pre class="brush: 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] +</pre> + +<h2 id="Especificaciones">Especificaciones</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificación</th> + <th scope="col">Estado</th> + <th scope="col">Comentario</th> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.matchall', 'String.prototype.matchAll')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidad_de_navegadores">Compatibilidad de navegadores</h2> + +<p class="hidden">The compatibility table on this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> + +<p>{{Compat("javascript.builtins.String.matchAll")}}</p> + +<h2 id="Ver_también">Ver también</h2> + +<ul> + <li>{{jsxref("RegExp")}}</li> + <li>{{jsxref("RegExp.prototype.exec()")}}</li> + <li>{{jsxref("RegExp.prototype.test()")}}</li> +</ul> diff --git a/files/es/web/javascript/referencia/objetos_globales/string/normalize/index.html b/files/es/web/javascript/referencia/objetos_globales/string/normalize/index.html new file mode 100644 index 0000000000..2794644f1c --- /dev/null +++ b/files/es/web/javascript/referencia/objetos_globales/string/normalize/index.html @@ -0,0 +1,126 @@ +--- +title: String.prototype.normalize() +slug: Web/JavaScript/Referencia/Objetos_globales/String/normalize +tags: + - Cadena + - ECMAScript 2015 + - JavaScript + - Prototipo + - Referencia + - String + - Unicode + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/String/normalize +--- +<div>{{JSRef}}</div> + +<p>El método <strong><code>normalize()</code></strong> retorna la Forma de Normalización Unicode de la cadena dada (si el valor no es una cadena, primero será convertido a ese tipo).</p> + +<h2 id="Sintaxis">Sintaxis</h2> + +<pre class="syntaxbox"><code><var>str</var>.normalize([<var>form</var>])</code></pre> + +<h3 id="Parámetros">Parámetros</h3> + +<dl> + <dt><code>form</code></dt> + <dd>Uno de<code>"NFC"</code>, <code>"NFD"</code>, <code>"NFKC"</code>, o <code>"NFKD"</code>, especificando la Forma de Normalización Unicode. Si es omitida o {{jsxref("undefined")}}, se utiliza <code>"NFC"</code>. + <ul> + <li><code>NFC</code> — Forma de Normalización de Composición Canónica.</li> + <li><code>NFD</code> — Forma de Normalización de Descomposición Canónica.</li> + <li><code>NFKC</code> — Forma de Normalización de Composición de Compatibilidad.</li> + <li><code>NFKD</code> — Forma de Normalización de Descomposición de Compatibilidad.</li> + </ul> + </dd> +</dl> + +<h3 id="Valor_de_retorno">Valor de retorno</h3> + +<p>Una cadena que contiene la Forma de Normalización Unicode de la cadena dada.</p> + +<h3 id="Errores_lanzados">Errores lanzados</h3> + +<dl> + <dt>{{jsxref("RangeError")}}</dt> + <dd>Un error {{jsxref("RangeError")}} es lanzado si <code>form</code> no es uno de los valores especificados arriba.</dd> +</dl> + +<h2 id="Descripción">Descripción</h2> + +<p>El método <code>normalize()</code> retorna la Forma de Normalización Unicode de una cadena. No afecta el valor de la cadena en sí misma.</p> + +<h2 id="Ejemplos">Ejemplos</h2> + +<h3 id="Uso_de_normalize()">Uso de <code>normalize()</code></h3> + +<pre class="brush: 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' +</pre> + +<h2 id="Especificaciones">Especificaciones</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificación</th> + <th scope="col">Estado</th> + <th scope="col">Comentario</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-string.prototype.normalize', 'String.prototype.normalize')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Definición inicial.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.normalize', 'String.prototype.normalize')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidad_de_Navegadores">Compatibilidad de Navegadores</h2> + +<p class="hidden">La tabla de compatibilidad en esta página es generada desde datos estructurados. Si quiere contribuir a estos datos, por favor hágalo utilizando éste repositorio <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> y envíenos un pull request.</p> + +<p>{{Compat("javascript.builtins.String.normalize")}}</p> + +<h2 id="Vea_también">Vea también</h2> + +<ul> + <li><a href="http://www.unicode.org/reports/tr15/">Anexo del Estándar Unicode #15, Formas de Normalización Unicode</a></li> + <li><a href="http://en.wikipedia.org/wiki/Unicode_equivalence">Equivalencia Unicode</a></li> +</ul> diff --git a/files/es/web/javascript/referencia/objetos_globales/string/padstart/index.html b/files/es/web/javascript/referencia/objetos_globales/string/padstart/index.html new file mode 100644 index 0000000000..57abbd8f5c --- /dev/null +++ b/files/es/web/javascript/referencia/objetos_globales/string/padstart/index.html @@ -0,0 +1,100 @@ +--- +title: String.prototype.padStart() +slug: Web/JavaScript/Referencia/Objetos_globales/String/padStart +tags: + - Cadena + - Experimental + - JavaScript + - Método(2) + - Referencia +translation_of: Web/JavaScript/Reference/Global_Objects/String/padStart +--- +<div>{{JSRef}}{{SeeCompatTable}}</div> + +<p>El método <code><strong>padStart()</strong></code> 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.</p> + +<h2 id="Sintaxis">Sintaxis</h2> + +<pre class="syntaxbox"><var>str</var>.padStart(<var>targetLength</var> [, <var>padString</var>])</pre> + +<h3 id="Parámetros">Parámetros</h3> + +<dl> + <dt><code>targetLength</code></dt> + <dd>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.</dd> + <dt><code>padString</code> {{optional_inline}}</dt> + <dd>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).</dd> +</dl> + +<h3 id="Valor_devuelto">Valor devuelto</h3> + +<p>Un {{jsxref("String")}} de la longitud específicada con la cadena de relleno aplicada desde el inicio.</p> + +<h2 id="Ejemplos">Ejemplos</h2> + +<pre class="brush: js">'abc'.padStart(10); // " abc" +'abc'.padStart(10, "foo"); // "foofoofabc" +'abc'.padStart(6,"123465"); // "123abc" +</pre> + +<h2 id="Especificaciones">Especificaciones</h2> + +<p>Este método aún no ha alcanzado el estándar ECMAScript. Actualmente es una <a href="https://github.com/tc39/proposal-string-pad-start-end">propuesta para ECMAScript</a>.</p> + +<h2 id="Compatibilidad_con_navegadores">Compatibilidad con navegadores</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Soporte básico</td> + <td>{{CompatChrome("52")}} </td> + <td>{{CompatGeckoDesktop(48)}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Soporte básico</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatGeckoMobile(48)}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Ver_también">Ver también</h2> + +<ul> + <li>{{jsxref("String.padEnd()")}}</li> +</ul> diff --git a/files/es/web/javascript/referencia/objetos_globales/string/prototype/index.html b/files/es/web/javascript/referencia/objetos_globales/string/prototype/index.html new file mode 100644 index 0000000000..1ea663138c --- /dev/null +++ b/files/es/web/javascript/referencia/objetos_globales/string/prototype/index.html @@ -0,0 +1,117 @@ +--- +title: String.prototype +slug: Web/JavaScript/Referencia/Objetos_globales/String/prototype +tags: + - JavaScript + - Property + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String +--- +<p>{{JSRef("Objetos_globales", "String")}}</p> + +<h2 id="Resumen" name="Resumen">Resumen</h2> + +<p>The <strong><code>String.prototype</code></strong> propiedad representa el prototipo de esta clase. Puede usar el prototipo para añadir propiedades o métodos a todas las instancias de una clase.</p> + +<div>{{js_property_attributes(0,0,0)}}</div> + +<h2 id="Propiedades">Propiedades</h2> + +<dl> + <dt><code>String.prototype.constructor</code></dt> + <dd>Especifica la función que crea un prototipo de objeto.</dd> + <dt>{{jsxref("String.prototype.length")}}</dt> + <dd>Refleja la longitud de la cadena.</dd> +</dl> + +<div>{{ jsOverrides("Object", "properties", "constructor", "length") }}</div> + +<h2 id="Métodos">Métodos</h2> + +<h3 id="M.C3.A9todos_no_relacionados_con_HTML" name="M.C3.A9todos_no_relacionados_con_HTML">Métodos no relacionados con HTML</h3> + +<dl> + <dt>{{jsxref("String.prototype.charAt()")}}</dt> + <dd>Devuelve el carácter en el índice especificado.</dd> + <dt>{{jsxref("String.prototype.charCodeAt()")}}</dt> + <dd>Devuelve el número que indica el valor Unicode del carácter en el índice especificado.</dd> + <dt>{{jsxref("String.prototype.concat()")}}</dt> + <dd>Combina el texto de dos cadenas y devuelve una nueva cadena.</dd> + <dt>{{jsxref("String.prototype.indexOf()")}}</dt> + <dd>Devuelve el índice dentro del objeto <code>String</code> que realiza la llamada de la primera ocurrencia del valor especificado, o -1 si no lo encuentra.</dd> + <dt>{{jsxref("String.prototype.lastIndexOf()")}}</dt> + <dd>Devuelve el índice dentro del objeto <code>String</code> que realiza la llamada de la última ocurrencia del valor especificado, o -1 si no lo encuentra.</dd> + <dt>{{jsxref("String.prototype.match()")}}</dt> + <dd>Se usa para emparejar una expresión regular con una cadena.</dd> + <dt>{{jsxref("String.prototype.replace()")}}</dt> + <dd>Se usa para emparejar una expresión regular con una cadena, y reemplezar la subcadena emparejada con una nueva subcadena.</dd> + <dt>{{jsxref("String.prototype.search()")}}</dt> + <dd>Realiza una búsqueda de una expresión regular en una cadena especificada.</dd> + <dt>{{jsxref("String.prototype.slice()")}}</dt> + <dd>Extrae una sección de una cadena y devuelve una nueva cadena.</dd> + <dt>{{jsxref("String.prototype.split()")}}</dt> + <dd>Divide un objeto <code>String</code> en un arreglo de cadenas, separando la cadena en subcadenas.</dd> + <dt>{{jsxref("String.prototype.substr()")}}</dt> + <dd>Devuelve los caracteres de una cadena comenzando en la localización especificada y hasta el número de caracteres especificado.</dd> + <dt>{{jsxref("String.prototype.substring()")}}</dt> + <dd>Devuelve los caracteres de una cadena entre dos índices dentro de la cadena.</dd> + <dt>{{jsxref("String.prototype.toLowerCase()")}}</dt> + <dd>Devuelve el valor de la cadena que realiza la llamada en minúsculas.</dd> + <dt>{{jsxref("String.prototype.toSource()")}}</dt> + <dd>Devuelve el objeto literal que representa el objeto especificado; puede usar este valor para crear un nuevo objeto. Sobreescribe el método {{jsxref("Object.prototype.toSource()")}}.</dd> + <dt>{{jsxref("String.prototype.toString()")}}</dt> + <dd>Devuelve una cadena que representa el objeto especificado. Sobreescribe el método {{jsxref("Object.prototype.toString()")}}.</dd> + <dt>{{jsxref("String.prototype.toUpperCase()")}}</dt> + <dd>Devuelve el valor de la cadena que realiza la llamada en mayúsculas.</dd> + <dt>{{jsxref("String.prototype.valueOf()")}}</dt> + <dd>Devuelve el valor primitivo del objeto especificado. Sobreescribe el método {{jsxref("Object.prototype.valueOf()")}}.</dd> +</dl> + +<h3 id="HTML_wrapper_methods" name="HTML_wrapper_methods">Métodos de encapsulado HTML</h3> + +<p>Cada uno de los métodos siguientes devuelve una copia de la cadena encapsulada dentro de una etiqueta HTML. Por ejemplo, "test".bold() devuelve "<b>test</b>".</p> + +<dl> + <dt>{{jsxref("String.prototype.anchor()")}}</dt> + <dd><a class="external" href="http://www.w3.org/TR/html401/struct/links.html#adef-name-A"><code><a name="<em>name</em>"></code></a> (Ancha Hipertexto)</dd> + <dt>{{jsxref("String.prototype.big()")}}</dt> + <dd>{{HTMLElement("big")}}</dd> + <dt>{{jsxref("String.prototype.blink()")}}</dt> + <dd>{{HTMLElement("blink")}}</dd> + <dt>{{jsxref("String.prototype.bold()")}}</dt> + <dd>{{HTMLElement("b")}}</dd> + <dt>{{jsxref("String.prototype.fixed()")}}</dt> + <dd>{{HTMLElement("tt")}}</dd> + <dt>{{jsxref("String.prototype.fontcolor()")}}</dt> + <dd><code><font color="<em>color</em>"></code></dd> + <dt>{{jsxref("String.prototype.fontsize()")}}</dt> + <dd><code><font size="<em>size</em>"></code></dd> + <dt>{{jsxref("String.prototype.italics()")}}</dt> + <dd>{{HTMLElement("i")}}</dd> + <dt>{{jsxref("String.prototype.link()")}}</dt> + <dd><a class="external" href="http://www.w3.org/TR/html401/struct/links.html#adef-href"><code><a href="<em>url</em>"></code></a> (Enlace a URL)</dd> + <dt>{{jsxref("String.prototype.small()")}}</dt> + <dd>{{HTMLElement("small")}}</dd> + <dt>{{jsxref("String.prototype.strike()")}}</dt> + <dd>{{HTMLElement("strike")}}</dd> + <dt>{{jsxref("String.prototype.sub()")}}</dt> + <dd>{{HTMLElement("sub")}}</dd> + <dt>{{jsxref("String.prototype.sup()")}}</dt> + <dd>{{HTMLElement("sup")}}</dd> +</dl> + +<p>Estos métodos son de uso limitado, ya que sólo están disponibles un subconjunto de etiquetas HTML y atributos.</p> + +<p>{{ jsOverrides("Object", "methods", "charAt", "charCodeAt", "concat", "indexOf", "lastIndexOf", "localeCompare", "match", "quote", "replace", "search", "slice", "split", "substr", "substring", "toLocaleLowerCase", "toLocaleUpperCase", "toLowerCase", "toSource", "toString", "toUpperCase", "trim", "trimLeft", "trimRight", "valueOf", "anchor", "big", "blink", "bold", "fixed", "fontcolor", "fontsize", "italics", "link", "small", "strike", "sub", "sup") }}</p> + +<h2 id="See_also" name="See_also">Vea también</h2> + +<ul> + <li>{{jsxref("String")}}</li> + <li>{{jsxref("Function.prototype")}}</li> +</ul> + +<dl> + <dt> </dt> +</dl> diff --git a/files/es/web/javascript/referencia/objetos_globales/string/raw/index.html b/files/es/web/javascript/referencia/objetos_globales/string/raw/index.html new file mode 100644 index 0000000000..3c8f3c1d55 --- /dev/null +++ b/files/es/web/javascript/referencia/objetos_globales/string/raw/index.html @@ -0,0 +1,112 @@ +--- +title: String.raw() +slug: Web/JavaScript/Referencia/Objetos_globales/String/raw +translation_of: Web/JavaScript/Reference/Global_Objects/String/raw +--- +<div>{{JSRef}}</div> + +<p>El método estatico <strong><code>String.raw()</code> </strong> es una función de <a href="/en-US/docs/Web/JavaScript/Reference/template_strings"> plantilla de literales</a>, similar al prefijo <code>r</code> en Python o al prefijo <code>@</code> en C# para strings literales (con ciertas diferencias: ver la explicación en <a href="https://bugs.chromium.org/p/v8/issues/detail?id=5016">este problema</a>). Se utiliza para obtener un <em>string</em> crudo a partir de plantillas de <em>string</em> (es decir, el original, texto no interpretado).</p> + +<h2 id="Sintaxis">Sintaxis</h2> + +<pre class="syntaxbox"><code>String.raw(<var>callSite</var>, <var>...substitutions</var>) + +String.raw`templateString` +</code></pre> + +<h3 id="Parametros">Parametros</h3> + +<dl> + <dt><code>callSite</code></dt> + <dd>Plantilla bien estructurada, similar a <code>{ raw: ['foo', 'bar', 'baz'] }</code>.</dd> + <dt><code>...substitutions</code></dt> + <dd>Contiene valores de sustitución.</dd> + <dt><code>templateString</code></dt> + <dd>[opcional] Una <a href="/en-US/docs/Web/JavaScript/Reference/template_strings">plantilla <em>string</em></a>, con sustituciones (<code>${...}</code>).</dd> +</dl> + +<h3 id="Valor_de_regreso">Valor de regreso</h3> + +<p>La forma cruda del <em>string </em>de una plantilla <em>string </em>proporcionada.</p> + +<h3 id="Excepciones">Excepciones</h3> + +<dl> + <dt>{{jsxref("TypeError")}}</dt> + <dd>Un {{jsxref("TypeError")}} es arrojado si el primer argumento no es un objeto bien estructurado.</dd> +</dl> + +<h2 id="Descripción">Descripción</h2> + +<p>En la mayoría de los casos, <code>String.raw()</code> es usado con plantillas <em>string</em>. 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 <a href="/en-US/docs/Web/JavaScript/Reference/template_strings#Tagged_template_literals">funciones de etiqueta</a>.</p> + +<p><code>String.raw()</code> es la unica función de etiqueta incorporada en las plantillas <em>string</em>; 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.</p> + +<h2 id="Ejemplos">Ejemplos</h2> + +<h3 id="Usando_String.raw()">Usando <code>String.raw()</code></h3> + +<pre class="brush: 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' + +</pre> + +<h2 id="Especificaciónes">Especificaciónes</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificación</th> + <th scope="col">Estado</th> + <th scope="col">Comentario</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-string.raw', 'String.raw')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Definicion inicial.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.raw', 'String.raw')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidad_de_navegador">Compatibilidad de navegador</h2> + +<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> + +<p>{{Compat("javascript.builtins.String.raw")}}</p> + +<h2 id="Tambien_ver">Tambien ver</h2> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Reference/template_strings">Template strings</a></li> + <li>{{jsxref("String")}}</li> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Lexical_grammar">Lexical grammar</a></li> +</ul> diff --git a/files/es/web/javascript/referencia/objetos_globales/string/repeat/index.html b/files/es/web/javascript/referencia/objetos_globales/string/repeat/index.html new file mode 100644 index 0000000000..a449bdfb27 --- /dev/null +++ b/files/es/web/javascript/referencia/objetos_globales/string/repeat/index.html @@ -0,0 +1,128 @@ +--- +title: String.prototype.repeat() +slug: Web/JavaScript/Referencia/Objetos_globales/String/repeat +tags: + - ECMAScript2015 + - JavaScript + - Prototype + - Referencia + - String + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/String/repeat +--- +<div>{{JSRef}}</div> + +<p>El método <strong><code>repeat()</code></strong> construye y devuelve una nueva cadena que contiene el número especificado de copias de la cadena en la cual fue llamada, concatenados.</p> + +<h2 id="Sintáxis">Sintáxis</h2> + +<pre class="syntaxbox"><code><var>str</var>.repeat(<var>count</var>)</code></pre> + +<h3 id="Parámetros">Parámetros</h3> + +<dl> + <dt><code>count</code></dt> + <dd>Un entero entre 0 y +∞: [0, +∞), indicando el número de veces a repetir la cadena en la nueva cadenada creada que será devuelta.</dd> +</dl> + +<h3 id="Valor_devuelto">Valor devuelto</h3> + +<p>Un nuevo string que contiene el número especificado de copias del string original.</p> + +<h3 id="Excepciones">Excepciones</h3> + +<ul> + <li>{{jsxref("Errors/Negative_repetition_count", "RangeError")}}: El número de repeticiones no debe ser negativo.</li> + <li>{{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.</li> +</ul> + +<dl> +</dl> + +<h2 id="Ejemplos">Ejemplos</h2> + +<pre class="brush: 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) +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>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 <code>String.prototype.repeat()</code> con el siguiente fragmento de código:</p> + +<pre class="brush: 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; + } +} +</pre> + +<h2 id="Especificaciones">Especificaciones</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificación</th> + <th scope="col">Estado</th> + <th scope="col">Comentarios</th> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.repeat', 'String.prototype.repeat')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Definición inicial.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.repeat', 'String.prototype.repeat')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidad_en_Navegadores">Compatibilidad en Navegadores</h2> + +<div>{{Compat("javascript.builtins.String.repeat")}}</div> + +<div id="compat-mobile"> </div> diff --git a/files/es/web/javascript/referencia/objetos_globales/string/replace/index.html b/files/es/web/javascript/referencia/objetos_globales/string/replace/index.html new file mode 100644 index 0000000000..680393ece1 --- /dev/null +++ b/files/es/web/javascript/referencia/objetos_globales/string/replace/index.html @@ -0,0 +1,202 @@ +--- +title: String.prototype.replace() +slug: Web/JavaScript/Referencia/Objetos_globales/String/replace +tags: + - JavaScript + - Method + - Prototype + - Regular Expressions + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/replace +--- +<p>{{JSRef("Objetos_globales", "String")}}</p> + +<h2 id="Resumen" name="Resumen">Resumen</h2> + +<p><span class="seoSummary">El método <strong><code>replace()</code></strong> devuelve una nueva cadena con algunas o todas las coincidencias de un <code>patrón</code>, siendo cada una de estas coincidencias reemplazadas por <code>remplazo</code></span>. El <code>patrón</code> puede ser una cadena o una {{jsxref("RegExp")}}, y el <code>reemplazo</code> puede ser una cadena o una función que será llamada para cada coincidencia. Si el <code>patrón</code> es una cadena, sólo la primera coincidencia será reemplazada.</p> + +<p>La cadena original permanecerá inalterada.</p> + +<div>{{EmbedInteractiveExample("pages/js/string-replace.html")}}</div> + +<h2 id="Sintaxis" name="Sintaxis">Sintaxis</h2> + +<pre class="eval"><code class="language-html"><em>cadena</em>.replace(regexp|substr, newSubStr|function[, </code>{{ Non-standard_inline() }} <code class="language-html">flags]);</code> +</pre> + +<h3 id="Par.C3.A1metros" name="Par.C3.A1metros">Parámetros</h3> + +<dl> + <dt><code>expresionregular</code></dt> + <dd>Un objeto {{jsxref("RegExp")}} o literal. Las coincidencias son reemplazadas por <code class="language-html">ewSubSt</code> o el valor devuelto por la función especificada.</dd> +</dl> + +<dl> + <dt><code>subcadena</code></dt> + <dd>Un objeto {{jsxref("String")}} que será reemplazado por <code>nuevaSubcadena</code>.</dd> +</dl> + +<dl> + <dt><code>nuevaSubcadena</code></dt> + <dd>El objeto {{jsxref("String")}} que reemplaza la subcadena que recibida desde el primer parámetro.</dd> +</dl> + +<dl> + <dt><code>funcion</code></dt> + <dd>Una función que será invocada para crear la nueva subcadena (para ponerla en lugar de la subcadena recibida por el primer parámetro).</dd> +</dl> + +<dl> + <dt><code>flags</code> {{ non-standard_inline() }}</dt> + <dd>Un objeto {{jsxref("String")}} que contiene cualquier combinación de flags de la clase RegExp: <code>g</code> - emparejamiento global, <code>i</code> - ignorar mayúsculas, <code>m</code> - emparejar multiples líneas. Este parámetro se usa sólo si el primer parámetro es una cadena.</dd> +</dl> + +<h2 id="Descripci.C3.B3n" name="Descripci.C3.B3n">Descripción</h2> + +<p>Este método no cambia el objeto <code>String</code> sobre el que se realiza la llamada. Simplemente devuelve una nueva cadena.</p> + +<p>Para realizar una búsqueda global y reemplazarla, o se incluye el flag <code>g</code> en la expresión regular o si el primer parámetro es una cadena, se incluye <code>g</code> en el parámetro <code>flags</code>.</p> + +<h4 id="Especificando_una_cadena_como_un_par.C3.A1metro" name="Especificando_una_cadena_como_un_par.C3.A1metro">Especificando una cadena como un parámetro</h4> + +<p>La cadena de reemplazo puede incluir los siguientes patrones de reemplazo especiales:</p> + +<table class="fullwidth-table"> + <tbody> + <tr> + <td class="header">Patrón</td> + <td class="header">Inserta</td> + </tr> + <tr> + <td><code>$$</code></td> + <td>Inserta una "$".</td> + </tr> + <tr> + <td><code>$&</code></td> + <td>Inserta la subcadena emparejada.</td> + </tr> + <tr> + <td><code>$`</code></td> + <td>Inserta la sección de cadena que precede a la subcadena emparejada.</td> + </tr> + <tr> + <td><code>$'</code></td> + <td>Inserta la porción de subcadena que sigue a la subcadena emparejada.</td> + </tr> + <tr> + <td style="white-space: nowrap;"><code>$<em>n</em> </code> o <code>$<em>nn</em> </code></td> + <td>Donde <code><em>n</em> </code> o <code><em>nn</em> </code> son dígitos decimales positivos menores a 100, inserta la subcadena emparejada de orden <em>n</em> del paréntesis, proporcionado por el primer argumento del objeto <code>RegExp</code>.</td> + </tr> + </tbody> +</table> + +<h3 id="Especificando_una_funci.C3.B3n_con_un_par.C3.A1metro" name="Especificando_una_funci.C3.B3n_con_un_par.C3.A1metro">Especificando una función con un parámetro</h3> + +<p>Cuando se especifica una función en el segundo parámetro, la función es invocada después de que el emparejamiento se haya realizado. (El uso de una función de este modo se llama expresión lambda.)</p> + +<p>En la función, puedes generar dinámicamente la cadena que reemplaza la subcadena emparejada. El resultado de la llamada de la función se usa como valor de reemplazo.</p> + +<p>The nested function can use the matched substrings to determine the new string (<code>newSubStr</code>) that replaces the found substring. You get the matched substrings through the parameters of your function. The first parameter of your function holds the complete matched substring. If the first argument was a <code>RegExp</code> object, then the following<em>n</em> parameters can be used for parenthetical matches, remembered submatch strings, where<em>n</em> is the number of submatch strings in the regular expression. Finally, the last two parameters are the offset within the string where the match occurred and the string itself. For example, the following <code>replace</code> method returns XXzzzz - XX , zzzz.</p> + +<pre class="brush: js">function replacer(str, p1, p2, offset, s) +{ + return str + " - " + p1 + " , " + p2; +} +var newString = "XXzzzz".replace(/(X*)(z*)/, replacer); +console.log(newString); // XXzzzz - XX , zzzz +</pre> + +<h2 id="Ejemplos" name="Ejemplos">Ejemplos</h2> + +<h3 id="Ejemplo_Using_global_and_ignore_with_replace" name="Ejemplo:_Using_global_and_ignore_with_replace">Ejemplo: Usando <code>global</code> e <code>ignore</code> con <code>replace</code></h3> + +<p>En el siguiente ejemplo, la expresión regular incluye las banderas "global" e "ignore case", las cuales permiten al método <code>replace</code> reemplazar cada aparición de la cadena 'apples' por la cadena 'oranges'.</p> + +<pre class="eval">var re = /apples/gi; +var str = "Apples are round, and apples are juicy."; +var newstr = str.replace(re, "oranges"); +print(newstr); +</pre> + +<p>In this version, a string is used as the first parameter and the global and ignore case flags are specified in the <code>flags</code> parameter.</p> + +<pre class="eval">var str = "Apples are round, and apples are juicy."; +var newstr = str.replace("apples", "oranges", "gi"); +print(newstr); +</pre> + +<p>Both of these examples print "oranges are round, and oranges are juicy."</p> + +<h3 id="Ejemplo_Definiendo_la_expresi.C3.B3n_regular_en_replace" name="Ejemplo:_Definiendo_la_expresi.C3.B3n_regular_en_replace">Ejemplo: Definiendo la expresión regular en <code>replace</code></h3> + +<p>En el siguiente ejemplo, se define la expresión regular en <code>replace</code> e incluye el flag de ignorar mayúsculas.</p> + +<pre class="eval">var cadena = "Twas the night before Xmas..."; +var nuevaCadena = cadena.replace(/xmas/i, "Christmas"); +print(nuevaCadena); +</pre> + +<p>Esto muestra "Twas the night before Christmas..."</p> + +<h3 id="Ejemplo_Conectando_palabras_en_una_cadena" name="Ejemplo:_Conectando_palabras_en_una_cadena">Ejemplo: Conectando palabras en una cadena</h3> + +<p>El siguiente código conecta las palabras dentro de la cadena. Para reemplazar el texto, el código usa <code>$1</code> y <code>$2</code> como patrones de reemplazo.</p> + +<pre class="eval">var expresion = /(\w+)\s(\w+)/; +var cadena = "John Smith"; +var nuevaCadena = cadena.replace(expresion, "$2, $1"); +print(nuevaCadena); +</pre> + +<p>Esto muestra "Smith, John".</p> + +<h3 id="Ejemplo_Using_an_inline_function_that_modifies_the_matched_characters" name="Ejemplo:_Using_an_inline_function_that_modifies_the_matched_characters">Ejemplo: Using an inline function that modifies the matched characters</h3> + +<p>In this example, all occurrences of capital letters in the string are converted to lower case, and a hyphen is inserted just before the match location. The important thing here is that additional operations are needed on the matched item before it is given back as a replacement.</p> + +<p>The replacement function accepts the matched snippet as its parameter, and uses it to transform the case and concatenate the hyphen before returning.</p> + +<pre class="brush: js">function styleHyphenFormat(propertyName) +{ + function upperToHyphenLower(match) + { + return '-' + match.toLowerCase(); + } + return propertyName.replace(/[A-Z]/, upperToHyphenLower); +} +</pre> + +<p>Given <code>styleHyphenFormat('borderTop')</code>, this returns 'border-top'.</p> + +<p>Because we want to further transform the<em>result</em> of the match before the final substitution is made, we must use a function. This forces the evaluation of the match prior to the <code>toLowerCase()</code> method. If we had tried to do this using the match without a function, the toLowerCase() would have no effect.</p> + +<pre class="brush: js">var newString = propertyName.replace(/[A-Z]/, '-' + '$&'.toLowerCase()); // won't work +</pre> + +<p>This is because <code>'$&'.toLowerCase()</code> would be evaluated first as a string literal (resulting in the same <code>'$&'</code>) before using the characters as a pattern.</p> + +<h3 id="Ejemplo_Reemplazando_grandos_Fahrenheit_con_su_equivalente_Celsius" name="Ejemplo:_Reemplazando_grandos_Fahrenheit_con_su_equivalente_Celsius">Ejemplo: Reemplazando grados Fahrenheit con su equivalente Celsius</h3> + +<p>El siguiente ejemplo reemplaza los grados Fahrenheit con su enquivalente en grados Celsius. Los grados Fahrenheit deberían ser un número acabado en F. La función devuelve el número Celsius acabado en C. Por ejemplo, si el número de entrada es 212F, la función devuelve 100C. Si el número es 0F, la función devuelve -17.77777777777778C.</p> + +<p>La expresión regular <code>test</code> revisa si para un número termina en F. El número de grados Fahrenheit es accesible a la función a través de su segundo parámetro, <code>p1</code>. La función establece el número Celsius basado en los grados Fahrenheit pasados en una cadena a la función <code>f2c</code>. Entonces <code>f2c</code> devuelve el número Celsius. Esta función aproxima al flag de Perl s///e.</p> + +<pre class="brush: js">function f2c(x) +{ + function convert(str, p1, offset, s) + { + return ((p1-32) * 5/9) + "C"; + } + var s = String(x); + var test = /(\d+(?:\.\d*)?)F\b/g; + return s.replace(test, convert); +} +</pre> + +<h2 id="Vea_También">Vea También</h2> + +<ul> + <li>{{jsxref("String.prototype.match()")}}</li> + <li>{{jsxref("RegExp.prototype.exec()")}}</li> + <li>{{jsxref("RegExp.prototype.test()")}}</li> +</ul> diff --git a/files/es/web/javascript/referencia/objetos_globales/string/search/index.html b/files/es/web/javascript/referencia/objetos_globales/string/search/index.html new file mode 100644 index 0000000000..23e37234d1 --- /dev/null +++ b/files/es/web/javascript/referencia/objetos_globales/string/search/index.html @@ -0,0 +1,153 @@ +--- +title: String.prototype.search() +slug: Web/JavaScript/Referencia/Objetos_globales/String/search +tags: + - JavaScript + - Method + - Prototype + - Reference + - Regular Expressions + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/search +--- +<p>{{JSRef("Objetos_globales", "String")}}</p> + +<h2 id="Resumen" name="Resumen">Resumen</h2> + +<p>El método <code><strong>search() </strong></code>ejecuta una búsqueda que encaje entre una expresión regular y el objeto <code>String</code> desde el que se llama.</p> + +<h2 id="Sintaxis" name="Sintaxis">Sintaxis</h2> + +<pre class="syntaxbox"><em>str</em>.search(<em>expresionregular</em>)</pre> + +<h3 id="Par.C3.A1metros" name="Par.C3.A1metros">Parámetros</h3> + +<dl> + <dt>regexp</dt> + <dd>Un objeto <a href="/es/docs/Web/JavaScript/Referencia/Objetos_globales/RegExp"> expresión regular</a>. Si se pasa un objeto <code>obj </code>que no sea una expresión regular, se convierte implicitamente en una expresión regualar usando <code>new RegExp(obj)</code>.</dd> +</dl> + +<h3 id="Valor_devuelto">Valor devuelto</h3> + +<p>El índice de la primera coincidencia entre la expresión regular y la cadena de texto proporcionada, si no se encuentra devuelve <strong>-1</strong>.</p> + +<h2 id="Description" name="Description">Descripción</h2> + +<p>Cuando se desee saber en qué casos un patrón se encuentra en una cadena de texto utiliza <code>search()</code> (si sólo deseas saber si existe, utiliza el método {{jsxref("RegExp.prototype.test()", "test()")}} del prototipo de <code>RegExp</code>); 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).</p> + +<h2 id="Examples" name="Examples">Ejemplos</h2> + +<h3 id="Example:_Using_search" name="Example:_Using_search">Utilizando <code>search()</code></h3> + +<p>El siguiente ejemplo imprime un mensaje dependiendo de cuál sea el resultado de la evaluación.</p> + +<pre class="brush: js">function testinput(re, str) { + var midstring; + if (str.search(re) != -1) { + midstring = ' contains '; + } else { + midstring = ' does not contain '; + } + console.log(str + midstring + re); +} +</pre> + +<h2 id="Especificaciones">Especificaciones</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificaciones</th> + <th scope="col">Estado</th> + <th scope="col">Comentario</th> + </tr> + <tr> + <td>{{SpecName('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Definición inicial. Implementado en JavaScript 1.2.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.12', 'String.prototype.search')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.search', 'String.prototype.search')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.search', 'String.prototype.search')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidad_con_navegadores">Compatibilidad con navegadores</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Soporte básico</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome para Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Soporte básico</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Notas_específicas_de_Gecko">Notas específicas de Gecko</h2> + +<ul> + <li>Antes de {{Gecko("8.0")}}, <code>search()</code> 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 <code>'a'.search()</code> y <code>'a'.search(undefined)</code> devuelven correctamente un 0.</li> + <li>Desde Gecko 39 {{geckoRelease(39)}}, el argumento no estándar <code>flags </code>está obsoleto y muestra un aviso en la consola ({{bug(1142351)}}).</li> + <li>Desde Gecko 47 {{geckoRelease(47)}}, el argumento no estándar <code>flags</code> no es soportado en compilaciones que no sean lanzamientos y pronto serán eliminadas por completo ({{bug(1245801)}}).</li> + <li>Desde Gecko 49 {{geckoRelease(49)}}, el argumento no estándar <code>flags </code>no es soportado ({{bug(1108382)}}).</li> +</ul> + +<h2 id="Vea_Tambi.C3.A9n" name="Vea_Tambi.C3.A9n">Vea también</h2> + +<ul> + <li>{{jsxref("String.prototype.match()")}}</li> + <li>{{jsxref("RegExp.prototype.exec()")}}</li> +</ul> diff --git a/files/es/web/javascript/referencia/objetos_globales/string/slice/index.html b/files/es/web/javascript/referencia/objetos_globales/string/slice/index.html new file mode 100644 index 0000000000..cbfe5a716b --- /dev/null +++ b/files/es/web/javascript/referencia/objetos_globales/string/slice/index.html @@ -0,0 +1,161 @@ +--- +title: String.prototype.slice() +slug: Web/JavaScript/Referencia/Objetos_globales/String/slice +tags: + - Cadena + - JavaScript + - Método(2) + - Prototipo + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/slice +--- +<p>{{JSRef("Objetos_globales", "String")}}</p> + +<h2 id="Resumen" name="Resumen">Resumen</h2> + +<p>El método <strong><code>slice()</code></strong> extrae una sección de una cadena y devuelve una cadena nueva.</p> + +<h2 id="Sintaxis" name="Sintaxis">Sintaxis</h2> + +<pre class="eval"><code class="language-html"><em>cadena</em>.slice(<em>inicioTrozo</em>[, <em>finTrozo</em>])</code> +</pre> + +<h3 id="Parameters" name="Parameters">Parameters</h3> + +<dl> + <dt><code>inicioTrozo</code></dt> + <dd>El índice basado en cero en el cual empieza la extracción. Si es negativo, se trata como <code>longCadena + inicioTrozo</code> donde <code>longCadena</code> es la longitud de la cadena (por ejemplo, si <code>inicioTrozo</code> es <code>-3</code> se trata como <code>longCadena - 3</code>)</dd> +</dl> + +<dl> + <dt><code>finTrozo</code></dt> + <dd>Opcional. El índice basado en cero en el que termina la extracción. Si se omite, <code>slice</code> extrae hasta el final de la cadena. Si es negativo, se trata como <code>longCadena + finTrozo</code> donde <code>longCadena</code> es la longitud de la cadena (por ejemplo, si <code>finTrozo </code>es <code>-3</code> se trata como <code>longCadena - 3</code>).</dd> +</dl> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>Una nueva cadena que contiene la sección de la cadena.</p> + +<h2 id="Descripci.C3.B3n" name="Descripci.C3.B3n">Descripción</h2> + +<p><code>slice</code> 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.</p> + +<p><code>slice</code> extrae hasta, pero sin incluir <code>finalTrozo</code>. <code>string.slice(1,4)</code> extrae del segundo carácter hasta el cuarto carácter (caracteres con índice 1, 2 y 3).</p> + +<p>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.</p> + +<h2 id="Ejemplos" name="Ejemplos">Ejemplos</h2> + +<h3 id="Ejemplo:_Usando_slice_para_crear_una_nueva_cadena" name="Ejemplo:_Usando_slice_para_crear_una_nueva_cadena">Ejemplo: Uso de <code>slice()</code> para crear una nueva cadena</h3> + +<p>El siguiente ejemplo usa <code>slice()</code> para crear una nueva cadena.</p> + +<pre class="brush: js">var cadena1 = "La mañana se nos echa encima."; +var cadena2 = cadena1.slice(3, -2); +console.log(cadena2); +</pre> + +<p>Esto escribe:</p> + +<pre class="eval">mañana se nos echa encim</pre> + +<h3 id="Uso_de_slice()_con_índices_negativos">Uso de <code>slice()</code> con índices negativos</h3> + +<p>El siguiente ejemplo usa <code>slice()</code> con índices negativos.</p> + +<pre>var cad = "La mañana se nos echa encima.";<code> +cad.slice(-3); // retorna 'ma.' +cad.slice(-3, -1); // retorna 'ma' +cad.slice(0, -1); // retorna 'La mañana se nos echa encima'</code></pre> + +<h2 id="Especificaciones">Especificaciones</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificación</th> + <th scope="col">Estado</th> + <th scope="col">Comentario</th> + </tr> + <tr> + <td>{{SpecName('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Definición inicial. Implementado en JavaScript 1.2.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.13', 'String.prototype.slice')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.slice', 'String.prototype.slice')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.slice', 'String.prototype.slice')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidad_en_navegadores">Compatibilidad en navegadores</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Soporte básico</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Soporte básico</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vea_Tambi.C3.A9n" name="Vea_Tambi.C3.A9n">Vea También</h2> + +<ul> + <li>{{jsxref("String.prototype.substr()")}}</li> + <li>{{jsxref("String.prototype.substring()")}}</li> + <li>{{jsxref("Array.prototype.slice()")}}</li> +</ul> diff --git a/files/es/web/javascript/referencia/objetos_globales/string/small/index.html b/files/es/web/javascript/referencia/objetos_globales/string/small/index.html new file mode 100644 index 0000000000..a8b2f302fd --- /dev/null +++ b/files/es/web/javascript/referencia/objetos_globales/string/small/index.html @@ -0,0 +1,38 @@ +--- +title: String.prototype.small() +slug: Web/JavaScript/Referencia/Objetos_globales/String/small +tags: + - Deprecated + - HTML wrapper methods + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/small +--- +<p>{{JSRef("Objetos_globales", "String")}}</p> +<p>{{deprecated_header}}</p> +<h2 id="Resumen" name="Resumen">Resumen</h2> +<p>Causa que una cadena se muestra con una fuente pequeña, como si estuviese dentro de una etiqueta {{HTMLElement("small")}}.</p> +<h2 id="Sintaxis" name="Sintaxis">Sintaxis</h2> +<pre class="syntaxbox"><em>cadena</em>.small()</pre> +<h2 id="Descripci.C3.B3n" name="Descripci.C3.B3n">Descripción</h2> +<p>Usa el método <code>small</code> para formatear y mostrar una cadena en un documento.</p> +<h2 id="Ejemplos" name="Ejemplos">Ejemplos</h2> +<h3 id="Ejemplo:_Usando_m.C3.A9todos_de_string_para_cambiar_el_tama.C3.B1o_de_una_cadena" name="Ejemplo:_Usando_m.C3.A9todos_de_string_para_cambiar_el_tama.C3.B1o_de_una_cadena">Ejemplo: Usando métodos de <code>string</code> para cambiar el tamaño de una cadena</h3> +<pre class="brush: js">var cadenaMundo="¡Hola mundo!" + +console.log(cadenaMundo.small()) +console.log(cadenaMundo.big()) +console.log(cadenaMundo.fontsize(7)) +</pre> +<p>Este ejemplo produce el mismo resultado que el siguiente código HTML:</p> +<pre class="brush: html"><small>¡Hola mundo!</small> +<big>¡Hola mundo!</big> +<fontsize=7>¡Hola mundo!</fontsize> +</pre> +<h3 id="Vea_Tambi.C3.A9n" name="Vea_Tambi.C3.A9n">Vea También</h3> +<ul> + <li>{{jsxref("String.prototype.fontsize()")}}</li> + <li>{{jsxref("String.prototype.big()")}}</li> +</ul> diff --git a/files/es/web/javascript/referencia/objetos_globales/string/split/index.html b/files/es/web/javascript/referencia/objetos_globales/string/split/index.html new file mode 100644 index 0000000000..ade291da0f --- /dev/null +++ b/files/es/web/javascript/referencia/objetos_globales/string/split/index.html @@ -0,0 +1,240 @@ +--- +title: String.prototype.split() +slug: Web/JavaScript/Referencia/Objetos_globales/String/split +tags: + - JavaScript + - Method + - Prototype + - Regular Expressions + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/split +--- +<p>{{JSRef("Objetos_globales", "String")}}</p> + +<p>El método <strong><code>split()</code></strong> divide un objeto de tipo <code>String</code> en un array (vector) de cadenas mediante la separación de la cadena en subcadenas.</p> + +<h2 id="Sintaxis" name="Sintaxis">Sintaxis</h2> + +<pre class="syntaxbox"><em>cadena</em>.split([<em>separador</em>][,<em>limite</em>])</pre> + +<h3 id="Par.C3.A1metros" name="Par.C3.A1metros">Parámetros</h3> + +<dl> + <dt><code>separador</code></dt> + <dd>Especifica el carácter a usar para la separación de la cadena. El <code>separador</code> es tratado como una cadena o como una <a href="/es/docs/Web/JavaScript/Referencia/Objetos_globales/RegExp"> </a>{{jsxref("Objetos_globales/RegExp", "expresión regular", "", 1)}}. Si se omite el <code>separador</code>, el array devuelto contendrá un sólo elemento con la cadena completa.</dd> +</dl> + +<dl> + <dt><code>limite</code></dt> + <dd>Opcional. Entero que especifica un límite sobre el número de divisiones a realizar. El método <code>split()</code> todavía se divide en todas las concordancias del <code>separador</code>, pero divide la matriz devuelta en la cantidad de elementos impuesta por el <code>limite</code>.</dd> +</dl> + +<h2 id="Descripci.C3.B3n" name="Descripci.C3.B3n">Descripción</h2> + +<p>El método <code>split()</code> devuelve el nuevo array.</p> + +<p>Cuando se encuentra, el <code>separador</code> es eliminado de la cadena y las subcadenas obtenidas se devuelven en un array. Si el <code>separador</code> no es encontrado o se omite, el array contendrá un único elemento con la cadena original completa. Si el <code>separador</code> es una cadena vacía la cadena es convertida en un array de carácteres.</p> + +<p>Si el <code>separador</code> es una expresión regular que contiene paréntesis de captura, entonces cada vez que el <code>separador</code> concuerda, los resultados (incluído cualquier resultado indefinido) de los paréntesis de captura son divididos en el array resultante. Sin embargo no todos los navegadores soportan esta característica.</p> + +<p>{{Note("Cuando la cadena está vacía, <code>split()</code> devuelve un array que contiene una cadena vacía, en lugar de un array vacío.")}}</p> + +<h2 id="Ejemplos" name="Ejemplos">Ejemplos</h2> + +<h3 id="Ejemplo:_Usando_split" name="Ejemplo:_Usando_split">Usando <code>split()</code></h3> + +<p>El siguiente ejemplo define una función que divide una cadena en un array de cadenas usando el separador especificado. Después de la división de la cadena, la función muestra mensajes indicando la cadena original (antes de la división), el separador usado, el número de elementos del array y los elementos individuales del array.</p> + +<pre class="brush: js">function dividirCadena(cadenaADividir,separador) { + var arrayDeCadenas = cadenaADividir.split(separador); + document.write('<p>La cadena original es: "' + cadenaADividir + '"'); + document.write('<br>El separador es: "' + separador + '"'); + document.write("<br>El array tiene " + arrayDeCadenas.length + " elementos: "); + + for (var i=0; i < arrayDeCadenas.length; i++) { + document.write(arrayDeCadenas[i] + " / "); + } +} + +var cadenaVerso = "Oh brave new world that has such people in it."; +var cadenaMeses = "Jan,Feb,Mar,Apr,May,Jun,Jul,Aug,Sep,Oct,Nov,Dec"; + +var espacio = " "; +var coma = ","; + +dividirCadena(cadenaVerso, espacio); +dividirCadena(cadenaVerso); +dividirCadena(cadenaMeses, coma); +</pre> + +<p>Este ejemplo produce el siguiente resultado:</p> + +<pre>La cadena original es: "Oh brave new world that has such people in it." +El separador es: " " +El array tiene 10 elementos: Oh / brave / new / world / that / has / such / people / in / it. / + +La cadena original es: "Oh brave new world that has such people in it." +El separador es: "undefined" +El array tiene 1 elementos: Oh brave new world that has such people in it. / + +La cadena original es: "Jan,Feb,Mar,Apr,May,Jun,Jul,Aug,Sep,Oct,Nov,Dec" +El separador es: "," +El array tiene 12 elementos: Jan / Feb / Mar / Apr / May / Jun / Jul / Aug / Sep / Oct / Nov / Dec / +</pre> + +<h3 id="Ejemplo:_Eliminar_espacios_de_una_cadena" name="Ejemplo:_Eliminar_espacios_de_una_cadena">Eliminar espacios de una cadena</h3> + +<p>En el siguiente ejemplo, <code>split</code> busca 0 o más espacios seguidos de un punto y coma seguido por 0 o más espacios y, cuando los halla, elimina los espacios de la cadena. <code>listaNombres</code> es el array devuelto como resultado de la llamada a <code>split</code>.</p> + +<pre class="brush: js">var nombres = "Harry Trump ;Fred Barney; Helen Rigby ; Bill Abel ;Chris Hand "; +document.write(nombres + "<br>" + "<br>"); +var expresionRegular = /\s*;\s*/; +var listaNombres = nombres.split(expresionRegular); +document.write(listaNombres); +</pre> + +<p>Esto imprime dos líneas; la primera línea imprime la cadena original, y la segunda línea imprime el array resultante.</p> + +<pre>Harry Trump ;Fred Barney; Helen Rigby ; Bill Abel ;Chris Hand +Harry Trump,Fred Barney,Helen Rigby,Bill Abel,Chris Hand +</pre> + +<h3 id="Ejemplo:_Devolviendo_un_n.C3.BAmero_limitado_de_divisiones" name="Ejemplo:_Devolviendo_un_n.C3.BAmero_limitado_de_divisiones">Devolviendo un número limitado de divisiones</h3> + +<p>El el siguiente ejemplo, <code>split</code> busca 0 o más espacios en una cadena y devuelve las tres primeras divisiones que encuentra.</p> + +<pre class="brush: js">var miCadena = "Hola Mundo. Cómo estás hoy?"; +var divisiones = miCadena.split(" ", 3); + +print(divisiones); +</pre> + +<p>Este script muestra lo siguiente:</p> + +<pre>Hola,Mundo.,Cómo +</pre> + +<h3 id="Paréntesis_de_captura" style="font-size: 1.71428571428571rem;">Paréntesis de captura</h3> + +<p>Si el separador contiene paréntesis de capturaI los resultados que concuerden son devueltos en el array.</p> + +<pre class="brush: js language-js" style="padding: 1em 0px 1em 30px; font-size: 14px; white-space: normal;"><code class="language-js" style="font-family: Consolas, Monaco, 'Andale Mono', monospace; direction: ltr; white-space: pre;"><span class="keyword token" style="color: #0077aa;">var</span> miCadena <span class="operator token" style="background: rgba(255, 255, 255, 0.498039); color: #a67f59;">=</span> <span class="string token" style="color: #669900;">'Hola 1 mundo. Oración número 2.'</span><span class="punctuation token" style="color: #999999;">;</span> +<span class="keyword token" style="color: #0077aa;">var</span> division <span class="operator token" style="background: rgba(255, 255, 255, 0.498039); color: #a67f59;">=</span> miCadena<span class="punctuation token" style="color: #999999;">.</span><span class="function token" style="color: #dd4a68;">split<span class="punctuation token" style="color: #999999;">(</span></span><span class="regex token" style="color: #ee9900;">/(\d)/</span><span class="punctuation token" style="color: #999999;">)</span><span class="punctuation token" style="color: #999999;">;</span> + +console<span class="punctuation token" style="color: #999999;">.</span><span class="function token" style="color: #dd4a68;">log<span class="punctuation token" style="color: #999999;">(</span></span>division<span class="punctuation token" style="color: #999999;">)</span><span class="punctuation token" style="color: #999999;">;</span></code></pre> + +<div class="line-number" style="margin-top: 1em; position: absolute; left: 0px; right: 0px; line-height: inherit; top: 0px; background: 0px 0px;"> </div> + +<div class="line-number" style="margin-top: 1em; position: absolute; left: 0px; right: 0px; line-height: inherit; top: 19px; background: 0px 0px;"> </div> + +<div class="line-number" style="margin-top: 1em; position: absolute; left: 0px; right: 0px; line-height: inherit; top: 38px; background: 0px 0px;"> </div> + +<div class="line-number" style="margin-top: 1em; position: absolute; left: 0px; right: 0px; line-height: inherit; top: 57px; background: 0px 0px;"> </div> + +<p>Este script muestra lo siguiente:</p> + +<pre class="language-html" style="padding: 1em 0px 1em 30px; font-size: 14px; white-space: normal;"><code class="language-html" style="font-family: Consolas, Monaco, 'Andale Mono', monospace; direction: ltr; white-space: pre;">Hola ,1, mundo. Oración número ,2,.</code></pre> + +<div class="line-number" style="margin-top: 1em; position: absolute; left: 0px; right: 0px; line-height: inherit; top: 0px; background: 0px 0px;"> </div> + +<h3 id="Dar_la_vuelta_a_una_cadena_usando_split()" style="font-size: 1.71428571428571rem;">Dar la vuelta a una cadena usando <code>split()</code></h3> + +<pre class="brush: js language-js" style="padding: 1em 0px 1em 30px; font-size: 14px; white-space: normal;"><code class="language-js" style="font-family: Consolas, Monaco, 'Andale Mono', monospace; direction: ltr; white-space: pre;"><span class="keyword token" style="color: #0077aa;">var</span> str <span class="operator token" style="background: rgba(255, 255, 255, 0.498039); color: #a67f59;">=</span> <span class="string token" style="color: #669900;">'asdfghjkl'</span><span class="punctuation token" style="color: #999999;">;</span> +<span class="keyword token" style="color: #0077aa;">var</span> strReverse <span class="operator token" style="background: rgba(255, 255, 255, 0.498039); color: #a67f59;">=</span> str<span class="punctuation token" style="color: #999999;">.</span><span class="function token" style="color: #dd4a68;">split<span class="punctuation token" style="color: #999999;">(</span></span><span class="string token" style="color: #669900;">''</span><span class="punctuation token" style="color: #999999;">)</span><span class="punctuation token" style="color: #999999;">.</span><span class="function token" style="color: #dd4a68;">reverse<span class="punctuation token" style="color: #999999;">(</span></span><span class="punctuation token" style="color: #999999;">)</span><span class="punctuation token" style="color: #999999;">.</span><span class="function token" style="color: #dd4a68;">join<span class="punctuation token" style="color: #999999;">(</span></span><span class="string token" style="color: #669900;">''</span><span class="punctuation token" style="color: #999999;">)</span><span class="punctuation token" style="color: #999999;">;</span><span class="comment token" style="color: #708090;"> // 'lkjhgfdsa' +</span><span class="comment token" style="color: #708090;">// split() retorna un array en el cual reverse() y join() pueden ser aplicados</span></code></pre> + +<div class="line-number" style="margin-top: 1em; position: absolute; left: 0px; right: 0px; line-height: inherit; top: 0px; background: 0px 0px;"> </div> + +<div class="line-number" style="margin-top: 1em; position: absolute; left: 0px; right: 0px; line-height: inherit; top: 19px; background: 0px 0px;"> </div> + +<div class="line-number" style="margin-top: 1em; position: absolute; left: 0px; right: 0px; line-height: inherit; top: 38px; background: 0px 0px;"> </div> + +<p><strong>Extra:</strong> usar el operador <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators#Identity_.2F_strict_equality_(.3D.3D.3D)">===</a> para verificar si la cadena anterior era un palíndromo.</p> + +<h2 id="Specifications" style="margin-bottom: 20px; font-size: 2.14285714285714rem;">Specifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificación</th> + <th scope="col">Estado</th> + <th scope="col">Comentario</th> + </tr> + <tr> + <td>ECMAScript 3rd Edition.</td> + <td>Estándar</td> + <td>Definición inicial. Implementado en JavaScript 1.1.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.14', 'String.prototype.split')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.split', 'String.prototype.split')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidad_con_los_navegadores" style="margin-bottom: 20px; font-size: 2.14285714285714rem;">Compatibilidad con los navegadores</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table" style="border-color: transparent;"> + <tbody> + <tr> + <th style="line-height: 16px;">Característica</th> + <th style="line-height: 16px;">Chrome</th> + <th style="line-height: 16px;">Firefox (Gecko)</th> + <th style="line-height: 16px;">Internet Explorer</th> + <th style="line-height: 16px;">Opera</th> + <th style="line-height: 16px;">Safari</th> + </tr> + <tr> + <td>Soporte básico</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table" style="border-color: transparent;"> + <tbody> + <tr> + <th style="line-height: 16px;">Característica</th> + <th style="line-height: 16px;">Android</th> + <th style="line-height: 16px;">Chrome for Android</th> + <th style="line-height: 16px;">Firefox Mobile (Gecko)</th> + <th style="line-height: 16px;">IE Mobile</th> + <th style="line-height: 16px;">Opera Mobile</th> + <th style="line-height: 16px;">Safari Mobile</th> + </tr> + <tr> + <td>Soporte básico</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vea_Tambi.C3.A9n" name="Vea_Tambi.C3.A9n">Ver también</h2> + +<ul> + <li>{{jsxref("String.prototype.charAt()")}}</li> + <li>{{jsxref("String.prototype.indexOf()")}}</li> + <li>{{jsxref("String.prototype.lastIndexOf()")}}</li> + <li>{{jsxref("Array.prototype.join()")}}</li> +</ul> diff --git a/files/es/web/javascript/referencia/objetos_globales/string/startswith/index.html b/files/es/web/javascript/referencia/objetos_globales/string/startswith/index.html new file mode 100644 index 0000000000..c658cc80da --- /dev/null +++ b/files/es/web/javascript/referencia/objetos_globales/string/startswith/index.html @@ -0,0 +1,97 @@ +--- +title: String.prototype.startsWith() +slug: Web/JavaScript/Referencia/Objetos_globales/String/startsWith +tags: + - ECMAScript 2015 + - JavaScript + - Method + - Prototipo + - Prototype + - Reference + - Referencia + - String + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/String/startsWith +--- +<div>{{JSRef}}</div> + +<p>El método <strong><code>startsWith()</code></strong> indica si una cadena de texto comienza con los caracteres de una cadena de texto concreta, devolviendo <code>true</code> o <code>false</code> según corresponda.</p> + +<div>{{EmbedInteractiveExample("pages/js/string-startswith.html")}}</div> + +<h2 id="Sintaxis">Sintaxis</h2> + +<pre class="syntaxbox notranslate"><var>str</var>.startsWith(<var>stringBuscada</var>[, <var>posicion</var>])</pre> + +<h3 id="Parámetros">Parámetros</h3> + +<dl> + <dt><code><var>stringBuscada</var></code></dt> + <dd>Los caracteres a ser buscados al inicio de la cadena de texto.</dd> + <dt><code><var>posicion</var></code> {{optional_inline}}</dt> + <dd>La posición de <code><em>str</em></code> en la cual debe comenzar la búsqueda de <code>stringBuscada</code>. El valor por defecto es <code>0</code>.</dd> +</dl> + +<h3 id="Valor_devuelto">Valor devuelto</h3> + +<p><strong><code>true</code></strong> si los caracteres dados se encuentran al inicio de la cadena de texto; <strong><code>false</code></strong> en cualquier otro caso.</p> + +<h2 id="Descripción">Descripción</h2> + +<p>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.</p> + +<h2 id="Polyfill">Polyfill</h2> + +<p>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 <em>polyfill</em> de <code>String.prototype.startsWith()</code> con el siguiente fragmento de código:</p> + +<pre class="brush: js notranslate">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; + } + }); +} +</pre> + +<p>Un <em>polyfill</em> más robusto (totalmente compatible con la especificación ES2015), pero con menos rendimiento y menos compacto está disponible <a href="https://github.com/mathiasbynens/String.prototype.startsWith">en GitHub, por Mathias Bynens</a>.</p> + +<h2 id="Ejemplos">Ejemplos</h2> + +<h3 id="Usando_startsWith">Usando <code>startsWith()</code></h3> + +<pre class="brush: js notranslate">//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 +</pre> + +<h2 id="Especificaciones">Especificaciones</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Especificación</th> + </tr> + </thead> + <tbody> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.startswith', 'String.prototype.startsWith')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidad_en_navegadores">Compatibilidad en navegadores</h2> + +<p>{{Compat("javascript.builtins.String.startsWith")}}</p> + +<h2 id="Ver_también">Ver también</h2> + +<ul> + <li>{{jsxref("String.prototype.endsWith()")}}</li> + <li>{{jsxref("String.prototype.includes()")}}</li> + <li>{{jsxref("String.prototype.indexOf()")}}</li> + <li>{{jsxref("String.prototype.lastIndexOf()")}}</li> +</ul> diff --git a/files/es/web/javascript/referencia/objetos_globales/string/strike/index.html b/files/es/web/javascript/referencia/objetos_globales/string/strike/index.html new file mode 100644 index 0000000000..20ba5e9c90 --- /dev/null +++ b/files/es/web/javascript/referencia/objetos_globales/string/strike/index.html @@ -0,0 +1,42 @@ +--- +title: String.prototype.strike() +slug: Web/JavaScript/Referencia/Objetos_globales/String/strike +tags: + - Deprecated + - HTML wrapper methods + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/strike +--- +<p>{{JSRef("Objetos_globales", "String")}}</p> +<p>{{deprecated_header}}</p> +<h2 id="Resumen" name="Resumen">Resumen</h2> +<p>Causa que una cadena se muestre como texto tachado, como si estuviese dentro de una etiqueta {{HTMLElement("strike")}}.</p> +<h2 id="Sintaxis" name="Sintaxis">Sintaxis</h2> +<pre class="syntaxbox"><em>cadena</em>.strike()</pre> +<h2 id="Descripci.C3.B3n" name="Descripci.C3.B3n">Descripción</h2> +<p>Usa el método <code>strike</code> para formatear y mostrar una cadena en un documento.</p> +<h2 id="Ejemplos" name="Ejemplos">Ejemplos</h2> +<h3 id="Ejemplo:_Usando_m.C3.A9todos_de_string_para_cambiar_el_formateado_de_una_cadena" name="Ejemplo:_Usando_m.C3.A9todos_de_string_para_cambiar_el_formateado_de_una_cadena">Ejemplo: Usando métodos de <code>string</code> para cambiar el formateado de una cadena</h3> +<p>El siguiente ejemplo usa los métodos de <code>string</code> para cambiar el formateado de una cadena:</p> +<pre class="brush: js">var cadenaMundo="¡Hola mundo!" + +console.log(cadenaMundo.blink()) +console.log(cadenaMundo.bold()) +console.log(cadenaMundo.italics()) +console.log(cadenaMundo.strike()) +</pre> +<p>Este ejemplo produce el mismo resultado que el siguiente código HTML:</p> +<pre class="brush: html"><blink>¡Hola mundo!</blink> +<b>¡Hola mundo!</b> +<i>¡Hola mundo!</i> +<strike>¡Hola mundo!</strike> +</pre> +<h2 id="Vea_Tambi.C3.A9n" name="Vea_Tambi.C3.A9n">Vea También</h2> +<ul> + <li>{{jsxref("String.prototype.blink()")}}</li> + <li>{{jsxref("String.prototype.bold()")}}</li> + <li>{{jsxref("String.prototype.italics()")}}</li> +</ul> diff --git a/files/es/web/javascript/referencia/objetos_globales/string/sub/index.html b/files/es/web/javascript/referencia/objetos_globales/string/sub/index.html new file mode 100644 index 0000000000..195bca9d1e --- /dev/null +++ b/files/es/web/javascript/referencia/objetos_globales/string/sub/index.html @@ -0,0 +1,35 @@ +--- +title: String.prototype.sub() +slug: Web/JavaScript/Referencia/Objetos_globales/String/sub +tags: + - HTML wrapper methods + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/sub +--- +<p>{{JSRef("Objetos_globales", "String")}}</p> +<h2 id="Resumen" name="Resumen">Resumen</h2> +<p>Causa que una cadena se muestre como subíndice, como si estuviese dentro de una etiqueta {{HTMLElement("sub")}}.</p> +<h2 id="Sintaxis" name="Sintaxis">Sintaxis</h2> +<pre class="syntaxbox"><em>cadena</em>.sub()</pre> +<h2 id="Descripci.C3.B3n" name="Descripci.C3.B3n">Descripción</h2> +<p>Usa el método <code>sub</code> junto para formatear y mostrar una cadena en un documento.</p> +<h2 id="Ejemplos" name="Ejemplos">Ejemplos</h2> +<h3 id="Ejemplo:_Usando_los_m.C3.A9todos_sub_y_sup_para_formatear_una_cadena" name="Ejemplo:_Usando_los_m.C3.A9todos_sub_y_sup_para_formatear_una_cadena">Ejemplo: Usando los métodos <code>sub</code> y <code>sup</code> para formatear una cadena</h3> +<p>El siguiente ejemplo usa los métodos <code>sub</code> y <code>sup</code> para formatear una cadena:</p> +<pre class="brush: 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.") +</pre> +<p>Este ejemplo produce el mismo resultado que el siguiente código HTML:</p> +<pre class="brush: html">Esto es lo que <sup>superscript</sup> parece. +Esto es lo que <sub>subscript</sub> parece. +</pre> +<h3 id="Vea_Tambi.C3.A9n" name="Vea_Tambi.C3.A9n">Vea También</h3> +<ul> + <li>{{jsxref("String.prototype.sup()")}}</li> +</ul> diff --git a/files/es/web/javascript/referencia/objetos_globales/string/substr/index.html b/files/es/web/javascript/referencia/objetos_globales/string/substr/index.html new file mode 100644 index 0000000000..290d1292ab --- /dev/null +++ b/files/es/web/javascript/referencia/objetos_globales/string/substr/index.html @@ -0,0 +1,83 @@ +--- +title: String.prototype.substr() +slug: Web/JavaScript/Referencia/Objetos_globales/String/substr +tags: + - JavaScript + - Método(2) + - Prototipo + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/substr +--- +<p>{{JSRef("Objetos_globales", "String")}}</p> + +<div class="warning">Advertencia: Aunque <code>String.prototype.substr(…) </code><span style="font-size: 1.125rem;">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:</span> + +<blockquote>... 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.</blockquote> +</div> + +<p> </p> + +<h2 id="Resumen" name="Resumen">Resumen</h2> + +<p>El método <strong><code>substr()</code></strong> devuelve los caracteres de una cadena que comienzan en una localización especificada y de acuerdo al número de caracteres que se especifiquen.</p> + +<h2 id="Sintaxis" name="Sintaxis">Sintaxis</h2> + +<pre class="syntaxbox"><em>cadena</em>.substr(<em>inicio</em>[, <em>longitud</em>])</pre> + +<h3 id="Par.C3.A1metros" name="Par.C3.A1metros">Parámetros</h3> + +<dl> + <dt><code>inicio</code></dt> + <dd>Localización en la cual se empiezan a extraer caracteres. Si se da un número negativo, se trata como <code>longCad + inicio</code> donde <code>longCad</code> es la longitud de la cadena (por ejemplo, si <code>inicio</code> es -3 se trata como <code>longCad - 3</code>).</dd> +</dl> + +<dl> + <dt><code>longitud</code></dt> + <dd>Opcional. El número de caracteres a extraer. Si este argumento es {{jsxref("undefined")}}, todos los caracteres desde <code><em>inicio</em></code> hasta el final de la cadena serán extraidos.</dd> +</dl> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>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.</p> + +<h2 id="Descripci.C3.B3n" name="Descripci.C3.B3n">Descripción</h2> + +<p><code>inicio</code> 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. <code>substr</code> comienza extrayendo caracteres a partir de <code>inicio</code> y recolecta <code>longitud</code> caracteres (a menos que se alcance primero el final de la cadena, en cuyo caso devuelve menos).</p> + +<p>Si <code>inicio</code> es positivo y es mayor o igual que la longitud de la cadena, <code>substr()</code> devuelve una cadena vacía.</p> + +<p>Si <code>inicio</code> es negativo, <code>substr()</code> lo usa como un índice de carácter desde el final de la cadena. Si <code>inicio</code> es negativo y <code>abs(inicio)</code> es mayor que la longitud de la cadena, <code>substr</code> usa 0 como índice inical. Nota: el uso descrito de valores negativos del argumento <code>inicio</code> no es soportado por Microsoft JScript <a class="external" href="http://msdn2.microsoft.com/en-us/library/0esxc5wy.aspx">. </a></p> + +<p>Si <code>longitud</code> es 0 o negativa, <code>substr</code> devuelve una cadena vacía. Si se omite <code>longitud</code>, <code>inicio</code> extrae caracteres hasta el final de la cadena.</p> + +<h2 id="Ejemplos" name="Ejemplos">Ejemplos</h2> + +<h3 id="Ejemplo:_Usando_substr" name="Ejemplo:_Usando_substr">Ejemplo: Uso de <code>substr()</code></h3> + +<pre class="brush: js">var cadena = "abcdefghij"; + +console.log("(1,2): " + cadena.substr(1,2)); <code>// '(1, 2): bc'</code> +console.log("(-3,2): " + cadena.substr(-3,2)); <code>// '(-3, 2): hi'</code> +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): ' +</pre> + +<p>Este script muestra:</p> + +<pre class="eval">(1,2): bc +(-3,2): hi +(-3): hij +(1): bcdefghij +(-20, 2): ab +(20, 2): +</pre> + +<h2 id="Vea_Tambi.C3.A9n" name="Vea_Tambi.C3.A9n">Vea También</h2> + +<ul> + <li>{{jsxref("String.prototype.slice()")}}</li> + <li>{{jsxref("String.prototype.substring()")}}</li> +</ul> diff --git a/files/es/web/javascript/referencia/objetos_globales/string/substring/index.html b/files/es/web/javascript/referencia/objetos_globales/string/substring/index.html new file mode 100644 index 0000000000..9918417f95 --- /dev/null +++ b/files/es/web/javascript/referencia/objetos_globales/string/substring/index.html @@ -0,0 +1,92 @@ +--- +title: String.prototype.substring() +slug: Web/JavaScript/Referencia/Objetos_globales/String/substring +tags: + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/substring +--- +<p>{{JSRef("Objetos_globales", "String")}}</p> + +<h2 id="Resumen" name="Resumen">Resumen</h2> + +<p>El <strong><code>substring()</code></strong> método devuelve un subconjunto de un objeto <code>String</code>.</p> + +<h2 id="Sintaxis" name="Sintaxis">Sintaxis</h2> + +<pre class="syntaxbox"><em>cadena</em>.substring(<em>indiceA</em>[, <em>indiceB</em>'])</pre> + +<h3 id="Par.C3.A1metros" name="Par.C3.A1metros">Parámetros</h3> + +<dl> + <dt><code>indiceA</code></dt> + <dd>Un entero entre 0 y la longitud de la cadena menos 1.</dd> + <dt><code>indiceB</code></dt> + <dd>(opcional) Un entero entre 0 y la longitud de la cadena.</dd> +</dl> + +<h2 id="Descripci.C3.B3n" name="Descripci.C3.B3n">Descripción</h2> + +<p><code>substring</code> extrae caracteres desde <code>indiceA</code> hasta <code>indiceB</code> sin incluirlo. En particular:</p> + +<ul> + <li>Si <code>indiceA</code> es igual a <code>indiceB</code>, <code>substring</code> devuelve una cadena vacía.</li> + <li>Si se omite el <code>indiceB</code>, <code>substring</code> extrae caracteres hasta el final de la cadena.</li> + <li>Si el argumento es menor que 0 o es <code>NaN</code>, se trata como si fuese 0.</li> + <li>Si el argumento es mayor que <code>nombreCadena.length</code>, se trata como si fuese <code>nombreCadena.length</code>.</li> +</ul> + +<p>Si <code>indiceA</code> es mayor que <code>indiceB</code>, entonces el efecto de <code>substring</code> es como si los dos argumentos se intercambiasen; por ejemplo, <code><em>cadena</em>.substring(1, 0) == <em>cadena</em>.substring(0, 1)</code>.</p> + +<h2 id="Ejemplos" name="Ejemplos">Ejemplos</h2> + +<h3 id="Ejemplo:_Usando_substring" name="Ejemplo:_Usando_substring">Ejemplo: Usando <code>substring</code></h3> + +<p>El siguiente ejemplo usa <code>substring</code> para mostrar caracteres de la cadena "<code>Mozilla</code>":</p> + +<pre class="brush: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)); +</pre> + +<h3 id="Ejemplo:_Reemplazar_una_subcadena_dentro_de_una_cadena" name="Ejemplo:_Reemplazar_una_subcadena_dentro_de_una_cadena">Ejemplo: Reemplazar una subcadena dentro de una cadena</h3> + +<p>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 "<code>Bravo Nuevo Mundo</code>" por "<code>Bravo Nueva Web</code>".</p> + +<pre class="brush: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"); +</pre> + +<h2 id="Vea_Tambi.C3.A9n" name="Vea_Tambi.C3.A9n">Vea También</h2> + +<ul> + <li>{{jsxref("String.prototype.substr()")}}</li> + <li>{{jsxref("String.prototype.slice()")}}</li> +</ul> diff --git a/files/es/web/javascript/referencia/objetos_globales/string/sup/index.html b/files/es/web/javascript/referencia/objetos_globales/string/sup/index.html new file mode 100644 index 0000000000..6b8db218b6 --- /dev/null +++ b/files/es/web/javascript/referencia/objetos_globales/string/sup/index.html @@ -0,0 +1,35 @@ +--- +title: String.prototype.sup() +slug: Web/JavaScript/Referencia/Objetos_globales/String/sup +tags: + - HTML wrapper methods + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/sup +--- +<p>{{JSRef("Objetos_globales", "String")}}</p> +<h2 id="Resumen" name="Resumen">Resumen</h2> +<p>Causa que una cadena se muestre como superíndice, como si estuviese dentro de una etiqueta {{HTMLElement("sup")}}.</p> +<h2 id="Sintaxis" name="Sintaxis">Sintaxis</h2> +<pre class="syntaxbox"><em>cadena</em>.sup()</pre> +<h2 id="Descripci.C3.B3n" name="Descripci.C3.B3n">Descripción</h2> +<p>Usa el método <code>sup</code> junto para formatear y mostrar una cadena en un documento.</p> +<h2 id="Ejemplos" name="Ejemplos">Ejemplos</h2> +<h3 id="Ejemplo:_Usando_los_m.C3.A9todos_sub_y_sup_para_formatear_una_cadena" name="Ejemplo:_Usando_los_m.C3.A9todos_sub_y_sup_para_formatear_una_cadena">Ejemplo: Usando los métodos <code>sub</code> y <code>sup</code> para formatear una cadena</h3> +<p>El siguiente ejemplo usa los métodos <code>sub</code> y <code>sup</code> para formatear una cadena:</p> +<pre class="brush: 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.") +</pre> +<p>Este ejemplo produce el mismo resultado que el siguiente código HTML:</p> +<pre class="brush: html">Esto es lo que <sup>superscript</sup> parece. +Esto es lo que <sub>subscript</sub> parece. +</pre> +<h3 id="Vea_Tambi.C3.A9n" name="Vea_Tambi.C3.A9n">Vea También</h3> +<ul> + <li>{{jsxref("String.prototype.sub()")}}</li> +</ul> diff --git a/files/es/web/javascript/referencia/objetos_globales/string/tolocalelowercase/index.html b/files/es/web/javascript/referencia/objetos_globales/string/tolocalelowercase/index.html new file mode 100644 index 0000000000..5c1eae2144 --- /dev/null +++ b/files/es/web/javascript/referencia/objetos_globales/string/tolocalelowercase/index.html @@ -0,0 +1,113 @@ +--- +title: String.prototype.toLocaleLowerCase() +slug: Web/JavaScript/Referencia/Objetos_globales/String/toLocaleLowerCase +tags: + - Cadena + - Internacionalizacion + - Prototipo + - Referencia + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase +--- +<div>{{JSRef}}</div> + +<div>El método <strong><code>toLocaleLowerCase()</code> </strong>retorna la cadena de texto desde la que se llama convertida en minúsculas, de acuerdo con cualquier localización específica de correspondencia de mayúsculas y minúsculas.</div> + +<div> </div> + +<div>{{EmbedInteractiveExample("pages/js/string-tolocalelowercase.html")}}</div> + +<p class="hidden">Los fuentes para este ejemplo interactivo están almacenados en un repositorio GitHub. Si quieres contribuir en el proyecto de ejemplos interactivos, por favor clona https://github.com/mdn/interactive-examples y envíanos un pull request.</p> + +<h2 id="Sintaxis">Sintaxis</h2> + +<pre class="syntaxbox"><var>str</var>.toLocaleLowerCase() +<var>str</var>.toLocaleLowerCase(locale) +<var>str</var>.toLocaleLowerCase([locale, locale, ...]) +</pre> + +<h3 id="Parámetros">Parámetros</h3> + +<dl> + <dt><code>locale</code> {{optional_inline}}</dt> + <dd>El parámetro <code>locale</code> indica la localización que se utilizará para convertir a minúsculas de acuerdo con culalquier correspondencia de mayúsculas y minúsculas. Si se proporcionan múltiples locales en un {{jsxref("Array")}}, se utiliza <a href="https://tc39.github.io/ecma402/#sec-bestavailablelocale">el mejor local disponible</a>. La localización por defecto es la localización actual configurada en el <em>host</em>.</dd> +</dl> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>Una nueva cadena que representa la cadena desde la que se llama convertida a minúsculas, de acuerdo con cualquier localización específica de correspondencia de mayúsculas y minúsculas.</p> + +<h3 id="Excepciones">Excepciones</h3> + +<ul> + <li>Una excepción de tipo {{jsxref("RangeError")}} ("invalid language tag: xx_yy") se lanzará si el argumento <code>locale</code> no es una etiqueta válida de lenguaje.</li> + <li>Una excepción de tipo {{jsxref("TypeError")}} ("invalid element in locales argument") se lanzará si un elemento del arreglo no es del tipo cadena.</li> +</ul> + +<h2 id="Descripción">Descripción</h2> + +<p>El método <code>toLocaleLowerCase()</code><strong> </strong>retorna la cadena de texto desde la que se llama convertida en minúsculas, de acuerdo con cualquier localización específica de correspondencia de mayúsculas y minúsculas. <code>toLocaleLowerCase()</code> no afecta el valor de la cadena desde la que se llama. En la mayoría de los casos, producirá el mismo resultado que {{jsxref("String.prototype.toLowerCase()", "toLowerCase()")}}, pero para algunos locales, como el turco, cuyas correspondencias de mayúsculas y minúsculas no siguen las correpsondencias por defecto de Unicode, podría producir de un resultado diferente.</p> + +<h2 id="Ejemplos">Ejemplos</h2> + +<h3 id="Utilizando_toLocaleLowerCase()">Utilizando <code>toLocaleLowerCase()</code></h3> + +<pre class="brush: js">'ALPHABET'.toLocaleLowerCase(); // 'alphabet' + +'\u0130'.toLocaleLowerCase('tr') === 'i'; // true +'\u0130'.toLocaleLowerCase('en-US') === 'i'; // false + +let locales = ['tr', 'TR', 'tr-TR', 'tr-u-co-search', 'tr-x-turkish']; +'\u0130'.toLocaleLowerCase(locales) === 'i'; // true +</pre> + +<h2 id="Especificaciones">Especificaciones</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificación</th> + <th scope="col">Estatus</th> + <th scope="col">Comentario</th> + </tr> + <tr> + <td>{{SpecName('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Initial definition. Implemented in JavaScript 1.2.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.17', 'String.prototype.toLocaleLowerCase')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.tolocalelowercase', 'String.prototype.toLocaleLowerCase')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.tolocalelowercase', 'String.prototype.toLocaleLowerCase')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES Int Draft', '#sup-string.prototype.tolocalelowercase', 'String.prototype.toLocaleLowerCase')}}</td> + <td>{{Spec2('ES Int Draft')}}</td> + <td>ES Intl 2017 added the <code>locale</code> parameter.</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidad_entre_navegadores">Compatibilidad entre navegadores</h2> + +<p class="hidden">La tabla de compatibilidad en esta pádina se gnera desde datos estructurados. Si quieres contribuir a estos datos, por favor obtén <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> y envíanos una pull request.</p> + +<p>{{Compat("javascript.builtins.String.toLocaleLowerCase")}}</p> + +<h2 id="Vea_también">Vea también</h2> + +<ul> + <li>{{jsxref("String.prototype.toLocaleUpperCase()")}}</li> + <li>{{jsxref("String.prototype.toLowerCase()")}}</li> + <li>{{jsxref("String.prototype.toUpperCase()")}}</li> +</ul> diff --git a/files/es/web/javascript/referencia/objetos_globales/string/tolocaleuppercase/index.html b/files/es/web/javascript/referencia/objetos_globales/string/tolocaleuppercase/index.html new file mode 100644 index 0000000000..7199ca3ae5 --- /dev/null +++ b/files/es/web/javascript/referencia/objetos_globales/string/tolocaleuppercase/index.html @@ -0,0 +1,100 @@ +--- +title: String.prototype.toLocaleUpperCase() +slug: Web/JavaScript/Referencia/Objetos_globales/String/toLocaleUpperCase +translation_of: Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase +--- +<div>{{JSRef}}</div> + +<p>El método <strong><code>toLocaleUpperCase()</code></strong> 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.</p> + +<h2 id="Syntaxis">Syntaxis</h2> + +<pre class="syntaxbox"><var>str</var>.toLocaleUpperCase() +<var>str</var>.toLocaleUpperCase(locale) +<var>str</var>.toLocaleUpperCase([locale, locale, ...]) +</pre> + +<h3 id="Parámetros">Parámetros</h3> + +<dl> + <dt><code>locale</code> {{optional_inline}}</dt> + <dd>El parámetro <code>locale</code> 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.</dd> +</dl> + +<h3 id="Valor_de_retorno">Valor de retorno</h3> + +<p>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.</p> + +<h3 id="Exceciones">Exceciones</h3> + +<ul> + <li>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.</li> + <li>Un {{jsxref("TypeError")}} ("invalid element in locales argument") se lanzará si un elemento de matriz no es de tipo cadena.</li> +</ul> + +<h2 id="Descripción">Descripción</h2> + +<p>El método <code>toLocaleUpperCase()</code> devuelve el valor de la cadena convertida en mayúsculas según las asignaciones de casos específicos de la configuración regional. <code>toLocaleUpperCase()</code> 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.</p> + +<h2 id="Ejemplos">Ejemplos</h2> + +<h3 id="Usando_toLocaleUpperCase()">Usando <code>toLocaleUpperCase()</code></h3> + +<pre class="brush: 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' +</pre> + +<h2 id="Especificaciones">Especificaciones</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificación</th> + <th scope="col">Status</th> + <th scope="col">Comentario</th> + </tr> + <tr> + <td>{{SpecName('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Initial definition. Implemented in JavaScript 1.2.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.19', 'String.prototype.toLocaleUpperCase')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.tolocaleuppercase', 'String.prototype.toLocaleUpperCase')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.tolocaleuppercase', 'String.prototype.toLocaleUpperCase')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES Int Draft', '#sup-string.prototype.tolocaleuppercase', 'String.prototype.toLocaleUpperCase')}}</td> + <td>{{Spec2('ES Int Draft')}}</td> + <td>ES Intl 2017 added the <code>locale</code> parameter.</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidad_de_navegadores">Compatibilidad de navegadores</h2> + +<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> + +<p>{{Compat("javascript.builtins.String.toLocaleUpperCase")}}</p> + +<h2 id="Ver_también">Ver también</h2> + +<ul> + <li>{{jsxref("String.prototype.toLocaleLowerCase()")}}</li> + <li>{{jsxref("String.prototype.toLowerCase()")}}</li> + <li>{{jsxref("String.prototype.toUpperCase()")}}</li> +</ul> diff --git a/files/es/web/javascript/referencia/objetos_globales/string/tolowercase/index.html b/files/es/web/javascript/referencia/objetos_globales/string/tolowercase/index.html new file mode 100644 index 0000000000..8060f3dd1c --- /dev/null +++ b/files/es/web/javascript/referencia/objetos_globales/string/tolowercase/index.html @@ -0,0 +1,40 @@ +--- +title: String.prototype.toLowerCase() +slug: Web/JavaScript/Referencia/Objetos_globales/String/toLowerCase +tags: + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/toLowerCase +--- +<p>{{JSRef("Objetos_globales", "String")}}</p> + +<h2 id="Resumen" name="Resumen">Resumen</h2> + +<p>El método <strong><code>toLowerCase()</code></strong> devuelve el valor <strong>en minúsculas </strong>de la cadena que realiza la llamada.</p> + +<h2 id="Sintaxis" name="Sintaxis">Sintaxis</h2> + +<pre><code><em>cadena</em>.toLowerCase() </code></pre> + +<h2 id="Descripci.C3.B3n" name="Descripci.C3.B3n">Descripción</h2> + +<p>El método <code>toLowerCase</code> devuelve el valor de la cadena convertida a minúsculas. <code>toLowerCase</code> no afecta al valor de la cadena en sí misma.</p> + +<h2 id="Ejemplos" name="Ejemplos">Ejemplos</h2> + +<h3 id="Ejemplo:_Usando_toLowerCase" name="Ejemplo:_Usando_toLowerCase">Ejemplo: Usando <code>toLowerCase</code></h3> + +<p>El siguiente ejemplo muestra la cadena "alfabeto" en minúsculas:</p> + +<pre>var textoMayusculas="ALFABETO" +document.write(textoMayusculas.toLowerCase()) +</pre> + +<h2 id="Vea_Tambi.C3.A9n" name="Vea_Tambi.C3.A9n">Vea También</h2> + +<ul> + <li>{{jsxref("String.prototype.toLocaleLowerCase()")}}</li> + <li>{{jsxref("String.prototype.toUpperCase()")}}</li> +</ul> diff --git a/files/es/web/javascript/referencia/objetos_globales/string/tosource/index.html b/files/es/web/javascript/referencia/objetos_globales/string/tosource/index.html new file mode 100644 index 0000000000..104738c22d --- /dev/null +++ b/files/es/web/javascript/referencia/objetos_globales/string/tosource/index.html @@ -0,0 +1,56 @@ +--- +title: String.prototype.toSource() +slug: Web/JavaScript/Referencia/Objetos_globales/String/toSource +tags: + - Cadena + - JavaScript + - No estandar + - Prototipo + - Referencia + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/String/toSource +--- +<div>{{JSRef}} {{non-standard_header}}</div> + +<p>El método <strong><code>toSource()</code></strong> devuelve una cadena que representa el código fuente del objeto.</p> + +<h2 id="Sintaxis">Sintaxis</h2> + +<pre class="syntaxbox"><code>String.toSource() +<var>str</var>.toSource() +</code></pre> + +<h3 id="Valor_devuelto">Valor devuelto</h3> + +<p>Una cadena que representa el código fuente del objeto.</p> + +<h2 id="Descripción">Descripción</h2> + +<p>El método <code>toSource()</code> devuelve los siguientes valores:</p> + +<p>Para el objeto incorporado {{jsxref("String")}}, <code>toSource()</code> devuelve la siguiente cadena indicando que el código fuente no está disponible:</p> + +<pre class="brush: js">function String() { + [native code] +} +</pre> + +<p>Para instancias de {{jsxref("String")}} o cadenas literales, <code>toSource()</code> devuelve una cadena representando el código fuente.</p> + +<p>Este método usualmente es llamado internamente por JavaScript y no explícitamente en código.</p> + +<h2 id="Especificaciones">Especificaciones</h2> + +<p>No es parte de ningún estándar. Implementado en JavaScript 1.3.</p> + +<h2 id="Compatibilidad_entre_navegadores">Compatibilidad entre navegadores</h2> + +<p class="hidden">La tabla de compatibilidad en esta página es generada desde datos estructurados. Si deseas contribuir a los datos, por favor visita <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> y envianos un pull request.</p> + +<p>{{Compat("javascript.builtins.String.toSource")}}</p> + +<h2 id="Véase_también">Véase también</h2> + +<ul> + <li>{{jsxref("Object.prototype.toSource()")}}</li> +</ul> diff --git a/files/es/web/javascript/referencia/objetos_globales/string/tostring/index.html b/files/es/web/javascript/referencia/objetos_globales/string/tostring/index.html new file mode 100644 index 0000000000..89f53666b1 --- /dev/null +++ b/files/es/web/javascript/referencia/objetos_globales/string/tostring/index.html @@ -0,0 +1,28 @@ +--- +title: String.prototype.toString() +slug: Web/JavaScript/Referencia/Objetos_globales/String/toString +tags: + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/toString +--- +<p>{{JSRef("Objetos_globales", "String")}}</p> +<h2 id="Resumen" name="Resumen">Resumen</h2> +<p>El <strong><code>toString()</code></strong> método devuelve una cadena que representa al objeto especificado.</p> +<h2 id="Sintaxis" name="Sintaxis">Sintaxis</h2> +<pre><code><em>cadena</em>.toString() </code></pre> +<h2 id="Descripci.C3.B3n" name="Descripci.C3.B3n">Descripción</h2> +<p>El objeto <code>String</code> sobreescribe el método <code>toString</code> del objeto {{jsxref("Object")}} object; no hereda {{jsxref("Object.toString()")}}. Para objetos <code>String</code>, el método <code>toString</code> devuelve una cadena que representa al objeto.</p> +<h2 id="Ejemplos" name="Ejemplos">Ejemplos</h2> +<h3 id="Ejemplo:_Usando_toString" name="Ejemplo:_Usando_toString">Ejemplo: Usando <code>toString</code></h3> +<p>El siguiente ejemplo muestra el valor cadena de un objeto String:</p> +<pre class="brush: js">cadena = new String("Hello world"); +alert(cadena.toString()) // Displays "Hello world" +</pre> +<h2 id="Vea_Tambi.C3.A9n" name="Vea_Tambi.C3.A9n">Vea También</h2> +<ul> + <li>{{jsxref("Object.prototype.toSource()")}}</li> + <li>{{jsxref("String.prototype.valueOf()")}}</li> +</ul> diff --git a/files/es/web/javascript/referencia/objetos_globales/string/touppercase/index.html b/files/es/web/javascript/referencia/objetos_globales/string/touppercase/index.html new file mode 100644 index 0000000000..77b05b28b4 --- /dev/null +++ b/files/es/web/javascript/referencia/objetos_globales/string/touppercase/index.html @@ -0,0 +1,39 @@ +--- +title: String.prototype.toUpperCase() +slug: Web/JavaScript/Referencia/Objetos_globales/String/toUpperCase +tags: + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/toUpperCase +--- +<p>{{JSRef("Objetos_globales", "String")}}</p> + +<h2 id="Resumen" name="Resumen">Resumen</h2> + +<p>El <strong><code>toUpperCase()</code></strong> método devuelve el valor convertido en mayúsculas de la cadena que realiza la llamada.</p> + +<h2 id="Sintaxis" name="Sintaxis">Sintaxis</h2> + +<pre><code><em>cadena</em>.toUpperCase() </code></pre> + +<h2 id="Descripci.C3.B3n" name="Descripci.C3.B3n">Descripción</h2> + +<p>El método <code>toUpperCase</code> devuelve el valor de la cadena convertida a mayúsculas. <code>toUpperCase</code> no afecta al valor de la cadena en sí mismo.</p> + +<h2 id="Ejemplos" name="Ejemplos">Ejemplos</h2> + +<h3 id="Ejemplo:_Usando_toUpperCase" name="Ejemplo:_Usando_toUpperCase">Ejemplo: Usando <code>toUpperCase</code></h3> + +<p>El siguiente ejemplo muestra la cadena "<code>ALPHABET</code>":</p> + +<pre class="brush: js">console.log( "alphabet".toUpperCase() ); // "ALPHABET" +</pre> + +<h3 id="Vea_Tambi.C3.A9n" name="Vea_Tambi.C3.A9n">Vea También</h3> + +<ul> + <li>{{jsxref("String.prototype.toLocaleUpperCase()")}}</li> + <li>{{jsxref("String.prototype.toLowerCase()")}}</li> +</ul> diff --git a/files/es/web/javascript/referencia/objetos_globales/string/trim/index.html b/files/es/web/javascript/referencia/objetos_globales/string/trim/index.html new file mode 100644 index 0000000000..d958d713eb --- /dev/null +++ b/files/es/web/javascript/referencia/objetos_globales/string/trim/index.html @@ -0,0 +1,133 @@ +--- +title: String.prototype.trim() +slug: Web/JavaScript/Referencia/Objetos_globales/String/Trim +translation_of: Web/JavaScript/Reference/Global_Objects/String/Trim +--- +<div>{{JSRef("Global_Objects", "String")}}</div> + +<h2 id="Summary" name="Summary">Resumen</h2> + +<p>El método <strong>trim( )</strong> 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.).</p> + +<h2 id="Syntax" name="Syntax">Sintaxis</h2> + +<pre class="syntaxbox"><code><var>str</var>.trim()</code></pre> + +<p>Una nueva cadena que representa la cadena de llamada sin espacios en blanco de ambos extremos.</p> + +<h2 id="Description" name="Description">Descripción</h2> + +<p>El método <strong>trim( ) </strong>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.</p> + +<h2 id="Examples" name="Examples">Ejemplos</h2> + +<h3 id="Example:_Using_trim" name="Example:_Using_trim">Ejemplo: Uso de <code>trim()</code></h3> + +<p>El siguiente ejemplo muestra la cadena de texto en minúsculas 'foo':</p> + +<pre class="brush: 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' +</pre> + +<h2 id="Polyfill" name="Polyfill">Polyfill</h2> + +<p>Ejecutar el siguiente código antes de cualquier otro código creará un trim ( ) si este no está disponible de manera nativa.</p> + +<pre class="brush: 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, ''); + }; + })(); +} +</pre> + +<h2 id="Especificaciones">Especificaciones</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificación</th> + <th scope="col">Estatus</th> + <th scope="col">Comentario</th> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.20', 'String.prototype.trim')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> + <p>Definición inicial. Implementado en JavaScript 1.8.1.</p> + </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.trim', 'String.prototype.trim')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidad_en_Navegadores">Compatibilidad en Navegadores</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Soporte Básico</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoDesktop("1.9.1")}}</td> + <td>{{CompatIE("9")}}</td> + <td>{{CompatOpera("10.5")}}</td> + <td>{{CompatSafari("5")}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Soporte Básico</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Ver también</h2> + +<ul> + <li>{{jsxref("String.prototype.trimLeft()")}} {{non-standard_inline}}</li> + <li>{{jsxref("String.prototype.trimRight()")}} {{non-standard_inline}}</li> +</ul> diff --git a/files/es/web/javascript/referencia/objetos_globales/string/trimend/index.html b/files/es/web/javascript/referencia/objetos_globales/string/trimend/index.html new file mode 100644 index 0000000000..6252141adf --- /dev/null +++ b/files/es/web/javascript/referencia/objetos_globales/string/trimend/index.html @@ -0,0 +1,82 @@ +--- +title: String.prototype.trimEnd() +slug: Web/JavaScript/Referencia/Objetos_globales/String/trimEnd +tags: + - Espacios en blanco + - JavaScript + - Métodos + - Prototype + - String + - Texto + - cadenas de texto +translation_of: Web/JavaScript/Reference/Global_Objects/String/trimEnd +--- +<div>{{JSRef}}</div> + +<p>El método <strong><code>trimEnd()</code></strong> elimina los espacios en blanco al final de una cadena de carácteres. <code>trimRight()</code> es el alias de este método.</p> + +<div>{{EmbedInteractiveExample("pages/js/string-trimend.html")}}</div> + + + +<h2 id="Sintaxis">Sintaxis</h2> + +<pre class="syntaxbox notranslate"><code><var>str</var>.trimEnd(); +<var>str</var>.trimRight();</code></pre> + +<h3 id="Valor_de_retorno">Valor de retorno</h3> + +<p>Una nueva cadena de texto que representa la cadena de texto llamada sin espacios en blanco de su extremo (derecho).</p> + +<h2 id="Descripción">Descripción</h2> + +<p><code>trimEnd()</code> / <code>trimRight()</code> Los metodos devuelven una cadena de texto sin espacios en blanco desde su extremo derecho. <code>trimEnd()</code> ó <code>trimRight()</code> no afectan el valor de la cadena de texto en sí.</p> + +<h3 id="Superposición">Superposición</h3> + +<p>Por coherencia de funciones como {{jsxref("String.prototype.padEnd")}} el nombre del método estandar es <code>trimEnd</code>. Sin embargo por compatibilidad web, <code>trimRight</code> permanece como un alias para <code>trimEnd</code>. En algunos motores esto significa: </p> + +<pre class="brush: js notranslate">String.prototype.trimRight.name === "trimEnd";</pre> + +<h2 id="Ejemplo">Ejemplo</h2> + +<h3 id="Usando_trimEnd">Usando <code>trimEnd()</code></h3> + +<p>El siguiente ejemplo muestra la cadena de texto en minusculas <code>' foo'</code>:</p> + +<pre class="brush: js; highlight: [5] notranslate">var str = ' foo '; + +console.log(str.length); // 8 + +str = str.trimEnd(); +console.log(str.length); // 6 +console.log(str); // ' foo' +</pre> + +<h2 id="Especificaciones">Especificaciones</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Especificación</th> + </tr> + </thead> + <tbody> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.trimend', 'String.prototype.trimEnd')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidad_en_Navegadores">Compatibilidad en Navegadores</h2> + +<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> + +<p>{{Compat("javascript.builtins.String.trimEnd")}}</p> + +<h2 id="Ver_también">Ver también</h2> + +<ul> + <li>{{jsxref("String.prototype.trim()")}}</li> + <li>{{jsxref("String.prototype.trimStart()")}}</li> +</ul> diff --git a/files/es/web/javascript/referencia/objetos_globales/string/valueof/index.html b/files/es/web/javascript/referencia/objetos_globales/string/valueof/index.html new file mode 100644 index 0000000000..b287c4d774 --- /dev/null +++ b/files/es/web/javascript/referencia/objetos_globales/string/valueof/index.html @@ -0,0 +1,28 @@ +--- +title: String.prototype.valueOf() +slug: Web/JavaScript/Referencia/Objetos_globales/String/valueOf +tags: + - JavaScript + - Method + - Prototype + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/valueOf +--- +<p>{{JSRef("Objetos_globales", "String")}}</p> +<h2 id="Resumen" name="Resumen">Resumen</h2> +<p>The <strong><code>valueOf()</code></strong> método devuelve el valor primitivo de un objeto String.</p> +<h2 id="Sintaxis" name="Sintaxis">Sintaxis</h2> +<pre><code><em>caneda</em>.valueOf() </code></pre> +<h2 id="Descripci.C3.B3n" name="Descripci.C3.B3n">Descripción</h2> +<p>El método <code>valueOf</code> de <code>String</code> devuelve el valor primitivo de un objeto String como un tipo de dato cadena. Este valor es equivalente a String.toString.</p> +<p>Normalmente este método es llamado internamente por JavaScript y no en el código.</p> +<h2 id="Ejemplos" name="Ejemplos">Ejemplos</h2> +<h3 id="Ejemplo:_Usando_valueOf" name="Ejemplo:_Usando_valueOf">Ejemplo: Usando <code>valueOf</code></h3> +<pre class="brush: js">cadena = new String("Hello world"); +alert(cadena.valueOf()) // Displays "Hello world" +</pre> +<h2 id="Vea_Tambi.C3.A9n" name="Vea_Tambi.C3.A9n">Vea También</h2> +<ul> + <li>{{jsxref("String.prototype.toString()")}}</li> + <li>{{jsxref("Object.prototype.valueOf()")}}</li> +</ul> |