about_Regular_Expressions

  • Artículo

Descripción breve

Describe expresiones regulares en PowerShell.

Descripción larga

Nota:

En este artículo se muestran la sintaxis y los métodos para usar expresiones regulares en PowerShell, no se describe toda la sintaxis. Para obtener una referencia más completa, consulte lenguaje de expresiones regulares: referencia rápida.

Una expresión regular es un patrón que se usa para hacer coincidir el texto. Se puede componer de caracteres literales, operadores y otras construcciones.

En este artículo se muestra la sintaxis de expresiones regulares en PowerShell. PowerShell tiene varios operadores y cmdlets que usan expresiones regulares. Puede obtener más información sobre su sintaxis y su uso en los vínculos siguientes.

Las expresiones regulares de PowerShell no distinguen mayúsculas de minúsculas de forma predeterminada. Cada método mostrado anteriormente tiene una manera diferente de forzar la distinción entre mayúsculas y minúsculas.

  • Para Select-String, use el parámetro CaseSensitive .
  • Para los operadores que usan expresiones regulares, use la versión que distingue mayúsculas de minúsculas: -cmatch, -creplaceo -csplit
  • Para la switch instrucción , use la opción .-casesensitive

Literales de carácter

Una expresión regular puede ser un carácter literal o una cadena. La expresión hace que el motor coincida exactamente con el texto especificado.

# This statement returns true because book contains the string "oo"
'book' -match 'oo'

Clase de caracteres

Aunque los literales de caracteres funcionan si conoce el patrón exacto, las clases de caracteres permiten ser menos específicas.

Grupos de caracteres

[character group] permite que coincida con cualquier número de caracteres una vez, mientras que [^character group] solo coincide con los caracteres NO en el grupo.

# This expression returns true if the pattern matches big, bog, or bug.
'big' -match 'b[iou]g'

Si la lista de caracteres que debe coincidir incluye el carácter de guion (-), debe estar al principio o al final de la lista para distinguirlo de una expresión de intervalo de caracteres.

Intervalos de caracteres

Un patrón también puede ser un intervalo de caracteres. Los caracteres pueden ser alfabéticos [A-Z], numéricos [0-9]o incluso basados en [ -~] ASCII (todos los caracteres imprimibles).

# This expression returns true if the pattern matches any 2 digit number.
42 -match '[0-9][0-9]'

Números

La \d clase de caracteres coincidirá con cualquier dígito decimal. Por el contrario, \D coincidirá con cualquier dígito no decimal.

# This expression returns true if it matches a server name.
# (Server-01 - Server-99).
'Server-01' -match 'Server-\d\d'

Caracteres de palabra

La \w clase de caracteres coincidirá con cualquier carácter [a-zA-Z_0-9]de palabra . Para que coincida con cualquier carácter que no sea de palabra, use \W.

# This expression returns true.
# The pattern matches the first word character 'B'.
'Book' -match '\w'

Comodines

El punto (.) es un carácter comodín en expresiones regulares. Coincidirá con cualquier carácter excepto una nueva línea (\n).

# This expression returns true.
# The pattern matches any 4 characters except the newline.
'a1\ ' -match '....'

Espacio en blanco

Puede hacer coincidir cualquier carácter de espacio en blanco con la \s clase de caracteres. Puede coincidir con cualquier carácter que no sea de espacio en blanco con \S. Puede hacer coincidir caracteres de espacio literal con .

# This expression returns true.
# The pattern uses the whitespace character class to match the leading
# space and a literal space to matching the trailing space.
' - ' -match '\s- '

Cuantificadores

Los cuantificadores controlan cuántas instancias de cada elemento deben estar presentes en la cadena de entrada.

A continuación se muestran algunos de los cuantificadores disponibles en PowerShell:

Cuantificador Descripción
* Cero o más veces.
+ Una o varias veces.
? Cero o una vez.
{n,m} Al menos n, pero no más de m veces.

El asterisco (*) coincide con el elemento anterior cero o más veces. El resultado es que incluso una cadena de entrada sin el elemento sería una coincidencia.

# This returns true for all account name strings even if the name is absent.
'ACCOUNT NAME:    Administrator' -match 'ACCOUNT NAME:\s*\w*'

El signo más (+) coincide con el elemento anterior una o varias veces.

# This returns true if it matches any server name.
'DC-01' -match '[A-Z]+-\d\d'

El signo ? de interrogación coincide con el elemento anterior cero o una vez. Al igual que el asterisco *, incluso coincidirá con cadenas donde el elemento está ausente.

# This returns true for any server name, even server names without dashes.
'SERVER01' -match '[A-Z]+-?\d\d'

El {n, m} cuantificador se puede usar de varias maneras diferentes para permitir el control pormenorizado sobre el cuantificador. El segundo elemento m y la coma , son opcionales.

Cuantificador Descripción
{n} Coincide exactamente con n el número de veces.
{n,} Coincide con al MENOS n el número de veces.
{n,m} Coincidencia entre n y m número de veces. 
# This returns true if it matches any phone number.
'111-222-3333' -match '\d{3}-\d{3}-\d{4}'

Delimitadores

Los delimitadores permiten hacer que una coincidencia se realice correctamente o se produzca un error en función de la posición de coincidencia dentro de la cadena de entrada.

Los dos anclajes usados habitualmente son ^ y $. El símbolo de intercalación ^ coincide con el inicio de una cadena y $, que coincide con el final de una cadena. Los delimitadores permiten hacer coincidir el texto en una posición específica, al tiempo que descartan caracteres no deseados.

# The pattern expects the string 'fish' to be the only thing on the line.
# This returns FALSE.
'fishing' -match '^fish$'

Nota:

Al definir una expresión regular que contenga un $ delimitador, asegúrese de incluir la expresión regular mediante comillas simples () en lugar de comillas dobles ('") o PowerShell expandirá la expresión como una variable.

Al usar anclajes en PowerShell, debe comprender la diferencia entre las opciones de expresión regular de línea única y multilínea .

  • Multilínea: el modo multilínea fuerza ^ y $ para que coincida con el final inicial de cada LÍNEA en lugar del principio y el final de la cadena de entrada.
  • Singleline: el modo singleline trata la cadena de entrada como SingleLine. Obliga al . carácter a que coincida con cada carácter (incluidas las nuevas líneas), en lugar de coincidir con cada carácter EXCEPTO la nueva línea \n.

Para obtener más información sobre estas opciones y cómo usarlas, visite el lenguaje de expresiones regulares - Referencia rápida.

Caracteres de escape

La barra diagonal inversa (\) se usa para escapar caracteres para que el motor de expresiones regulares no los analice.

Los siguientes caracteres están reservados: []().\^$|?*+{}.

Tendrá que escapar estos caracteres en los patrones para que coincidan con ellos en las cadenas de entrada.

# This returns true and matches numbers with at least 2 digits of precision.
# The decimal point is escaped using the backslash.
'3.141' -match '3\.\d{2,}'

Hay un método estático de la clase regex que puede escapar texto por usted.

[regex]::escape('3.\d{2,}')

3\.\\d\{2,}

Nota:

Esto hace que se escapen todos los caracteres de expresión regular reservados, incluidas las barras diagonales inversas existentes usadas en las clases de caracteres. Asegúrese de usarlo solo en la parte del patrón que necesita para escapar.

Otros escapes de caracteres

También hay escapes de caracteres reservados que puede usar para buscar coincidencias con tipos de caracteres especiales.

A continuación se muestran algunos escapes de caracteres usados habitualmente:

Escape de caracteres Descripción
\t Coincide con una pestaña
\n Coincide con una nueva línea
\r Coincide con un retorno de carro

Grupos, capturas y sustituciones

La agrupación crea una cadena de entrada independiente en subcadenas que se pueden capturar o omitir. Las subcadenas agrupadas se denominan subexpresiones. De forma predeterminada, las subexpresiones se capturan en grupos numerados, aunque también puede asignar nombres a ellos.

Una construcción de agrupación es una expresión regular rodeada de paréntesis. Se captura cualquier texto coincidente con la expresión regular incluida. En el ejemplo siguiente se divide el texto de entrada en dos grupos de captura.

'The last logged on user was CONTOSO\jsmith' -match '(.+was )(.+)'

True

Use la $Matchesvariable automática Hashtable para recuperar texto capturado. El texto que representa toda la coincidencia se almacena en la clave 0. Es importante tener en cuenta que la $Matches tabla hash contiene solo la primera aparición de cualquier patrón coincidente.

$Matches.0

The last logged on user was CONTOSO\jsmith

Las capturas se almacenan en claves enteras numéricas que aumentan de izquierda a derecha. La captura 1 contiene todo el texto hasta que el nombre de usuario, la captura 2 contiene solo el nombre de usuario.

$Matches

Name           Value
----           -----
2              CONTOSO\jsmith
1              The last logged on user was
0              The last logged on user was CONTOSO\jsmith

Importante

La 0 clave es un entero. Puede usar cualquier método Hashtable para acceder al valor almacenado.

PS> 'Good Dog' -match 'Dog'
True

PS> $Matches[0]
Dog

PS> $Matches.Item(0)
Dog

PS> $Matches.0
Dog

Capturas con nombre

De forma predeterminada, las capturas se almacenan en orden numérico ascendente, de izquierda a derecha. También puede asignar un nombre a un grupo de captura. Este nombre se convierte en una clave de la $Matchesvariable automática hashtable .

Dentro de un grupo de captura, use ?<keyname> para almacenar los datos capturados en una clave con nombre.

PS> $string = 'The last logged on user was CONTOSO\jsmith'
PS> $string -match 'was (?<domain>.+)\\(?<user>.+)'
True

PS> $Matches

Name                           Value
----                           -----
domain                         CONTOSO
user                           jsmith
0                              was CONTOSO\jsmith

PS> $Matches.domain
CONTOSO

PS> $Matches.user
jsmith

En el ejemplo siguiente se almacena la entrada de registro más reciente en el registro de Seguridad de Windows. La expresión regular proporcionada extrae el nombre de usuario y el dominio del mensaje y los almacena en las claves:N para el nombre y D del dominio.

$log = (Get-WinEvent -LogName Security -MaxEvents 1).message
$r = '(?s).*Account Name:\s*(?<N>.*).*Account Domain:\s*(?<D>[A-Z,0-9]*)'
$log -match $r

True

$Matches

Name                           Value
----                           -----
D                              CONTOSO
N                              jsmith
0                              A process has exited....

Para obtener más información, vea Construcciones de agrupación en expresiones regulares.

Sustituciones en expresiones regulares

El uso de las expresiones regulares (regex) con el -replace operador permite reemplazar dinámicamente el texto mediante texto capturado.

<input> -replace <original>, <substitute>

  • <input>: cadena en la que se va a buscar.
  • <original>: expresión regular usada para buscar en la cadena de entrada
  • <substitute>: expresión de sustitución regex para reemplazar coincidencias encontradas en la cadena de entrada.

Los <original> operandos y <substitute> están sujetos a reglas del motor de expresiones regulares, como las expresiones de escape o sustitución de caracteres. El patrón de reemplazo puede estar compuesto de una o más sustituciones junto con caracteres literales.

Se puede hacer referencia a grupos de captura en la <substitute> cadena mediante el $ carácter antes del identificador de grupo.

Dos maneras de hacer referencia a los grupos de captura son por Número y por Nombre.

  • Por número : los grupos de captura se numeran de izquierda a derecha.

    'John D. Smith' -replace '(\w+) (\w+)\. (\w+)', '$1.$2.$3@contoso.com'

    John.D.Smith@contoso.com

  • Por nombre : también se puede hacer referencia a grupos de captura por nombre.

    'CONTOSO\Administrator' -replace '\w+\\(?<user>\w+)', 'FABRIKAM\${user}'

    FABRIKAM\Administrator

La $& expresión representa todo el texto coincidente.

'Gobble' -replace 'Gobble', '$& $&'

Gobble Gobble

Advertencia

Dado que el carácter se usa en la $ expansión de cadenas, deberá usar cadenas literales con sustitución o escape del $ carácter al usar comillas dobles.

'Hello World' -replace '(\w+) \w+', '$1 Universe'
"Hello World" -replace "(\w+) \w+", "`$1 Universe"

Hello Universe
Hello Universe

Además, si desea tener como $ carácter literal, use $$ en lugar de los caracteres de escape normales. Cuando se usan comillas dobles, se siguen escapando todas las instancias de $ para evitar la sustitución incorrecta.

'5.72' -replace '(.+)', '$$$1'
"5.72" -replace "(.+)", "`$`$`$1"

$5.72
$5.72

Para obtener información detallada sobre las expresiones de sustitución, vea Sustituciones en expresiones regulares.

Consulte también