Históricamente, las utilidades de línea de comandos en sistemas Unix están mejor desarrolladas que en Windows, sin embargo, con el advenimiento de una nueva solución, la situación ha cambiado.
Para PowerShell, puede escribir scripts en un lenguaje interpretado de paradigmas múltiples que contenga elementos de programación clásica procesal, orientada a objetos e incluso funcional: ramificación condicional, bucles, variables, matrices, tablas hash, clases, manejo de errores, así como funciones, cmdlets y tuberías. . El artículo anterior estaba dedicado a los conceptos básicos del trabajo en un entorno, y ahora ofrecemos a nuestros lectores una pequeña guía para programadores.Tabla de contenido:
ComentariosLas variables y sus tiposvariables del sistemaScopesvariables de entorno (aritmética ) aritmético y de comparaciónOperadores de asignaciónOperadores Los operadores lógicosde transición condicionalBuclesmatricestablas hashFunciones demanejo Usted errorpuede escribir código en cualquier editor de texto o utilizando el entorno de desarrollo integrado - la forma más fácil de tomar Windows PowerShell ISE incluido con los sistemas operativos de Microsoft Server. Esto solo es necesario para scripts bastante complejos: conjuntos cortos de comandos son más fáciles de ejecutar de forma interactiva.Comentarios
El uso de comentarios se considera parte de un buen estilo de programación junto con sangría y espacios adecuados:
Variables y sus tipos.
Las variables en PowerShell son objetos con nombre. Sus nombres pueden incluir un guión bajo, así como letras y números. El símbolo $ siempre se usa antes del nombre, y para declarar una variable, es suficiente indicarle al intérprete un nombre válido:
Para inicializar la variable (asignarle un valor), se usa el operador de asignación (símbolo =):$test = 100
Puede declarar una variable indicando su tipo entre corchetes (operador de conversión de tipo) antes del nombre o valor:[int]$test = 100
$test = [int]100
Es importante comprender que las variables en PowerShell son objetos (clases) completos con propiedades y métodos cuyos tipos se basan en los disponibles en .NET Core. Enumeramos los principales:PowerShell admite la conversión implícita de tipos, además, el tipo de la variable puede cambiar sobre la marcha (por ejemplo, utilizando el operador de asignación) si no se especifica a la fuerza; en este caso, el intérprete arrojará un error. Puede determinar el tipo de variable del ejemplo anterior llamando al método GetType ():$test.GetType().FullName
Hay varios cmdlets para administrar variables. Su lista en una forma conveniente se muestra con el comando:Get-Command -Noun Variable | ft -Property Name, Definition -AutoSize -Wrap
Para ver las variables declaradas y sus valores, puede usar el cmdlet especial:Get-Variable | more
Este método parece excesivamente engorroso, es mucho más conveniente trabajar con variables a través de operadores o accediendo a sus propiedades y métodos directamente. Sin embargo, los cmdlets tienen derecho a existir porque le permiten especificar algunos parámetros adicionales. Es importante comprender que las variables de usuario se definen solo dentro de la sesión actual. Después de cerrar la consola o completar el script, se eliminan.Variables del sistema
Además de las declaradas por el usuario, hay variables integradas (del sistema) que no se eliminan después del final de la sesión actual. Se dividen en dos tipos, mientras que los datos de estado de PowerShell se almacenan en variables automáticas, a las que no se les pueden asignar valores arbitrarios por sí mismos. Estos incluyen, por ejemplo, $ PWD:$PWD.Path
Para almacenar la configuración del usuario, necesita variables de preferencia cuyos valores se puedan cambiar. Por ejemplo, con la ayuda de $ ErrorActionPreference, se establece la respuesta del intérprete de comandos ante la aparición de errores no críticos.Además de operadores y cmdlets, existe la Variable: pseudoacumulador para acceder a las variables declaradas. Puede trabajar con él por analogía con otras unidades, y las variables en este caso se parecen a los objetos del sistema de archivos:Get-ChildItem Variable: | more
ols Variable: | more
Alcances
Para las variables en PowerShell, existe la noción de alcance. La acción del área global (Global) se extiende a toda la sesión actual; incluye, por ejemplo, variables del sistema. Las variables locales solo están disponibles en el área donde se definieron: digamos dentro de la función. También existe el concepto de un alcance de script, pero para los comandos de script, es esencialmente local. Por defecto, cuando se declaran variables, se les da un alcance local, y para cambiar esto, se necesita una construcción especial del formulario: $ Global: variable = valor.Por ejemplo, así:$Global:test = 100
Variables de entorno
PowerShell tiene disponible otra pseudo-unidad Env, que puede usarse para acceder a las variables de entorno. Cuando se inicia el shell, se copian del proceso principal (es decir, del programa que inició la sesión actual) y, por lo general, sus valores iniciales coinciden con los valores del panel de control. Para ver las variables de entorno, use el cmdlet Get-ChildItem o sus alias (liases): ls y dir.dir Env:
Estas variables son secuencias de bytes (o caracteres, si lo desea), cuya interpretación depende solo del programa que los usa. * -Los cmdlets variables no funcionan con variables de entorno. Para acceder a ellos, deberá usar el prefijo del disco:$env:TEST = "Hello, World!"
Operadores aritméticos y de comparación
PowerShell tiene los siguientes operadores aritméticos: + (suma), - (resta), * (multiplicación), / (división) y% (módulo o resto de división). El resultado de una expresión aritmética se calcula de izquierda a derecha de acuerdo con el orden de operaciones generalmente aceptado, y los paréntesis se utilizan para agrupar partes de la expresión. Los espacios entre operadores se ignoran, solo se usan para facilitar la percepción. El operador + también se concatena, y el operador * repite las líneas. Si intenta agregar un número a una cadena, se convertirá en una cadena. Además, PowerShell tiene muchos operadores de comparación que verifican la correspondencia entre dos valores y devuelven verdadero o falso booleano:Hay otros operadores similares que permiten, por ejemplo, comparar cadenas con un carácter comodín o usar expresiones regulares para unir patrones. Los consideraremos en detalle en los siguientes artículos. Los símbolos <,> y = no se usan para comparación, ya que se usan para otros fines.Operadores de Asignación
Además del operador más común =, hay otros operadores de asignación: + =, - =, * =, / = y% =. Cambian el valor antes de la asignación. Los operadores unarios ++ y - se comportan de manera similar, lo que aumenta o disminuye el valor de una variable - también se relacionan con operadores de asignación.Operadores logicos
La comparación no es suficiente para describir condiciones difíciles. Puede escribir cualquier expresión lógica utilizando los operadores: -and, -or, -xor, -not y! .. Funcionan como en otros lenguajes de programación, y puede usar paréntesis para especificar el orden de cálculo:("" -eq "") -and (100 -eq 100)
-not (123 -gt 321)
!(123 -gt 321)
Salto condicional
Los operadores de ramificación en PowerShell son estándar: IF (IF ... ELSE, IF ... ELSEIF ... ELSE) y SWITCH. Considere su uso con ejemplos:[int]$test = 100
if ($test -eq 100) {
Write-Host "test = 100"
}
[int]$test = 50
if ($test -eq 100) {
Write-Host "test = 100"
}
else {
Write-Host "test <> 100"
}
[int]$test = 10
if ($test -eq 100) {
Write-Host "test = 100"
}
elseif ($test -gt 100) {
Write-Host "test > 100"
}
else {
Write-Host "test < 100"
}
[int]$test = 5
switch ($test) {
0 {Write-Host "test = 0"}
1 {Write-Host "test = 1"}
2 {Write-Host "test = 2"}
3 {Write-Host "test = 3"}
4 {Write-Host "test = 4"}
5 {Write-Host "test = 5"}
default {Write-Host "test > 5 "}
}
Ciclos
Hay varios tipos de bucles en PowerShell: WHILE, DO WHILE, DO UNTIL, FOR y FOREACH.El bucle de precondición funciona si / mientras se está ejecutando:[int]$test = 0
while ($test -lt 10) {
Write-Host $test
$test = $test + 1
}
Los bucles con una condición posterior funcionarán al menos una vez, porque la condición se verifica después de la iteración. En este caso, DO WHILE funciona mientras la condición sea verdadera y DO HASTA que sea falsa:[int]$test = 0
do {
Write-Host $test
$test = $test + 1
}
while ($test -lt 10)
[int]$test = 0
do {
Write-Host $test
$test = $test + 1
}
until ($test -gt 9)
El número de iteraciones del bucle FOR se conoce de antemano:for ([int]$test = 0; $test -lt 10; $test++) {
Write-Host $test
}
En un bucle FOREACH itera sobre elementos de una matriz o colección (tabla hash):$test_collection = "item1", "item2", "item3"
foreach ($item in $test_collection)
{
Write-Host $item
}
Matrices
Las variables de PowerShell almacenan no solo objetos individuales (número, cadena, etc.), sino también objetos plurales. La variedad más simple de tales variables son las matrices. Una matriz puede constar de varios elementos, un elemento o estar vacío, es decir no contienen elementos Para declararlo, use el operador @ (), que necesitaremos en el siguiente artículo: es muy importante para agregar otras matrices a la matriz (crear matrices multidimensionales), pasar matrices a funciones como argumentos y tareas similares:$test_array = @()
Cuando se inicializa la matriz, sus valores se enumeran con una coma (operador especial):$test_array = @(1, 2, 3, 4)
En la mayoría de los casos, se puede omitir el operador @ ():$test_array = 1, 2, 3, 4
En este caso, una matriz de un elemento se inicializa de la siguiente manera$test_array = , 1
Para acceder a los elementos de la matriz, se utiliza un índice entero a partir de cero y un operador de índice (corchetes):$test_array[0] = 1
Puede especificar varios índices, separados por comas, incluidos duplicar:$test_array = "", "", "", ""
$test_array[0,1,2,3]
$test_array[1,1,3,3,0]
El operador ..(dos puntos: el operador de rango) devuelve una matriz de enteros en un segmento definido por los límites superior e inferior. Por ejemplo, la expresión 1..4 muestra una matriz de cuatro elementos @ (1, 2, 3, 4), y la expresión 8..5 muestra una matriz @ (8, 7, 6, 5).
Usando el operador de rango, puede inicializar una matriz ($ test_array = 1..4) u obtener un segmento, es decir Una secuencia de elementos en una matriz con índices de otra. En este caso, un número negativo -1 indica el último elemento de la matriz, -2: el penúltimo, etc.$test_array = "", "", "", ""
$test_array[0..2]
$test_array[2..0]
$test_array[-1..0]
$test_array[-2..1]
Tenga en cuenta que los valores de la matriz de enteros pueden ser mayores que el valor máximo del índice de la matriz de datos. En este caso, todos los valores se devuelven al último:$test_array[0..100]
Si intenta acceder a un único elemento de matriz inexistente, se devuelve $ null.
En PowerShell, las matrices pueden contener elementos de diferentes tipos o estar fuertemente tipadas:$test_array = 1, 2, "", 3, 4
for ([int]$i = 0; $i -lt $test_array.count; $i++)
{
Write-Host $test_array[$i]
}
Donde la propiedad $ test_array.count es el número de elementos en la matriz.Un ejemplo de creación de una matriz fuertemente tipada:[int[]]$test_array = 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
Tablas hash
Otro tipo básico de variable en PowerShell son las tablas hash, también llamadas matrices asociativas. Hashtable son similares a los objetos JSON y se construyen sobre una base de valor clave. A diferencia de las matrices ordinarias, el acceso a sus elementos se lleva a cabo utilizando claves con nombre, que son propiedades de objeto (también puede usar el operador de índice - corchetes).Se declara una tabla hash vacía utilizando el símbolo de servicio @ y los corchetes del operador:$test_hashtable = @{}
Al declarar, puede crear claves inmediatamente y asignarles valores:$test_hashtable = @{one=""; two=""; three=""; "some key"="some value"}
Para agregar un elemento a la tabla hash, debe asignarle una clave que aún no existe o usar el método Add (). Si la asignación se realiza con una clave existente, su valor cambiará. Para eliminar un elemento de una tabla hash, use el método Remove ().$test_hashtable."some key"
$test_hashtable["some key"]
$test_hashtable.Add("four", "")
$test_hashtable.five = ""
$test_hashtable['five'] = " "
$test_hashtable.Remove("one")
Las variables de este tipo se pueden pasar como argumentos a funciones y cmdlets; en el próximo artículo aprenderemos cómo hacerlo y también consideraremos otro tipo similar: PSCustomObject.Las funciones
PowerShell tiene todos los elementos necesarios para la programación de procedimientos, incluidas las funciones. La palabra de función Función se usa para describirlos, después de lo cual se requiere indicar el nombre de la función y el cuerpo entre corchetes de operador. Si es necesario, pase argumentos a la función, puede especificarlos inmediatamente después del nombre entre paréntesis.function - (1, ..., N)
{
-
}
Una función siempre devuelve un resultado: esta es una matriz de los resultados de todas sus declaraciones, si hay más de una. Si hay una declaración, se devuelve un solo valor del tipo correspondiente. La construcción return $ value agrega un elemento con el valor $ value a la matriz de resultados y aborta la lista de instrucciones, y una función vacía devuelve $ null.Por ejemplo, cree una función para cuadrar un número:function sqr ($number)
{
return $number * $number
}
Tenga en cuenta que en el cuerpo de la función puede usar cualquier variable declarada antes de su llamada, y llamar a funciones en PowerShell puede parecer inusual: los argumentos (si los hay) no están encerrados entre paréntesis y están separados por espacios.sqr 2
más o menos:sqr -number 2
Debido a la forma en que se pasan los argumentos, la función misma a veces tiene que estar entre corchetes:function test_func ($n) {}
test_func -eq $null
(test_func) -eq $null
Al describir una función, puede asignar valores predeterminados a los argumentos:function func ($arg = value) {
}
Hay otra sintaxis para describir los argumentos de la función, además, los parámetros se pueden leer desde la tubería; todo esto será útil en el próximo artículo cuando consideremos los módulos exportados y creemos sus propios cmdlets.Error al procesar
PowerShell tiene un mecanismo Try ... Catch ... Finalmente para manejar excepciones. El bloque Try contiene código en el que puede ocurrir un error, y el bloque Catch contiene su controlador. Si no hubo error, no se ejecuta. El bloque Finalmente se ejecuta después del bloque Try, independientemente de la ocurrencia de un error, y puede haber varios bloques Catch para excepciones de varios tipos. La excepción en sí misma se escribe en la variable predeterminada sin declaración ($ _) y se puede recuperar fácilmente. En el siguiente ejemplo, implementamos protección contra la entrada de un valor incorrecto:try {
[int]$test = Read-Host " "
100 / $test
} catch {
Write-Warning " "
Write-Host $_
}
Ahí es donde se refieren los conceptos básicos de programación de PowerShell. En los siguientes artículos estudiaremos con más detalle el trabajo con variables de diferentes tipos, colecciones, expresiones regulares, la creación de funciones, módulos y cmdlets personalizados, así como la programación orientada a objetos.Parte 1: las características principales de Windows PowerShellParte 3: pasar parámetros a scripts y funciones, crear cmdletsParte 4: Trabajar con objetos, clases personalizadas
