Comparaciones, condiciones y bucles en PowerShell

Lección 3 de 8: comparaciones, condiciones y bucles en PowerShell. Un script de verdad toma decisiones: si el archivo existe, si el total pasa de cierta cantidad, qué hacer con cada tipo de archivo. Aquí verás los operadores de comparación (-eq, -gt, -like, -match), if y switch, y los bucles foreach, for, while y ForEach-Object.

Los operadores de comparación

En PowerShell no se compara con ==, > ni <, sino con operadores que empiezan con guion. La razón es histórica y práctica: > ya significaba «manda la salida a un archivo», como en la consola de Windows y en Bash, y no podía tener dos significados.

  • OperadorSignificaEjemplo que da True
  • -eq / -neigual / distinto5 -eq 5
  • -gt / -gemayor / mayor o igual10 -gt 3
  • -lt / -lemenor / menor o igual2 -le 2
  • -like / -notlikeparecido, con comodines'informe.pdf' -like '*.pdf'
  • -match / -notmatchcumple una expresión regular'MX-1234' -match '^MX-\d{4}$'
  • -contains / -inla lista contiene / está en la lista'b' -in 'a','b','c'
"Mango" -eq "mango"
"Mango" -ceq "mango"
10 -gt 9
"10" -gt "9"
"reporte-2026.xlsx" -like "reporte-*.xlsx"
"Pedido 4521 enviado" -match "\d+"
$Matches[0]
"rojo", "verde", "azul" -contains "verde"
"gris" -in "rojo", "verde", "azul"
salidaTrue
False
True
False
True
True
4521
True
False

Lo importante de esta salida:

  • Las comparaciones de texto no distinguen mayúsculas. Para que sí lo hagan, se antepone una c: -ceq, -clike, -cmatch.
  • "10" -gt "9" da False: entre dos textos se compara en orden alfabético, y el «1» va antes que el «9». Con números de verdad (10 -gt 9) da True. Esto muerde mucho al leer un CSV, donde todo llega como texto (lección 6).
  • Cuando -match encuentra algo, deja lo encontrado en la variable automática $Matches.
  • -contains pregunta si una lista contiene un elemento; no sirve para buscar un trozo dentro de un texto. Para eso está -like "*trozo*" o el método .Contains().
Tres operadores para comparar texto en PowerShell. -eq compara igualdad sin importar mayúsculas: Mango -eq mango da True. -like usa comodines asterisco e interrogación: foto.jpg -like asterisco punto jpg da True. -match usa una expresión regular: Pedido 123 -match barra d más da TrueTres formas de comparar texto-eqigual, sin importar mayúsculas"Mango" -eq "mango" True-likecon comodines * y ?"foto.jpg" -like "*.jpg" True-matchcon expresión regular"Pedido 123" -match "\d+" True
Igualdad, comodines o expresión regular: elige el operador según lo que necesites. Esquema: decodigo.com.

El error que te ahorra: usar > para comparar

Quien viene de otros lenguajes escribe esto sin pensarlo:

$edad = 40
if ($edad > 18) {
    "Mayor de edad"
} else {
    "Menor de edad"
}
Get-ChildItem -Name
salidaMenor de edad
18
mayor_mal.ps1

Dos sorpresas: dice «Menor de edad» con 40 años, y en la carpeta apareció un archivo llamado 18. Dentro del if, > 18 no comparó nada: mandó el valor de $edad al archivo 18. Como lo que se manda a un archivo ya no queda para la condición, la condición se queda vacía, que cuenta como falso, y el script dirá «Menor de edad» con cualquier edad. Además, cada vez que se ejecute sobrescribirá ese archivo. PSScriptAnalyzer lo detecta antes de ejecutar:

PSScriptAnalyzerlínea 2 · PSPossibleIncorrectUsageOfRedirectionOperator · Did you mean to use the redirection operator '>'? The comparison operators in PowerShell are '-gt' (greater than) or '-ge' (greater or equal).

La forma correcta es if ($edad -gt 18).

if, elseif y else

La condición va entre paréntesis y cada bloque entre llaves. Las condiciones se combinan con -and, -or y -not (o !):

$total = 1850
$esCliente = $true

if ($total -ge 2000 -and $esCliente) {
    $descuento = 0.15
} elseif ($total -ge 1000 -or $esCliente) {
    $descuento = 0.10
} else {
    $descuento = 0
}
"Descuento: {0:P0}, a pagar: {1:N2}" -f $descuento, ($total * (1 - $descuento))

if (-not (Test-Path "config.json")) {
    "No hay config.json: uso los valores de fábrica"
}
salidaDescuento: 10%, a pagar: 1,665.00
No hay config.json: uso los valores de fábrica

El formato {0:P0} escribe un número como porcentaje sin decimales. Test-Path devuelve True o False según exista o no la ruta, y es la forma normal de comprobar un archivo antes de usarlo.

Al convertir otros valores en verdadero o falso, PowerShell sigue unas reglas sencillas: son falsos el 0, el texto vacío "", $null y una lista vacía; casi todo lo demás es verdadero. Ojo con una: el texto "False" es verdadero, porque no está vacío. Más en las rarezas.

$null va a la izquierda

Una regla que parece manía y no lo es: al comparar con $null, pon $null a la izquierda. Si la variable es una lista, el operador no compara la lista entera sino que filtra sus elementos:

$lista = @(1, $null, $null, 3)
if ($lista -eq $null) { "Según esto, la lista es nula" }
($lista -eq $null).Count
if ($null -eq $lista) { "La lista es nula" } else { "La lista existe" }
salidaSegún esto, la lista es nula
2
La lista existe

Con una lista a la izquierda, -eq devuelve los elementos que cumplen la condición. Aquí devolvió los dos $null que había dentro, y una lista con dos elementos cuenta como verdadera, así que el if afirmó que la lista era nula. (Con un solo $null dentro habría dado falso, por casualidad: una lista de un elemento vale lo que valga ese elemento.) Con $null a la izquierda, la comparación es la que esperas. PSScriptAnalyzer tiene una regla para esto, PSPossibleIncorrectComparisonWithNull, que aquí desactivamos a propósito para enseñar el fallo.

switch

Cuando hay muchas opciones, switch es más claro que una cadena de elseif. Tiene dos detalles que lo hacen distinto al de otros lenguajes: se pueden usar comodines o expresiones regulares, y no se detiene en la primera coincidencia si no pones break:

$archivos = "foto.JPG", "contrato.pdf", "notas.txt", "video.mp4", "respaldo.zip"
foreach ($archivo in $archivos) {
    $tipo = switch -Wildcard ($archivo) {
        "*.jpg" { "imagen"; break }
        "*.png" { "imagen"; break }
        "*.pdf" { "documento"; break }
        "*.txt" { "documento"; break }
        "*.zip" { "comprimido"; break }
        default { "otro" }
    }
    "{0,-14} {1}" -f $archivo, $tipo
}
salidafoto.JPG       imagen
contrato.pdf   documento
notas.txt      documento
video.mp4      otro
respaldo.zip   comprimido

-Wildcard hace que cada caso se compare con -like (sin distinguir mayúsculas: foto.JPG cayó en *.jpg), y default recoge lo que no coincidió con nada. Lo que escribe el bloque elegido se guarda en $tipo, porque en PowerShell switch e if devuelven valores. {0,-14} rellena el texto con espacios hasta 14 caracteres, para alinear la columna.

switch (5) {
    { $_ -gt 1 } { "mayor que 1" }
    { $_ -gt 3 } { "mayor que 3" }
    5 { "es 5" }
}
salidamayor que 1
mayor que 3
es 5

Sin break, se ejecutan todos los casos que coinciden. Un caso puede ser un bloque entre llaves que recibe el valor en $_ y decide si coincide.

Bucles

foreach, el más usado

$ventas = 1200, 850, 3100, 560
$suma = 0
foreach ($venta in $ventas) {
    if ($venta -lt 600) { continue }
    $suma += $venta
}
"Suma de ventas de 600 o más: $suma"

$cuadrados = foreach ($n in 1..5) { $n * $n }
$cuadrados -join " "
salidaSuma de ventas de 600 o más: 5150
1 4 9 16 25

continue salta a la siguiente vuelta y break sale del bucle. 1..5 es un rango: la lista del 1 al 5. Y fíjate en la segunda parte: todo lo que escribe el bucle se puede guardar de una vez en una variable. Es la forma recomendada de armar una lista, mucho más rápida que ir haciendo += en cada vuelta, porque += copia el arreglo completo cada vez.

for, while y do

for ($i = 10; $i -ge 0; $i -= 5) {
    "Cuenta atrás: $i"
}

$saldo = 1000
$meses = 0
while ($saldo -lt 1500) {
    $saldo *= 1.05
    $meses++
}
"Con 5 % al mes, en $meses meses tienes {0:N2}" -f $saldo

do {
    $intento = Read-Host "Escribe SI para continuar"
} until ($intento -eq "SI")
"Continuamos"
salida (respondiendo «no», «quizá» y «si»)Cuenta atrás: 10
Cuenta atrás: 5
Cuenta atrás: 0
Con 5 % al mes, en 9 meses tienes 1,551.33
Escribe SI para continuar: no
Escribe SI para continuar: quizá
Escribe SI para continuar: si
Continuamos

while revisa la condición antes de cada vuelta; do … until la revisa después, así que siempre se ejecuta al menos una vez, que es justo lo que se necesita para pedir un dato hasta que sea válido. Y el último si, en minúsculas, valió como SI, porque -eq no distingue mayúsculas.

ForEach-Object: el bucle del pipeline

Además de la instrucción foreach, existe el cmdlet ForEach-Object, que recibe los elementos por el pipeline y ejecuta un bloque con cada uno, que llega en la variable $_:

1..4 | ForEach-Object { "Archivo_{0:D3}.txt" -f $_ }
"ana", "LUIS", "marta" | ForEach-Object { $_.Substring(0, 1).ToUpper() + $_.Substring(1).ToLower() }
salidaArchivo_001.txt
Archivo_002.txt
Archivo_003.txt
Archivo_004.txt
Ana
Luis
Marta

{0:D3} rellena un entero con ceros a la izquierda hasta tres cifras. ¿Cuándo usar cada uno? foreach (...) es más rápido cuando ya tienes la lista en una variable; ForEach-Object encaja cuando los datos vienen de otro cmdlet, porque los procesa a medida que llegan sin esperar a tenerlos todos. Y en PowerShell 7, ForEach-Object -Parallel procesa varios a la vez; lo vemos en el ejemplo de tareas en paralelo.

Ojo con la seguridad: no metas lo que escribe el usuario en una expresión regular sin escaparlo

Si buscas con -match un texto que escribió el usuario, sus caracteres especiales se interpretan como expresión regular: un punto vale por cualquier carácter y un paréntesis suelto rompe el script. Con [regex]::Escape() el texto se busca tal cual:

$buscado = "1.5"
"versión 125" -match $buscado
"versión 125" -match [regex]::Escape($buscado)
"versión 1.5" -match [regex]::Escape($buscado)
salidaTrue
False
True

Sin escapar, «1.5» encontró «125», porque el punto aceptó el 2. Si solo necesitas saber si un texto contiene otro, sin patrones, usa .Contains(), que es más rápido y no interpreta nada.

Retos

Reto 1. Escribe un bucle que recorra los números del 1 al 15 y escriba «Fizz» si es múltiplo de 3, «Buzz» si es múltiplo de 5, «FizzBuzz» si es de los dos, y el número si no es de ninguno. Todo en una línea separada por espacios.

Ver la solución
$salida = foreach ($n in 1..15) {
    if ($n % 15 -eq 0) { "FizzBuzz" }
    elseif ($n % 3 -eq 0) { "Fizz" }
    elseif ($n % 5 -eq 0) { "Buzz" }
    else { $n }
}
$salida -join " "
salida1 2 Fizz 4 Buzz Fizz 7 8 Fizz Buzz 11 Fizz 13 14 FizzBuzz

% da el resto de la división. El caso de 15 va primero: si fuera después del de 3, nunca llegaría a él.

Reto 2. Con switch -Regex, clasifica estos textos como «correo», «teléfono» o «desconocido»: ana@example.com, 55 1234 5678 y hola.

Ver la solución
foreach ($dato in "ana@example.com", "55 1234 5678", "hola") {
    $tipo = switch -Regex ($dato) {
        '^\S+@\S+\.\S+$' { "correo"; break }
        '^[\d ]{10,}$' { "teléfono"; break }
        default { "desconocido" }
    }
    "$dato -> $tipo"
}
salidaana@example.com -> correo
55 1234 5678 -> teléfono
hola -> desconocido

Con -Regex cada caso es una expresión regular. Las comillas simples evitan que PowerShell intente sustituir algo dentro del patrón.

Reto 3. ¿Qué escribe esto? Piénsalo antes de mirar: $numeros = 4, 8, 15, 16, 23, 42 y después $numeros -gt 15.

Ver la solución
$numeros = 4, 8, 15, 16, 23, 42
$numeros -gt 15
salida16
23
42

Escribe 16, 23 y 42, uno por línea. Con una lista a la izquierda, los operadores de comparación no devuelven True o False: filtran y devuelven los elementos que cumplen. Es útil, pero es la misma razón por la que $null va a la izquierda.

Todos los scripts de esta lección se ejecutaron con PowerShell 7.6.10 (la versión LTS) en un contenedor limpio sin acceso a la red, y se revisaron con PSScriptAnalyzer 1.25 antes de publicarla; las salidas están copiadas de esa ejecución. El contenedor es Linux, así que las rutas salen como /home/ana/proyecto; en tu Windows verás algo como C:\Users\ana. Mira tu versión con $PSVersionTable.PSVersion.