Windows PowerShell nedir ve ne ile yenir? Bölüm 2: Programlama diline giriş

Tarihsel olarak, Unix sistemlerindeki komut satırı yardımcı programları Windows'takinden daha iyi geliştirilmiştir, ancak yeni bir çözümün ortaya çıkmasıyla durum değişti.

PowerShell, klasik yordamsal, nesne yönelimli ve hatta işlevsel programlama öğelerine sahip yorumlanmış, çok paradigmalı bir dilde yazılabilir: koşullu dallanma, döngüler, değişkenler, diziler, karma tablolar, sınıflar, hata işleme ve işlevler, cmdlet'ler ve işlem hatları . önceki makale çevrede çalışmanın temellerine ayrılmıştı ve şimdi okuyuculara programcılar için küçük bir rehber sunuyoruz.

İçindekiler:

Yorumlar
Değişkenler ve türleri
sistem değişkenleri
Kapsamlar
Ortam değişkenleri (ortam)
Aritmetik ve karşılaştırma işleçleri
Atama işleçleri
Mantıksal operatörler
Koşullu Atlama
döngüleri
Diziler
Hash tabloları
fonksiyonlar
Hata işleme

Herhangi bir metin düzenleyicide veya entegre bir geliştirme ortamı kullanarak kod yazabilirsiniz - en kolay yol, Microsoft sunucu işletim sistemleriyle birlikte gelen Windows PowerShell ISE'yi almaktır. Bu yalnızca oldukça karmaşık betikler için gereklidir: kısa komut kümelerinin etkileşimli olarak yürütülmesi daha kolaydır.

Yorumlar

Yorum kullanmak, uygun girinti ve boşlukla birlikte iyi programlama stilinin bir parçası olarak kabul edilir:

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

<# 

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

#>

Değişkenler ve türleri

PowerShell'deki değişkenler, adlandırılmış nesnelerdir. Adları, alt çizgi karakterinin yanı sıra harf ve sayıları içerebilir. $ Sembolü her zaman isimden önce kullanılır ve bir değişken bildirmek için yorumlayıcıya geçerli bir isim vermek yeterlidir:

Bir değişkeni başlatmak (ona bir değer atamak) için, atama işleci (sembol =) kullanılır:

$test = 100

Ad veya değerden önce türünü köşeli parantez içinde (tür atama işleci) belirterek bir değişken bildirebilirsiniz:

[int]$test = 100

$test = [int]100

PowerShell'deki değişkenlerin, türleri .NET Core'dakilere dayanan özelliklere ve yöntemlere sahip tam teşekküllü nesneler (sınıflar) olduğunu anlamak önemlidir. Ana olanları listeliyoruz:

Tür (.NET sınıfı)

Açıklama

Kod örneği

[dize] System.String

Unicode dizesi 

$ testi = "deneme"
$ testi = 'deneme'

[char]System.Char

Unicode karakteri (16 bit)

[char]$ testi = 'c'

[bool] Sistem.Boolean

boole tipi (boole True veya False)

[bool]$test = $doğru

[int] System.Int32

otuz iki bit tamsayı (32 bit)

[int]$ testi = 123456789

[uzun] System.Int64

altmış dört bit tamsayı (64 bit)

[uzun]$testi = 12345678910

[tek] System.Single

kayan nokta sayısı 32 bit uzunluğunda

[tek]$ testi = 12345.6789

[çift]System.Double

uzunluk kayan nokta sayısı 64 bit (8 bayt)

[çift]$testi = 123456789.101112

[ondalık]System.Decimal

128 bit kayan noktalı sayı (d ile bitmesi gerekir)

[ondalık]$testi = 12345.6789d

[DateTime]System.DateTime

tarih ve saat 

$ testi = GetDate

[dizi] System.Object[]

eleman indeksi 0'dan başlayan bir dizi

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

[karma tablo] System.Collections.Hashtable

hash tabloları, şu ilkeye göre oluşturulmuş, adlandırılmış anahtarlara sahip ilişkisel dizilerdir: @{key = "value"}

$test_hashtable = @{bir="bir"; iki=iki”; üç="üç"}

PowerShell, örtük tür dönüştürmeyi destekler, ek olarak, bir değişkenin türü, zorla belirtilmezse anında değiştirilebilir (örneğin, bir atama işleci kullanılarak), bu durumda yorumlayıcı bir hata verir. Önceki örnekteki değişkenin türünü GetType() yöntemini çağırarak belirleyebilirsiniz:

$test.GetType().FullName

Değişkenleri işlemek için bir dizi cmdlet vardır. Listeleri uygun bir biçimde şu komut kullanılarak görüntülenir:

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

Bildirilen değişkenleri ve değerlerini görüntülemek için özel bir cmdlet kullanabilirsiniz:

Get-Variable | more

Bu yöntem aşırı hantal görünüyor, değişkenlerle operatörler aracılığıyla veya özelliklerine ve yöntemlerine doğrudan erişerek çalışmak çok daha uygun. Ancak, cmdlet'ler bazı ek parametreler ayarlamanıza izin verdiği için var olma hakkına sahiptir. Kullanıcı değişkenlerinin yalnızca mevcut oturumda tanımlandığını anlamak önemlidir. Konsol kapatıldığında veya komut dosyası bittiğinde silinirler.

sistem değişkenleri

Kullanıcı tarafından bildirilenlere ek olarak, geçerli oturum sona erdikten sonra silinmeyen yerleşik (sistem) değişkenler vardır. PowerShell durum verileri kendi başına keyfi değerler atanamayan otomatik değişkenlerde saklanırken, iki türe ayrılırlar. Bunlar, örneğin $PWD'yi içerir:

$PWD.Path

Değerleri değiştirilebilen kullanıcı tercihlerini saklamak için tercih değişkenlerine ihtiyaç vardır. Örneğin, $ErrorActionPreference kullanılarak, komut yorumlayıcısının ölümcül olmayan hataların oluşumuna tepkisi ayarlanır.

Bildirilen değişkenlere erişim için işleçlere ve cmdlet'lere ek olarak, bir Değişken: sözde toplayıcı vardır. Onunla diğer sürücülere benzeterek çalışabilirsiniz ve bu durumda değişkenler dosya sistemi nesnelerine benzer:

Get-ChildItem Variable: | more

veya

ls Variable: | more

Kapsamlar

PowerShell'deki değişkenler için kapsam (Scope) kavramı vardır. Global kapsamın (Global) eylemi mevcut oturumun tamamı için geçerlidir - örneğin sistem değişkenlerini içerir. Yerel (Yerel) değişkenler, yalnızca tanımlandıkları kapsamda kullanılabilir: örneğin bir işlevin içinde. Komut dosyasının kapsamı (Script) kavramı da vardır, ancak komut dosyası komutları için esasen yereldir. Varsayılan olarak, değişkenleri bildirirken, onlara yerel bir kapsam verilir ve bunu değiştirmek için, $Global: değişken = değer gibi özel bir yapıya ihtiyacınız vardır.

Örneğin, bu:

$Global:test = 100

Ortam değişkenleri (ortam)

Başka bir sözde sürücü olan Env:, PowerShell'den edinilebilir ve ortam değişkenlerine erişmek için kullanılabilir. Kabuk başladığında, ana süreçten (yani mevcut oturumu başlatan programdan) kopyalanırlar ve genellikle başlangıç ​​​​değerleri, kontrol panelindeki değerlerle aynıdır. Ortam değişkenlerini görüntülemek için Get-ChildItem cmdlet'ini veya diğer adlarını (takma adları) kullanın: ls ve dir.

dir Env:

Bu değişkenler, yorumlanması yalnızca onları kullanan programa bağlı olan bayt dizileridir (veya isterseniz karakter). *-Variable cmdlet'leri ortam değişkenleriyle çalışmaz. Bunlara erişmek için sürücü önekini kullanmanız gerekir:

$env:TEST = "Hello, World!"

Aritmetik ve karşılaştırma işleçleri

PowerShell şu aritmetik işleçleri sağlar: + (toplama), - (çıkarma), * (çarpma), / (bölme) ve % (modulo veya modulo). Bir aritmetik ifadenin sonucu, genel kabul görmüş işlem sırasına göre soldan sağa doğru değerlendirilir ve ifadenin bölümlerini gruplandırmak için parantezler kullanılır. Operatörler arasındaki boşluklar göz ardı edilir, sadece okumayı kolaylaştırmak için kullanılırlar. + operatörü de birleştirir ve * operatörü dizeleri tekrarlar. Bir diziye bir sayı eklemeye çalışırsanız, bir diziye dönüştürülür. Ek olarak, PowerShell dili, iki değer arasında bir eşleşme olup olmadığını kontrol eden ve boole True veya False döndüren birçok karşılaştırma işlecine sahiptir:

operatör

Açıklama

Kod örneği

-eşit

Eşittir / Eşittir (diğer dillerdeki = veya == benzeri)

$ testi = 100
$test -eq 123 

-ne

Eşit değil / Eşit değil (<> veya !='ye benzer)

$ testi = 100
$test -ne 123   

-gt

Daha büyük / Daha fazla (analog>)

$ testi = 100
$ testi -gt 123

-ge

Büyüktür veya eşittir / Büyüktür veya eşittir (>='ye benzer)

$ testi = 100
$ testi -ge 123

-Bu

Daha az / Daha az (<'a benzer)

$ testi = 100
$ testi -lt 123  

Onları

Küçüktür veya eşittir / Küçüktür veya eşittir (<='ye benzer)

$ testi = 100
$test -le 123

Örneğin, bir joker karaktere dayalı olarak dizeleri karşılaştırmanıza veya bir kalıbı eşleştirmek için normal ifadeler kullanmanıza izin veren başka benzer işleçler vardır. Bunları ileriki yazılarımızda ayrıntılı olarak ele alacağız. <, > ve = sembolleri başka amaçlar için kullanıldıklarından karşılaştırma için kullanılmazlar.

Atama işleçleri

En yaygın = işlecine ek olarak başka atama işleçleri de vardır: +=, -=, *=, /= ve %=. Atamadan önce değeri değiştirirler. Bir değişkenin değerini artıran veya azaltan tekli işleçler ++ ve - benzer şekilde davranır - bunlar atama işleçleri için de geçerlidir.

Mantıksal operatörler

Karmaşık koşulları tanımlamak için tek başına karşılaştırma yeterli değildir. Operatörleri kullanarak herhangi bir mantıksal ifade yazabilirsiniz: -and, -or, -xor, -not ve! .. Diğer programlama dillerindeki gibi çalışırlar, değerlendirme sırasını belirtmek için parantez kullanabilirsiniz:

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

-not (123 -gt 321) 

!(123 -gt 321)

Koşullu Atlama

PowerShell'deki şube işleçleri standarttır: IF(IF…ELSE, IF…ELSEIF…ELSE) ve SWITCH. Kullanımlarına örneklerle bakalım:

[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 или значение не определено"}
}

döngüleri

PowerShell'de çeşitli döngü türleri vardır: WHILE, DO WHILE, DO UNTIL, FOR ve FOREACH.

Önkoşulu olan bir döngü, doğruysa/olduğu sürece çalışır:

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

Koşul yinelemeden sonra kontrol edildiğinden, son koşullu döngüler en az bir kez çalışır. Aynı zamanda, koşul doğruyken DO WHILE çalışır ve yanlışken DO UNTIL çalışır:

[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)

FOR döngüsünün yineleme sayısı önceden bilinir:

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

FOREACH döngüsünde, bir dizinin veya koleksiyonun (hash tablosu) öğeleri üzerinde yinelenir:

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

Diziler

PowerShell değişkenleri yalnızca tek nesneleri (sayı, dizi vb.) değil, birden çok nesneyi de depolar. Bu tür değişkenlerin en basit türü dizilerdir. Bir dizi birkaç elemandan, bir elemandan oluşabilir veya boş olabilir, yani. eleman içermez. Bir sonraki makalede ihtiyaç duyacağımız @() operatörü kullanılarak bildirilir - bir diziye başka diziler eklemek (çok boyutlu diziler oluşturmak), dizileri işlevlere argüman olarak geçirmek ve benzeri görevler için çok önemlidir:

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

Bir dizi başlatıldığında, değerleri virgülle ayrılmış olarak listelenir (özel operatör ,):

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

Çoğu durumda, @() operatörü atlanabilir:

$test_array = 1, 2, 3, 4

Bu durumda, bir eleman dizisi aşağıdaki gibi başlatılır.

$test_array = , 1

Dizi öğelerine sıfır tabanlı bir tamsayı dizini ve dizin işleci (köşeli parantezler) kullanılarak erişilir:

$test_array[0] = 1

Dahil olmak üzere virgülle ayrılmış birkaç dizin belirleyebilirsiniz. yinelenen:

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

operatör .. (iki nokta - aralık operatörü), belirtilen üst ve alt sınırlar içinde bir tamsayı dizisi döndürür. Örneğin, 1..4 ifadesi dört öğeden oluşan bir dizi @(1, 2, 3, 4) çıkarır ve 8..5 ifadesi bir @(8, 7, 6, 5) dizisi verir.

Aralık operatörünü kullanarak, bir dizi ($test_array = 1..4) başlatabilir veya bir dilim (dilim) alabilirsiniz, yani. bir diziden diğerinden indeksler içeren bir dizi öğe. Bu durumda, negatif bir sayı -1, dizinin son öğesini, -2 - sondan bir önceki öğeyi vb.

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

Tamsayı dizisi değerlerinin, veri dizisinin maksimum dizin değerinden büyük olabileceğini unutmayın. Bu durumda, son değere kadar olan tüm değerler döndürülür:

$test_array[0..100]

Var olmayan tek bir dizi öğesine erişmeye çalışırsanız, $null döndürülür.

PowerShell'de diziler farklı türde öğeler içerebilir veya kesinlikle yazılabilir:

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

$test_array.count özelliği, dizi öğelerinin sayısıdır.

Türü kesin olarak belirlenmiş bir dizi oluşturmaya bir örnek:

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

Hash tabloları

PowerShell dilindeki diğer bir temel değişken türü, ilişkisel diziler olarak da bilinen karma tablolardır. Hashtable'lar, JSON nesnelerine benzer ve anahtar/değer temelinde oluşturulur. Sıradan dizilerin aksine, öğelerine nesnenin özellikleri olan adlandırılmış anahtarlarla erişilir (ayrıca dizin işlecini - köşeli parantezler de kullanabilirsiniz).

@ sembolü ve operatör parantezleri kullanılarak boş bir hash tablosu bildirilir:

$test_hashtable = @{}

Beyan ederken, hemen anahtarlar oluşturabilir ve bunlara değerler atayabilirsiniz:

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

Bir hash tablosuna öğe eklemek için, ona henüz var olmayan bir anahtar atamanız veya Add () yöntemini kullanmanız gerekir. Mevcut bir anahtara atama yapılırsa değeri değişir. Remove() yöntemi, bir hash tablosundan bir öğeyi kaldırmak için kullanılır.

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

Bu tür değişkenler, işlevlere ve cmdlet'lere argüman olarak iletilebilir - sonraki makalede bunun nasıl yapıldığını inceleyeceğiz ve ayrıca benzer başka bir türü - PSCustomObject ele alacağız.

fonksiyonlar

PowerShell, işlevler de dahil olmak üzere yordamsal programlama için ihtiyacınız olan her şeye sahiptir. Bunları tanımlamak için, işlev sözcüğü İşlev kullanılır, bundan sonra işlevin adını ve operatör parantezleri içine alınmış gövdeyi belirtmeniz gerekir. İşleve bağımsız değişkenler iletmeniz gerekirse, bunları parantez içindeki adlardan hemen sonra belirtebilirsiniz.

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

İşlev her zaman bir sonuç döndürür - birden fazla varsa, tüm ifadelerinin sonuçlarının bir dizisidir. Yalnızca bir ifade varsa, karşılık gelen türün tek değeri döndürülür. $değer döndürme yapısı, sonuç dizisine $değer değerine sahip bir öğe ekler ve deyim listesinin yürütülmesini iptal eder ve boş işlev, $null değerini döndürür.

Örneğin, bir sayının karesini almak için bir fonksiyon oluşturalım:

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

Bir işlevin gövdesinde, onu çağırmadan önce bildirilen tüm değişkenleri kullanabileceğinizi ve PowerShell'de işlevleri çağırmanın sıra dışı görünebileceğini unutmayın: bağımsız değişkenler (varsa) parantez içine alınmaz ve boşluklarla ayrılır.

sqr 2

ya da öylesine:

sqr -number 2

Argümanların iletilme şekli nedeniyle, işlevin kendisinin bazen parantez içine alınması gerekir:

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

Bir işlevi tanımlarken, bağımsız değişkenlere varsayılan değerler atayabilirsiniz:

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

İşlev bağımsız değişkenlerini açıklamak için başka bir sözdizimi vardır, ek olarak, parametreler ardışık düzenden okunabilir - tüm bunlar, dışa aktarılan modüllere baktığımızda ve kendi cmdlet'lerimizi oluşturduğumuzda bir sonraki makalede kullanışlı olacaktır.

Hata işleme

PowerShell, istisnaları işlemek için bir Try...Catch...Finally mekanizmasına sahiptir. Try bloğu, bir hatanın oluşabileceği kodu içerir ve Catch bloğu işleyicisini içerir. Hata yoksa yürütülmez. Nihayet bloğu, Try bloğundan sonra, bir hata oluşmasına bakılmaksızın yürütülür ve farklı istisna türleri için birkaç Catch bloğu olabilir. İstisnanın kendisi bildirilmemiş bir varsayılan değişkene ($_) yazılır ve kolayca alınabilir. Aşağıdaki örnekte, geçersiz bir değer girmeye karşı koruma uyguluyoruz:

try {

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

} catch {

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

}

Bu, PowerShell dilinde programlamanın temellerinin gözden geçirilmesini tamamlıyor. Aşağıdaki makalelerde, farklı türlerdeki değişkenler, koleksiyonlar, normal ifadeler, işlev oluşturma, modüller ve özel cmdlet'lerin yanı sıra nesne yönelimli programlama ile çalışmayı daha ayrıntılı olarak inceleyeceğiz.

Kaynak: habr.com