Búsqueda de sitios web

Pasar varios parámetros al script de PowerShell [4 formas]

Todos los fragmentos de código están escritos en el archivo MyScript.ps1; Puede nombrar este archivo con cualquier nombre que elija.

Usando la variable automática $args

Utilice la variable automática $args para pasar múltiples parámetros al script de PowerShell.

Utilice $args en el archivo MyScript.ps1:

foreach ($arg in $args) {
    Write-Host "Argument: $arg"
}

Llame al script MyScript.ps1:

.\MyScript.ps1 "Param1" "Param2" "Param3"

Producción :

Argument: Param1
Argument: Param2
Argument: Param3

La variable args es una matriz que contiene el valor de todos los parámetros pasados al script mientras se llama al script. En el ejemplo anterior, los parámetros 3 "Param1" "Param2" "Param3" se pasan al llamar al archivo de script MyScript.ps1.

El espacio se utiliza como separador entre los parámetros.

También debe tenerse en cuenta que estos parámetros no tienen nombre y solo contienen valores de parámetros que se almacenan automáticamente en la matriz args. Como podemos observar, arriba en el archivo de script MyScript.ps1, el bucle foreach se usa para recorrer todos los argumentos recibidos. Luego, el cmdlet Write-Host mostró todos los argumentos en la consola.

Veamos otro ejemplo a continuación para comprender mejor.

Utilice $args en MyScript.ps1:

Write-Host "First argument is "$args[0]
Write-Host "Second argument is "$args[1]

Llame al script MyScript.ps1:

.\MyScript.ps1 "Hello" "World"

Producción :

First argument is  Hello
Second argument is  World

En el caso anterior, la matriz args contenía dos elementos "Hello" y "World", que se pasaron al MyScript. ps1 archivo. Se puede acceder a estos valores consultando su posición en la matriz. Por eso también se les llama parámetros posicionales.

El primer valor del parámetro "Hello", se asigna al primer elemento de la matriz ($args[0]), y el segundo valor del parámetro "World" se asigna al segundo elemento ($args[2]) de la matriz.

Los parámetros posicionales son útiles cuando se conoce el número exacto y el orden de los parámetros que requiere el script.

Usando el bloque param()

Utilice el bloque param() para pasar varios parámetros al script de PowerShell.

Utilice el bloque param() en el archivo MyScript.ps1:

param(
  [string]$userName,
  [int]$userId,
  [string]$ProductName,
  [int]$ProductPrice
)
write-output "User name is $userName"
write-output "User id is $userId"
write-output "Product name is $ProductName"
write-output "Product Price is $ProductPrice"

Llame al script MyScript.ps1:

.\MyScript.ps1 -userName "Ayesha" -userId 689 -productName mouse -productPrice 200

Producción :

User name is Ayesha
User id is 689
Product name is mouse
Product Price is 200

En este método, el bloque param() en el script MyScript.ps1 definió los parámetros con nombres y tipos de datos. Se puede acceder a los valores de estos parámetros en cualquier parte del script. Los parámetros se pasan utilizando la sintaxis -ParameterName Value al llamar al script.

En el ejemplo proporcionado, el script se llamó con cuatro parámetros con nombre. El valor "Ayesha" se asignó al parámetro "-userName", el valor "689" se asignó al parámetro " -userId", el valor "mouse" se asignó al parámetro "-productName" y el valor "200" fue asignado al parámetro "-productPrice". Luego, el cmdlet write-output imprime los parámetros con sus valores en la consola.

El bloque param() debe estar al inicio del script.

Usando salpicaduras

Utilice salpicaduras para pasar múltiples parámetros al script de PowerShell.

Utilice Splatting en el archivo MyScript.ps1:

param (
  [string]$Param1,
  [string]$Param2
)
Write-Host "Param1: $Param1"
Write-Host "Param2: $Param2"

Llame al script MyScript.ps1:

$params = @{
  Param1 = "value1"
  Param2 = "value2"
}
& .\Myscript.ps1 @params

Producción :

Param1: value1
Param2: value2

En el método dado, se crea una hashtable, que contiene los nombres de los parámetros y sus respectivos valores. Luego, el operador de llamada (&) se usa con la sintaxis de dispersión @params para pasar la hashtable como parámetros con nombre al script de PowerShell.

Dentro del script MyScript.ps1, se puede acceder a los parámetros nombrados utilizando los nombres de parámetros especificados en la hashtable. Este método es beneficioso cuando tiene numerosos parámetros o cuando los parámetros tienen nombres/valores dinámicos que se desconocen hasta el tiempo de ejecución.

Tenga en cuenta que los nombres de los parámetros en la hashtable deben coincidir con los nombres definidos en el bloque param() del script; de lo contrario, los valores no se pasarán correctamente.

Usando el parámetro ValueFromRemainingArguments

Utilice el parámetro ValueFromRemainingArguments para pasar varios parámetros al script de PowerShell.

Utilice ValueFromRemainingArguments en el archivo MyScript.ps1:

param(
  [Parameter(ValueFromRemainingArguments=$true)]
  [string[]]$Param1
)
$i = 1
foreach ($value in $Param1) {
  Write-Host "Param${i}: {value}"
  $i++
}

Llame al script MyScript.ps1:

.\myscript.ps1 value1 value2 value3

Producción :

Param1: value1
Param1: value2
Param1: value3

Los parámetros ValueFromRemainingArguments se definen en el bloque param() del script y se les asignan todos los argumentos restantes como entrada. En este ejemplo, el parámetro $Param1 se define como un parámetro ValueFromRemainingArguments, lo que le permite aceptar todos los argumentos restantes como entrada.

El valor del parámetro ValueFromRemainingArguments se establece en true. De forma predeterminada, su valor es $false.

Al llamar al script, pase la matriz de parámetros como valores separados. Por ejemplo, en el caso anterior, Value1, Value2 y Value3 se pasan a MyScript.ps1. script, que luego se asigna al parámetro $Param1 como una matriz. Finalmente, el bucle foreach se usa para iterar a través de cada elemento de la matriz $Param1 y mostrarlo en la consola usando el cmdlet Write-Host. .

Veamos otro ejemplo:

Utilice ValueFromRemainingArguments en el archivo MyScript.ps1:

param(
    [Parameter(Position=0)][String]$Vlan,
    [Parameter(ValueFromRemainingArguments=$true)][String[]]$Hosts
)
Write-Host "Param: ${Vlan}"
foreach ($p in $Hosts) {
  Write-Host "Param: $p"
}

Llame al script MyScript.ps1:

.\MyScript.ps1 VLAN1 Host1 Host2 Host3

Producción :

Param: VLAN1
Param: Host1
Param: Host2
Param: Host3

El código de PowerShell anterior demuestra el uso de parámetros posicionales y el atributo de parámetro ValueFromRemainingArguments en un script.

El bloque param() del script definió dos parámetros: $Vlan y $Hosts. El primer parámetro, $Vlan, es un parámetro posicional con una posición de 0. El segundo parámetro, $Hosts, es un parámetro con nombre con el atributo ValueFromRemainingArguments establecido en $true. Esto significa que $Hosts aceptó una matriz de cadenas que contienen todos los argumentos que no fueron asignados a parámetros posicionales.

Mientras se llama al script, se pasan al script cuatro valores de parámetros, VLAN1 Host1 Host2 Host3. El primer valor, VLAN1, se asigna a la variable $Vlan; el resto de los argumentos Host1, Host2 y Host3 se establecen en $Hosts como una matriz de cadenas en este script de PowerShell.

Luego, el cmdlet Write-Host se utiliza para mostrar el valor del parámetro posicional $Vlan. Los argumentos restantes Host1, Host2 y Host3 también se asignan a la matriz $Hosts.

Se trata de cómo pasar varios parámetros a PowerShell Script.

Artículos relacionados