HOWTO · PowerShell

Sustitución de cadenas en PowerShell

El tutorial muestra cómo utilizar el método de reemplazo de PowerShell y el operador de reemplazo de PowerShell.

En esta página

PowerShell ofrece dos formas útiles de cambiar texto en una cadena: el método .NET String.Replace para texto literal y el operador -replace para patrones de expresiones regulares. Ambos devuelven una cadena que puedes guardar, mostrar o pasar a otra operación. Estos ejemplos trabajan con valores en memoria y no modifican archivos.

Cómo funciona la sustitución de cadenas en PowerShell

Una sustitución recibe una cadena de origen, un valor o patrón de búsqueda y el texto de reemplazo. En el ejemplo siguiente, $string contiene el texto original y $result contiene el valor modificado. PowerShell muestra el resultado como texto seleccionable.

Ejecuta este ejemplo. El código y las cadenas visibles que muestra se conservan en inglés:

El código y las etiquetas o salidas visibles de esta sección se mantienen en inglés.

$string = 'hello, world'
$result = $string.Replace('hello', 'hi')
Write-Output $result

El término de búsqueda es hello y el reemplazo es hi. La variable original sigue disponible porque el resultado del método se asigna por separado. Usa String.Replace cuando la búsqueda deba coincidir con esos caracteres literales y -replace cuando deba describir un patrón.

Sustituir texto literal con el método String.Replace

String.Replace es un método de una cadena, no una función de PowerShell. Acepta el texto que se busca y el texto que lo sustituye. La búsqueda es literal y distingue entre mayúsculas y minúsculas: caracteres como . no tienen un significado especial, y las letras mayúsculas y minúsculas son distintas. El método devuelve una cadena. Si el texto buscado no está presente, la cadena devuelta no cambia.

Puedes llamar al método desde una variable o directamente desde una cadena entre comillas. Este ejemplo independiente lo llama desde una variable. El código y las cadenas visibles que muestra se conservan en inglés:

El código y las etiquetas o salidas visibles de esta sección se mantienen en inglés.

$string = 'hello, world'
$result = $string.Replace('world', 'PowerShell')
Write-Output $result

El valor original de $string no se modifica directamente. También puedes asignar la cadena devuelta a $string si quieres que la variable contenga el nuevo valor.

Eliminar texto y encadenar llamadas a String.Replace

Para eliminar una subcadena literal, pasa una cadena vacía ('') como reemplazo. Cada llamada devuelve una cadena, por lo que una segunda llamada al método puede operar sobre el resultado de la primera. Las operaciones se realizan de izquierda a derecha.

El código y las cadenas visibles que muestra el ejemplo se conservan en inglés:

El código y las etiquetas o salidas visibles de esta sección se mantienen en inglés.

$string = 'hello, world'
$result = $string.Replace('hello', '').Replace('world', 'globe')
Write-Output $result

Este patrón resulta útil para una secuencia breve de sustituciones literales. Para un conjunto más amplio de términos literales sin relación entre sí, considera una secuencia clara de llamadas o un enfoque basado en un mapa; -replace no es automáticamente más sencillo, porque el texto de búsqueda utiliza sintaxis de patrones.

Usar el operador -replace para buscar patrones

El operador -replace de PowerShell recibe la cadena de entrada a la izquierda y, como primer argumento a la derecha, un patrón de expresión regular, seguido del texto de reemplazo. Por ejemplo, en $string -replace 'pattern', 'replacement', $string es la entrada y 'pattern' es el patrón de búsqueda. El operador sustituye todas las coincidencias. De forma predeterminada, la búsqueda no distingue entre mayúsculas y minúsculas; la variante -creplace, que sí las distingue, está disponible cuando la capitalización debe coincidir. En una expresión regular, caracteres como . y * actúan como operadores, no como texto ordinario.

Este ejemplo sustituye cada secuencia de dígitos por una marca. El código y las cadenas visibles que muestra se conservan en inglés:

El código y las etiquetas o salidas visibles de esta sección se mantienen en inglés.

$string = 'Order 17, shelf 204'
$result = $string -replace '\d+', '[number]'
Write-Output $result

Cuando un patrón de -replace deba coincidir con texto literal que contiene metacaracteres de expresiones regulares, escapa esos caracteres con [regex]::Escape(). El código y las cadenas visibles de este ejemplo se conservan en inglés:

$string = 'file.name and fileXname'
$pattern = [regex]::Escape('file.name')
$result = $string -replace $pattern, 'document'
Write-Output $result

Aquí el punto forma parte del texto literal buscado, por lo que el patrón no lo interpreta como un comodín. Elige el operador para buscar patrones o cuando quieras su comportamiento predeterminado, que no distingue entre mayúsculas y minúsculas; elige -creplace cuando el mismo patrón deba distinguirlas.

Eliminar texto y encadenar operaciones con -replace

Un reemplazo vacío también elimina coincidencias con -replace. Para aplicar varios cambios, coloca otra operación -replace después de la primera; esta recibe la cadena devuelta por la operación anterior. El lado de búsqueda de cada operación sigue siendo una expresión regular.

El código y las cadenas visibles que muestra el ejemplo se conservan en inglés:

El código y las etiquetas o salidas visibles de esta sección se mantienen en inglés.

$string = 'hello, world'
$result = $string -replace 'hello', '' -replace 'world', 'globe'
Write-Output $result

Si un patrón incluye paréntesis, corchetes, un punto u otra sintaxis de expresiones regulares que deba tratarse literalmente, escapa el texto literal de búsqueda antes de usarlo. Así evitarás que una eliminación o una sustitución encadenada coincida con más texto del previsto.

Elegir entre String.Replace y -replace

Usa String.Replace para buscar texto literal exacto y distinguir entre mayúsculas y minúsculas; si el texto literal no aparece, el resultado no cambia. Usa -replace para buscar con expresiones regulares y aprovechar su comportamiento predeterminado, que no distingue entre mayúsculas y minúsculas, o usa -creplace para que la búsqueda de patrones sí las distinga. Ambos enfoques devuelven una cadena que se puede asignar o encadenar. Para buscar texto literal con -replace, escapa el patrón con [regex]::Escape(); para una sustitución literal sencilla, String.Replace evita por completo la sintaxis de expresiones regulares.