Nota:
El acceso a esta página requiere autorización. Puede intentar iniciar sesión o cambiar directorios.
El acceso a esta página requiere autorización. Puede intentar cambiar los directorios.
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 cubre todas las expresiones posibles. Para obtener una referencia más completa, consulte el 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. PowerShell usa el motor de regex de .NET.
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 exigir la distinción entre mayúsculas y minúsculas.
- Para
Select-String, utilice 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 instrucción
switch, 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 hacer coincidir 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 colocarse al principio o al final de la lista para que se distinga 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], [0-9]numéricos 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 coincide con cualquier dígito decimal. Por el contrario, \D coincide con cualquier carácter excepto los dígitos decimales.
# This expression returns true if it matches a server name.
# (Server-01 - Server-99).
'Server-01' -match 'Server-\d\d'
Caracteres de palabra
La clase de caracteres \w coincide con cualquier carácter de palabra [a-zA-Z_0-9]. Para que coincida con cualquier carácter que no sea una 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. Coincide 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 clase de caracteres \s. Puede hacer coincidir cualquier carácter que no sea un 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 coincide 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 cuantificador de {n, m} se puede usar de varias maneras diferentes para permitir un control pormenorizado sobre el cuantificador. El segundo elemento m y la coma , son opcionales.
| Cuantificador | Descripción |
|---|---|
{n} |
Coincide EXACTAMENTE n veces. |
{n,} |
Coincide AL MENOS n veces. |
{n,m} |
Coincide entre n y m veces. |
# This returns true if it matches any phone number.
'111-222-3333' -match '\d{3}-\d{3}-\d{4}'
Delimitadores
Los delimitadores permiten que una coincidencia sea correcta o falle según la posición de la coincidencia dentro de la cadena de entrada.
Los dos anclajes usados habitualmente son ^ y $. El símbolo de acento circunflejo ^ coincide con el inicio de una cadena y $, que corresponde al 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 ($ ), debe incluir la expresión regular entre comillas simples ('). Si usa comillas dobles ("), PowerShell interpreta la cadena como una expresión de variable expandible.
Al usar delimitadores en PowerShell, debe comprender la diferencia entre las opciones de expresión regular de línea única y varias líneas.
-
Multilínea: El modo multilínea fuerza
^y$para que coincida con el principio y el final de cada LÍNEA en lugar de con el principio y el final de la cadena de entrada. -
SingleLine: el modo SingleLine trata la cadena de entrada como SingleLine.
Obliga al carácter de
.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 caracteres de escape, de modo 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 automáticamente.
[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 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 algunas secuencias de escape de caracteres usadas habitualmente.
| Escape de carácter | 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 de constructos separa una cadena de entrada en subcadenas que se pueden capturar u 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 $Matcheshashtable variable automática para recuperar texto capturado.
El texto que representa la coincidencia completa 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 de entero numérico, 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 clave 0 es un número 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 capturas. Este nombre se convierte en una clave en la variable automática $MatchesHashtable.
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 nombre y D para el 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, consulte Construcciones de agrupación en expresiones regulares.
Sustituciones en expresiones regulares
El uso de las expresiones regulares (regex) con el operador -replace permite reemplazar dinámicamente el texto mediante texto capturado.
<input> -replace <original>, <substitute>
-
<input>: la cadena 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 operandos <original> 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 constar de una o varias sustituciones junto con caracteres literales.
Se puede hacer referencia a grupos de captura en la cadena <substitute> mediante el carácter $ antes del identificador de grupo.
Dos maneras de hacer referencia a grupos de capturas son por Número y por Nombre.
Por número: los grupos de capturas se numeran de izquierda a derecha.
'John D. Smith' -replace '(\w+) (\w+)\. (\w+)', '$1.$2.$3@contoso.com'John.D.Smith@contoso.comPor nombre: también se puede hacer referencia a grupos de capturas 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 de literales con sustitución o escapar el carácter $ cuando se utilizan 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 el $ como carácter literal, use $$ en lugar de los caracteres de escape normales. Al usar comillas dobles, siga escapando todas las instancias de $ para evitar una 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.
Comentarios en expresiones regulares
Las expresiones regulares pueden ser muy complejas y difíciles de leer. Puede usar comentarios para que sean más comprensibles. Hay dos tipos de comentarios permitidos en expresiones regulares.
- Comentario alineado (
(?#)) - Comentario de fin de línea (
#)
Para obtener más información, consulte la sección Comentarios de expresiones regulares de about_Comments.
Consulte también
Colaborar con nosotros en GitHub
El origen de este contenido se puede encontrar en GitHub, donde también puede crear y revisar problemas y solicitudes de incorporación de cambios. Para más información, consulte nuestra guía para colaboradores.
