Lección 7 de 8: errores y scripts robustos en PowerShell. Un script que funciona en tu computadora tiene que aguantar el día en que el archivo no esté, la carpeta no tenga permisos o el usuario escriba letras donde iban números. Aquí verás las dos clases de errores de PowerShell, -ErrorAction Stop, try, catch y finally, Set-StrictMode, los códigos de salida y PSScriptAnalyzer, el revisor que detecta muchos fallos antes de ejecutar.
Errores que detienen y errores que no
PowerShell tiene dos clases de errores, y entender la diferencia es la mitad de esta lección. La mayoría de los errores de los cmdlets no detienen nada: se muestran y el script sigue con la siguiente línea, porque un cmdlet que procesa cien archivos no debería rendirse por uno que falla. Otros, como throw o una conversión imposible, sí detienen la ejecución.
"Inicio" Get-Item -Path "no-existe.txt" "Esto se ejecuta: el error anterior no detuvo nada" [int]"doce" "Esto también se ejecuta" throw "Algo salió muy mal" "Esto ya no se ejecuta"
salida con errorInicio
Get-Item: /home/ana/proyecto/dos_clases.ps1:2
Line |
2 | Get-Item -Path "no-existe.txt"
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
| Cannot find path '/home/ana/proyecto/no-existe.txt' because it does not
| exist.
Esto se ejecuta: el error anterior no detuvo nada
InvalidArgument: /home/ana/proyecto/dos_clases.ps1:4
Line |
4 | [int]"doce"
| ~~~~~~~~~~~
| Cannot convert value "doce" to type "System.Int32". Error: "The input
| string 'doce' was not in a correct format."
Esto también se ejecuta
Exception: /home/ana/proyecto/dos_clases.ps1:6
Line |
6 | throw "Algo salió muy mal"
| ~~~~~~~~~~~~~~~~~~~~~~~~~~
| Algo salió muy mal
código de salida: 1Fíjate en que hasta la conversión [int]"doce" dejó seguir al script, porque en un script no hay un try que la reciba; solo throw lo terminó, con código de salida 1. Los mensajes de error en PowerShell 7 dicen el archivo, el número de línea y subrayan la parte que falló.
El error que te ahorra: el try/catch que no atrapa nada
Es el error más común al empezar: rodear un cmdlet con try y esperar que el catch se encargue:
try {
$contenido = Get-Content -Path "config.ini"
"Configuración leída: $($contenido.Count) líneas"
} catch {
"No pude leer la configuración: uso los valores de fábrica"
}salidaGet-Content: /home/ana/proyecto/catch_mal.ps1:2
Line |
2 | $contenido = Get-Content -Path "config.ini"
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
| Cannot find path '/home/ana/proyecto/config.ini' because it does not
| exist.
Configuración leída: 0 líneasEl catch nunca se ejecutó: el error de Get-Content no detiene, así que el try no se enteró, y el script siguió con $contenido vacío como si nada. La solución es pedirle al cmdlet que su error sí detenga, con -ErrorAction Stop:
try {
$contenido = Get-Content -Path "config.ini" -ErrorAction Stop
"Configuración leída: $($contenido.Count) líneas"
} catch {
"No pude leer la configuración: uso los valores de fábrica"
"Motivo: $($_.Exception.Message)"
}salidaNo pude leer la configuración: uso los valores de fábrica Motivo: Cannot find path '/home/ana/proyecto/config.ini' because it does not exist.
Dentro del catch, $_ es el error, y $_.Exception.Message su mensaje. Para que todo el script se comporte así sin escribir -ErrorAction Stop en cada línea, pon al principio $ErrorActionPreference = "Stop". Es lo recomendable en scripts que corren solos, donde seguir después de un fallo puede hacer daño.
try, catch y finally
Un try puede tener varios catch, cada uno para un tipo de error, y un finally, que se ejecuta siempre, haya fallado algo o no. Es el lugar para cerrar archivos o borrar temporales:
function Read-Cantidad {
param([string]$Texto)
try {
$n = 0
if (-not [int]::TryParse($Texto, [ref]$n)) {
throw [System.FormatException]::new("'$Texto' no es un número")
}
if ($n -lt 0) {
throw [System.ArgumentOutOfRangeException]::new("Texto", "no puede ser negativa")
}
"Cantidad válida: $n"
} catch [System.FormatException] {
"Rechazada: $($_.Exception.Message)"
} catch [System.ArgumentOutOfRangeException] {
"Rechazada: $($_.Exception.Message)"
} finally {
"(revisado: $Texto)"
}
}
Read-Cantidad "12"
Read-Cantidad "doce"
Read-Cantidad "-3"salidaCantidad válida: 12 (revisado: 12) Rechazada: 'doce' no es un número (revisado: doce) Rechazada: no puede ser negativa (Parameter 'Texto') (revisado: -3)
[int]::TryParse() intenta convertir sin lanzar errores: devuelve False si no puede y, si puede, deja el número en $n (el [ref] es lo que le permite escribir en la variable). Con throw lanzamos un error del tipo que queremos, y cada catch atiende el suyo. El orden importa: PowerShell usa el primer catch cuyo tipo coincida, y uno sin tipo atrapa todo. Un throw sin nada, dentro de un catch, vuelve a lanzar el mismo error para que lo atienda alguien más arriba. Para saber el tipo exacto de un error, provócalo y mira $Error[0].Exception.GetType().FullName.
Set-StrictMode: que las erratas no pasen en silencio
$total = 1500 $descuento = 0.1 "A pagar: $($totl * (1 - $descuento))"
salidaA pagar:
Escribimos $totl en vez de $total, y PowerShell, en lugar de quejarse, usó una variable inexistente, que vale $null; la cuenta dio $null y el total salió vacío. Con Set-StrictMode, leer una variable que no existe es un error:
Set-StrictMode -Version Latest $ErrorActionPreference = "Stop" $total = 1500 $descuento = 0.1 "A pagar: $($totl * (1 - $descuento))"
salida con errorInvalidOperation: /home/ana/proyecto/estricto_si.ps1:5
Line |
5 | "A pagar: $($totl * (1 - $descuento))"
| ~~~~~
| The variable '$totl' cannot be retrieved because it has not been set.
código de salida: 1Ahora la errata se señala con su número de línea, y como además pusimos $ErrorActionPreference = "Stop", el script se detiene ahí con código 1 en lugar de seguir con un total vacío. (Sin esa segunda línea, el error se mostraría pero el script seguiría.) Set-StrictMode -Version Latest también protege contra leer propiedades que no existen y contra llamar funciones con paréntesis y comas, el error de la lección 5. Ponlo, junto con $ErrorActionPreference = "Stop", al principio de tus scripts.
Códigos de salida: exit y $LASTEXITCODE
Cuando otro programa ejecuta tu script (el Programador de tareas, un pipeline de integración continua, otro script), lo único que ve es su código de salida: 0 si todo fue bien, otro número si no. Lo fijas con exit. Y al revés: después de ejecutar un programa externo, su código queda en $LASTEXITCODE, y $? dice si la última orden tuvo éxito:
param([string]$Archivo)
if (-not (Test-Path -Path $Archivo)) {
Write-Error "No existe $Archivo"
exit 2
}
"Revisado: $Archivo"
exit 0consolaPS> pwsh -NoProfile -File ./revisar.ps1 -Archivo revisar.ps1 Revisado: revisar.ps1 PS> $LASTEXITCODE 0 PS> pwsh -NoProfile -File ./revisar.ps1 -Archivo falta.txt Write-Error: No existe falta.txt PS> $LASTEXITCODE 2
Aquí revisar.ps1 se ejecutó con pwsh -File, como lo haría cualquier otro programa. En la segunda vez, Write-Error mostró el motivo y exit 2 dejó el código 2, que es lo que leería el Programador de tareas para marcar la tarea como fallida. Si justo después de la orden consultas $?, vale False.
Ojo con algo que sorprende: un programa externo que falla no lanza un error de PowerShell, así que ni try ni $ErrorActionPreference = "Stop" lo detectan; hay que revisar $LASTEXITCODE. En PowerShell 7 (no en la 5.1) puedes cambiarlo con $PSNativeCommandUseErrorActionPreference = $true; vale $false de fábrica:
$ErrorActionPreference = "Stop"
$PSNativeCommandUseErrorActionPreference = $true
try {
pwsh -NoProfile -Command "exit 3"
"No llego aquí"
} catch {
"Atrapado: $($_.Exception.Message)"
}salidaAtrapado: Program "pwsh" ended with non-zero exit code: 3 (0x03).
PSScriptAnalyzer: revisa antes de ejecutar
Muchos de los errores de este curso los detecta PSScriptAnalyzer, el analizador oficial de Microsoft, sin ejecutar el script. Es el mismo que usa la extensión de PowerShell de Visual Studio Code para subrayar el código. Se instala una vez desde la PowerShell Gallery y se usa con Invoke-ScriptAnalyzer:
Install-PSResource PSScriptAnalyzer Invoke-ScriptAnalyzer -Path .\mi-script.ps1
Este script tiene varios problemas típicos: un alias y dos variables que se crean y nunca se usan, una de ellas con una contraseña escrita en el código:
function Get-Reporte {
$clave = "Secreta123"
$archivos = dir *.csv
$sinUsar = 5
$archivos | ForEach-Object { $_.Name }
}PSScriptAnalyzerlínea 2 · PSUseDeclaredVarsMoreThanAssignments · The variable 'clave' is assigned but never used. línea 4 · PSUseDeclaredVarsMoreThanAssignments · The variable 'sinUsar' is assigned but never used. línea 3 · PSAvoidUsingCmdletAliases · 'dir' is an alias of 'Get-ChildItem'. Alias can introduce possible problems and make scripts hard to maintain. Please consider changing alias to its full content.
Cada aviso trae la línea, el nombre de la regla y una explicación. Fíjate en lo que no dijo: no se queja de la contraseña escrita en el texto, solo de que la variable no se usa. Su regla de contraseñas (PSAvoidUsingPlainTextForPassword) revisa los parámetros con nombres como Password, no cualquier texto. Un analizador ayuda, pero no sustituye a revisar el código. Si alguna regla no aplica a tu caso, se puede desactivar con -ExcludeRule, pero conviene entender primero por qué existe. En este curso, cada script pasó por PSScriptAnalyzer antes de publicarse.
Ojo con la seguridad: nunca uses Invoke-Expression con datos de fuera
Invoke-Expression ejecuta un texto como si fuera código. Si ese texto incluye algo que escribió el usuario, o que viene de un archivo o de una página web, el usuario puede meter sus propias órdenes:
$nombre = "x'; 'ESTO NO DEBÍA EJECUTARSE'; '" Invoke-Expression "'Hola, $nombre'" "---" "Hola, $nombre"
salidaHola, x ESTO NO DEBÍA EJECUTARSE --- Hola, x'; 'ESTO NO DEBÍA EJECUTARSE'; '
El «nombre» cerró la comilla y coló una orden propia, que se ejecutó; aquí solo escribe un texto, pero podría borrar archivos. La segunda forma, una cadena normal, no ejecuta nada de lo que hay dentro. Casi nunca hace falta Invoke-Expression: para llamar a un comando cuyo nombre está en una variable, usa el operador &, y para pasar parámetros armados en una hashtable, splatting (Get-ChildItem @parametros). PSScriptAnalyzer lo avisa con la regla PSAvoidUsingInvokeExpression, que aquí apagamos para enseñar el problema.
Solo en Windows
Para dejar registro de todo lo que pasa en una ejecución, Start-Transcript -Path registro.txt al principio y Stop-Transcript al final guardan en un archivo todo lo que el script escribe, errores incluidos. Funciona en todos los sistemas. Lo propio de Windows es el Visor de eventos: con Get-WinEvent -LogName Application -MaxEvents 20 lees los últimos eventos del registro de aplicaciones, útil para saber por qué falló una tarea programada.
Retos
Reto 1. Escribe un script que intente leer tres archivos (a.txt, b.txt y c.txt, de los que solo existe b.txt) y al final diga cuántos pudo leer y cuáles fallaron, sin detenerse en el primer error.
Ver la solución
Set-Content -Path "b.txt" -Value "hola"
$fallidos = foreach ($archivo in "a.txt", "b.txt", "c.txt") {
try {
$null = Get-Content -Path $archivo -ErrorAction Stop
} catch {
$archivo
}
}
"Leídos: $(3 - @($fallidos).Count). Fallaron: $($fallidos -join ', ')"salidaLeídos: 1. Fallaron: a.txt, c.txt
El try está dentro del bucle, así que un fallo solo salta ese archivo. @($fallidos) asegura una lista aunque haya fallado uno solo.
Reto 2. Haz una función Get-Division que divida dos números y, si el divisor es 0, lance un error con el mensaje «No se puede dividir entre cero». Llámala con 10 y 0 dentro de un try.
Ver la solución
function Get-Division {
param([double]$A, [double]$B)
if ($B -eq 0) { throw "No se puede dividir entre cero" }
$A / $B
}
try {
Get-Division -A 10 -B 4
Get-Division -A 10 -B 0
"No llego aquí"
} catch {
"Error: $($_.Exception.Message)"
}salida2.5 Error: No se puede dividir entre cero
Hay que lanzar el error a mano: en PowerShell, dividir un double entre 0 no falla, da infinito.
Reto 3. ¿Qué escribe esto? Piénsalo antes de mirar: try { Get-Item nope; "sigo" } catch { "atrapado" }, sin -ErrorAction.
Ver la solución
try { Get-Item -Path "nope"; "sigo" } catch { "atrapado" }salidaGet-Item: /home/ana/proyecto/reto3.ps1:1
Line |
1 | try { Get-Item -Path "nope"; "sigo" } catch { "atrapado" }
| ~~~~~~~~~~~~~~~~~~~~~
| Cannot find path '/home/ana/proyecto/nope' because it does not exist.
sigoEscribe el error de Get-Item y después «sigo». Nunca llega al catch, porque el error no detiene. Es el mismo caso del recuadro «El error que te ahorra».
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.
