PowerShell elimina caracteres especiales de una cadena [5 formas]

Usando el método Regex.Replace()

Utilice el método Regex.Replace() para eliminar caracteres especiales de la cadena especificada en PowerShell.

Utilice el método Regex.Replace():

$str = "How #$%are ^&*you?@!"
$cleanedStr = [System.Text.RegularExpressions.Regex]::Replace($str, '[^\w\s]', '')

Write-Host @"
Original String: $str
Cleaned String: $cleanedStr
"@

PRODUCCIÓN :

Original String: How #$%are ^&*you?@!
Cleaned String: How are you

Primero, declaramos una variable llamada $str y establecimos su valor en una cadena que contiene algunos caracteres especiales. Luego, utilizamos el método Replace() de la clase Regex del espacio de nombres System.Text.RegularExpressions para reemplazar los caracteres especiales con un carácter vacío. cadena.

El método Replace() tomó tres argumentos: la cadena ($str), la expresión regular ('[^\w\s]' ) y una cadena vacía (''). El patrón de expresión regular coincidía con cualquier carácter que no fuera un carácter de palabra (representado por \w) o un carácter de espacio en blanco (indicado por \s). Aquí, ^ significaba negación. Tenga en cuenta que la cadena de reemplazo estaba vacía (''), lo que eliminó los caracteres especiales coincidentes de la cadena de entrada.

A continuación, utilizamos el cmdlet Write-Host para mostrar la cadena original y limpia en la consola de PowerShell; la notación @"..."@ se utilizó para escribir una declaración de varias líneas.

Los caracteres de la palabra son [a-zA-Z0-9_].

Recuerde, si el espacio de nombres System.Text.RegularExpressions aún no está disponible en su sistema, utilice el cmdlet Add-Type de la siguiente manera:

Agregar espacio de nombres:

Add-Type -TypeDefinition @"
using System.Text.RegularExpressions;
"@

El cmdlet Add-Type agrega dinámicamente un ensamblado o un tipo .NET a la sesión de PowerShell. Este cmdlet es necesario si el espacio de nombres requerido aún no está disponible.

De manera similar, utilizamos el método Regex.Replace() dentro del bucle ForEach para eliminar caracteres especiales de una matriz de cadenas en PowerShell.

Utilice el método Regex.Replace():

$strArray = @("How #$%are ^&*you?@!", "Hello $&World")

$cleanedStr = foreach ($string in $strArray) {
        [System.Text.RegularExpressions.Regex]::Replace($string, '[^\w\s]', '')
}

Write-Host @"
Original Array of Strings: $strArray
Cleaned Array of Strings: $cleanedStr
"@

PRODUCCIÓN :

Original Array of Strings: How #$%are ^&*you?@! Hello $&World
Cleaned Array of Strings: How are you Hello World

En el código anterior, creamos una matriz de cadenas usando un operador de matriz (@()) y asignamos esta matriz a la variable $strArray. A continuación, utilizamos el bucle ForEach para iterar sobre $strArray. Después de eso, utilizamos el método Regex.Replace() en cada iteración para eliminar caracteres especiales de la cadena actual ($string). Hemos aprendido sobre el método Regex.Replace() con ejemplos de código anteriores; puedes referirte a eso.

Asignamos las cadenas limpias a la variable $cleanedStr. Finalmente, utilizamos el cmdlet Write-Host para imprimir la matriz de cadenas original y actualizada en la consola.

Usando el método String.Replace()

Utilice el método String.Replace() para eliminar caracteres especiales de la cadena especificada en PowerShell. Este enfoque es útil cuando se eliminan caracteres especiales en particular.

Utilice el método String.Replace():

$str = "How #$%are ^&*you?@!"
$specialChars = @('#','$','%','^','&','*','@','!')
echo "Original String: $str"

ForEach ($character in $specialChars) {
    $str = $str.Replace($character, '')
}

echo "Cleaned String: $str"

PRODUCCIÓN :

Original String: How #$%are ^&*you?@!
Cleaned String: How are you?

Nuevamente, tenemos $str que contiene caracteres especiales. Luego, usamos un operador de matriz (@()) para crear una matriz donde cada elemento era un carácter especial que no queríamos en la cadena de salida. Almacenamos esta matriz en la variable $specialChars. A continuación, utilizamos el comando echo para mostrar $str en la consola de PowerShell.

Después de eso, usamos el bucle ForEach (también conocido como declaración ForEach) para iterar sobre $specialChars. Invocamos el método Replace() de la clase String en cada iteración. Se necesitaron dos argumentos, el carácter actual y una cadena vacía; Aquí queríamos reemplazar el carácter actual coincidente con una cadena vacía.

Observe que actualizamos $str en cada iteración. Finalmente, usamos otro echo para imprimir el $str actualizado.

De manera similar, utilizamos el método String.Replace() dentro del bucle ForEach anidado para eliminar caracteres especiales de una matriz de cadenas en PowerShell.

Utilice el método String.Replace():

$strArray = @("How #$%are ^&*you?@!", "Hello $&World")
$specialChars = @('#','$','%','^','&','*','@','!')
echo "Original Array of Strings: $strArray"

ForEach ($index in 0..($strArray.Length - 1)) {
    ForEach ($character in $specialChars) {
        $strArray[$index] = $strArray[$index].Replace($character, '')
    }
}

echo "Cleaned Array of Strings: $strArray"

PRODUCCIÓN :

Original Array of Strings: How #$%are ^&*you?@! Hello $&World
Cleaned Array of Strings: How are you? Hello World

Este ejemplo es comparable al anterior, que tenía una matriz de cadenas ($strArray), una matriz de caracteres especiales ($specialChars) y usaba el comando echo para mostrar $strArray en la consola de PowerShell.

Luego, utilizamos el bucle ForEach anidado. El bucle externo era responsable de iterar sobre $strArray; usó la variable $index para acceder a cada elemento en $strArray. El bucle interno era responsable de recorrer la matriz $specialChars.

Dentro del bucle interno ForEach, utilizamos el método String.Replace() para reemplazar efectivamente el carácter especial con una cadena vacía para extraerlos de la cadena. Por último, utilizamos otro echo para mostrar la matriz de cadenas actualizada.

Usando el operador -replace

El operador -replace se puede utilizar con diferentes variaciones de una expresión regular para eliminar caracteres especiales de la cadena o matriz de cadenas dada. Aprendamos cómo usar el operador -replace.

Utilice el operador -replace con expresiones regulares, especificadas mediante rangos, para eliminar caracteres especiales de la cadena especificada en PowerShell.

Utilice -reemplace el operador:

$str = "How #$%are ^&*you?@!"
$cleanedStr = $str -replace '[^a-zA-Z0-9\s]', ''
Write-Host @"
Original String: $str
Cleaned String: $cleanedStr
"@

PRODUCCIÓN :

Original String: How #$%are ^&*you?@!
Cleaned String: How are you

Utilice el operador -replace con expresiones regulares, escritas con caracteres ASCII, para eliminar caracteres especiales de la cadena especificada en PowerShell.

Utilice -reemplace el operador:

$str = "How #$%are ^&*you?@!"
$cleanedStr = $str -replace '[^\x30-\x39\x41-\x5A\x61-\x7A\x20]+', ''
Write-Host @"
Original String: $str
Cleaned String: $cleanedStr
"@

PRODUCCIÓN :

Original String: How #$%are ^&*you?@!
Cleaned String: How are you

Utilice el operador -replace con expresiones regulares, escritas con caracteres Unicode, para eliminar caracteres especiales de la cadena especificada en PowerShell.

Utilice -reemplace el operador:

$str = "How #$%are ^&*you?@!"
$cleanedStr = $str -replace '[^\u0030-\u0039\u0041-\u005A\u0061-\u007A\u0020]+', ''
Write-Host @"
Original String: $str
Cleaned String: $cleanedStr
"@

PRODUCCIÓN :

Original String: How #$%are ^&*you?@!
Cleaned String: How are you

Utilice el operador -replace con expresiones regulares especificadas mediante metacarácter (\W) para eliminar caracteres especiales de la cadena especificada en PowerShell.

Utilice -reemplace el operador:

$str = "How #$%are ^&*you?@!"
$cleanedStr = $str -replace '[\W]', ''
Write-Host @"
Original String: $str
Cleaned String: $cleanedStr
"@

PRODUCCIÓN :

Original String: How #$%are ^&*you?@!
Cleaned String: Howareyou

Utilice el operador -replace con la expresión regular escrita usando categorías Unicode para eliminar caracteres especiales de la cadena especificada en PowerShell.

Utilice -reemplace el operador:

$str = "How #$%are ^&*you?@!"
$cleanedStr = $str -replace '[^\p{L}\p{Nd}]', ''
Write-Host @"
Original String: $str
Cleaned String: $cleanedStr
"@

PRODUCCIÓN :

Original String: How #$%are ^&*you?@!
Cleaned String: Howareyou

Como alternativa, puede hacer lo siguiente si desea conservar algunos caracteres especiales según las necesidades del proyecto.

Utilice -reemplace el operador:

$str = "How #$%are ^&*you?@!"
$cleanedStr = $str -replace '[^\p{L}\p{Nd}/?/!/\s]', ''
Write-Host @"
Original String: $str
Cleaned String: $cleanedStr
"@

PRODUCCIÓN :

Original String: How #$%are ^&*you?@!
Cleaned String: How are you?!

Los ejemplos anteriores en esta sección se parecían entre sí y tenían un $str que contenía caracteres especiales. Todos usaron el operador -replace con una expresión regular para eliminar caracteres especiales reemplazándolos con una cadena vacía. Asignamos la cadena limpia a la variable $cleanedStr.

Además, los ejemplos anteriores utilizaron el cmdlet Write-Host para imprimir la cadena principal y actualizada en la consola de PowerShell. Sólo se diferenciaban en especificar la expresión regular. Aprendamoslos a continuación.

1. [^a-zA-Z0-9\s]: este patrón de expresión regular coincide con todos los caracteres, excepto los alfabetos (a-z y A-Z), números (0-9) y un carácter de espacio (\s).
2. [^\x30-\x39\x41-\x5A\x61-\x7A\x20]+: este patrón de expresión regular se escribió utilizando caracteres ASCII; coincidió con todos los caracteres, excepto los números que van desde 0 hasta 9 (\x30-\x39), alfabetos en mayúsculas (\x41 -\x5A), alfabetos en minúsculas (\x61-\x7A) y un carácter de espacio (\x20). Aquí, + indica que el grupo o clase de carácter anterior debe tener al menos una o varias apariciones.
3. [^\u0030-\u0039\u0041-\u005A\u0061-\u007A\u0020]+: esta expresión regular era similar a la última pero se especificaba usando caracteres Unicode. Coincidió con todos los caracteres, excepto los números 0-9 (\u0030-\u0039), letras mayúsculas y minúsculas (\u0041-\u005A y \u0061 -\u007A) y un carácter de espacio (\u0020).
4. [\W]: coincide con cualquier carácter que no sea una palabra. Recuerde que los caracteres de la palabra son [a-zA-Z0-9_]. Por lo tanto, no debe utilizar esta expresión regular si no necesita un guión bajo (_) en su cadena de salida.
5. [^\p{L}\p{Nd}]: coincidió con todos los caracteres que no eran letras o dígitos. Aquí, \p{L} coincidió con cualquier carácter de letra Unicode, incluidas las letras de diferentes idiomas o escrituras. Mientras que \p{Nd} coincidía con cualquier carácter de dígito decimal Unicode.
6. [^\p{L}\p{Nd}/?/!/\s]: esta expresión regular es similar a la anterior pero se usa cuando queremos conservar ciertos caracteres especiales. En este caso, mantuvo ?, ! y un carácter de espacio (\s) en la cadena de salida.

En las expresiones regulares anteriores, ^ significa la negación, mientras que [] se usaba para definir la clase o grupo de caracteres.

Los caracteres ASCII y Unicode en una expresión regular tienen como prefijo las secuencias de escape \x y \u. Por otro lado, la secuencia de escape \p representa la categoría de caracteres Unicode.

Utilice el operador -replace para eliminar caracteres especiales de una matriz de cadenas en PowerShell.

Utilice -reemplace el operador:

$strArray = @("How #$%are ^&*you?@!", "Hello $&World")
$specialChars = '[^\w\s]+'

$cleanedStr = $strArray -replace $specialChars, ''

Write-Host @"
Original Array of Strings: $strArray
Cleaned Array of Strings: $cleanedStr
"@

PRODUCCIÓN :

Original Array of Strings: How #$%are ^&*you?@! Hello $&World
Cleaned Array of Strings: How are you Hello World

Usando el método Char.IsLetterOrDigit

Utilice el método Char.IsLetterOrDigit() para eliminar caracteres especiales de la cadena dada en PowerShell.

Utilice el método Char.IsLetterOrDigit():

$str = "How #$%are ^&*you?@!"
$cleanedStr = ""

ForEach ($char in $str.ToCharArray()) {
    if ([Char]::IsLetterOrDigit($char)) {
        $cleanedStr += $char
    }
}

Write-Host @"
Original String: $str
Cleaned String: $cleanedStr
"@

PRODUCCIÓN :

Original String: How #$%are ^&*you?@!
Cleaned String: Howareyou

Creamos dos variables de cadena; uno tenía un valor de cadena con caracteres especiales ($str) y el otro se inicializó con una cadena vacía ($cleanedStr). Luego, usamos el bucle ForEach para iterar sobre la matriz de caracteres, que creamos usando el método ToCharArray() como $str.ToCharArray().

Dentro del bucle, utilizamos la instrucción if con el método IsLetterOrDigit() para comprobar si el carácter actual representado por $char era una letra o dígito. Si así fuera, agregamos $cleanedStr con $char usando el operador += para omitir los caracteres especiales de manera efectiva. Finalmente, utilizamos el cmdlet Write-Host para imprimir la cadena original y actualizada en la consola.

Para mantener caracteres de espacio en la cadena de salida, utilice el método Char.IsWhiteSpace() como se muestra a continuación.

Utilice los métodos IsLetterOrDigit()/IsWhiteSpace():

$str = "How #$%are ^&*you?@!"
$cleanedStr = ""

ForEach ($char in $str.ToCharArray()) {
    if ([Char]::IsLetterOrDigit($char) -or [Char]::IsWhiteSpace($char)) {
        $cleanedStr += $char
    }
}

Write-Host @"
Original String: $str
Cleaned String: $cleanedStr
"@

PRODUCCIÓN :

Original String: How #$%are ^&*you?@!
Cleaned String: How are you

Consulte el siguiente ejemplo de código para eliminar caracteres especiales de una matriz de cadenas mediante PowerShell.

Utilice los métodos IsLetterOrDigit()/IsWhiteSpace():

$strArray = @("How #$%are ^&*you?@!", "Hello $&World")
$cleanedStrArray = @()

foreach ($string in $strArray) {
    $cleanedStr = ""

    foreach ($char in $string.ToCharArray()) {
        if ([Char]::IsLetterOrDigit($char) -or [Char]::IsWhiteSpace($char)) {
            $cleanedStr += $char
        }
    }

    $cleanedStrArray += $cleanedStr
}

Write-Host @"
Original Array of Strings: $strArray
Cleaned Array of Strings: $cleanedStrArray
"@

PRODUCCIÓN :

Original Array of Strings: How #$%are ^&*you?@! Hello $&World
Cleaned Array of Strings: How are you Hello World

Este ejemplo es similar a los últimos para eliminar caracteres especiales de una serie de cadenas. El bucle externo recorrió la matriz de cadenas ($strArray), mientras que el bucle interno repitió la matriz de caracteres de la cadena actual, que se convirtió como $string.ToCharArray().

Usamos la declaración if dentro del bucle interno con los métodos IsLetterOrDigit() y IsWhiteSpace(). Estos métodos tomaron el carácter actual ($char) y determinaron si era una letra, un dígito o un espacio en blanco. Si así fuera, entonces se concatenaría con la variable $cleanedStr usando el operador +=.

Una vez que finalizó el bucle interno, $cleanedStr se agregó a $cleanedStrArray usando el operador += en el bucle externo. Finalmente, usamos Write-Host para mostrar la matriz de cadenas original y actualizada en la consola de PowerShell.

Usando el método String.Join()

Utilice el método String.Join() para eliminar caracteres especiales de la cadena de entrada en PowerShell.

Utilice el método String.Join():

$str = "How #$%are ^&*you?@!"

$cleanedStr = [String]::Join('', 
                     ($str.ToCharArray() |
                      Where-Object { 
                         $_ -match '\w|\s' 
                      }))

Write-Host @"
Original String: $str
Cleaned String: $cleanedStr
"@

PRODUCCIÓN :

Original String: How #$%are ^&*you?@!
Cleaned String: How are you

Usamos el método String.Join(), que tomó dos argumentos. La primera fue la cadena vacía. Mientras que para el segundo argumento, convertimos la cadena a la matriz de caracteres usando ToCharArray() y la canalizamos al cmdlet Where-Object.

Este cmdlet se repitió sobre la matriz de caracteres y coincidió con el carácter actual ($_) con el patrón \w|\s mediante el operador -match. y los unió usando una cadena vacía (el primer argumento). En el patrón \w|\s, \w coincidía con el carácter de palabra, mientras que \s coincidía con un carácter de espacio. Finalmente, utilizamos el cmdlet Write-Host para mostrar los resultados en la consola.

Utilice el método String.Join() para eliminar caracteres especiales de una matriz de cadenas en PowerShell.

Utilice el método String.Join():

$strArray = @("How #$%are ^&*you?@!", "Hello $&World")
$cleanedStrArray = @()

ForEach ($string in $strArray) {
    $cleanedStrArray += [String]::Join('',
                   ($string.ToCharArray() |
                    Where-Object { 
                        $_ -match '\w|\s'
                    }))
}

Write-Host @"
Original String: $strArray
Cleaned String: $cleanedStrArray
"@

PRODUCCIÓN :

Original String: How #$%are ^&*you?@! Hello $&World
Cleaned String: How are you Hello World

Este fragmento de código es similar al anterior, pero usamos ForEach para recorrer $strArray y almacenamos las cadenas limpias en $cleanedStr. formación.

Se trata de que PowerShell elimine los caracteres especiales de String.