replace

  • Enlace amigable (slug) de la revisión: Referencia_de_JavaScript_1.5/Objetos_globales/String/replace
  • Título de la revisión: replace
  • Id de la revisión: 181346
  • Creada:
  • Creador: Talisker
  • ¿Es la revisión actual? No
  • Comentario /* Descripción */

Contenido de la revisión

Resumen

Halla un emparejamiento entre una expresión regular y una cadena, y reemplaza la subcadena emparejada con una nueva subcadena.

Método de String
Implementado en: JavaScript 1.2

JavaScript 1.3 añade la capacidad de especificar una función como segundo parámetro.

Versión ECMA: ECMA-262

Sintaxis

var nuevaCadena = cadena.replace(expresionregular/subcadena, nuevaSubcadena/funcion[, flags]);

Parámetros

expresionregular 
Un objeto RegExp. El emparejamiento es reemplazado por el valor de devuelto por el segundo parámetro.
subcadena 
Un objeto String que será reemplazado por nuevaSubcadena.
nuevaSubcadena 
El objeto String que reemplaza la subcadena que recibida desde el primer parámetro.
funcion 
Una función que será invocada para crear la nueva subcadena (para ponerla en lugar de la subcadena recibida por el primer parámetro).
flags 
(extensión SpiderMonkey) Un objeto String que contiene cualquier combinación de flags de la clase RegExp: g - emparejamiento global, i - ignorar mayúsculas, m - emparejar multiples líneas. Este parámetro se usa sólo si el primer parámetro es una cadena.

Descripción

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

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

Especificando una cadena como un parámetro

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

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

Especificando una función con un parámetro

When you specify a function as the second parameter, the function is invoked after the match has been performed. (The use of a function in this manner is often called a lambda expression.)

In your function, you can dynamically generate the string that replaces the matched substring. The result of the function call is used as the replacement value.

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

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

Ejemplos

Ejemplo: Using global and ignore with replace

In the following example, the regular expression includes the global and ignore case flags which permits replace to replace each occurrence of 'apples' in the string with 'oranges'.

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

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

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

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

Ejemplo: Defining the regular expression in replace

In the following example, the regular expression is defined in replace and includes the ignore case flag.

var str = "Twas the night before Xmas...";
var newstr = str.replace(/xmas/i, "Christmas");
print(newstr);

This prints "Twas the night before Christmas..."

Ejemplo: Switching words in a string

The following script switches the words in the string. For the replacement text, the script uses the $1 and $2 replacement patterns.

var re = /(\w+)\s(\w+)/;
var str = "John Smith";
var newstr = str.replace(re, "$2, $1");
print(newstr);

This prints "Smith, John".

Ejemplo: Using an inline function that modifies the matched characters

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

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

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

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

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

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

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

Ejemplo: Replacing a Fahrenheit degree with its Celsius equivalent

The following example replaces a Fahrenheit degree with its equivalent Celsius degree. The Fahrenheit degree should be a number ending with F. The function returns the Celsius number ending with C. For example, if the input number is 212F, the function returns 100C. If the number is 0F, the function returns -17.77777777777778C.

The regular expression test checks for any number that ends with F. The number of Fahrenheit degree is accessible to the function through its second parameter, p1. The function sets the Celsius number based on the Fahrenheit degree passed in a string to the f2c function. f2c then returns the Celsius number. This function approximates Perl's s///e flag.

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


{{ wiki.languages( { "en": "en/Core_JavaScript_1.5_Reference/Global_Objects/String/replace", "fr": "fr/R\u00e9f\u00e9rence_de_JavaScript_1.5_Core/Objets_globaux/String/replace", "ja": "ja/Core_JavaScript_1.5_Reference/Global_Objects/String/replace", "pl": "pl/Dokumentacja_j\u0119zyka_JavaScript_1.5/Obiekty/String/replace" } ) }}

Fuente de la revisión

<p>
</p>
<h3 name="Resumen"> Resumen </h3>
<p>Halla un emparejamiento entre una expresión regular y una cadena, y reemplaza la subcadena emparejada con una nueva subcadena.
</p>
<table class="fullwidth-table">
<tbody><tr>
<td class="header" colspan="2">Método de <a href="es/Referencia_de_JavaScript_1.5/Objetos_globales/String">String</a></td>
</tr>
<tr>
<td>Implementado en:</td>
<td>JavaScript 1.2
<p>JavaScript 1.3 añade la capacidad de especificar una función como segundo parámetro.
</p>
</td>
</tr>
<tr>
<td>Versión ECMA:</td>
<td>ECMA-262</td>
</tr>
</tbody></table>
<h3 name="Sintaxis"> Sintaxis </h3>
<pre class="eval">var nuevaCadena = <i>cadena</i>.replace(<i>expresionregular</i>/<i>subcadena</i>, <i>nuevaSubcadena</i>/<i>funcion</i>[, <i>flags</i>]);
</pre>
<h3 name="Par.C3.A1metros"> Parámetros </h3>
<dl><dt> <code>expresionregular</code> </dt><dd> Un objeto <a href="es/Referencia_de_JavaScript_1.5/Objetos_globales/RegExp"> RegExp</a>. El emparejamiento es reemplazado por el valor de devuelto por el segundo parámetro.
</dd></dl>
<dl><dt> <code>subcadena</code> </dt><dd> Un objeto <a href="es/Referencia_de_JavaScript_1.5/Objetos_globales/String"> String</a> que será reemplazado por <code>nuevaSubcadena</code>.
</dd></dl>
<dl><dt> <code>nuevaSubcadena</code> </dt><dd> El objeto <a href="es/Referencia_de_JavaScript_1.5/Objetos_globales/String"> String</a> 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> </dt><dd> <i>(extensión <a href="es/SpiderMonkey">SpiderMonkey</a>)</i> Un objeto <a href="es/Referencia_de_JavaScript_1.5/Objetos_globales/String"> String</a> 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>
<h3 name="Descripci.C3.B3n"> Descripción </h3>
<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 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>$&amp;</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>$<i>n</i></code> o <code>$<i>nn</i></code></td>
<td>Donde <code><i>n</i></code> o <code><i>nn</i></code> son dígitos decimales, inserta la subcadena emparejada de orden <i>n</i> del paréntesis, proporcionado por el primer argumento del objeto <code>RegExp</code>.</td>
</tr>
</tbody></table>
<h4 name="Especificando_una_funci.C3.B3n_con_un_par.C3.A1metro"> Especificando una función con un parámetro </h4>
<p>When you specify a function as the second parameter, the function is invoked after the match has been performed. (The use of a function in this manner is often called a lambda expression.)
</p><p>In your function, you can dynamically generate the string that replaces the matched substring. The result of the function call is used as the replacement value.
</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 <i>n</i> parameters can be used for parenthetical matches, remembered submatch strings, where <i>n</i> 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="eval">function replacer(str, p1, p2, offset, s)
{
  return str + " - " + p1 + " , " + p2;
}
var newString = "XXzzzz".replace(/(X*)(z*)/, replacer);
</pre>
<h3 name="Ejemplos"> Ejemplos </h3>
<h4 name="Ejemplo:_Using_global_and_ignore_with_replace"> Ejemplo: Using <code>global</code> and <code>ignore</code> with <code>replace</code> </h4>
<p>In the following example, the regular expression includes the global and ignore case flags which permits <code>replace</code> to replace each occurrence of 'apples' in the string with '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>
<h4 name="Ejemplo:_Defining_the_regular_expression_in_replace"> Ejemplo: Defining the regular expression in <code>replace</code> </h4>
<p>In the following example, the regular expression is defined in <code>replace</code> and includes the ignore case flag.
</p>
<pre class="eval">var str = "Twas the night before Xmas...";
var newstr = str.replace(/xmas/i, "Christmas");
print(newstr);
</pre>
<p>This prints "Twas the night before Christmas..."
</p>
<h4 name="Ejemplo:_Switching_words_in_a_string"> Ejemplo: Switching words in a string </h4>
<p>The following script switches the words in the string. For the replacement text, the script uses the <code>$1</code> and <code>$2</code> replacement patterns.
</p>
<pre class="eval">var re = /(\w+)\s(\w+)/;
var str = "John Smith";
var newstr = str.replace(re, "$2, $1");
print(newstr);
</pre>
<p>This prints "Smith, John".
</p>
<h4 name="Ejemplo:_Using_an_inline_function_that_modifies_the_matched_characters"> Ejemplo: Using an inline function that modifies the matched characters </h4>
<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="eval">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 <i>result</i> 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="eval">var newString = propertyName.replace(/[A-Z]/, '-' + '$&amp;'.toLowerCase());  // won't work
</pre>
<p>This is because <code>'$&amp;'.toLowerCase()</code> would be evaluated first as a string literal (resulting in the same <code>'$&amp;'</code>) before using the characters as a pattern.
</p>
<h4 name="Ejemplo:_Replacing_a_Fahrenheit_degree_with_its_Celsius_equivalent"> Ejemplo: Replacing a Fahrenheit degree with its Celsius equivalent </h4>
<p>The following example replaces a Fahrenheit degree with its equivalent Celsius degree. The Fahrenheit degree should be a number ending with F. The function returns the Celsius number ending with C. For example, if the input number is 212F, the function returns 100C. If the number is 0F, the function returns -17.77777777777778C.
</p><p>The regular expression <code>test</code> checks for any number that ends with F. The number of Fahrenheit degree is accessible to the function through its second parameter, <code>p1</code>. The function sets the Celsius number based on the Fahrenheit degree passed in a string to the <code>f2c</code> function. <code>f2c</code> then returns the Celsius number. This function approximates Perl's s///e flag.
</p>
<pre class="eval">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>
<p><br>
</p>
<div class="noinclude">
</div>
{{ wiki.languages( { "en": "en/Core_JavaScript_1.5_Reference/Global_Objects/String/replace", "fr": "fr/R\u00e9f\u00e9rence_de_JavaScript_1.5_Core/Objets_globaux/String/replace", "ja": "ja/Core_JavaScript_1.5_Reference/Global_Objects/String/replace", "pl": "pl/Dokumentacja_j\u0119zyka_JavaScript_1.5/Obiekty/String/replace" } ) }}
Revertir a esta revisión