PowerShell HashTable – Todo lo que necesitas saber

Las tablas hash en PowerShell se pueden usar para almacenar información de manera estructurada.

Esto se hace mediante el uso de pares clave/valor que le permiten extraer fácilmente la información necesaria de la tabla hash.

Puede comparar una tabla hash en PowerShell con una matriz asociativa si lo desea.

Las tablas hash se usan con bastante frecuencia en PowerShell porque son una excelente manera de almacenar y procesar información.

Lo mejor de las tablas hash es que la clave y el valor pueden ser cualquier tipo de objeto.

Por lo tanto, no está limitado a números enteros y cadenas, sino que también puede crear tablas hash anidadas, por ejemplo.

En este artículo, vamos a echar un vistazo a las tablas hash y cómo usarlas en sus scripts de PowerShell.

Tabla Hash vs Matriz

Antes de que echemos un vistazo a las tablas hash, primero expliquemos la diferencia entre tablas hash y matrices.

Esta es una pregunta que se hace a menudo, y las personas a menudo se confunden entre los dos.

Una matriz es una lista indexada de valores. El índice se genera automáticamente cuando agrega valores a la matriz.

Por lo tanto, no tiene control sobre dónde almacena la información en la matriz.

$array = @('apple','raspberry','kiwi')

Podemos acceder a los elementos de la matriz recorriéndolos o accediendo a los elementos por su número de índice:

$array | Foreach { Write-Host $_ }

# Result
apple
raspberry
kiwi

# Or by index number
write-host $array[1]

# Result
raspberry

También podemos agregar o actualizar valores en una matriz, pero no podemos cambiar ni determinar el número de índice del elemento:

# Replace the raspberry with melon
$array[1] = 'melon'

# Add a fruit to the array
$array += 'banana'

Tabla de picadillo

Como hemos visto, una matriz es solo una lista (colección) de elementos, que podemos agregar, modificar o eliminar de la lista. El índice se genera automáticamente cuando le agrega elementos. Por el contrario, con un PowerShell HashTable, debemos definir el índice (claves) del valor que queremos agregar.

Para crear una tabla hash usamos {} en vez de ():

# Creating a hashtable
$serverIps= @{}

# Or creating a pre-populate hashtable
$serverIps= @{
  'la-srv-lab02' = '192.168.10.2'
  'la-srv-db01' = '192.168.10.100'
}

Para agregar la dirección IP de un servidor a la tabla hash, necesitaremos definir una clave. No podemos hacer simplemente $hashtable.add('value')porque la tabla hash no creará un índice automáticamente.

$key = 'la-srv-lab01'
$value="192.168.10.1"
$serverIps.add($key,$value)

# Or simply
$serverIps.add('la-srv-lab03','192.168.10.3')

# Result:
$serverips

Name                           Value
----                           -----
la-srv-lab03                   192.168.10.3
la-srv-lab01                   192.168.10.1

La clave en este caso es el nombre del servidor y el valor de la dirección IP del servidor. Si necesitamos la dirección IP del servidor lab03 simplemente podemos hacer lo siguiente:

Recuperación de datos de una tabla Hash

Para recuperar datos de la tabla hash en PowerShell, simplemente podemos especificar la clave, que devolverá el valor de la clave:

$serverIps['la-srv-lab03']

# Result
192.168.10.3

Otra opción es iterar a través de la tabla hash, pero esto funciona de manera un poco diferente en comparación con una matriz. Si simplemente canalizamos un foreach detrás de la tabla hash, notará que solo devuelve un objeto de tabla hash:

$serverIps | foreach {write-host $_}
System.Collections.Hashtable

Para obtener solo los valores de la tabla hash, podemos usar el .value propiedad:

# Return only the values
$serverIps.values

# Or pipe them in a foreach to ping the servers for example:
$serverIps.values | foreach {ping $_}

Cuando trabaje con una tabla hash, probablemente también desee recuperar los datos como pares clave/valor. Para ello, podemos utilizar el GetEnumerator función:

$serverIps.GetEnumerator() | ForEach-Object {
   $result="{0} IP address is {1}" -f $_.key, $_.value
   write-host $result
}

# Result
la-srv-lab03 IP address is 192.168.10.3
la-srv-lab01 IP address is 192.168.10.1

Actualizar valores

La actualización de valores en una tabla hash se puede hacer usando la clave para seleccionar el par clave/valor correcto:

$serverIps['la-srv-lab03'] = '192.168.10.5'

Si necesita actualizar varios valores en una tabla hash, no puede simplemente usar un bucle ForEach para iterar a través de la tabla hash. Por ejemplo, esto no funcionará:

$serverIps.Keys | ForEach-Object {
    $serverIps[$_] = '192.168.10.20'
}

Primero deberá clonar las claves antes de poder actualizar los valores:

$serverIps.Keys.Clone() | ForEach-Object {
   $serverIps[$_] = '192.168.10.20'
}

Eliminación de claves o valores

Para eliminar completamente un par clave/valor de la tabla hash, puede usar el .remove función. Deberá especificar la clave que desea eliminar:

$serverIps.Remove('la-srv-lab03')

También es posible eliminar solo el valor de una clave:

$serverIps['la-srv-lab03'] = $null

Para borrar completamente la tabla hash, tiene dos opciones, puede volver a crear la instancia de la tabla hash o usar la función de borrado.

Se prefiere este último porque hace que su código sea más fácil de leer.

# Recreate the hashtable instance
$serverIps = @{}

# Better option for readability, use the clear function
$serverIps.clear()

Salpicaduras de tablas hash

Algunos cmdlets en PowerShell requieren muchas propiedades que generalmente escribimos en una sola línea.

Esto puede hacer que sus scripts de PowerShell sean más difíciles de leer porque es posible que deba desplazarse horizontalmente para ver el comando completo.

Por ejemplo, cuando desee enviar un correo electrónico desde PowerShell, terminará con una larga lista de parámetros.

Send-MailMessage -SmtpServer smtp.contoso.com -To [email protected] -From [email protected] -Subject 'super long subject goes here' -Body 'Test email from PowerShell' -Priority High

Para hacer esto más legible, podemos usar una tabla hash y aplastarla. Splatting reemplaza todos los parámetros y valores con una sola variable. Tenga en cuenta que usamos el @ símbolo para salpicar la variable en lugar de $

$mail = @{
	SmtpServer="smtp.contoso.com"
	To 		= '[email protected]'
	From            = '[email protected]'
	Subject="super long subject goes here"
	Body 		= 'Test email from PowerShell'
	Priority        = High
}

# Note the @ infront of mail, instead of $
Send-MailMessage @mail

Como puede ver, splatting hace que su código sea más fácil de leer y mantener en lugar de una larga línea de parámetros.

Creación de objetos a partir de tablas hash

Las tablas hash son excelentes cuando necesita estructurar datos para un solo objeto o para salpicar, pero no son objetos reales.

Las tablas hash solo tienen dos columnas, clave y valor.

Entonces, podemos crear una tabla hash con las especificaciones de un solo servidor, pero cuando necesitamos almacenar datos sobre varios servidores, nos encontramos con limitaciones (por ejemplo, no podemos reutilizar los nombres de las columnas).

Entonces, una mejor manera de estructurar sus datos cuando tiene múltiples entradas es usar objetos. La forma más fácil de crear objetos en PowerShell es convertir una tabla hash en un objeto de PowerShell personalizado. Esto lo hacemos agregando [pscustomobject] delante de la tabla hash.

Tome el siguiente ejemplo, primero creamos una tabla hash con las especificaciones del servidor:

$servers = @{
  'name'    = 'la-srv-db01'
  'ip'      = '192.168.10.100'
  'model'   = 'Hp DL380 G10'
  'memory'  = '96Gb'
}

# Result
Name                           Value
----                           -----
memory                         96Gb
ip                             192.168.10.100
name                           la-srv-db01
model                          Hp DL380 G10

Como puede ver, solo tenemos dos columnas, nombre y valor. La tabla hash representa un solo servidor y no podemos usarla para crear una lista de servidores.

Sin embargo, si convertimos la tabla hash en un objeto de PowerShell personalizado, obtenemos una tabla real, donde tenemos varias columnas.

$servers = [pscustomobject]@{
  'name'    = 'la-srv-db01'
  'ip'      = '192.168.10.100'
  'model'   = 'Hp DL380 G10'
  'memory'  = '96Gb'
}

# Result
name        ip             model        memory
----        --             -----        ------
la-srv-db01 192.168.10.100 Hp DL380 G10 96Gb

Así que ahora podemos agregar otro servidor al pscustomobject también:

function servers {
  [pscustomobject]@{
    'name'    = 'la-srv-db01'
    'ip'      = '192.168.10.100'
    'model'   = 'Hp DL380 G10'
    'memory'  = '96Gb'  
  }
  [pscustomobject]@{
    'name'    = 'la-srv-lab03'
    'ip'      = '192.168.10.3'
    'model'   = 'Hp DL180 G9'
    'memory'  = '32Gb'
  }
}

servers

# Result
name         ip             model        memory
----         --             -----        ------
la-srv-db01  192.168.10.100 Hp DL380 G10 96Gb
la-srv-lab03 192.168.10.3   Hp DL180 G9  32Gb

Exportación de tabla hash a CSV

Cuando exporte una tabla hash a CSV, notará que, de forma predeterminada, la clave y los valores no se exportan.

La salida solo contendrá información sobre el objeto de tabla hash, no los datos dentro de la tabla hash.

Para exportar realmente el contenido de la tabla hash, deberá usar el método GetEnumerator, tal como lo hicimos al ver el contenido de la tabla hash.

Solo necesitamos la clave y el valor de la tabla hash, por lo que también deberá agregar una selección al comando.

$serverIps= @{
  'la-srv-lab02' = '192.168.10.2'
  'la-srv-db01' = '192.168.10.100'
  'la-srv-lab03' = '192.168.10.3'
}

$serverIps.GetEnumerator() | Select Key, Value | Export-CSV -path c:\temp\hash.csv -No
Exportar tabla hash a CSV
Exportar tabla hash a CSV

Terminando

Las tablas hash en PowerShell son una excelente manera de estructurar datos o de usar en combinación con splatting.

Sin embargo, tenga en cuenta que están destinados a usarse para un solo artículo. No podemos crear una columna personalizada o almacenar varias filas con la misma clave.

Para eso, realmente necesita usar los objetos de PowerShell personalizados.

Espero que este artículo le haya resultado útil, si tiene alguna pregunta, simplemente deje un comentario a continuación.

Si desea obtener más información sobre PowerShell, asegúrese de leer también los 10 comandos principales de PowerShell que debe conocer

Otros artículos relacionados

La solución a las Plantillas de Microsoft Planner que faltan

La solución a las Plantillas de Microsoft Planner que faltan

Una de las funciones más solicitadas en el foro de UserVoice para Microsoft Planner es la capacidad de crear plantillas ...
Leer Más
Get-ADComputer- Cómo encontrar y exportar computadoras AD PowerShell

Get-ADComputer- Cómo encontrar y exportar computadoras AD PowerShell

¿Necesita exportar todas las computadoras desde una unidad organizativa o buscar una computadora en su Active Directory? ¿O quieres contar ...
Leer Más
Cómo descargar un archivo con PowerShell

Cómo descargar un archivo con PowerShell

PowerShell es un excelente lenguaje de secuencias de comandos para escribir todo tipo de secuencias de comandos. Pero, ¿sabía que ...
Leer Más
PSDrive - Cómo usar la alternativa PowerShell Net Use

PSDrive – Cómo usar la alternativa PowerShell Net Use

Todos conocemos el comando Net Use que podemos usar para mapear unidades de red desde la línea de comandos. Aunque ...
Leer Más
Los 10 principales comandos de PowerShell que debe conocer

Los 10 principales comandos de PowerShell que debe conocer

PowerShell es realmente poderoso y puede hacer que su trabajo diario sea mucho más fácil. Con todos los módulos que ...
Leer Más
GUI de PowerShell - Cómo empezar

GUI de PowerShell – Cómo empezar

He creado muchos scripts de PowerShell durante los últimos años. Todo con un solo propósito para automatizar mi trabajo de ...
Leer Más

Deja un comentario