Cómo usar Powershell Arrays

Introducción

Un array es una estructura de datos que puede contener más de un valor a la vez. Piénselo como una colección o una lista de elementos del mismo tipo de datos o de diferentes tipos. Los arrays se utilizan en muchos lenguajes de scripting y programación, incluido Windows PowerShell.

Profundicemos en cómo crear y usar un array in PowerShell.

Creando un arreglo de objetos

Por defecto, cada elemento en un arreglo es un objeto, en lugar de otro tipo de dato como cadena de texto o entero. Aquí hay un ejemplo de cómo crear un arreglo de objetos añadiendo explícitamente los objetos:

      $people = @(

    [PSCustomObject]@{Name='Alice'; Age=30},

    [PSCustomObject]@{Name='Bob'; Age=25}
      

Creando un arreglo con solo un elemento

Si asignas solo un valor a una variable, entonces PowerShell no creará un array. Para confirmar esto, usemos dos scripts y mostremos sus tipos de datos.

Primero, crearemos un array en PowerShell con cinco elementos:

      $array = @(1, 2, 3, 4, 5)

$array1.GetType()
      

Ahora intentemos usar un script similar para crear un arreglo con solo un elemento:

      $array1 = 1

$array1.GetType()
      

Como puede ver en el resultado a continuación, PowerShell creó un arreglo (System.Array) para el primer script de ejemplo, pero no para el segundo.

Este comportamiento es particularmente preocupante si quieres crear un arreglo al recuperar objetos ejecutando un comando específico, ya que no sabes de antemano cuántos objetos se devolverán en los resultados.

Para evitar este problema, puedes utilizar el operador , (coma). Si se usa una coma como operador binario, entonces se crea un arreglo normal; si se usa como operador unario, el arreglo tiene solo un elemento.

Por ejemplo, aquí está cómo podemos obtener un arreglo que consiste en un solo elemento:

      $array1 = ,1

$array1.GetType()
      

Podemos confirmar la creación del arreglo con la salida mostrada a continuación:

Creando un arreglo vacío

En PowerShell, también puedes crear un arreglo — incluyendo un arreglo vacío — utilizando el operador @. Si especificas @(), obtienes un arreglo sin ningún objeto en absoluto, puedes crear uno. Es una forma conveniente de inicializar variables como arreglos y luego agregar objetos a los arreglos sin preocuparte por su número.

      $array3 = @()

$array3.GetType()
      

Creando un Array de Tipado Fuerte

Por defecto, los elementos de un arreglo pueden tener diferentes tipos de datos. Pero también puedes crear arreglos que acepten únicamente valores de un tipo designado. Intentar agregar un valor de un tipo diferente producirá un error. Aquí está cómo crear los arreglos fuertemente tipados más comunes:

Entero:

      [int[]]$intArray = 1, 2, 3
      

Cadena:

      [string[]]$strArray = "one", "two", "three"
      

Fecha/Hora:

[datetime[]]$dateArray = (Get-Date), (Get-Date).AddDays(1)

Creando un arreglo multidimensional (matriz)

Al anidar arreglos utilizando comas, puedes crear una disposición estructurada de datos en filas o columnas. Aquí creamos una matriz de 3×3:

$twoDArray = @(

@(1, 2, 3),

@(4, 5, 6),

@(7, 8, 9)

)

Comparando, agrupando, seleccionando y ordenando arreglos

Otros cmdlets de PowerShell útiles para trabajar con arrays incluyen:

• Compare-Object — Compara dos arreglos y devuelve las diferencias.
• Group-Object — Agrupa elementos de un arreglo basándose en los valores de sus propiedades.
• Select-Object — Selecciona propiedades específicas de un objeto o conjunto de objetos, y también puede usarse para seleccionar un número específico de elementos de un arreglo.
• Sort-Object — Se utiliza para ordenar arreglos que contienen solo un tipo de dato, como se muestra a continuación:

      $array = @(3, 1, 4, 2)
$sortedArray = $array | Sort-Object
      

Recorriendo un arreglo

Para manejar cada elemento en un arreglo uno tras otro, necesitamos hacer un bucle utilizando el operador foreach. Por ejemplo, si declaramos un arreglo de cadenas y queremos contar la longitud de cada palabra en el arreglo, deberíamos ejecutar el siguiente script:

      $array8 = @("Earth","Mercury","Venus","Jupiter","Saturn","Mars", "Neptune", "Pluto")
foreach ($array in $array8) {
 "$array = " + $array.length
}
      

El resultado se verá así:

Usando un Pipeline

La tubería se utiliza en PowerShell para pasar la salida de un comando como entrada a otro. Al trabajar con arreglos, puedes usar la tubería para procesar y manipular los datos en el arreglo y asignar los resultados a un nuevo arreglo o modificar el existente.

Aquí multiplicaremos cada elemento del array por 2:

      $numbers = 1,2,3,4,5

$doubled = $numbers | ForEach-Object { $_ * 2 }
      

Añadiendo a un Array

El tamaño de un array en PowerShell es inmutable una vez que se define. Sin embargo, el operador += te permite crear un nuevo array al añadir elementos a un array existente — esencialmente creando un nuevo array combinado.

      $array = @(1, 2, 3)
$array += 4
      

Creando un ArrayList

Para arreglos grandes o adiciones frecuentes, el uso de += puede ser una preocupación de rendimiento, ya que cada vez que lo utiliza, se crea un nuevo arreglo, se copian los elementos antiguos y se agrega el nuevo elemento al final. En esos casos, es posible que desee utilizar un ArrayList.

El tamaño de un ArrayList es mutable, por lo que puedes añadir o eliminar elementos sin tener que recrear toda la colección. Al igual que un arreglo estándar, un ArrayList puede contener elementos de diferentes tipos de datos.

Aquí está el cmdlet para crear un ArrayList:

      $array3 = New-Object System.Collections.ArrayList

      

Eliminar un elemento de un arreglo

Ahora usemos un ArrayList para eliminar un elemento de un arreglo. Primero creemos un arreglo.

      $array5 = "one", "two", "three", "four", "five"
$array5.gettype()
      

Ahora lo añadiremos a un ArrayList para poder modificarlo fácilmente.

      [System.Collections.ArrayList]$ArrayList1 = $array5

$ArrayList1.GetType()
      

Luego utilizaremos el comando .Remove.

      $ArrayList1.Remove("three")

      

Borrando un Array

No hay una manera definida de eliminar un array, pero hay varias formas de deshacerse del contenido de un array (vaciarlo). Una es asignar la variable $null al array:

      $array7 = $null
$array7
      

Aquí hay otra forma de vaciar un arreglo:

      $array = @("element1", "element2", "element3")

$array = @()
      

Aquí se explica cómo limpiar un ArrayList:

      $arrayList = New-Object System.Collections.ArrayList
$arrayList.Add("element1")
$arrayList.Add("element2")
$arrayList.Clear()
      

Imprimiendo un arreglo

La manera más fácil de mostrar el contenido de un arreglo es simplemente referenciando la variable del arreglo. El ejemplo a continuación muestra cómo incluir el texto “Elemento:” antes de cada ítem en el arreglo:

Para escribir en un archivo .txt, utilice el comando Out-File :

      $var5 | Out-File C:scriptsarray.txt

      

Para exportar a un archivo .csv, utilice el comando Export-Csv:

      $var6 | Export-Csv -Path C:scriptsarray.csv

      

Filtrando un Array

Podemos usar el cmdlet Where-Object para recuperar solo los números pares de un arreglo:

      $numbers = 1,2,3,4,5,6

$evenNumbers = $numbers | Where-Object { $_ % 2 -eq 0 }

$evenNumbers
      

Alternativamente, podemos usar el método .Where() que no requiere un pipeline:

      $numbers = 1,2,3,4,5,6

$evenNumbers = $numbers.Where({ $_ % 2 -eq 0 })

$evenNumbers

      

Comprobando la longitud de un arreglo

Para devolver el número de elementos en un arreglo, use el parámetro .length :

      $array6 = 1,2,3,4,5,6
echo $array6.Length
      

Comprobando si un arreglo contiene un valor particular

Si quieres comprobar si alguno de los elementos de un arreglo contiene un valor particular, utiliza el método Contains. Este código mostrará si un arreglo contiene un 2 o un 12:

      $array7 = 1,2,5,8,3,4,5
$array7.Contains(2)
$array7.Contains(12)
      

Accediendo a elementos utilizando el índice del array

Como ocurre con la mayoría de los lenguajes de programación, cada elemento individual en un array de PowerShell se puede acceder mediante un índice. El índice de un array comienza en cero, por lo que en un array de tres elementos, el primer elemento está en el índice 0, el segundo está en el índice 1 y el tercero en el índice 2.

Para acceder a los elementos utilizando el índice del arreglo, necesitas proporcionar el índice entre corchetes después de la variable del arreglo. A continuación se muestra un ejemplo de cómo crear un arreglo y mostrar el segundo elemento:

      $colors = "Red", "Green", "Blue", "Yellow"

$secondColor = $colors[1]

Write-Output $secondColor
      

Puedes acceder a los elementos desde el final de un arreglo utilizando un índice negativo. -1 se refiere al último elemento, -2 al penúltimo elemento, etc.

Usando el operador Join y el operador Split

En PowerShell, el operador join se utiliza para concatenar un arreglo de cadenas en una sola cadena, opcionalmente utilizando un delimitador especificado. Aquí hay un ejemplo sin delimitador.

      $array = "Power", "Shell"

$joined = $array -join ""

# Output: "PowerShell"
      

Aquí está lo que sería con un delimitador:

El operador split básicamente hace lo contrario del operador join, como se muestra en el ejemplo a continuación:

      $string = "apple,banana,grape"
$fruits = $string -split ","
      

Usando el operador Replace

El operador replace se utiliza para reemplazar una cadena por otra. Aquí está la estructura del cmdlet:

      <originalString> -replace <patternToFind>, <replacementString>

      

Aquí hay un ejemplo que reemplazará “Hello World” con “PowerShell”:

      $string = "Hello World"

$newString = $string -replace "World", "PowerShell"

      

Dividir un Array

Puede crear un subarreglo especificando un rango, como se muestra aquí:

      $array = 1,2,3,4,5,6,7,8,9

$subset = $array[3..6]

      

Invertir un Array

Aquí hay un ejemplo de cómo invertir el orden de los elementos en un array:

      $numbers = 1..5

[Array]::Reverse($numbers)
      

Conclusión

Los arrays son una estructura de datos fundamental en la mayoría de los lenguajes de scripting y programación porque te permiten almacenar, recuperar y manipular una colección de elementos de varios tipos de datos. Comprender los arrays mejorará tu capacidad para automatizar tareas utilizando PowerShell.

Ahora Netwrix puede ayudar

¿Necesita asegurar su Active Directory y el entorno de Entra ID (Azure AD) de manera más eficiente y efectiva? Considere Netwrix Directory Manager. Sus capacidades automatizadas de gestión de grupos y usuarios reducen el riesgo de violaciones de datos mientras eliminan las tareas administrativas manuales que consumen tiempo.

Netwrix Directory Manager le otorga la capacidad de:

• Automatice la provisión y desactivación de usuarios desde su sistema de información de recursos humanos (HRIS) a Active Directory, Entra ID y aplicaciones habilitadas para SCIM, permitiendo así que los nuevos empleados sean productivos rápidamente y reduciendo el riesgo de que los adversarios se apoderen de identidades obsoletas.
• Actualice automáticamente los grupos de directorios basándose en cambios como la promoción de un empleado o su cambio a otro rol, según se registra en su HRIS. Esta automatización mantiene los derechos de acceso actualizados en tiempo casi real según lo requerido para la seguridad y el cumplimiento, al mismo tiempo que ahorra tiempo al equipo de TI.
• Delegue la gestión de grupos y usuarios a las personas que saben quién debe tener acceso a qué. Flujos de trabajo sencillos permiten a los propietarios de líneas de negocio revisar sus grupos y aprobar o denegar solicitudes de acceso de usuarios, reduciendo el riesgo de tener grupos y usuarios con demasiados privilegios en su directorio.
• Mantenga el directorio limpio y más fácil de gestionar con la creación, expiración y eliminación automáticas de usuarios.
• Mantenga y demuestre el cumplimiento de las regulaciones y estándares con una visión profunda, automatización efectiva e informes claros sobre grupos y miembros.