Parámetros de función en PowerShell

1. Definir parámetros de funciones de PowerShell
2. Parámetros con nombre en la función de PowerShell
3. Parámetros posicionales en la función de PowerShell
4. Cambiar parámetros en la función PowerShell
5. Splatting en los parámetros de la función PowerShell
6. Atributos de parámetros de PowerShell
7. Función avanzada con sintaxis de parámetros con nombre

Los parámetros de función de PowerShell hacen que las funciones sean más potentes al aprovechar las características y los argumentos para limitar a los usuarios el ingreso de valores particulares. Agrega algunas reglas y validaciones para evitar tener que escribir scripts extensos, y son fáciles de usar.

Los argumentos también se pueden dar a través de la línea de comando una vez que se han especificado los parámetros de la función. Los parámetros con nombre, posicionales, de conmutación y dinámicos son ejemplos de parámetros de función. Los parámetros de función también se pueden usar para convertir una función básica en una más compleja.

Definir parámetros de funciones de PowerShell

Los parámetros se definen de la siguiente manera.

param(
  $Parameter1
)

Las mejores prácticas recomiendan agregar un tipo al parámetro e insertar un bloque Parameter() para garantizar que el parámetro tome justo el tipo de entrada que necesita y habilitará más funciones en el futuro. Por lo tanto, se hace como se muestra a continuación.

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

Incluso se pueden agregar parámetros adicionales a la sintaxis anterior, como se muestra a continuación.

param(
     [Parameter()]
     [string]$Param1,
 
     [Parameter()]
     [string]$Param2
 )
 
Write-Host "Param1 value is $Param1"
Write-Host "Param 2 value is $Param2"

Parámetros con nombre en la función de PowerShell

Los parámetros con nombre son una técnica para usar los parámetros de función de PowerShell dentro de un script. Utilice el nombre completo del argumento cuando invoque un script o una función con parámetros con nombre.

Supongamos que el script de PowerShell anterior está almacenado en test.ps1. Aquí proporcionaremos valores a param1 y param2; puede notar en el ejemplo a continuación que se debe pasar el nombre completo del parámetro.

./test.ps1 -Param1 'value' -Param2 'valuenext'

Producción:

Cuando ejecute este script, verá algo como esto, donde cada variable de argumento se reemplaza con el valor proporcionado en tiempo de ejecución.

Parámetros posicionales en la función de PowerShell

Pasar elementos por posición en lugar de por nombre es otra forma de utilizar parámetros. El nombre del parámetro no se utiliza al pasar un valor de parámetro a través de la posición. En su lugar, PowerShell compara los valores de cada argumento con su ubicación en la función. PowerShell reconoce que Param1 se especificó antes que Param2 en el código y hace coincidir los valores en la secuencia correcta.

./test.ps1 'value' 'valuenext'

Producción

Param1 value value
Param 2 value is valuenext

Tanto param1 como param2 se declararon como tipos de cadena en el ejemplo anterior, pero no es el único tipo que puede usar. Se puede utilizar cualquier tipo de la biblioteca de clases .NET.

Además del orden original, también podemos avanzar dando la posición dentro de la construcción del parámetro. Se muestra a continuación.

param(
     [Parameter(position = 1)]
     [string]$Param1,
 
     [Parameter(position = 0)]
     [string]$Param2
 )
 
Write-Host "Param1 value is $Param1"
Write-Host "Param 2 value is $Param2"

Aquí puede ver que se cambia el orden de los parámetros.

./test.ps1 'param2' 'param1'

Cambiar parámetros en la función PowerShell

Este parámetro se usa para indicar si algo está encendido o apagado usando valores binarios o booleanos. El tipo switch se utiliza para especificarlo. Continuando con el ejemplo anterior, agregaremos otro parámetro de cambio llamado DisplayParam2.

param(
     [Parameter()]
     [string]$Param1,
 
     [Parameter()]
     [string]$Param2,
 
     [Parameter()]
     [switch]$DisplayParam2
 )
 
 Write-Host "Param1 value is $Param1"
 if ($DisplayParam2.IsPresent) {
     Write-Host "Param2 value is $Param2"
 }

Producción:

Splatting en los parámetros de la función PowerShell

Splatting se usa principalmente cuando hay muchos parámetros. La configuración de parámetros para un script antes de ejecutar un comando se conoce como splatting. Ha estado definiendo y pasando valores a parámetros en tiempo de ejecución hasta ahora. Una vez que tenga una colección de parámetros que aparecen a continuación, esto puede ser un problema.

param(
     [Parameter()]
     [string]$Param1,
 
     [Parameter()]
     [string]$Param2,
 
     [Parameter()]
     [switch]$DisplayParam2,
 
     [Parameter()]
     [string]$Param3,
 
     [Parameter()]
     [string]$Param4,
 
     [Parameter()]
     [string]$Param5,
 
     [Parameter()]
     [string]$Param6,
 
     [Parameter()]
     [string]$Param7
 )
 
Write-Host "Param1 value is $Param1"
if ($DisplayParam2.IsPresent) {
 Write-Host "Param2 value is $Param2"
}
Write-Host "Param3 value is $Param3"
Write-Host "Param4 value is $Param4"
Write-Host "Param5 value is $Param5"
Write-Host "Param6 value is $Param6"
Write-Host "Param7 value is $Param7"

En lugar de deslizarse hacia la derecha, puede usar una tabla hash para especificar los valores de los parámetros en una fase separada, como se ilustra a continuación. Los valores de los parámetros pueden estar perfectamente alineados, lo que facilita mucho la comprensión de cuáles están en uso.

Una vez que se establece la tabla hash, puede especificar el nombre de la tabla hash seguido de un carácter @ para enviar todos los argumentos a la secuencia de comandos.

$params = @{
     Param1             = 'value'
     Param2             = 'valuenext'
     Param3             = 'somevalue'
     Param4             = 'somevalue'
     Param5             = 'somevalue'
     Param6             = 'somevalue'
     Param7             = 'somevalue'
     DisplayParam2 = $true
 }
 
 PS> ./test.ps1 @params

Atributos de parámetros de PowerShell

Las características de los parámetros le permiten cambiar la funcionalidad de los parámetros de varias formas. Puede usar expresiones regulares para ajustar una expresión regular, ordenar el uso de un parámetro determinado y verificar los valores proporcionados a un parámetro.

Parámetros Obligatorios

En PowerShell, podemos exigir que uno o más atributos se ejecuten en una función según nuestro deseo. Por lo tanto, podemos usar el atributo mandatory dentro de la construcción Parameter().

param(
     [Parameter(Mandatory)]
     [string]$Param1,
 
     [Parameter()]
     [string]$Param2,
 
     [Parameter()]
     [switch]$DisplayParam2
 )
 
Write-Host "Param1 value is $Param1"
if ($DisplayParam2.IsPresent) {
    Write-Host "Param2 value is $Param2"
}

Producción:

Validación de parámetros

Finalmente, vuelva a verificar que los valores proporcionados a los parámetros sean correctos. Es ideal para mantener al mínimo la posibilidad de que alguien dé un valor único a un parámetro. Por lo tanto, podemos especificar las entradas que queremos usando ‘ValidateSet()’ como se muestra a continuación.

param(
     [Parameter(Mandatory)]
     [ValidateSet('x', 'y')]
     [string]$Param1,
 
     [Parameter()]
     [string]$Param2,
 
     [Parameter()]
     [switch]$DisplayParam2
 )
 
 Write-Host "Param1 value is $Param1"
 if ($DisplayParam2.IsPresent) {
     Write-Host "Param2 value is $Param2"
 }

Si le damos valores distintos a x e y a param1, aparecerá un error.

Función avanzada con sintaxis de parámetros con nombre

Cuando el atributo Cmdletbinding se agrega a una función, la convierte en una función avanzada. Otros argumentos comunes se utilizan cuando se construye la función avanzada. La sintaxis es la siguiente.

function testfunction
{
    [CmdletBinding (DefaultParameterSetName='Param1')]
    Param
    (
         [Parameter(Mandatory=$true, Position=0, ParameterSetName='Param1')]
         [string] Param1,
         [Parameter(Mandatory=$true, Position=0, ParameterSetName='Param2')]
         [string] Param2,
    )
}