Que é Windows PowerShell e con que se come? Parte 2: Introdución á linguaxe de programación

Históricamente, as utilidades de liña de comandos nos sistemas Unix están mellor desenvolvidas que en Windows, pero coa chegada dunha nova solución, a situación cambiou.

PowerShell pódese escribir nunha linguaxe interpretada e multiparadigma que ten elementos de programación clásica de procedementos, orientados a obxectos e mesmo funcional: ramificación condicional, bucles, variables, matrices, táboas hash, clases, tratamento de erros, así como funcións. cmdlets e canalizacións . Artigo anterior dedicouse aos conceptos básicos de traballar no medio ambiente, e agora ofrecemos aos nosos lectores un pequeno libro de consulta para programadores.

Imaxe:

Comentarios
Variables e os seus tipos
Variables do sistema
Ámbitos
Variables de ambiente (ambiente)
Operadores aritméticos e de comparación
Operadores de asignación
Operadores lóxicos
Salto condicional
Ciclos
Arrays
Táboas hash
Funcións
Erro ao procesar

Podes escribir código en calquera editor de texto ou usando un ambiente de desenvolvemento integrado; o xeito máis sinxelo é tomar o Windows PowerShell ISE que inclúe os sistemas operativos de servidor de Microsoft. Isto só é necesario para scripts bastante complexos: os conxuntos curtos de comandos son máis fáciles de executar de forma interactiva.

Comentarios

O uso de comentarios considérase parte dun bo estilo de programación xunto cunha sangría e espazos en branco adecuados:

# Для строчных комментариев используется символ решетки — содержимое строки интерпретатор не обрабатывает.

<# 

       Так обозначаются начало и конец блочного комментария. 
       Заключенный между ними текст интерпретатор игнорирует.

#>

Variables e os seus tipos

As variables en PowerShell son obxectos denominados. Os seus nomes poden incluír o carácter de subliñado, así como letras e números. O símbolo $ úsase sempre antes do nome, e para declarar unha variable, abonda con darlle un nome válido ao intérprete:

Para inicializar unha variable (asignarlle un valor), utilízase o operador de asignación (símbolo =):

$test = 100

Podes declarar unha variable especificando o seu tipo entre corchetes (operador de emisión de tipos) antes do nome ou valor:

[int]$test = 100

$test = [int]100

É importante entender que as variables en PowerShell son obxectos completos (clases) con propiedades e métodos cuxos tipos están baseados nos de .NET Core. Enumeramos os principais:

Tipo (clase .NET)

Descrición

Exemplo de código

[cadea] System.String

Cadena Unicode 

$test = "proba"
$test = 'proba'

[char]System.Char

Carácter Unicode (16 bits)

[char]$test = 'c'

[bool] System.Boolean

tipo booleano (verdadero ou falso booleano)

[bool]$proba = $true

[int] System.Int32

enteiro de trinta e dous bits (32 bits)

[int]$proba = 123456789

[longo] System.Int64

enteiro de sesenta e catro bits (64 bits)

[longa]$proba = 12345678910

[single] System.Single

número de coma flotante de 32 bits de lonxitude

[single]$proba = 12345.6789

[double]Sistema.Dobre

número de coma flotante de lonxitude 64 bits (8 bytes)

[dobre]$proba = 123456789.101112

[decimal]Sistema.Decimal

Número de coma flotante de 128 bits (necesario para rematar con d)

[decimal]$proba = 12345.6789d

[DateTime]System.DateTime

data e hora 

$test = GetDate

[matriz] System.Object[]

unha matriz cuxo índice de elementos comeza en 0

$test_array = 1, 2, "proba", 3, 4

[hashtable] System.Collections.Hashtable

As táboas hash son matrices asociativas con claves nomeadas, construídas segundo o principio: @{key = "valor"}

$test_hashtable = @{one="one"; dous = "dous"; tres="tres"}

PowerShell admite a conversión implícita de tipos, ademais, o tipo dunha variable pódese cambiar sobre a marcha (por exemplo, mediante un operador de asignación), se non se especifica de forma forzada; neste caso, o intérprete dará un erro. Pode determinar o tipo da variable a partir do exemplo anterior chamando ao método GetType():

$test.GetType().FullName

Hai unha serie de cmdlets para manipular variables. A súa lista nun formulario cómodo móstrase mediante o comando:

Get-Command -Noun Variable | ft -Property Name, Definition -AutoSize -Wrap

Para ver as variables declaradas e os seus valores, pode usar un cmdlet especial:

Get-Variable | more

Este método parece excesivamente engorroso, é moito máis cómodo traballar con variables a través de operadores ou accedendo directamente ás súas propiedades e métodos. Non obstante, os cmdlets teñen dereito a existir porque permiten establecer algúns parámetros adicionais. É importante entender que as variables de usuario só se definen dentro da sesión actual. Cando se pecha a consola ou remata o script, elimínanse.

Variables do sistema

Ademais das declaradas polo usuario, hai variables integradas (sistema) que non se eliminan despois de finalizar a sesión actual. Divídense en dous tipos, mentres que os datos de estado de PowerShell almacénanse en variables automáticas ás que non se poden asignar valores arbitrarios por si só. Estes inclúen, por exemplo, $PWD:

$PWD.Path

As variables de preferencias son necesarias para almacenar as preferencias do usuario, cuxos valores poden cambiarse. Por exemplo, usando $ErrorActionPreference , establécese a reacción do intérprete de comandos ante a aparición de erros non graves.

Ademais dos operadores e cmdlets para acceder ás variables declaradas, hai unha Variable: pseudoacumulador. Pode traballar con el por analoxía con outras unidades, e as variables neste caso semellan obxectos do sistema de ficheiros:

Get-ChildItem Variable: | more

ou

ls Variable: | more

Ámbitos

Para as variables en PowerShell, existe o concepto de ámbito (Scope). A acción do ámbito global (Global) aplícase a toda a sesión actual; inclúe, por exemplo, as variables do sistema. As variables locais (locais) só están dispoñibles no ámbito onde foron definidas: digamos dentro dunha función. Tamén existe o concepto do alcance do script (Script), pero para os comandos do script, é esencialmente local. Por defecto, ao declarar variables, dáselles un ámbito local, e para cambialo, necesitas unha construción especial como: $Global: variable = value.

Por exemplo, así:

$Global:test = 100

Variables de ambiente (ambiente)

Outra pseudo-unidade, Env:, está dispoñible en PowerShell e pódese usar para acceder ás variables de ambiente. Cando se inicia o shell, cópiase do proceso pai (é dicir, do programa que iniciou a sesión actual) e normalmente os seus valores iniciais son os mesmos que os valores do panel de control. Para ver as variables de ambiente, use o cmdlet Get-ChildItem ou os seus alias (aliases): ls e dir.

dir Env:

Estas variables son secuencias de bytes (ou caracteres, se o desexa), cuxa interpretación depende só do programa que as utilice. Os cmdlets *-Variable non funcionan con variables de ambiente. Para acceder a eles, tes que usar o prefixo da unidade:

$env:TEST = "Hello, World!"

Operadores aritméticos e de comparación

PowerShell proporciona os seguintes operadores aritméticos: + (suma), - (resta), * (multiplicación), / (división) e % (módulo ou módulo). O resultado dunha expresión aritmética avalíase de esquerda a dereita de acordo coa orde xeralmente aceptada das operacións e úsanse parénteses para agrupar partes da expresión. Os espazos entre operadores ignóranse, úsanse só para facilitar a lectura. O operador + tamén concatena e o operador * repite cadeas. Se tentas engadir un número a unha cadea, converterase nunha cadea. Ademais, a linguaxe PowerShell ten moitos operadores de comparación que verifican a coincidencia entre dous valores e devolven o booleano True ou False:

Operador

Descrición

Exemplo de código

-eq

Iguais / Iguais (semellante a = ou == noutros idiomas)

$proba = 100
$proba -eq 123 

- é

Non é igual / Non é igual (semellante a <> ou !=)

$proba = 100
$proba -ne 123   

-gt

Maior que / Máis (analóxico>)

$proba = 100
$test -gt 123

-xe

Maior que ou igual / Maior que ou igual (semellante a >=)

$proba = 100
$test -ge 123

-lt

Menos de / Menos (semellante a <)

$proba = 100
$proba -lt 123  

-o

Menor ou igual / Menor ou igual (semellante a <=)

$proba = 100
$proba -le 123

Hai outros operadores similares que che permiten, por exemplo, comparar cadeas baseadas nun comodín ou usar expresións regulares para coincidir cun patrón. Cubrirémolos en detalle en próximos artigos. Os símbolos <, > e = non se usan para comparar porque se usan para outros fins.

Operadores de asignación

Ademais do operador = máis común, hai outros operadores de asignación: +=, -=, *=, /= e %=. Cambian o valor antes da asignación. Os operadores unarios ++ e -, que aumentan ou diminúen o valor dunha variable, compórtanse de xeito similar; tamén se aplican aos operadores de asignación.

Operadores lóxicos

A comparación por si soa non é suficiente para describir condicións complexas. Podes escribir calquera expresión lóxica usando os operadores: -and, -or, -xor, -not and! .. Funcionan como noutras linguaxes de programación, mentres que podes usar parénteses para especificar a orde de avaliación:

("Тест" -eq "Тест") -and (100 -eq 100)

-not (123 -gt 321) 

!(123 -gt 321)

Salto condicional

Os operadores de rama en PowerShell son estándar: IF(IF...ELSE, IF...ELSEIF...ELSE) e SWITCH. Vexamos o seu uso con exemplos:

[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

PowerShell ten varias variedades de bucles: WHILE, DO WHILE, DO UNTIL, FOR e FOREACH.

Un bucle cunha condición previa funciona se/sempre que sexa verdadeiro:

[int]$test = 0
while ($test -lt 10) {
      Write-Host $test
      $test = $test + 1
}

Os bucles cunha condición posterior executaranse polo menos unha vez, porque a condición compróbase despois da iteración. Ao mesmo tempo, DO WHILE funciona mentres a condición é verdadeira e DO UNTIL funciona mentres é 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)

O número de iteracións do bucle FOR coñécese de antemán:

for ([int]$test = 0; $test -lt 10; $test++) {
       Write-Host $test
}

No bucle FOREACH, itera sobre os elementos dunha matriz ou colección (taboa hash):

$test_collection = "item1", "item2", "item3"
foreach ($item in $test_collection)
{
        Write-Host $item
}

Arrays

As variables de PowerShell almacenan non só obxectos únicos (número, cadea, etc.), senón tamén varios. O tipo máis sinxelo destas variables son as matrices. Unha matriz pode constar de varios elementos, un elemento ou estar baleira, é dicir. non conteñen elementos. Declárase usando o operador @(), que necesitaremos no seguinte artigo; é moi importante para engadir outras matrices a unha matriz (creando matrices multidimensionais), pasar matrices a funcións como argumento e tarefas similares:

$test_array = @() #создаем пустой массив

Cando se inicializa unha matriz, os seus valores aparecen separados por comas (operador especial ,):

$test_array = @(1, 2, 3, 4) # создаем массив из четырех элементов 

Na maioría dos casos, o operador @() pódese omitir:

$test_array = 1, 2, 3, 4

Neste caso, unha matriz dun elemento iníciase como segue

$test_array = , 1

Accédese aos elementos da matriz mediante un índice enteiro de base cero e o operador de índice (corchetes):

$test_array[0] = 1

Podes especificar varios índices separados por comas, incl. recorrente:

$test_array = "один", "два", "три", "четыре"
$test_array[0,1,2,3]
$test_array[1,1,3,3,0]

Operador .. (dous puntos - operador de rango) devolve unha matriz de números enteiros dentro dos límites superior e inferior especificados. Por exemplo, a expresión 1..4 dá como resultado unha matriz de catro elementos @(1, 2, 3, 4) e a expresión 8..5 dá como resultado unha matriz @(8, 7, 6, 5).

Usando o operador de rango, pode inicializar unha matriz ($test_array = 1..4) ou obter unha porción (porción), é dicir. unha secuencia de elementos dunha matriz con índices doutra. Neste caso, un número negativo -1 denota o último elemento da matriz, -2 - o penúltimo, etc.

$test_array = "один", "два", "три", "четыре"
$test_array[0..2]
$test_array[2..0]
$test_array[-1..0]
$test_array[-2..1]

Teña en conta que os valores de matriz enteiro poden ser maiores que o valor de índice máximo da matriz de datos. Neste caso, todos os valores son devoltos ata o último:

$test_array[0..100]

Se tenta acceder a un único elemento de matriz inexistente, devólvese $null.

En PowerShell, as matrices poden conter elementos de diferentes tipos ou estar ben tecleadas:

$test_array = 1, 2, "тест", 3, 4
for ([int]$i = 0; $i -lt $test_array.count; $i++)
{
          Write-Host $test_array[$i]
}

Onde a propiedade $test_array.count é o número de elementos da matriz.

Un exemplo de creación dunha matriz de tipo forte:

[int[]]$test_array = 0, 1, 2, 3, 4, 5, 6, 7, 8, 9

Táboas hash

Outro tipo básico de variable en PowerShell son as táboas hash, tamén coñecidas como matrices asociativas. As táboas hash son similares aos obxectos JSON e constrúense en función da clave-valor. A diferenza das matrices comúns, accede aos seus elementos mediante claves con nome, que son propiedades do obxecto (tamén pode usar o operador índice - corchetes).

Declárase unha táboa hash baleira usando o símbolo @ e os corchetes do operador:

$test_hashtable = @{}

Ao declarar, pode crear claves inmediatamente e asignarlles valores:

$test_hashtable = @{one="один"; two="два"; three="три"; "some key"="some value"}

Para engadir un elemento a unha táboa hash, debes asignarlle unha clave que aínda non existe ou usar o método Engadir (). Se se asigna unha clave existente, o seu valor cambiará. O método Remove() úsase para eliminar un elemento dunha táboa hash.

$test_hashtable."some key"
$test_hashtable["some key"]
$test_hashtable.Add("four", "четыре")
$test_hashtable.five = "пять"
$test_hashtable['five'] = "заменяем значение"
$test_hashtable.Remove("one")

As variables deste tipo pódense pasar como argumentos a funcións e cmdlets; no seguinte artigo estudaremos como se fai isto, e tamén consideraremos outro tipo similar: PSCustomObject.

Funcións

PowerShell ten todo o que necesitas para a programación de procedementos, incluíndo funcións. Para describilos, utilízase a palabra función Función, despois de que cómpre especificar o nome da función e o corpo entre corchetes do operador. Se precisa pasar argumentos á función, pode especificalos inmediatamente despois do nome entre parénteses.

function имя-функции (аргумент1, ..., аргументN) 
{ 
        тело-функции 
} 

A función sempre devolve un resultado: é unha matriz dos resultados de todas as súas declaracións, se hai máis dunha. Se só hai unha instrución, devólvese o único valor do tipo correspondente. A construción $value de retorno engade un elemento co valor $valor á matriz de resultados e aborta a execución da lista de instrucións, e a función baleira devolve $null.

Por exemplo, imos crear unha función para cadrar un número:

function sqr ($number)
{
      return $number * $number
}

Teña en conta que no corpo dunha función, pode usar calquera variable declarada antes de chamala, e chamar a funcións en PowerShell pode parecer inusual: os argumentos (se os hai) non están entre parénteses e están separados por espazos.

sqr 2

máis ou menos:

sqr -number 2

Debido á forma en que se pasan os argumentos, ás veces a función en si debe estar entre parénteses:

function test_func ($n) {}
test_func -eq $null     # функция не вызывалась
(test_func) -eq $null   # результат выражения — $true

Ao describir unha función, pode asignar valores predeterminados aos argumentos:

function func ($arg = value) {
         #тело функции
}

Hai outra sintaxe para describir os argumentos das funcións, ademais, pódense ler parámetros desde o pipeline; todo isto será útil no seguinte artigo, cando vexamos os módulos exportados e creemos os nosos propios cmdlets.

Erro ao procesar

PowerShell ten un mecanismo Try...Catch...Finally para xestionar excepcións. O bloque Try contén o código no que se pode producir un erro e o bloque Catch contén o seu controlador. Se non houbo erro, non se executa. O bloque Finally execútase despois do bloque Try, independentemente de que se produza un erro, e pode haber varios bloques Catch para diferentes tipos de excepcións. A propia excepción está escrita nunha variable predeterminada non declarada ($_) e pódese recuperar facilmente. No seguinte exemplo, implementamos protección contra a introdución dun valor non válido:

try {

        [int]$test = Read-Host "Введите число"
        100 / $test

} catch {

         Write-Warning "Некорректное число"
         Write-Host $_

}

Conclúe así a revisión dos conceptos básicos de programación na linguaxe PowerShell. Nos artigos seguintes, estudaremos con máis detalle o traballo con variables de diferentes tipos, coleccións, expresións regulares, creación de funcións, módulos e cmdlets personalizados, así como a programación orientada a obxectos.

Fonte: www.habr.com