Scripts de PowerShell: guía definitiva para empezar

¿Automatizar tareas diarias, extraer información de los sistemas o administrar Microsoft 365? Los scripts de PowerShell realmente facilitan mucho su trabajo diario. Cuando trabajas en TI, no puedes evitar PowerShell.

PowerShell es una interfaz de línea de comandos (CLI) avanzada y un lenguaje de secuencias de comandos que se puede utilizar en Windows, Linux y macOS. Con la ayuda de cmdlets, podemos realizar tareas como recuperar usuarios de Active Directory o probar la conexión de red de un servidor. Podemos combinar estas tareas y procesos en scripts que podemos ejecutar rápidamente en varias computadoras o programar como una tarea diaria.

En este artículo, explicaré cómo puedes crear tus propios scripts de PowerShell. Qué herramientas puede utilizar, cómo formatear sus scripts y algunos consejos generales para comenzar. Al final del artículo, también encontrará una plantilla que puede utilizar para sus scripts.

Editor de PowerShell

La mayoría de las personas que empiezan a escribir scripts de PowerShell utilizan una herramienta de bloc de notas sencilla, como Notepad++. Funciona para scripts pequeños, pero un buen editor facilita mucho la escritura de scripts de PowerShell. Vienen con resaltado de sintaxis, funciones de autocompletar, detección de errores, etc. Y lo que más me gusta es que puedes crear un proyecto, lo que te permite cambiar rápidamente entre archivos y mantener tus archivos organizados.

Para PowerShell, uno de los mejores editores gratuitos para empezar es Visual Studio Code. Este editor, de Microsoft, es completamente gratuito y se puede utilizar en Windows, Linux y macOS. Para utilizar el editor con PowerShell, necesitará instalar un complemento (extensión).

1. Primero, instale Visual Studio Code usando el instalador. Simplemente haga clic en Siguiente en todas las pantallas.
2. Haga clic en Extensiones
3. Busque PowerShell
4. Instalar la extensión PowerShell de Microsoft

Para crear nuestro primer script de PowerShell necesitaremos crear un nuevo archivo. Para mantenernos organizados, crearemos una nueva carpeta “scripts” donde guardaremos nuestros archivos. En código de Visual Studio:

1. Abre el Explorador
2. Elija Abrir carpeta
3. Crea una nueva carpetar, scripts, en tu OneDrive, por ejemplo
4. Haga clic en Seleccionar carpeta

Recibirá un mensaje si confía en los archivos de esta carpeta. Asegúrese de marcar "Confiar en los autores de todos los archivos de la carpeta principal" y haga clic en Sí, confío en los autores.

Para crear un nuevo archivo, haga clic derecho en el editor (o haga clic en el ícono Nuevo archivo) y cree su primer script de PowerShell. Por supuesto, también puedes crear una subcarpeta para mantener tus scripts organizados.

Ejecutar un script de PowerShell

Antes de comenzar a escribir nuestro script de PowerShell, es bueno saber cómo ejecutar o probar sus scripts. Uno de los problemas comunes cuando intentas ejecutar tu script es el error “La ejecución de scripts está deshabilitada en este sistema”. Para solucionar esto tendremos que cambiar el permiso de ejecución en tu ordenador con Windows 10 u 11.

Abra PowerShell y escriba el siguiente comando para cambiar la política de ejecución. Lea más sobre la política de ejecución de PowerShell en este artículo.

Set-ExecutionPolicy -ExecutionPolicy RemoteSigned

# Verify the setting with
Get-ExecutionPolicy

Con la política de ejecución configurada, podemos ejecutar nuestros scripts sin errores de permisos. Ahora existen múltiples opciones para ejecutar un script de PowerShell; lea más sobre ellas en este artículo, pero para esta guía, nos centraremos en las dos siguientes:

• Usando la terminal incorporada en Visual Studio Code
• Ejecute el script en PowerShell

Usando código de Visual Studio

Una de las ventajas de utilizar Visual Studio Code como editor para sus scripts de PowerShell es que puede probar y ejecutar sus scripts en la terminal integrada. Puede ejecutar todo el script presionando F5 o ejecutar una selección de líneas presionando F8.

Usando PowerShell

Otro método es utilizar PowerShell para ejecutar el script. Abra Windows PowerShell o Windows Terminal (haga clic derecho en Inicio) y navegue hasta la carpeta donde está guardado su script. Escriba el nombre de archivo de su secuencia de comandos y presione Entrar.

Los conceptos básicos

Usar cmdlets en PowerShell

En el símbolo del sistema, tenemos comandos, que son funciones integradas (comandos) que realizan una tarea. Por ejemplo, si escribe hostname en el símbolo del sistema, se mostrará el nombre de su computadora. O el comando dir enumerará el contenido del directorio actual.

En PowerShell, tenemos comandos-lets (cmdlets). Puede reconocer un cmdlet por su nombre porque existe en un par Verbo-Sustantivo. Esta convención de nomenclatura le ayuda a comprender qué hace un cmdlet en particular.

Nota

En algunos ejemplos a continuación, estoy usando cmdlets del módulo Active Directory. Asegúrate de tener el módulo instalado si quieres seguir los pasos. Ejecute el siguiente comando para instalar el módulo:

Add-WindowsCapability -online -Name “Rsat.ActiveDirectory.DS-LDS.Tools~~~~0.0.1.0 ”

Por ejemplo, el cmdlet Get-ComputerInfo obtiene toda la información de su computadora. Para mostrar el contenido de una carpeta, podemos usar Get-ChildItem, por ejemplo.

Además de los cmdlets integrados, también puede instalar módulos en PowerShell. Estos módulos se pueden utilizar, por ejemplo, para trabajar con Exchange Online o Azure AD. Cada módulo viene con sus propios cmdlets para su tarea específica.

Hoja de referencia de PowerShell

Asegúrese de verificar y descargar también la hoja de referencia de PowerShell

Verbos de PowerShell

Hay muchos verbos aprobados que puede usar cuando crea sus propios comandos o funciones de PowerShell. Pero los verbos más comunes con los que te encontrarás son:

variables

Al escribir scripts, a menudo necesitará almacenar datos temporalmente, para poder utilizarlos más adelante en el script. Para ello utilizamos variables. En PowerShell no necesitamos inicializar las variables, simplemente podemos crearlas cuando sea necesario. Las variables no solo pueden almacenar datos, como cadenas y números enteros, sino también la salida completa de cmdlets.

Comencemos con un ejemplo simple, tomamos el cmdlet Get-Computer de antes. El cmdlet devuelve el nombre de su computadora:

Nota

El contenido después del # en un script de PowerShell es un comentario. Los comentarios se utilizan para explicar qué hace una función y hacer que su código sea más confiable.

hostname

# Result
LazyBook

No queremos simplemente mostrar el nombre de la computadora, sino que queremos incluir el nombre de la computadora dentro de una bonita cadena. En este caso, primero podemos almacenar el resultado del cmdlet Get-Computername en una variable, a la que llamaremos computername. Y luego incluya esta variable dentro de la cadena:

# Store computer name inside the variable
$computername = hostname

# Include the variable inside the string
Write-Host "The name of your computer is $computername"

# Result
The name of your computer is LazyBook

Operadores de comparación y condiciones If-Else

En PowerShell, podemos usar operadores de comparación para comparar o encontrar valores coincidentes. De forma predeterminada, los operadores no distinguen entre mayúsculas y minúsculas, pero puede marcar una c antes de un operador para que distinga entre mayúsculas y minúsculas. Por ejemplo:

'lazyadmin' -eq 'LazyAdmin'
# Result
True

'lazyadmin' -ceq 'LazyAdmin'
# Result
False

Los operadores que podemos utilizar en PowerShell son:

Podemos usar estos operadores en combinación con, por ejemplo, declaraciones If-Else. Las declaraciones If nos permiten comprobar si una comparación particular es cierta o no. Dependiendo del resultado podemos ejecutar un fragmento de código o pasar a otra parte.

Tomemos nuevamente el ejemplo del nombre de la computadora. Hemos almacenado el nombre de la computadora dentro de la variable. Ahora verifiquemos si el nombre de la computadora es mi computadora portátil:

$computername = hostname

# Check if the computer name equal LazyBook
if ($computername -eq 'LazyBook') {
  Write-Host "This computer is from LazyAdmin"
}else{
  Write-host "This is someone else's computer"
}

Los nombres de nuestras computadoras comienzan con LT para computadoras portátiles y PC para computadoras de escritorio. Entonces podríamos determinar si el dispositivo es una computadora portátil o no según el nombre de la computadora. Para esto, usaremos una declaración if con un operador -like. El operador like acepta un comodín, por lo que podemos, por ejemplo, comprobar si una cadena empieza por “LT” en este caso

$computername = hostname

# Or better is
$computername = $env:COMPUTERNAME

# Check if the computer name start with Lazy
if ($computername -like 'Lazy*') {
  Write-Host "This is a laptop"
}else{
  Write-host "This is something else"
}

Pasar resultados reales con Pipelining

Además de las variables, existe otra forma de pasar datos a otro cmdlet en PowerShell, que consiste en utilizar el operador de canalización | . El operador de la tubería pasa los resultados del comando al siguiente comando. El ejemplo más común de canalización es formatear o seleccionar el resultado de un cmdlet.

Tomemos el siguiente ejemplo, el cmdlet Get-NetIPAddress devuelve la configuración de la dirección IP de todas sus interfaces de red. De forma predeterminada, devolverá los resultados en formato de lista.

Get-NetIPAddress

Para que los resultados sean más legibles, podemos formatear los resultados en una tableta o seleccionar solo las propiedades que necesitamos. Hacemos esto colocando el cmdlet format-table (ft) detrás de él o el cmdlet select-object (select):

Get-NetIPAddress | FT

# Or select the fields
Get-NetIPAddress | Select InterfaceAlias, IPAddress, PrefixOrigin

Ahora bien, este es un ejemplo sencillo de cmdlets de canalización. Pero echemos un vistazo a un uso más avanzado de los cmdlets de tubería. Vamos a recopilar todos los buzones de correo de los usuarios, de cada buzón buscaremos las estadísticas del buzón, seleccionaremos solo los campos que necesitemos y exportaremos los resultados a un archivo CSV. Sin el operador de tubería, necesitaríamos escribir un código similar a este:

Nota

El cmdlet Get-EXOMailbox es parte del módulo Exchange Online. Asegúrese de haberlo instalado si desea seguir los pasos a continuación.

$mailboxes = Get-EXOMailbox -RecipientTypeDetails UserMailbox

$mailboxes.ForEach({
  $Mailboxstats = Get-EXOMailboxStatistics -Identity $_.Identity
  $fields = Select-Object -InputObject $Mailboxstats -Property DisplayName,ItemCount,TotalItemSize
  Export-CSV -InputObject $fields -Path c:\temp\file.csv -Append
})

Pero con piping en PowerShell simplemente podemos hacer lo siguiente:

Get-EXOMailbox -RecipientTypeDetails UserMailbox | Get-EXOMailboxStatistics | Select DisplayName, ItemCount, TotalItemSize | Export-CSV c:\temp\filename.csv

Almacenamiento de datos en matrices y tablas hash

Se pueden utilizar matrices y tablas hash para almacenar una colección de datos. Las tablas hash utilizan un principio de valor clave en el que es necesario definir la clave antes de poder almacenar el valor. Las matrices utilizan un índice generado automáticamente para almacenar los valores.

Para crear una matriz simplemente podemos asignar múltiples valores a una variable, separando cada uno de ellos con un común. Por ejemplo:

# Create an array of fruits
$array = 'apple','raspberry','kiwi'

Otra opción es inicializar primero la matriz y agregar valores a la matriz más adelante. Para crear una matriz vacía usaremos el símbolo @ seguido de paréntesis :

# Create an empty array
$fruits = @()

# Add content to the array
$fruits += "apple"

Las tablas hash también se conocen como matrices asociativas y se utilizan cuando es necesario almacenar datos de una manera más estructurada. En lugar de un índice numerado, se basa en un par clave-valor, donde usted mismo debe definir la clave. Para crear una tabla hash vacía necesitarás usar llaves y el símbolo @:

# Create empty hashtable
$hashTable = @{}

Por ejemplo, podría utilizar una tabla hash para almacenar las direcciones IP del servidor.

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

# Result
Name                           Value
----                           -----
la-srv-lab02                   192.168.10.2
la-srv-db01                    192.168.10.100

O como un archivo de configuración dentro de tu script:

$mail = @{
  SmtpServer  = 'smtp.contoso.com'
  To          = 'johndoe@lazyadmin.nl'
  From        = 'info@contoso.com'
  Subject     = 'super long subject goes here'
  Body        = 'Test email from PowerShell'
  Priority    = High
}

Recorriendo datos con Foreach y Do-While

Recorrer datos en bucle es una de las tareas comunes en cualquier lenguaje de programación. Los bucles ForEach le permiten revisar cada elemento de una colección y hacer algo con ese elemento. Por ejemplo, tomamos el conjunto de frutas y escribimos cada elemento (fruta) en la consola:

$fruits = @('apple','pear','banana','lemon','lime','mango')

# Foreach block
Foreach ($fruit in $fruits) {
    Write-Host $fruit;
}

# Shorthand
$fruits.foreach( {
    Write-Host $_;
})

En el ejemplo anterior solo usamos una matriz simple, pero también puedes usar ForEach en objetos. Dentro del bloque ForEach puede acceder a cada propiedad del objeto, por ejemplo, si obtenemos todos los buzones, podemos acceder al nombre para mostrar de la siguiente manera:

$mailboxes = Get-EXOMailbox -RecipientTypeDetails UserMailbox

$mailboxes.ForEach({ 
  # Write the displayname of each mailbox
  Write-host $_.DisplayName
})

Además de los bucles ForEach, también podemos utilizar los bucles While y Do-While. Un bucle while solo se ejecutará cuando se cumpla una condición, el Do-While siempre se ejecuta una vez y mientras la condición sea verdadera.

# Do While loop
Do {
    Write-Host "Online"
    Start-Sleep 5
}
While (Test-Connection -ComputerName 8.8.8.8 -Quiet -Count 1)

Write-Host "Offline"

# While loop
$i = 0;
$path = "C:\temp"

While ($i -lt 10) {
    # Do Something
    $newFile = "$path\while_test_file_" + $i + ".txt";
    New-Item $newFile
    $i++;
}

Obtenga más información sobre los bucles For, las declaraciones ForEach y los bucles Do While en este artículo.

Detectar errores con Try-Catch

Los bloques try-catch se utilizan para manejar los errores de forma adecuada. Normalmente, cuando una función no funciona o se produce un error, el script simplemente se detendrá y arrojará un error. A veces esto está bien, pero en otras ocasiones es posible que desees mostrar un error más legible o simplemente continuar.

Por ejemplo, cuando actualiza varios usuarios en Active Directory mediante un bucle ForEach. Cuando una de las cuentas de usuario no existe, el script generará un error y se detendrá. Pero una mejor solución sería si el script mostrara el nombre de los usuarios que no actualizó y simplemente continuara con el siguiente. Aquí es donde entran los bloques Try-Catch.

Tomando el ejemplo anterior, el siguiente bloque de código intentará encontrar y actualizar al usuario de Azure AD; si se produce un error en el bloque Try, la parte Catch mostrará un error.

$users.ForEach{
  Try{
    # Find the user to update
    $ADUser = Get-AzureAdUser -SearchString $_.name
    
    # Update the job title
    Set-AzureAdUser -ObjectId $ADUser.ObjectId -JobTitle $_.jobtitle
  }
  Catch{
    Write-Host ("Failed to update " + $($_.name)) -ForegroundColor Red
  }
}

Ahora, esta es una implementación básica de un bloque try-catch, incluso es posible usar múltiples bloques catch en una sola declaración Try, lo que le permite detectar diferentes errores. Lea más sobre los bloques Try-Catch en este artículo detallado.

Crear secuencias de comandos de PowerShell

Ahora debería tener una breve comprensión de qué herramientas puede utilizar en PowerShell para crear scripts. Entonces, echemos un vistazo a cómo combinamos esto en verdaderos scripts de PowerShell. Para los ejemplos siguientes, crearemos un pequeño script que crea archivos de prueba en una carpeta determinada.

A continuación encontrará el principio básico del script. Tenemos una ruta, codificada en el script, una matriz con los números del 1 al 10 y un bucle ForEach. Con los ejemplos siguientes, vamos a mejorar este script para convertirlo en un verdadero script de PowerShell.

$path = "C:\temp"

1..10 | ForEach-Object {
    $newFile = "$path\test_file_$_.txt";
    New-Item $newFile
}

Documentación y comentarios

Al crear scripts de PowerShell, siempre es una buena idea agregar documentación al script. La documentación se coloca en la parte superior de su script en un bloque de comentarios y describe lo que hace el script, un par de ejemplos sobre cómo usarlo y un bloque de notas con el autor, la versión, la fecha, etc.

Entonces, para nuestro script de archivo de prueba, podemos agregar la siguiente descripción al comienzo de nuestro archivo:

<#
  .SYNOPSIS
  Create test files in given directory

  .DESCRIPTION
  The script generates an x amount of text file based test file in the given folder. The files don't
  contain any content.

  .EXAMPLE
  CreateTestFiles.ps1 -path c:\temp -amount 50

  Create 50 files in c:\temp
  
  .NOTES
  Version:        1.0
  Author:         R. Mens - LazyAdmin.nl
  Creation Date:  04 oct 2022
  Modified Date:  
  Purpose/Change: Init
  Link:           https://lazyadmin.nl/powershell/powershell-scripting
#>

Si ahora ejecuta el comando Get-Help seguido del nombre del script en PowerShell, obtendrá la explicación de su script:

Lea más sobre comentarios y documentación en la Guía de mejores prácticas de PowerShell.

Parámetros del cmdlet

Al usar cmdlets de PowerShell probablemente hayas notado que la mayoría de ellos vienen con parámetros que podemos configurar. Por ejemplo, cuando desee obtener un buzón de Exchange Online, puede especificar el nombre de usuario con el parámetro -Identity. Podemos hacer lo mismo en nuestros propios scripts de PowerShell definiendo atributos de parámetros.

En el ejemplo anterior, hemos codificado la variable de ruta. Si desea crear los archivos de prueba en un directorio diferente, deberá cambiar el script. Una mejor opción sería si pudiera establecer la ruta desde la línea de comando. Entonces vamos a crear un bloque de parámetros, con la ruta del parámetro:

param(
  [Parameter()]
  [string]$path
)

# Create files
1..10 | ForEach-Object {
    $newFile = "$path\test_file_$_.txt";
    New-Item $newFile
}

Esperamos que la ruta sea una cadena; otras opciones son, por ejemplo, un interruptor donde puede elegir un valor o un número entero. Si abre PowerShell y escribe el nombre del archivo del script, también puede agregar el parámetro -path:

¿Pero qué pasa si el usuario del script no establece la ruta? En este caso, la ruta es obligatoria; sin ella, el archivo de prueba se creará en la ubicación raíz del script. Para que sea obligatorio, agregamos la propiedad del parámetro Mandatory y la configuramos en verdadero. Otra opción es establecer un valor predeterminado:

param(
  [Parameter(
    Mandatory = $true,
    HelpMessage = "Enter path were test files should be created"
  )]
  [string]$path,

  [Parameter(
    HelpMessage = "How many files should be created"
  )]
  [int]$amount = 10
)

Anfitrión de lectura

Nuestro script creará archivos de texto en la carpeta dada. Si el usuario comete un error tipográfico, entonces es posible que el script cree 1000 archivos, por ejemplo, en lugar de 100. Entonces, antes de crear los archivos, podría ser una buena idea pedir confirmación. Para esto, usaremos el cmdlet Read-Host.

Read-Host se utiliza para solicitar información al usuario. Puede ser una cadena o una contraseña, por ejemplo. Los resultados de la entrada se pueden validar con una simple comparación. En este caso primero vamos a escribir en la consola los valores que el usuario ha renunciado a través de los parámetros, y luego preguntaremos si el usuario quiere continuar:

# Ask for confirmation
Write-host "Creating $amount test files in $path" -ForegroundColor Cyan
$reply = Read-Host -Prompt "Is this correct? [Y] Yes [N] No "

# Check the reply and create the files:
if ( $reply -match "[yY]" ) { 
    # Create files
    1..10 | ForEach-Object {
      $newFile = "$path\test_file_$_.txt";
      New-Item $newFile
    }
}

Funciones

Las funciones son una excelente manera de organizar y reutilizar fragmentos de código dentro de su secuencia de comandos. Una función debe realizar una sola tarea. Puede encontrar un buen ejemplo de esto en este script de Informe de tamaño de OneDrive. La función ConvertTo-Gb toma un valor, lo convierte a Gigabytes y devuelve el resultado. Si te desplazas un poco hacia abajo en el script verás que la función Get-OneDriveStats reúne todos los OneDrive y procesa cada uno de ellos. Dentro del bucle ForEach, convierto los valores usando la función ConvertTo-GB.

La estructura de una función es básicamente un pequeño script. Empezamos con una breve descripción, la sinopsis. Si necesitamos pasar valores al script, usaremos Parámetros. También puede notar que algunas funciones tienen 3 bloques de código, un inicio, un proceso y un final. El bloque de proceso se ejecuta para todos los valores que pasa a la función y los bloques de inicio y fin solo una vez. Ahora tengo que decir que no uso el inicio y el final con frecuencia.

Entonces vamos a crear una función simple para nuestro script de archivos de prueba. También agregué el parámetro Ruta en la función. Realmente no es necesario, porque la función también tiene acceso a los parámetros que hemos configurado al principio del script. (esto es más para demostrar las posibilidades)

Function New-TestFiles{
  <#
    .SYNOPSIS
        Create test files
  #>
  param(
    [Parameter(Mandatory = $true)]
    [string]$path
  )
  1..$amount | ForEach-Object {
    $newFile = "$path\test_file_$_.txt";
    New-Item $newFile
  }
}

Ahora podemos usar la función en nuestro script de la siguiente manera:

if ( $reply -match "[yY]" ) { 
    New-TestFiles -path $path
}

Puntos de interrupción

Es fácil cometer un error tipográfico, una cita olvidada o un pequeño error al crear un script de PowerShell. Por eso es importante probar constantemente el guión cuando lo escribes. Pero incluso entonces, a veces puede resultar difícil encontrar la causa del error en el script.

Para ayudarle a encontrar errores en su secuencia de comandos, puede utilizar puntos de interrupción. Si está utilizando Visual Studio Code, puede utilizar la función Ejecutar y depurar integrada, que le permite establecer puntos de interrupción de línea y ejecutar su secuencia de comandos línea por línea.

En el código de Visual Studio, podemos establecer puntos de interrupción haciendo clic en el punto rojo justo antes del número de línea. En la captura de pantalla siguiente, establecí un punto de interrupción (1) en el cmdlet New-Item en la línea 46. Cuando hacemos clic en Ejecutar (2) el script se ejecutará y se detendrá en el punto de interrupción en la línea 46. Por el momento, podemos ver las variables en el lado izquierdo (3). Esto nos dice que el bucle ForEach-Object está en el primer elemento y que el nuevo archivo se creará en c:\temp\files con el nombre test_file_1. .txt

Con los botones de la parte superior (5) podremos pasar al siguiente paso, saltar un paso, etc.

Usar puntos de interrupción en PowerShell

Otra opción para depurar su script de PowerShell es usar el cmdlet Set-PSBreakpoint en la consola. Este cmdlet le permite establecer puntos de interrupción para cualquier script que desee ejecutar en PowerShell. Con el cmdlet, podemos establecer puntos de interrupción en un número de línea, acción o variable. Entonces, establezcamos el mismo punto de interrupción que establecimos en Visual Studio Code:

# Set the breakpoint on line 46 for the script CreateTestFiles.ps1
Set-PSBreakPoint -Script .\CreateTestFiles.ps1 -Line 46

Cuando ejecutemos el script, se detendrá en la línea 46:

El guión está detenido, pero no muestra nada. Entonces, comenzaremos mostrando el código alrededor de nuestro punto de interrupción. Simplemente escribe la letra L en la consola:

El símbolo de asterisco en la línea 46 indica los puntos de interrupción que hemos establecido. Si queremos saber cuál es la variable de ruta o el nuevo nombre del archivo, simplemente podemos escribir los nombres de las variables en la consola y presionar Enter:

Podemos ver todos los puntos de interrupción que hemos configurado con el cmdlet Get-PSBreakpoint y eliminarlos con Remove-PSBreakpoint. La combinación de ambos eliminará todos los puntos de interrupción:

Get-PSBreakPoint | Remove-PSBreakpoint

Concluyendo

Al crear secuencias de comandos de PowerShell, comience siempre poco a poco y pruebe su secuencia de comandos con frecuencia. Además, asegúrese de agregar comentarios a su código cuando sea necesario. Puede que ahora esté claro cuáles son los códigos, pero si necesita editar su script un año después, a veces puede ser un enigma descubrir qué hace el script y cómo funciona.

Si desea obtener más información sobre PowerShell, el siguiente libro es realmente una buena lectura. Este es uno de los más vendidos cuando se trata de aprender PowerShell:

• Plunk, Travis (Autor)
• Inglés (Idioma de publicación)
• 360 páginas - 26/04/2022 (Fecha de publicación) - Manning (Editor)

En los ejemplos anteriores creamos un pequeño script que crea archivos de prueba; a continuación encontrará el script completo. Como se mencionó, es un poco excesivo para una tarea tan simple, pero le da una idea de cómo desarrollar su guión.

<#
  .SYNOPSIS
  Create test files in given directory

  .DESCRIPTION
  The script generates an x amount (by default 10) of text file based test file in the 
  given folder. The files don't contain any content.

  .EXAMPLE
  CreateTestFiles.ps1 -path c:\temp -amount 50

  Create 50 files in c:\temp

  .NOTES
  Version:        1.0
  Author:         R. Mens - LazyAdmin.nl
  Creation Date:  04 oct 2022
  Modified Date:  
  Purpose/Change: Init
  Link:           https://lazyadmin.nl/powershell/powershell-scripting
#>

param(
  [Parameter(
    Mandatory = $true,
    HelpMessage = "Enter path were test files should be created"
  )]
  [string]$path,

  [Parameter(
    HelpMessage = "How many files should be created"
  )]
  [int]$amount = 10
)

Function New-TestFiles{
  <#
    .SYNOPSIS
        Create test files
  #>
  param(
    [Parameter(Mandatory = $true)]
    [string]$path
  )
  1..$amount | ForEach-Object {
    $newFile = "$path\test_file_$_.txt";
    New-Item $newFile
  }
}

# Ask for confirmation
Write-host "Creating $amount test files in $path" -ForegroundColor Cyan
$reply = Read-Host -Prompt "Is this correct? [Y] Yes [N] No "

if ( $reply -match "[yY]" ) { 
    New-TestFiles -path $path
}

Espero que este artículo te haya resultado útil. Si tienes alguna pregunta, deja un comentario a continuación. ¡Y por favor compártelo si te gustó!