El pipeline y los objetos en PowerShell

Lección 4 de 8: el pipeline y los objetos, la idea que hace distinto a PowerShell. La barra | conecta un cmdlet con el siguiente, pero lo que viaja no son líneas de texto sino objetos con propiedades. Aquí aprenderás a ver esas propiedades con Get-Member y a filtrar, elegir, ordenar, agrupar y sumar con Where-Object, Select-Object, Sort-Object, Group-Object y Measure-Object.

Todo es un objeto

Cuando un cmdlet escribe algo en la pantalla, lo que ves no es lo que produjo: es un dibujo de sus objetos. Para ver qué hay de verdad, se usa Get-Member, que lista el tipo, las propiedades (datos) y los métodos (acciones) de lo que le llega por el pipeline. Vamos a trabajar con este archivo, productos.csv:

Nombre,Categoria,Precio,Existencias
Teclado mecánico,Accesorios,1299.00,14
Mouse inalámbrico,Accesorios,349.50,40
Monitor 27 pulgadas,Pantallas,5899.00,6
Audífonos,Audio,899.00,0
Bocina portátil,Audio,1150.00,9
Laptop 14 pulgadas,Computadoras,18499.00,3
Cable USB-C,Accesorios,159.00,120
Monitor 24 pulgadas,Pantallas,3299.00,11
consolaPS> $productos = Import-Csv productos.csv
PS> $productos.Count
8
PS> $productos[0]

Nombre           Categoria  Precio  Existencias
------           ---------  ------  -----------
Teclado mecánico Accesorios 1299.00 14

PS> $productos[0] | Get-Member -MemberType NoteProperty

   TypeName: System.Management.Automation.PSCustomObject

Name        MemberType   Definition
----        ----------   ----------
Categoria   NoteProperty string Categoria=Accesorios
Existencias NoteProperty string Existencias=14
Nombre      NoteProperty string Nombre=Teclado mecánico
Precio      NoteProperty string Precio=1299.00

Import-Csv convirtió cada renglón en un objeto con una propiedad por columna. Los nombres de las columnas salen del primer renglón. Get-Member nos cuenta algo importante: todas las propiedades son string, texto, incluso el precio. Lo tendremos en cuenta enseguida.

Filtrar con Where-Object

Where-Object deja pasar los objetos que cumplen una condición. Dentro del bloque, el objeto actual se llama $_ (o $PSItem, que es lo mismo con nombre largo):

$productos = Import-Csv productos.csv
$productos | Where-Object { $_.Categoria -eq "Pantallas" } | Select-Object -ExpandProperty Nombre
"---"
$productos | Where-Object { [int]$_.Existencias -eq 0 } | Select-Object -ExpandProperty Nombre
"---"
$productos | Where-Object Categoria -eq "Audio" | Select-Object -ExpandProperty Nombre
salidaMonitor 27 pulgadas
Monitor 24 pulgadas
---
Audífonos
---
Audífonos
Bocina portátil

La última forma, sin llaves ni $_, es la sintaxis simplificada: vale para una sola condición sencilla. Para combinar condiciones (-and, -or) hacen falta las llaves. Select-Object -ExpandProperty Nombre saca solo el valor de esa propiedad, sin el encabezado de tabla.

Elegir columnas con Select-Object

Select-Object crea objetos nuevos con solo las propiedades que le pidas, y también corta la lista con -First, -Last o -Skip. Además admite propiedades calculadas: una hashtable con el nombre de la columna nueva y un bloque que la calcula.

Import-Csv productos.csv |
    Select-Object -First 4 Nombre,
        @{ Name = "Precio con IVA"; Expression = { ([double]$_.Precio * 1.16).ToString("N2") } },
        @{ Name = "Valor en bodega"; Expression = { ([double]$_.Precio * [int]$_.Existencias).ToString("N2") } }
salidaNombre              Precio con IVA Valor en bodega
------              -------------- ---------------
Teclado mecánico    1,506.84       18,186.00
Mouse inalámbrico   405.42         13,980.00
Monitor 27 pulgadas 6,842.84       35,394.00
Audífonos           1,042.84       0.00

.ToString("N2") escribe el número con separador de miles y dos decimales exactos. Si dejas que la tabla decida, el número de decimales depende de la configuración del sistema, y no es igual en Windows que en Linux. Fíjate también en que la orden ocupa varias líneas sin ningún carácter especial: si una línea termina en | o en una coma, PowerShell sabe que la orden sigue en la siguiente.

Ordenar con Sort-Object

El error que te ahorra: ordenar números que en realidad son texto

Queremos los productos del más barato al más caro:

Import-Csv productos.csv | Sort-Object Precio | Select-Object Nombre, Precio
salidaNombre              Precio
------              ------
Bocina portátil     1150.00
Teclado mecánico    1299.00
Cable USB-C         159.00
Laptop 14 pulgadas  18499.00
Monitor 24 pulgadas 3299.00
Mouse inalámbrico   349.50
Monitor 27 pulgadas 5899.00
Audífonos           899.00

El orden es absurdo: la bocina de 1,150 va antes que el cable de 159, y la laptop de 18,499 queda en cuarto lugar, antes que el monitor de 3,299. Como vimos con Get-Member, Precio es texto, y los textos se ordenan carácter por carácter: «11…» va antes que «12…», y este antes que «15…», sin importar cuántas cifras tenga cada uno. No hay error ni aviso; solo una lista mal ordenada. La solución es ordenar por el valor convertido a número:

Import-Csv productos.csv |
    Sort-Object { [double]$_.Precio } -Descending |
    Select-Object -First 3 Nombre, Precio
salidaNombre              Precio
------              ------
Laptop 14 pulgadas  18499.00
Monitor 27 pulgadas 5899.00
Monitor 24 pulgadas 3299.00

Sort-Object acepta un nombre de propiedad o un bloque que calcula el valor por el que se ordena, y -Descending invierte el orden. Para ordenar por varias cosas, se separan con comas: Sort-Object Categoria, Nombre.

Un pipeline de cinco pasos: Import-Csv crea 8 objetos de producto; Where-Object deja pasar solo los que tienen existencias; Sort-Object los ordena por precio; Select-Object toma los 3 primeros; y Format-Table, siempre al final, los dibuja en pantallaUn pipeline, paso a pasoImport-Csv8 productos (objetos)|Where-Objectse quedan los que tienen existencias|Sort-Objectlos ordena por precio|Select-Objecttoma los 3 primeros|Format-Tablelos dibuja en pantalla
Cada cmdlet recibe los objetos del anterior, hace su parte y los pasa al siguiente. Esquema: decodigo.com.

Agrupar y sumar

Group-Object junta los objetos que comparten un valor, y Measure-Object cuenta, suma, promedia y busca el mínimo y el máximo:

$productos = Import-Csv productos.csv
$productos | Group-Object Categoria | Sort-Object Count -Descending | Select-Object Count, Name

$m = $productos | ForEach-Object { [double]$_.Precio } | Measure-Object -Sum -Average -Maximum
"Productos: {0}  Suma: {1:N2}  Promedio: {2:N2}  Máximo: {3:N2}" -f $m.Count, $m.Sum, $m.Average, $m.Maximum
salidaCount Name
----- ----
    3 Accesorios
    2 Audio
    2 Pantallas
    1 Computadoras
Productos: 8  Suma: 31,553.50  Promedio: 3,944.19  Máximo: 18,499.00

Measure-Object devuelve un objeto con los resultados en sus propiedades; aquí los pusimos en una sola línea de texto con -f. Cada grupo que devuelve Group-Object tiene el valor común en Name, cuántos son en Count y los objetos del grupo en Group. Con eso se arma un resumen por categoría:

Import-Csv productos.csv | Group-Object Categoria | ForEach-Object {
    $piezas = [int]($_.Group | Measure-Object { [int]$_.Existencias } -Sum).Sum
    [pscustomobject]@{
        Categoria = $_.Name
        Productos = $_.Count
        Piezas    = $piezas
    }
} | Sort-Object Piezas -Descending
salidaCategoria    Productos Piezas
---------    --------- ------
Accesorios           3    174
Pantallas            2     17
Audio                2      9
Computadoras         1      3

Measure-Object siempre devuelve la suma como número con decimales; [int] la deja en entero. [pscustomobject]@{ … } crea un objeto con las propiedades que quieras, y es la forma normal de que tus scripts devuelvan resultados ordenados en columnas.

Format-Table y Format-List, siempre al final

PowerShell decide solo cómo dibujar los objetos: si tienen pocas propiedades, en tabla; si tienen muchas, en lista. Puedes elegir con Format-Table (con -AutoSize ajusta el ancho de las columnas) o Format-List:

$p = Import-Csv productos.csv | Select-Object -First 2
$p | Format-Table Nombre, Precio -AutoSize
$p | Format-List
salidaNombre            Precio
------            ------
Teclado mecánico  1299.00
Mouse inalámbrico 349.50

Nombre      : Teclado mecánico
Categoria   : Accesorios
Precio      : 1299.00
Existencias : 14

Nombre      : Mouse inalámbrico
Categoria   : Accesorios
Precio      : 349.50
Existencias : 40

El error que te ahorra: guardar lo que sale de Format-Table

Los cmdlets Format-* no devuelven tus objetos, sino instrucciones de dibujo. Si los mandas a un archivo, eso es lo que se guarda:

Import-Csv productos.csv | Select-Object -First 2 | Format-Table Nombre, Precio | Export-Csv salida.csv
Get-Content salida.csv | Select-Object -First 3
salida"ClassId2e4f51ef21dd47e99d3c952918aff9cd","pageHeaderEntry","pageFooterEntry","autosizeInfo","shapeInfo","groupingEntry"
"033ecb2bc07a4d43b5ef94ed5a35d280",,,,"Microsoft.PowerShell.Commands.Internal.Format.TableHeaderInfo",
"9e210fe47d09416682b841769c78b8a3",,,,,

Columnas como ClassId2e4f51ef21dd47e99d3c952918aff9cd son las tripas del sistema de formato, no tus datos. La regla: Format-Table y Format-List van solo al final, cuando lo que sigue es la pantalla. Para elegir columnas que vas a guardar o procesar, usa Select-Object.

Solo en Windows

En Windows existe Out-GridView, que abre los objetos en una ventana con una tabla en la que puedes ordenar y filtrar con el mouse: prueba Import-Csv productos.csv | Out-GridView. Con -PassThru, lo que selecciones en la ventana sigue por el pipeline. En Linux y macOS no viene incluido.

Ojo con la seguridad: revisa antes de borrar con el pipeline

El pipeline hace muy fácil encadenar una búsqueda con Remove-Item, y un filtro mal escrito borra de más. Antes de ejecutarlo de verdad, cambia el final por Select-Object FullName para ver la lista, o añade -WhatIf, que dice qué haría sin hacerlo:

consolaPS> "a.tmp", "b.tmp", "informe.docx" | ForEach-Object { New-Item $_ | Out-Null }
PS> Get-ChildItem *.tmp | Remove-Item -WhatIf
What if: Performing the operation "Remove File" on target "/home/ana/proyecto/a.tmp".
What if: Performing the operation "Remove File" on target "/home/ana/proyecto/b.tmp".
PS> (Get-ChildItem *.tmp).Count
2

Con -WhatIf no se borró nada: los dos .tmp siguen ahí. Casi todos los cmdlets que cambian algo aceptan -WhatIf y -Confirm; en la lección 5 verás cómo dárselos a tus propias funciones.

Retos

Reto 1. Escribe el nombre y el precio del producto más caro de cada categoría.

Ver la solución
Import-Csv productos.csv | Group-Object Categoria | ForEach-Object {
    $_.Group | Sort-Object { [double]$_.Precio } -Descending | Select-Object -First 1 Categoria, Nombre, Precio
}
salidaCategoria    Nombre              Precio
---------    ------              ------
Accesorios   Teclado mecánico    1299.00
Audio        Bocina portátil     1150.00
Computadoras Laptop 14 pulgadas  18499.00
Pantallas    Monitor 27 pulgadas 5899.00

Dentro de cada grupo se ordena por precio, convertido a número, y se toma el primero.

Reto 2. Calcula el valor total del inventario: la suma de precio por existencias de todos los productos.

Ver la solución
$total = Import-Csv productos.csv |
    ForEach-Object { [double]$_.Precio * [int]$_.Existencias } |
    Measure-Object -Sum
"Valor del inventario: {0:C2}" -f $total.Sum
salidaValor del inventario: $188,776.00

{0:C2} da formato de moneda según la configuración regional; en México, con el signo de pesos y separador de miles.

Reto 3. ¿Qué escribe esto? Piénsalo antes de mirar: 1..10 | Where-Object { $_ % 2 } | Measure-Object -Sum, y de ese resultado, solo la propiedad Sum.

Ver la solución
(1..10 | Where-Object { $_ % 2 } | Measure-Object -Sum).Sum
salida25

Escribe 25. $_ % 2 vale 1 en los impares y 0 en los pares; como 0 cuenta como falso, Where-Object solo deja pasar 1, 3, 5, 7 y 9, que suman 25.

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.