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"daFalse: 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) daTrue. Esto muerde mucho al leer un CSV, donde todo llega como texto (lección 6).- Cuando
-matchencuentra algo, deja lo encontrado en la variable automática$Matches. -containspregunta 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().
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 -NamesalidaMenor 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.
