Historicamente, os utilitários de linha de comando em sistemas Unix são mais bem desenvolvidos do que no Windows, mas com o advento de uma nova solução, a situação mudou.
O PowerShell pode ser programado em uma linguagem multiparadigma interpretada que possui elementos de programação clássica procedural, orientada a objetos e até mesmo funcional: ramificação condicional, loops, variáveis, arrays, tabelas de hash, classes, tratamento de erros, bem como funções, cmdlets e pipelines. foi dedicado aos fundamentos do trabalho no ambiente e agora oferecemos aos nossos leitores um pequeno livro de referência para programadores.
Sumário:
Você pode escrever código em qualquer editor de texto ou usando um ambiente de desenvolvimento integrado - a maneira mais fácil é usar o Windows PowerShell ISE que vem com os sistemas operacionais de servidor da Microsoft. Isso só é necessário para scripts bastante complexos: conjuntos curtos de comandos são mais fáceis de executar interativamente.
comentários
O uso de comentários é considerado parte de um bom estilo de programação, juntamente com recuo e espaço em branco adequados:
# Для строчных комментариев используется символ решетки — содержимое строки интерпретатор не обрабатывает.
<#
Так обозначаются начало и конец блочного комментария.
Заключенный между ними текст интерпретатор игнорирует.
#>
Variáveis e seus tipos
As variáveis no PowerShell são objetos nomeados. Seus nomes podem incluir o caractere sublinhado, bem como letras e números. O símbolo $ é sempre usado antes do nome, e para declarar uma variável basta dar um nome válido ao interpretador:
Para inicializar uma variável (atribuir um valor a ela), o operador de atribuição (símbolo =) é usado:
$test = 100Você pode declarar uma variável especificando seu tipo entre colchetes (operador de conversão de tipo) antes do nome ou valor:
[int]$test = 100
$test = [int]100É importante entender que as variáveis no PowerShell são objetos completos (classes) com propriedades e métodos cujos tipos são baseados no .NET Core. Listamos os principais:
Tipo (classe .NET)
descrição
Exemplo de código
[string] System.Stringstring Unicode
$teste = "teste"
$teste = 'teste'
Caractere Unicode (16 bits)
[char]$teste = 'c' [bool] System.Booleantipo booleano (booleano True ou False)
[bool]$teste = $verdadeiro [int] System.Int32inteiro de trinta e dois bits (32 bits)
[int]$teste = 123456789 [longo] System.Int64inteiro de sessenta e quatro bits (64 bits)
[longo]$teste = 12345678910 [single] System.Singlenúmero de ponto flutuante 32 bits de comprimento
[único]$teste = 12345.6789 [duplo]System.Doublenúmero de ponto flutuante de comprimento 64 bits (8 bytes)
[duplo]$teste = 123456789.101112 [decimal]Sistema.DecimalNúmero de ponto flutuante de 128 bits (necessário para terminar com d)
[decimal]$teste = 12345.6789d [DateTime]System.DateTimedata e hora
$teste = GetData
[array] System.Object[]uma matriz cujo índice de elemento começa em 0
$test_array = 1, 2, "teste", 3, 4
[hashtable] System.Collections.Hashtabletabelas hash são matrizes associativas com chaves nomeadas, construídas de acordo com o princípio: @{chave = "valor"}
$test_hashtable = @{one="one"; dois="dois"; três="três"}
O PowerShell oferece suporte à conversão implícita de tipo, além disso, o tipo de uma variável pode ser alterado em tempo real (por exemplo, usando um operador de atribuição), se não for especificado à força - nesse caso, o interpretador dará um erro. Você pode determinar o tipo da variável do exemplo anterior chamando o método GetType():
$test.GetType().FullName
Há vários cmdlets para manipular variáveis. Sua lista de forma conveniente é exibida usando o comando:
Get-Command -Noun Variable | ft -Property Name, Definition -AutoSize -Wrap
Para visualizar as variáveis declaradas e seus valores, você pode usar um cmdlet especial:
Get-Variable | moreEste método parece excessivamente complicado, é muito mais conveniente trabalhar com variáveis através de operadores ou acessando suas propriedades e métodos diretamente. No entanto, os cmdlets têm o direito de existir porque permitem que você defina alguns parâmetros adicionais. É importante entender que as variáveis de usuário são definidas apenas na sessão atual. Quando o console é fechado ou o script termina, eles são deletados.
Variáveis do sistema
Além daquelas declaradas pelo usuário, existem variáveis internas (do sistema) que não são excluídas após o término da sessão atual. Eles são divididos em dois tipos, enquanto os dados de estado do PowerShell são armazenados em variáveis automáticas que não podem receber valores arbitrários por conta própria. Estes incluem, por exemplo, $PWD:
$PWD.Path
As variáveis de preferência são necessárias para armazenar as preferências do usuário, cujos valores podem ser alterados. Por exemplo, usando $ErrorActionPreference , é definida a reação do interpretador de comandos à ocorrência de erros não fatais.
Além dos operadores e cmdlets para acessar as variáveis declaradas, existe uma Variável: pseudo-acumulador. Você pode trabalhar com ele por analogia com outras unidades, e as variáveis neste caso se assemelham a objetos do sistema de arquivos:
Get-ChildItem Variable: | moreou
ls Variable: | more
Escopos
Para variáveis no PowerShell, existe o conceito de escopo (Scope). A ação do escopo global (Global) se aplica a toda a sessão atual - inclui, por exemplo, variáveis do sistema. As variáveis locais (Local) estão disponíveis apenas no escopo em que foram definidas: digamos, dentro de uma função. Existe também o conceito de escopo do script (Script), mas para comandos de script é essencialmente local. Por padrão, ao declarar variáveis, elas recebem um escopo local e, para alterar isso, você precisa de uma construção especial como: $Global: variável = valor.
Por exemplo, isso:
$Global:test = 100
Variáveis de ambiente (ambiente)
Outra pseudounidade, Env:, está disponível no PowerShell e pode ser usada para acessar variáveis de ambiente. Quando o shell inicia, eles são copiados do processo pai (ou seja, do programa que iniciou a sessão atual) e geralmente seus valores iniciais são iguais aos valores no painel de controle. Para exibir variáveis de ambiente, use o cmdlet Get-ChildItem ou seus aliases (aliases): ls e dir.
dir Env:
Essas variáveis são sequências de bytes (ou caracteres, se preferir), cuja interpretação depende apenas do programa que as utiliza. Os cmdlets *-Variable não funcionam com variáveis de ambiente. Para acessá-los, você deve usar o prefixo da unidade:
$env:TEST = "Hello, World!"
Operadores aritméticos e de comparação
O PowerShell fornece os seguintes operadores aritméticos: + (adição), - (subtração), * (multiplicação), / (divisão) e % (módulo ou módulo). O resultado de uma expressão aritmética é avaliado da esquerda para a direita de acordo com a ordem de operações geralmente aceita e os parênteses são usados para agrupar partes da expressão. Os espaços entre os operadores são ignorados, são usados apenas para facilitar a leitura. O operador + também concatena e o operador * repete strings. Se você tentar adicionar um número a uma string, ele será convertido em uma string. Além disso, a linguagem PowerShell possui muitos operadores de comparação que verificam uma correspondência entre dois valores e retornam o booleano True ou False:
Operador
descrição
Exemplo de código
-eq
Equal / Equals (semelhante a = ou == em outros idiomas)
$teste = 100
$teste -eq 123
-um
Diferente / Diferente (semelhante a <> ou !=)
$teste = 100
$teste -ne 123
-gt
Maior que / Mais (analógico >)
$teste = 100
$teste -gt 123
-dar
Maior ou igual / Maior ou igual (semelhante a >=)
$teste = 100
$teste -ge 123
-lt
Menos que / Menos (semelhante a <)
$teste = 100
$teste -lt 123
Eles
Menor ou igual / Menor ou igual (semelhante a <=)
$teste = 100
$teste -le 123
Existem outros operadores semelhantes que permitem, por exemplo, comparar strings com base em um curinga ou usar expressões regulares para corresponder a um padrão. Vamos abordá-los em detalhes em artigos futuros. Os símbolos <, > e = não são usados para comparação porque são usados para outros propósitos.
Operadores de atribuição
Além do operador = mais comum, existem outros operadores de atribuição: +=, -=, *=, /= e %=. Eles alteram o valor antes da atribuição. Os operadores unários ++ e -, que aumentam ou diminuem o valor de uma variável, se comportam de maneira semelhante - eles também se aplicam a operadores de atribuição.
Operadores lógicos
A comparação por si só não é suficiente para descrever condições complexas. Você pode escrever qualquer expressão lógica usando os operadores: -and, -or, -xor, -not and! .. Eles funcionam como em outras linguagens de programação, enquanto você pode usar parênteses para especificar a ordem de avaliação:
("Тест" -eq "Тест") -and (100 -eq 100)
-not (123 -gt 321)
!(123 -gt 321)
salto condicional
Os operadores de ramificação no PowerShell são padrão: IF(IF…ELSE, IF…ELSEIF…ELSE) e SWITCH. Vejamos seu uso com 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
O PowerShell tem várias variedades de loops: WHILE, DO WHILE, DO UNTIL, FOR e FOREACH.
Um loop com uma pré-condição funciona se/desde que seja verdadeiro:
[int]$test = 0
while ($test -lt 10) {
Write-Host $test
$test = $test + 1
}
Loops com pós-condição serão executados pelo menos uma vez, porque a condição é verificada após a iteração. Ao mesmo tempo, DO WHILE funciona enquanto a condição é verdadeira e DO UNTIL funciona enquanto ela é 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 iterações do loop FOR é conhecido antecipadamente:
for ([int]$test = 0; $test -lt 10; $test++) {
Write-Host $test
}
No loop FOREACH, itera sobre os elementos de uma matriz ou coleção (tabela de hash):
$test_collection = "item1", "item2", "item3"
foreach ($item in $test_collection)
{
Write-Host $item
}
Matrizes
As variáveis do PowerShell armazenam não apenas objetos únicos (número, string, etc.), mas também vários. O tipo mais simples dessas variáveis são os arrays. Uma matriz pode consistir em vários elementos, um elemento ou estar vazio, ou seja, não contém elementos. Ele é declarado usando o operador @(), que precisaremos no próximo artigo - é muito importante para adicionar outros arrays a um array (criar arrays multidimensionais), passar arrays para funções como um argumento e tarefas semelhantes:
$test_array = @() #создаем пустой массивQuando um array é inicializado, seus valores são listados separados por vírgulas (operador especial ,):
$test_array = @(1, 2, 3, 4) # создаем массив из четырех элементов Na maioria dos casos, o operador @() pode ser omitido:
$test_array = 1, 2, 3, 4Nesse caso, uma matriz de um elemento é inicializada da seguinte maneira
$test_array = , 1Os elementos da matriz são acessados usando um índice inteiro baseado em zero e o operador de índice (colchetes):
$test_array[0] = 1Você pode especificar vários índices separados por vírgulas, incl. recorrente:
$test_array = "один", "два", "три", "четыре"
$test_array[0,1,2,3]
$test_array[1,1,3,3,0]
Operador .. (dois pontos - operador de intervalo) retorna uma matriz de inteiros dentro dos limites superior e inferior especificados. Por exemplo, a expressão 1..4 gera uma matriz de quatro elementos @(1, 2, 3, 4) e a expressão 8..5 gera uma matriz @(8, 7, 6, 5).
Usando o operador de intervalo, você pode inicializar uma matriz ($test_array = 1..4) ou obter uma fatia (slice), ou seja, uma sequência de elementos de um array com índices de outro. Nesse caso, um número negativo -1 denota o último elemento da matriz, -2 - o penúltimo e assim por diante.
$test_array = "один", "два", "три", "четыре"
$test_array[0..2]
$test_array[2..0]
$test_array[-1..0]
$test_array[-2..1]Observe que os valores inteiros da matriz podem ser maiores que o valor máximo do índice da matriz de dados. Neste caso, todos os valores são retornados até o último:
$test_array[0..100]Se você tentar acessar um único elemento inexistente da matriz, $null será retornado.
No PowerShell, os arrays podem conter elementos de diferentes tipos ou serem fortemente tipados:
$test_array = 1, 2, "тест", 3, 4
for ([int]$i = 0; $i -lt $test_array.count; $i++)
{
Write-Host $test_array[$i]
}
Onde a propriedade $test_array.count é o número de elementos da matriz.
Um exemplo de criação de um array fortemente tipado:
[int[]]$test_array = 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
Tabelas de hash
Outro tipo básico de variáveis na linguagem PowerShell são as tabelas de hash, também conhecidas como matrizes associativas. Hashtables são semelhantes a objetos JSON e são criados com base em chave-valor. Ao contrário dos arrays comuns, seus elementos são acessados por chaves nomeadas, que são propriedades do objeto (você também pode usar o operador de índice - colchetes).
Uma tabela de hash vazia é declarada usando o símbolo @ e colchetes de operador:
$test_hashtable = @{}Ao declarar, você pode criar chaves imediatamente e atribuir valores a elas:
$test_hashtable = @{one="один"; two="два"; three="три"; "some key"="some value"}Para adicionar um elemento a uma tabela de hash, você deve atribuir uma chave que ainda não existe a ela ou usar o método Add (). Se uma atribuição for feita a uma chave existente, seu valor será alterado. O método Remove() é usado para remover um elemento de uma tabela hash.
$test_hashtable."some key"
$test_hashtable["some key"]
$test_hashtable.Add("four", "четыре")
$test_hashtable.five = "пять"
$test_hashtable['five'] = "заменяем значение"
$test_hashtable.Remove("one")
Variáveis desse tipo podem ser passadas como argumentos para funções e cmdlets - no próximo artigo estudaremos como isso é feito e também consideraremos outro tipo semelhante - PSCustomObject.
funções
O PowerShell tem tudo o que você precisa para programação processual, incluindo funções. Para descrevê-los, a palavra de função Function é usada, após a qual você precisa especificar o nome da função e o corpo entre colchetes do operador. Se precisar passar argumentos para a função, você pode especificá-los imediatamente após o nome entre parênteses.
function имя-функции (аргумент1, ..., аргументN)
{
тело-функции
}
A função sempre retorna um resultado - é um array dos resultados de todas as suas declarações, se houver mais de uma. Se houver apenas uma instrução, o único valor do tipo correspondente será retornado. A construção return $value adiciona um elemento com o valor $value ao array de resultados e interrompe a execução da lista de instruções, e a função vazia retorna $null.
Por exemplo, vamos criar uma função para elevar ao quadrado um número:
function sqr ($number)
{
return $number * $number
}
Observe que no corpo de uma função, você pode usar qualquer variável declarada antes de chamá-la, e chamar funções no PowerShell pode parecer incomum: os argumentos (se houver) não estão entre parênteses e são separados por espaços.
sqr 2ou assim:
sqr -number 2Devido à forma como os argumentos são passados, a própria função às vezes precisa ser colocada entre parênteses:
function test_func ($n) {}
test_func -eq $null # функция не вызывалась
(test_func) -eq $null # результат выражения — $true
Ao descrever uma função, você pode atribuir valores padrão aos argumentos:
function func ($arg = value) {
#тело функции
}
Existe outra sintaxe para descrever os argumentos da função, além disso, os parâmetros podem ser lidos no pipeline - tudo isso será útil no próximo artigo, quando examinarmos os módulos exportados e criarmos nossos próprios cmdlets.
Erro ao processar
O PowerShell tem um mecanismo Try...Catch...Finally para lidar com exceções. O bloco Try contém o código no qual pode ocorrer um erro e o bloco Catch contém seu manipulador. Se não houve erro, não é executado. O bloco Finalmente é executado após o bloco Try, independentemente da ocorrência de um erro, podendo haver vários blocos Catch para diferentes tipos de exceções. A própria exceção é gravada em uma variável padrão não declarada ($_) e pode ser recuperada facilmente. No exemplo abaixo, implementamos a proteção contra a entrada de um valor inválido:
try {
[int]$test = Read-Host "Введите число"
100 / $test
} catch {
Write-Warning "Некорректное число"
Write-Host $_
}
Isso conclui a revisão dos fundamentos da programação na linguagem PowerShell. Nos artigos a seguir, estudaremos mais detalhadamente como trabalhar com variáveis de diferentes tipos, coleções, expressões regulares, criação de funções, módulos e cmdlets personalizados, bem como programação orientada a objetos.
Fonte: habr.com