Bucles ForEach en PowerShell: Tipos y Mejores Prácticas

Cuando comienzas a escribir scripts en PowerShell, inevitablemente llegarás a un punto en el que necesitarás procesar varios elementos de una colección. Es en ese momento cuando deberás adentrarte en los bucles foreach de PowerShell y aprender de qué se tratan.

Casi todos los lenguajes de programación tienen una construcción llamada bucles; PowerShell no es diferente. Uno de los tipos de bucles más populares en PowerShell es el bucle foreach. En su forma más básica, un bucle foreach lee toda una colección de elementos y ejecuta algún tipo de código para cada elemento.

Uno de los aspectos más confusos del bucle foreach de PowerShell para los principiantes es la variedad de opciones disponibles. No hay una sola manera de procesar cada elemento en una colección; ¡hay tres!

En este artículo, aprenderás cómo funciona cada tipo de bucle foreach y cuándo usar uno en lugar de otro. Al finalizar este artículo, tendrás una buena comprensión de cada tipo de bucle foreach.

Conceptos básicos del bucle foreach en PowerShell

Uno de los tipos de bucles más comunes que usarás en PowerShell es el bucle tipo foreach. Un bucle foreach lee un conjunto de objetos (itera) y se completa cuando termina con el último. La colección de objetos que se lee suele estar representada por una matriz o una tabla hash.

NOTA: El término “iteración” es un término de programación que hace referencia a cada ejecución de un bucle. Cada vez que un bucle completa un ciclo, esto se llama una iteración. El acto de ejecutar un bucle sobre un conjunto de objetos se conoce comúnmente como iterar sobre el conjunto.

Quizá necesites crear un archivo de texto en varias carpetas distribuidas en un sistema de archivos. Digamos que las rutas de las carpetas son C:\Carpeta, C:\Archivos de Programa\Carpeta2 y C:\Carpeta3. Sin un bucle, tendríamos que hacer referencia al cmdlet Add-Content tres veces.

Add-Content -Path 'C:\Folder\textfile.txt' -Value 'This is the content of the file'
Add-Content -Path 'C:\Program Files\Folder2\textfile.txt' -Value 'This is the content of the file'
Add-Content -Path 'C:\Folder2\textfile.txt' -Value 'This is the content of the file'

¿Cuál es la única diferencia entre cada una de estas referencias de comando? Es el valor de Ruta. El valor de Ruta es el único valor que cambia entre cada uno de estos.

Estás duplicando mucho código. Estás perdiendo tiempo escribiendo y te estás exponiendo a problemas más adelante. En cambio, deberías crear un “conjunto” que solo incluya todos los elementos que están cambiando. Para este ejemplo, usaremos un array.

$folders = @('C:\Folder','C:\Program Files\Folder2','C:\Folder3')

Ahora tienes cada una de estas rutas almacenadas en un solo “conjunto” o array. Ahora estás preparado para usar un bucle para iterar sobre cada uno de estos elementos. Antes de hacer eso, sin embargo, es un buen momento para mencionar un tema que generalmente confunde a los nuevos en PowerShell. A diferencia de otros tipos de bucles, los bucles foreach no son todos iguales.

Técnicamente, hay tres tipos de bucles foreach en PowerShell. Aunque cada uno es similar de usar, es importante entender la diferencia.

La Declaración foreach

El primer tipo de bucle foreach es una declaración. foreach es una palabra clave interna de PowerShell que no es un cmdlet ni una función. La declaración foreach siempre se usa en la forma: foreach ($i in $array).

Usando el ejemplo anterior, la variable $i representa el iterador o el valor de cada elemento en $path mientras se itera sobre cada elemento en el array.

Nota que la variable del iterador no tiene que ser $i. El nombre de la variable puede ser cualquier cosa.

En el siguiente ejemplo, puedes lograr la misma tarea que repetir la referencia de Add-Content haciendo lo siguiente:

# Crear un array de carpetas
$folders = @('C:\Folder','C:\Program Files\Folder2','C:\Folder3')

# Realizar la iteración para crear el mismo archivo en cada carpeta
foreach ($i in $folders) {
    Add-Content -Path "$i\SampleFile.txt" -Value "This is the content of the file"
}

La declaración foreach es conocida por ser una alternativa más rápida que usar el ForEach-Object cmdlet.

El CmdLet ForEach-Object

Si foreach es una declaración y solo puede ser usada de una manera, ForEach-Object es un cmdlet con parámetros que puede ser utilizado de muchas maneras diferentes. Al igual que la declaración foreach, el cmdlet ForEach-Object puede iterar sobre un conjunto de objetos. Esta vez, pasa ese conjunto de objetos y la acción a tomar en cada objeto como un parámetro, como se muestra a continuación.

$folders = @('C:\Folder','C:\Program Files\Folder2','C:\Folder3')
$folders | ForEach-Object (Add-Content -Path "$_\SampleFile.txt" -Value "This is the content of the file")

Nota: Para complicar las cosas, el cmdlet ForEach-Object tiene un alias llamado foreach. Dependiendo de cómo se llame el término “foreach”, se ejecuta la declaración foreach o se ejecuta ForEach-Object.

A good way to differentiate these situations is to notice if the term “foreach” is followed by ($someVariable in $someSet). Otherwise, in any other context, the code author is probably using the alias for ForEach-Object.

El Método foreach()

Uno de los bucles foreach más recientes fue introducido en PowerShell v4 y se llama método foreach(). Este método existe en un objeto de matriz o colección. El método foreach() tiene un parámetro de bloque de script estándar que contiene las acciones a realizar en cada iteración, al igual que los demás.

$folders = @('C:\Folder','C:\Program Files\Folder2','C:\Folder3')
$folders.ForEach({
	Add-Content -Path "$_\SampleFile.txt" -Value "This is the content of the file"
})

La diferencia más significativa con el método foreach() radica en cómo funciona bajo el capó.

Usar el método foreach() es considerablemente más rápido y se nota especialmente en conjuntos grandes. Se recomienda utilizar este método sobre los otros dos si es posible.

Mini-Proyecto: Iterar sobre un conjunto de nombres de servidor

Uno de los usos más comunes de un bucle en PowerShell es leer un conjunto de servidores desde alguna fuente y realizar alguna acción en cada uno de ellos. Para nuestro primer mini-proyecto, construyamos código que nos permita leer nombres de servidores (uno por línea) desde un archivo de texto y hacer ping a cada servidor para determinar si están en línea o no.

Para este flujo de trabajo, ¿qué tipo de bucle crees que funcionaría mejor?

Observa que mencioné la palabra “conjunto” como en “conjunto de servidores”. Esto ya es una pista. Ya tienes un número especificado de nombres de servidor y deseas realizar alguna acción en cada uno de ellos. Esto suena como una excelente oportunidad para probar el bucle foreach, que es el bucle más comúnmente utilizado en PowerShell.

La primera tarea es crear un conjunto de nombres de servidor en código. La forma más común de hacerlo es creando un array. Por suerte para nosotros, Get-Content, por defecto, devuelve un array con cada elemento representado por una sola línea en el archivo de texto.

Primero, crea un array con todos los nombres de mis servidores y llámalo $servidores.

$servers = Get-Content .\servers.txt

Ahora que tienes el array creado, ahora necesitarás confirmar si cada servidor está en línea o no. Un gran cmdlet para probar la conexión de un servidor se llama Test-Connection. Este cmdlet realiza algunas pruebas de conexión en una computadora para ver si está en línea o no.

Al ejecutar Test-Connection dentro de un bucle foreach para leer cada línea del archivo, puedes pasar cada nombre de servidor representado por la variable $servidor a Test-Connection. Así es como PowerShell recorre un archivo de texto. Puedes ver un ejemplo de cómo funciona esto a continuación.

foreach ($server in $servers) {
	try {
		$null = Test-Connection -ComputerName $server -Count 1 -ErrorAction STOP
		Write-Output "$server - OK"
	}
	catch {
		Write-Output "$server - $($_.Exception.Message)"
	}
}

Cuando se ejecuta el bucle foreach, se verá algo así:

¡Ahora has probado con éxito la conexión de un archivo de texto lleno de nombres de servidor! En este punto, ahora puedes agregar o eliminar nombres de servidor dentro del archivo de texto a voluntad sin cambiar el código.

Has practicado con éxito lo que hemos estado predicando, el método DRY.

Ejemplos de ForEach PowerShell

Vamos a ver algunos ejemplos de cómo usar el bucle ForEach. Estos se basan en casos de uso del mundo real que muestran el concepto y que puedes modificar para que se ajusten a tus requisitos.

Ejemplo 1: Crear un archivo en cada subcarpeta de un directorio utilizando la declaración ForEach

Este ejemplo demuestra el uso común del bucle ForEach de PowerShell en una carpeta de directorio.

Supongamos que hay diez subcarpetas dentro de la carpeta C:\ARCHIVE_VOLUMES. Cada subcarpeta representa un volumen de archivo que se respalda diariamente. Después de que se completa cada respaldo, se crea un archivo llamado BackupState.txt dentro de cada carpeta que contiene la fecha en que se realizó el respaldo.

Puedes ver un ejemplo de cómo podría verse esto a continuación.

El script a continuación realiza tres acciones:

• obtiene la lista de todas las subcarpetas dentro de C:\ARCHIVE_VOLUMES
• recorre cada carpeta
• crea un archivo de texto llamado BackupState.txt que contiene la fecha y hora actual como su valor

El ejemplo a continuación utiliza la declaración foreach.

# Define la carpeta de nivel superior
$TOP_FOLDER = "C:\ARCHIVE_VOLUMES"

# Obtén todas las subcarpetas de forma recursiva
$Child_Folders = Get-ChildItem -Path $TOP_FOLDER -Recurse | Where-Object { $_.PSIsContainer -eq $true }

# Crea un archivo de texto en cada subcarpeta y agrega la fecha/hora actual como valor.
foreach ($foldername in $Child_Folders.FullName) {
   (get-date -Format G) | Out-File -FilePath "$($foldername)\BackupState.txt" -Force
}

Usando el cmdlet Get-ChildItem, puedes confirmar que los archivos fueron creados o actualizados dentro de cada una de las subcarpetas.

Get-ChildItem -Recurse -Path C:\ARCHIVE_VOLUMES -Include backupstate.txt | Select-Object Fullname,CreationTime,LastWriteTime,Length

La captura de pantalla a continuación muestra la salida del script que muestra todos los archivos BackupState.txt encontrados en cada subdirectorio.

Ejemplo 2: Leyendo el contenido de cada archivo de texto en subdirectorios

A continuación, para demostrar el uso del bucle foreach de PowerShell para cada archivo en un directorio, el script a continuación leerá cada archivo BackupState.txt creado en Ejemplo 1.

• Encuentra de forma recursiva todos los archivos BackupState.txt dentro de cada subdirectorio.
• Usando la instrucción foreach, lee cada archivo de texto para obtener el valor de “última hora de respaldo”.
• Muestra el resultado en la pantalla.

## Encuentra todos los archivos BackupState.txt en C:\ARCHIVE_VOLUMES
$files = Get-ChildItem -Recurse -Path C:\ARCHIVE_VOLUMES -Include 'BackupState.txt' | Select-Object DirectoryName,FullName

## Lee el contenido de cada archivo
foreach ($file in $files) {
    Write-Output ("$($file.DirectoryName) last backup time - " + (Get-Content $file.FullName))
}

Una vez que se ejecuta el script en tu sesión de PowerShell, deberías ver una salida similar a la captura de pantalla a continuación. Esto muestra que PowerShell recorre los archivos, lee el contenido y muestra la salida.

Ejemplo 3: Obteniendo Servicios y Iniciándolos usando el CmdLet ForEach-Object

Los administradores del sistema a menudo necesitan conocer el estado de los servicios y activar un flujo de trabajo manual o automático para remediar cualquier servicio fallido. Veamos el script de ejemplo usando el cmdlet ForEach-Object.

Para este ejemplo, el script a continuación hará lo siguiente:

• Obtener una lista de servicios que están configurados para un inicio automático pero que actualmente no están en un estado de ejecución.
• A continuación, los elementos de la lista se pasan al cmdlet ForEach-Object para intentar iniciar cada servicio.
• A message of either success or failed is displayed depending on the result of the Start-Service command.

## Obtener una lista de servicios automáticos que están detenidos.
$services = Get-Service | Where-Object {$.StartType -eq 'Automatic' -and $.Status -ne 'Running'}

## Pasar cada objeto de servicio al conducto y procesarlos con el cmdlet Foreach-Object
$services | ForEach-Object {
    try {
        Write-Host "Attempting to start '$($.DisplayName)'"
        Start-Service -Name $.Name -ErrorAction STOP
        Write-Host "SUCCESS: '$($.DisplayName)' has been started"
    } catch {
        Write-output "FAILED: $($.exception.message)"
    }
}

Cuando se ejecuta el script, se verá como en la captura de pantalla de salida a continuación. Como se puede ver, se emitió un comando de inicio para cada servicio. Algunos se iniciaron correctamente mientras que algunos de ellos no pudieron iniciarse.

Ejemplo 4: Lectura de datos desde CSV usando el Método ForEach()

Usar datos de archivos CSV es popular entre los administradores del sistema. Colocar registros dentro de un archivo CSV facilita la ejecución de operaciones masivas usando la combinación Import-CSV y ForEach. Esta combinación se usa comúnmente para crear varios usuarios en Active Directory.

En este próximo ejemplo, se asume que tiene un archivo CSV con dos columnas – Nombre y Apellido. Este archivo CSV debería estar poblado con los nombres de los nuevos usuarios a crear. El archivo CSV se vería algo así.

"Firstname","Lastname"
"Grimm","Reaper"
"Hell","Boy"
"Rick","Rude"

Ahora, para el siguiente bloque de script. Primero, importa el archivo CSV pasando la ruta del contenido al cmdlet Import-CSV. Luego, utilizando el método foreach(), recorre los nombres y crea los nuevos usuarios en Active Directory.

# Importar lista de nombre y apellido desde el archivo CSV
$newUsers = Import-Csv -Path .\Employees.csv

Add-Type -AssemblyName System.Web

# Procesar la lista
$newUsers.foreach(
    {
        # Generar una contraseña aleatoria
        $password = [System.Web.Security.Membership]::GeneratePassword((Get-Random -Minimum 20 -Maximum 32), 3)
        $secPw = ConvertTo-SecureString -String $password -AsPlainText -Force

        # Formular un nombre de usuario
        $userName = '{0}{1}' -f $_.FirstName.Substring(0, 1), $_.LastName

        # Construir nuevos atributos de usuario
        $NewUserParameters = @{
            GivenName       = $_.FirstName
            Surname         = $_.LastName
            Name            = $userName
            AccountPassword = $secPw
        }

        try {
            New-AdUser @NewUserParameters -ErrorAction Stop
            Write-Output "User '$($userName)' has been created."
        }
        catch {
            Write-Output $_.Exception.Message
        }
    }
)

¡Al ejecutarlo, ahora deberías haber creado un usuario de AD para cada fila en el archivo CSV!

Resumen

La lógica detrás del bucle foreach en PowerShell no es diferente a la de otros lenguajes de programación. Solo cambia con cómo se usa y qué variación del bucle foreach se elige para una tarea específica.

En este artículo, has aprendido los diferentes tipos de bucles foreach disponibles en PowerShell y qué considerar en cuanto a cuál usar. También has visto los tres tipos de bucles foreach en acción utilizando diferentes escenarios de muestra.

Lectura adicional

• Manejo de archivos CSV en PowerShell con Import-Csv (bucle foreach)
• Nuevo-ADUser: Creación de usuarios de Active Directory con PowerShell
• Fundamentos del bucle en PowerShell: Foreach | Blog de script