PowerShell
Variables en PowerShell
Buscar..
Introducción
Las variables se utilizan para almacenar valores. Deje que el valor sea de cualquier tipo, necesitamos almacenarlo en algún lugar para poder usarlo en toda la consola / script. Los nombres de variables en PowerShell comienzan con $ , como en $ Variable1 , y los valores se asignan usando = , como $ Variable1 = "Valor 1". PowerShell admite una gran cantidad de tipos de variables; como cadenas de texto, enteros, decimales, matrices e incluso tipos avanzados como números de versión o direcciones IP.
Variable simple
Todas las variables en powershell comienzan con un signo de dólar estadounidense ( $ ). El ejemplo más simple de esto es:
$foo = "bar"
Esta declaración asigna una variable llamada foo con un valor de cadena de "barra".
Eliminando una variable
Para eliminar una variable de la memoria, se puede usar el cmdlet Remove-Item . Nota: El nombre de la variable NO incluye el $ .
Remove-Item Variable:\foo
Variable tiene un proveedor para permitir que la mayoría de los cmdlets * -item funcionen de manera similar a los sistemas de archivos.
Otro método para eliminar la variable es usar el cmdlet Remove-Variable y su alias rv
$var = "Some Variable" #Define variable 'var' containing the string 'Some Variable'
$var #For test and show string 'Some Variable' on the console
Remove-Variable -Name var
$var
#also can use alias 'rv'
rv var
Alcance
El ámbito predeterminado para una variable es el contenedor adjunto. Si está fuera de un script u otro contenedor, el alcance es Global . Para especificar un alcance , se le $scope:varname prefijo al nombre de variable $scope:varname así:
$foo = "Global Scope"
function myFunc {
$foo = "Function (local) scope"
Write-Host $global:foo
Write-Host $local:foo
Write-Host $foo
}
myFunc
Write-Host $local:foo
Write-Host $foo
Salida:
Global Scope
Function (local) scope
Function (local) scope
Global Scope
Global Scope
Leyendo una salida de CmdLet
De forma predeterminada, powershell devolvería la salida a la entidad llamante. Considere el siguiente ejemplo,
Get-Process -Name excel
Esto simplemente devolvería el proceso en ejecución que coincide con el nombre excel, a la entidad llamante. En este caso, el host de PowerShell. Imprime algo como
Handles NPM(K) PM(K) WS(K) VM(M) CPU(s) Id SI ProcessName
------- ------ ----- ----- ----- ------ -- -- -----------
1037 54 67632 62544 617 5.23 4544 1 EXCEL
Ahora, si asigna la salida a una variable, simplemente no imprimirá nada. Y, por supuesto, la variable mantiene la salida. (Ya sea una cadena, Objeto - Cualquier tipo para esa materia)
$allExcel = Get-Process -Name excel
Entonces, digamos que tiene un escenario donde desea asignar una variable por un nombre dinámico, puede usar el parámetro -OutVariable
Get-Process -Name excel -OutVariable AllRunningExcel
Tenga en cuenta que aquí falta el $. Una diferencia importante entre estas dos asignaciones es que, también imprime el resultado además de asignarlo a la variable AllRunningExcel. También puede optar por asignarlo a otra variable.
$VarOne = Get-Process -Name excel -OutVariable VarTwo
Aunque, el escenario anterior es muy raro, ambas variables $ VarOne y $ VarTwo tendrán el mismo valor.
Ahora considera esto,
Get-Process -Name EXCEL -OutVariable MSOFFICE
Get-Process -Name WINWORD -OutVariable +MSOFFICE
La primera declaración simplemente obtendría el proceso de Excel y lo asignaría a la variable MSOFFICE, y luego ejecutaría los procesos de ms word y lo "agregaría" al valor existente de MSOFFICE. Se vería algo como esto,
Handles NPM(K) PM(K) WS(K) VM(M) CPU(s) Id SI ProcessName
------- ------ ----- ----- ----- ------ -- -- -----------
1047 54 67720 64448 618 5.70 4544 1 EXCEL
1172 70 50052 81780 584 1.83 14968 1 WINWORD
Asignación de listas de múltiples variables
Powershell permite la asignación múltiple de variables y trata casi todo como una matriz o lista. Esto significa que en lugar de hacer algo como esto:
$input = "foo.bar.baz"
$parts = $input.Split(".")
$foo = $parts[0]
$bar = $parts[1]
$baz = $parts[2]
Simplemente puede hacer esto:
$foo, $bar, $baz = $input.Split(".")
Dado que Powershell trata las asignaciones de esta manera como si fueran listas, si hay más valores en la lista que elementos en su lista de variables a las que asignarlos, la última variable se convierte en una matriz de los valores restantes. Esto significa que también puedes hacer cosas como esta:
$foo, $leftover = $input.Split(".") #Sets $foo = "foo", $leftover = ["bar","baz"]
$bar = $leftover[0] # $bar = "bar"
$baz = $leftover[1] # $baz = "baz"
Arrays
La declaración de arrays en Powershell es casi lo mismo que crear una instancia de cualquier otra variable, es decir, se usa una sintaxis de $name = . Los elementos de la matriz se declaran separándolos con comas ( , ):
$myArrayOfInts = 1,2,3,4
$myArrayOfStrings = "1","2","3","4"
Añadiendo a un arry
Agregar a una matriz es tan simple como usar el operador + :
$myArrayOfInts = $myArrayOfInts + 5
//now contains 1,2,3,4 & 5!
Combinando matrices juntas
De nuevo, esto es tan simple como usar el operador +
$myArrayOfInts = 1,2,3,4
$myOtherArrayOfInts = 5,6,7
$myArrayOfInts = $myArrayOfInts + $myOtherArrayOfInts
//now 1,2,3,4,5,6,7
