Rarezas de PowerShell: 13 comportamientos que sorprenden

PowerShell es cómodo y legible, pero tiene comportamientos que sorprenden hasta a quien lo usa a diario: operadores que cambian según el orden, listas que se desarman solas, un return que no sale y un espacio invisible que parte una orden en dos. Aquí tienes trece, con su salida real y la forma de evitarlos.

Cada fragmento de esta página se ejecutó con PowerShell 7.6 tal como está, y la salida es la real. Ninguno es un error de PowerShell: son decisiones de diseño, casi todas pensadas para que la consola sea cómoda, que se vuelven trampas dentro de un script. Si vienes de otro lenguaje, la mayoría te va a sorprender.

  1. Dos puntos después de una variable rompen el script
  2. El tipo de la izquierda decide la operación
  3. [bool]»False» es verdadero
  4. [int]2.5 da 2 y [int]3.5 da 4
  5. Una lista de un elemento deja de ser lista
  6. El segundo objeto desaparece de la pantalla
  7. return no sale de ForEach-Object y break sale de todo
  8. Las claves de una hashtable no distinguen mayúsculas
  9. Un espacio invisible parte la orden en dos
  10. -replace con comillas dobles se come los grupos
  11. mm son minutos y hh es la hora de 12
  12. Sort-Object -Unique y Select-Object -Unique no coinciden
  13. $null no da error casi nunca

Dos puntos después de una variable rompen el script

Un saludo inocente, con dos puntos justo después de la variable:

$cliente = "Luis"
"Hola, $cliente: tu pedido salió"
salida con errorParserError: /home/ana/proyecto/r01.ps1:2
Line |
   2 |  "Hola, $cliente: tu pedido salió"
     |         ~~~~~~~~~
     | Variable reference is not valid. ':' was not followed by a valid
     | variable name character. Consider using ${} to delimit the name.

El script ni siquiera empieza: es un error de sintaxis. En PowerShell, $nombre:algo es una forma de indicar un ámbito o una unidad, como en $env:PATH o $script:total, así que al ver $cliente: espera que siga otro nombre. La solución la da el propio mensaje: delimitar el nombre con llaves, "Hola, ${cliente}: tu pedido salió".

El tipo de la izquierda decide la operación

El mismo + y el mismo * dan resultados distintos según qué va primero:

"10" + 5
5 + "10"
"3" * 3
3 * "3"
@(1, 2) + 3
salida105
15
333
9
1
2
3

PowerShell mira el operando de la izquierda y convierte el de la derecha a su tipo. Texto más número pega textos (105); número más texto suma (15). Texto por número repite el texto (333), y número por texto multiplica (9). Una lista más un número añade el número al final. Cuando leas datos de un archivo, conviértelos con [int] o [double] antes de operar.

[bool]»False» es verdadero

Convertir algo en verdadero o falso sigue reglas muy simples, que no siempre coinciden con la intuición:

[bool]"False"
[bool]"0"
[bool]0
[bool]""
[bool]@(0)
[bool]@(0, 0)
[int]""
salidaTrue
True
False
False
False
True
0

Un texto es verdadero si no está vacío, diga lo que diga: "False" y "0" son verdaderos. Una lista de un solo elemento vale lo que valga ese elemento (@(0) es falso), pero una de dos o más siempre es verdadera, aunque sean ceros. Y el texto vacío convertido a número da 0, sin error. Si lees «true» o «false» de un archivo, conviértelo con [bool]::Parse("False") o compáralo como texto.

[int]2.5 da 2 y [int]3.5 da 4

Redondear medio punto no siempre sube:

[int]2.5
[int]3.5
[math]::Round(2.5)
[math]::Round(2.5, [MidpointRounding]::AwayFromZero)
salida2
4
2
3

.NET usa por omisión el redondeo del banquero: cuando el número está justo a la mitad, redondea al par más cercano. 2.5 baja a 2 y 3.5 sube a 4. Así, al redondear muchas cantidades, los errores no se acumulan siempre hacia arriba. Para el redondeo de la escuela, pide AwayFromZero. Importa al calcular dinero.

Una lista de un elemento deja de ser lista

Una función que devuelve una lista con un solo elemento:

function Get-Lista { @("único") }
$r = Get-Lista
$r.GetType().Name
$r.Count
@(Get-Lista).GetType().Name
@([pscustomobject]@{ id = 1 }) | ConvertTo-Json -Compress
ConvertTo-Json -InputObject @([pscustomobject]@{ id = 1 }) -Compress
@([pscustomobject]@{ id = 1 }) | ConvertTo-Json -Compress -AsArray
salidaString
1
Object[]
{"id":1}
[{"id":1}]
[{"id":1}]

Al salir de la función, la lista se desarma y sus elementos viajan sueltos por el pipeline; como solo había uno, $r recibe un texto, no una lista. .Count da 1 de todos modos, porque PowerShell se lo añade a cualquier valor, pero el tipo cambió. Para tener siempre una lista, envuelve la llamada en @( ). Donde más duele es con JSON: por el pipeline, una lista de un elemento se convierte en un objeto {…} y no en una lista […], y una API que espera una lista falla. Pásala con -InputObject o usa -AsArray.

El segundo objeto desaparece de la pantalla

Un script que escribe dos objetos con propiedades distintas:

[pscustomobject]@{ Nombre = "Ana"; Edad = 31 }
[pscustomobject]@{ Ciudad = "Puebla"; Estado = "Puebla" }
"fin"
salidaNombre Edad
------ ----
Ana      31

fin

El segundo objeto no aparece: en su lugar hay una línea en blanco. Todo lo que escribe un script va a una sola tabla, y la tabla toma sus columnas del primer objeto (Nombre y Edad). El segundo no tiene esas propiedades, así que su fila sale vacía. Los datos están ahí, es solo el dibujo. Si un script debe mostrar cosas distintas, dale a cada una su Format-Table o Format-List, o mejor, devuelve objetos de un solo tipo.

return no sale de ForEach-Object y break sale de todo

Dentro del bloque de ForEach-Object, las palabras de control no hacen lo que parecen:

1..5 | ForEach-Object { if ($_ -eq 3) { return }; $_ }
"--- con break:"
1..5 | ForEach-Object { if ($_ -eq 3) { break }; $_ }
"fin del script"
salida1
2
4
5
--- con break:
1
2

El bloque de ForEach-Object es una pequeña función que se llama una vez por elemento. Por eso return sale solo de esa llamada y el pipeline sigue con el 4: se comporta como un continue. Y break, como no hay un bucle de verdad alrededor, detiene el script entero: «fin del script» nunca se escribió. Si necesitas salir de un recorrido, usa la instrucción foreach ($x in …), donde break y continue funcionan como siempre.

Las claves de una hashtable no distinguen mayúsculas

Como casi todo en PowerShell:

$t = @{ Mango = 25 }
$t["MANGO"]
$t2 = @{ a = 1; A = 2 }
"no llego aquí"
salida con errorParserError: /home/ana/proyecto/r08.ps1:3
Line |
   3 |  $t2 = @{ a = 1; A = 2 }
     |                  ~
     | Duplicate keys 'A' are not allowed in hash literals.

"MANGO" encontró la clave Mango. Y una hashtable con a y A es un error de sintaxis: para PowerShell son la misma clave repetida. Si de verdad necesitas distinguirlas, crea la tabla con [System.Collections.Hashtable]::new([StringComparer]::Ordinal).

Un espacio invisible parte la orden en dos

El acento grave al final de una línea dice que la orden sigue en la siguiente. En este script hay un espacio después del acento grave de la primera línea, que no se ve:

Get-Date -Date "2026-11-18" ` 
    -Format "dd/MM/yyyy"
salidamiércoles, 18 de noviembre de 2026 12:00:00 a.m.
-Format: /home/ana/proyecto/r09.ps1:2
Line |
   2 |      -Format "dd/MM/yyyy"
     |      ~~~~~~~
     | The term '-Format' is not recognized as a name of a cmdlet, function,
     | script file, or executable program. Check the spelling of the name, or
     | if a path was included, verify that the path is correct and try again.

El acento grave escapó al espacio, no al salto de línea, así que la orden terminó en la primera línea: escribió la fecha completa. La segunda línea, sola, intentó ejecutar -Format como si fuera un comando. Es de los errores más difíciles de ver. La alternativa más segura es cortar las líneas largas después de un |, una coma o una llave, donde PowerShell ya sabe que la orden sigue, o pasar los parámetros en una hashtable con splatting: $p = @{ Date = "2026-11-18"; Format = "dd/MM/yyyy" }; Get-Date @p.

PSScriptAnalyzer sí lo detecta, con una regla hecha justo para esto:

PSScriptAnalyzerlínea 1 · PSMisleadingBacktick · This line has a backtick at the end trailed by a whitespace character. Did you mean for this to be a line continuation?

-replace con comillas dobles se come los grupos

Reordenar una fecha con -replace, primero con comillas dobles y después con simples:

"2026-11-18" -replace '(\d+)-(\d+)-(\d+)', "$3/$2/$1"
"2026-11-18" -replace '(\d+)-(\d+)-(\d+)', '$3/$2/$1'
salida//
18/11/2026

Con comillas dobles, PowerShell sustituye $3, $2 y $1 como si fueran variables (vacías) antes de que -replace las vea, y solo quedan las barras. Con comillas simples, -replace recibe $3/$2/$1 intacto y usa los grupos de la expresión regular. Regla práctica: patrón y reemplazo de -replace, siempre entre comillas simples.

mm son minutos y hh es la hora de 12

Formatear una fecha a las 10:45 de la noche:

$d = Get-Date -Date "2026-11-18 22:45"
$d.ToString("yyyy-mm-dd")
$d.ToString("yyyy-MM-dd")
$d.ToString("hh:mm")
$d.ToString("HH:mm")
salida2026-45-18
2026-11-18
10:45
22:45

En los formatos de .NET, MM en mayúsculas es el mes y mm en minúsculas son los minutos: «2026-45-18» no es un día que exista. Igual con las horas: hh es el reloj de 12 horas y HH el de 24. Un nombre de archivo con hh se repetirá dos veces al día y uno con mm en lugar de MM, cada hora. Para nombres de archivo, el formato seguro es yyyy-MM-dd_HHmm.

Sort-Object -Unique y Select-Object -Unique no coinciden

Quitar repetidos de una lista con dos cmdlets que parecen hacer lo mismo:

"b", "B", "a" | Sort-Object -Unique
"---"
"b", "B", "a" | Select-Object -Unique
salidaa
B
---
b
B
a

Sort-Object -Unique no distingue mayúsculas (como casi todo en PowerShell) y dejó una sola «b» (la primera que encontró al ordenar, «B»). Select-Object -Unique sí las distingue y conservó las dos, en su orden original. Si te importan las mayúsculas, Sort-Object -Unique -CaseSensitive; si no, normaliza antes con .ToLower().

$null no da error casi nunca

Operar con una variable vacía:

$x = $null
$x + 1
$x.Count
"[$x]"
$y = @()
$null -eq $y
$y.Count
salida1
0
[]
False
0

$null + 1 da 1, $null.Count da 0 y dentro de un texto se convierte en nada. Es cómodo, pero esconde erratas: una variable mal escrita es $null y el script sigue como si nada. Por eso conviene Set-StrictMode -Version Latest, como vimos en la lección 7. Y una lista vacía no es lo mismo que $null: existe, solo que no tiene elementos.

¿Conoces otra rareza de PowerShell? Todas las de esta página están comprobadas con PowerShell 7.6.10 en un contenedor sin red. Para aprender PowerShell desde el principio, empieza por el curso de PowerShell, y para ponerte a prueba, el test de 24 preguntas.

Todos los fragmentos se ejecutaron con PowerShell 7.6.10 en un contenedor Linux limpio y sin red, con la configuración regional de México; las salidas están copiadas de esa ejecución. Las fechas se escriben con el formato regional de ese sistema, que en Windows puede variar en detalles como «a.m.». Los mensajes de error salen en inglés, como en PowerShell 7.