🥇Apakah Windows PowerShell dan dengan apa ia dimakan? Bahagian 2: Pengenalan kepada bahasa pengaturcaraan

Dari segi sejarah, utiliti baris arahan pada sistem Unix dibangunkan dengan lebih baik daripada Windows, tetapi dengan kemunculan penyelesaian baharu, keadaan telah berubah.

PowerShell boleh diskrip dalam bahasa berbilang paradigma yang ditafsirkan yang mempunyai unsur-unsur prosedur klasik, berorientasikan objek dan juga pengaturcaraan berfungsi: percabangan bersyarat, gelung, pembolehubah, tatasusunan, jadual cincang, kelas, pengendalian ralat, serta fungsi, cmdlet, dan saluran paip . Artikel sebelumnya telah menumpukan kepada asas bekerja di alam sekitar, dan kini kami menawarkan pembaca kami sebuah buku rujukan kecil untuk pengaturcara.

:Лавление:

Comments
Pembolehubah dan jenisnya
Pembolehubah sistem
Skop
Pembolehubah persekitaran (persekitaran)
Operator aritmetik dan perbandingan
Pengendali tugasan
Pengendali logik
Lompat Bersyarat
Kitaran
Tatasusunan
Hash jadual
Fungsi
Ralat pemprosesan

Anda boleh menulis kod dalam mana-mana editor teks atau menggunakan persekitaran pembangunan bersepadu - cara paling mudah ialah menggunakan Windows PowerShell ISE yang disertakan dengan sistem pengendalian pelayan Microsoft. Ini hanya perlu untuk skrip yang agak kompleks: set arahan pendek lebih mudah untuk dilaksanakan secara interaktif.

Comments

Menggunakan ulasan dianggap sebagai sebahagian daripada gaya pengaturcaraan yang baik bersama-sama dengan lekukan dan ruang kosong yang betul:

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

<# 

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

#>

Pembolehubah dan jenisnya

Pembolehubah dalam PowerShell dinamakan objek. Nama mereka boleh termasuk aksara garis bawah, serta huruf dan nombor. Simbol $ sentiasa digunakan sebelum nama, dan untuk mengisytiharkan pembolehubah, sudah cukup untuk memberi penterjemah nama yang sah:

Untuk memulakan pembolehubah (menetapkan nilai kepadanya), pengendali tugasan (simbol =) digunakan:

$test = 100

Anda boleh mengisytiharkan pembolehubah dengan menyatakan jenisnya dalam kurungan segi empat sama (operator pemutus jenis) sebelum nama atau nilai:

[int]$test = 100

$test = [int]100

Adalah penting untuk memahami bahawa pembolehubah dalam PowerShell ialah objek (kelas) lengkap dengan sifat dan kaedah yang jenisnya berdasarkan pada .NET Core. Kami menyenaraikan yang utama:

Jenis (kelas .NET)

Описание

Contoh kod

[rentetan] System.String

Rentetan Unicode

$test = "ujian"
$test = 'test'

[char]System.Char

aksara Unicode (16 bit)

[char]$test = 'c'

[bool] System.Boolean

jenis boolean (boolean True atau False)

[bool]$test = $true

[int] System.Int32

tiga puluh dua bit integer (32 bit)

[int]$test = 123456789

[panjang] System.Int64

enam puluh empat bit integer (64 bit)

[panjang]$test = 12345678910

[single] System.Single

titik terapung nombor 32 bit panjang

[single]$test = 12345.6789

[double]System.Double

nombor titik terapung panjang 64 bit (8 bait)

[double]$test = 123456789.101112

[perpuluhan]Sistem.Perpuluhan

Nombor titik terapung 128-bit (diperlukan untuk berakhir dengan d)

[perpuluhan]$ujian = 12345.6789d

[DateTime]System.DateTime

tarikh dan masa

$test = GetDate

[array] System.Object[]

tatasusunan yang indeks elemennya bermula pada 0

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

[hashtable] System.Collections.Hashtable

jadual hash ialah tatasusunan bersekutu dengan kekunci bernama, dibina mengikut prinsip: @{key = "value"}

$test_hashtable = @{one="one"; dua="dua"; tiga="tiga"}

PowerShell menyokong penukaran jenis tersirat, di samping itu, jenis pembolehubah boleh ditukar dengan cepat (contohnya, menggunakan pengendali tugasan), jika ia tidak dinyatakan secara paksa - dalam kes ini, jurubahasa akan memberikan ralat. Anda boleh menentukan jenis pembolehubah daripada contoh sebelumnya dengan memanggil kaedah GetType() :

$test.GetType().FullName

Terdapat beberapa cmdlet untuk memanipulasi pembolehubah. Senarai mereka dalam bentuk yang mudah dipaparkan menggunakan arahan:

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

Untuk melihat pembolehubah yang diisytiharkan dan nilainya, anda boleh menggunakan cmdlet khas:

Get-Variable | more

Kaedah ini kelihatan terlalu menyusahkan, adalah lebih mudah untuk bekerja dengan pembolehubah melalui pengendali atau dengan mengakses sifat dan kaedah mereka secara langsung. Walau bagaimanapun, cmdlet mempunyai hak untuk wujud kerana ia membenarkan anda menetapkan beberapa parameter tambahan. Adalah penting untuk memahami bahawa pembolehubah pengguna hanya ditakrifkan dalam sesi semasa. Apabila konsol ditutup atau skrip tamat, ia akan dipadamkan.

Pembolehubah sistem

Sebagai tambahan kepada yang diisytiharkan oleh pengguna, terdapat pembolehubah terbina dalam (sistem) yang tidak dipadamkan selepas sesi semasa tamat. Mereka dibahagikan kepada dua jenis, manakala data keadaan PowerShell disimpan dalam pembolehubah automatik yang tidak boleh diberikan nilai sewenang-wenangnya sendiri. Ini termasuk, sebagai contoh, $PWD:

$PWD.Path

Pembolehubah keutamaan diperlukan untuk menyimpan pilihan pengguna, yang nilainya boleh diubah. Sebagai contoh, menggunakan $ErrorActionPreference , tindak balas penterjemah arahan kepada berlakunya ralat bukan maut ditetapkan.

Sebagai tambahan kepada pengendali dan cmdlet untuk mengakses pembolehubah yang diisytiharkan, terdapat Pembolehubah: pseudo-akumulator. Anda boleh bekerja dengannya dengan analogi dengan pemacu lain, dan pembolehubah dalam kes ini menyerupai objek sistem fail:

Get-ChildItem Variable: | more

atau

ls Variable: | more

Skop

Untuk pembolehubah dalam PowerShell, terdapat konsep skop (Skop). Tindakan skop global (Global) digunakan pada keseluruhan sesi semasa - ia termasuk, sebagai contoh, pembolehubah sistem. Pembolehubah setempat (Tempatan) tersedia hanya dalam skop yang ditakrifkan: katakan di dalam fungsi. Terdapat juga konsep skop skrip (Skrip), tetapi untuk arahan skrip, ia pada dasarnya adalah tempatan. Secara lalai, apabila mengisytiharkan pembolehubah, ia diberikan skop setempat, dan untuk mengubahnya, anda memerlukan binaan khas seperti: $Global: variable = value.

Sebagai contoh, seperti ini:

$Global:test = 100

Pembolehubah persekitaran (persekitaran)

Satu lagi pemacu pseudo, Env:, tersedia daripada PowerShell dan boleh digunakan untuk mengakses pembolehubah persekitaran. Apabila shell bermula, ia disalin daripada proses induk (iaitu, dari program yang memulakan sesi semasa) dan biasanya nilai awalnya adalah sama dengan nilai dalam panel kawalan. Untuk melihat pembolehubah persekitaran, gunakan cmdlet Get-ChildItem atau alias (alias): ls dan dir.

dir Env:

Pembolehubah ini ialah jujukan bait (atau aksara, jika anda suka), tafsirannya hanya bergantung pada program yang menggunakannya. Cmdlet *-Variable tidak berfungsi dengan pembolehubah persekitaran. Untuk mengaksesnya, anda perlu menggunakan awalan pemacu:

$env:TEST = "Hello, World!"

Operator aritmetik dan perbandingan

PowerShell menyediakan operator aritmetik berikut: + (tambahan), - (tolak), * (darab), / (bahagi), dan % (modulo atau modulo). Hasil ungkapan aritmetik dinilai dari kiri ke kanan mengikut susunan operasi yang diterima umum, dan kurungan digunakan untuk mengumpulkan bahagian ungkapan. Ruang antara operator diabaikan, ia hanya digunakan untuk memudahkan pembacaan. Operator + juga bergabung, dan operator * mengulangi rentetan. Jika anda cuba menambah nombor pada rentetan, ia akan ditukar kepada rentetan. Selain itu, bahasa PowerShell mempunyai banyak operator perbandingan yang menyemak padanan antara dua nilai dan mengembalikan boolean Benar atau Salah:

Pengendali

Описание

Contoh kod

-persamaan

Equal / Equals (serupa dengan = atau == dalam bahasa lain)

$ujian = 100
$ujian -eq 123

- ialah

Tidak sama / Tidak sama (serupa dengan <> atau !=)

$ujian = 100
$ujian -ne 123

-gt

Lebih besar daripada / Lebih (analog >)

$ujian = 100
$test -gt 123

-ge

Lebih besar daripada atau sama / Lebih besar daripada atau sama (serupa dengan >=)

$ujian = 100
$ujian -ge 123

-lt

Kurang daripada / Kurang (serupa dengan <)

$ujian = 100
$ujian -lt 123

-tempat

Kurang daripada atau sama / Kurang daripada atau sama (serupa dengan <=)

$ujian = 100
$ujian -le 123

Terdapat pengendali lain yang serupa yang membolehkan anda, contohnya, membandingkan rentetan berdasarkan kad bebas atau menggunakan ungkapan biasa untuk memadankan corak. Kami akan membincangkannya secara terperinci dalam artikel akan datang. Simbol <, > dan = tidak digunakan untuk perbandingan kerana ia digunakan untuk tujuan lain.

Pengendali tugasan

Selain operator = yang paling biasa, terdapat operator penugasan lain: +=, -=, *=, /= dan %=. Mereka menukar nilai sebelum tugasan. Pengendali unary ++ dan -, yang meningkatkan atau menurunkan nilai pembolehubah, berkelakuan serupa - ia juga digunakan untuk pengendali tugasan.

Pengendali logik

Perbandingan sahaja tidak cukup untuk menggambarkan keadaan yang kompleks. Anda boleh menulis sebarang ungkapan logik menggunakan operator: -and, -or, -xor, -not and! .. Mereka berfungsi seperti dalam bahasa pengaturcaraan lain, manakala anda boleh menggunakan kurungan untuk menentukan susunan penilaian:

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

-not (123 -gt 321) 

!(123 -gt 321)

Lompat Bersyarat

Pengendali cawangan dalam PowerShell adalah standard: IF(IF...ELSE, IF...ELSEIF...ELSE) dan SWITCH. Mari kita lihat penggunaannya dengan contoh:

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

Kitaran

PowerShell mempunyai beberapa jenis gelung: WHILE, DO WHILE, DO UNTIL, FOR, dan FOREACH.

Gelung dengan prasyarat berfungsi jika/selagi ia benar:

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

Gelung dengan postcondition akan dijalankan sekurang-kurangnya sekali, kerana keadaan disemak selepas lelaran. Pada masa yang sama, DO WHILE berfungsi semasa syarat adalah benar, dan DO SAMPAI berfungsi semasa ia adalah palsu:

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

Bilangan lelaran gelung FOR diketahui terlebih dahulu:

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

Dalam gelung FOREACH, mengulangi elemen tatasusunan atau koleksi (jadual cincang):

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

Tatasusunan

Pembolehubah PowerShell menyimpan bukan sahaja objek tunggal (nombor, rentetan, dll.), tetapi juga berbilang objek. Jenis pembolehubah yang paling mudah ialah tatasusunan. Tatasusunan boleh terdiri daripada beberapa elemen, satu elemen, atau kosong, i.e. tidak mengandungi unsur. Ia diisytiharkan menggunakan pengendali @(), yang kita perlukan dalam artikel seterusnya - adalah sangat penting untuk menambah tatasusunan lain pada tatasusunan (membuat tatasusunan multidimensi), menghantar tatasusunan kepada fungsi sebagai hujah, dan tugas yang serupa:

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

Apabila tatasusunan dimulakan, nilainya disenaraikan dipisahkan dengan koma (pengendali khas ,):

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

Dalam kebanyakan kes, pengendali @() boleh diabaikan:

$test_array = 1, 2, 3, 4

Dalam kes ini, tatasusunan satu elemen dimulakan seperti berikut

$test_array = , 1

Elemen tatasusunan diakses menggunakan indeks integer berasaskan sifar dan pengendali indeks (kurung persegi):

$test_array[0] = 1

Anda boleh menentukan beberapa indeks yang dipisahkan dengan koma, termasuk. berulang:

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

Pengendali .. (dua titik - operator julat) mengembalikan tatasusunan integer dalam batas atas dan bawah yang ditentukan. Contohnya, ungkapan 1..4 mengeluarkan tatasusunan empat elemen @(1, 2, 3, 4), dan ungkapan 8..5 mengeluarkan tatasusunan @(8, 7, 6, 5).

Menggunakan operator julat, anda boleh memulakan tatasusunan ($test_array = 1..4) atau mendapatkan kepingan (slice), i.e. urutan unsur dari satu tatasusunan dengan indeks dari yang lain. Dalam kes ini, nombor negatif -1 menandakan elemen terakhir tatasusunan, -2 - yang kedua dari belakang, dan seterusnya.

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

Ambil perhatian bahawa nilai tatasusunan integer boleh lebih besar daripada nilai indeks maksimum tatasusunan data. Dalam kes ini, semua nilai dikembalikan sehingga yang terakhir:

$test_array[0..100]

Jika anda cuba mengakses satu elemen tatasusunan yang tidak wujud, $null dikembalikan.

Dalam PowerShell, tatasusunan boleh mengandungi unsur-unsur jenis yang berbeza atau ditaip dengan kuat:

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

Di mana sifat $test_array.count ialah bilangan elemen tatasusunan.

Contoh mencipta tatasusunan yang ditaip kuat:

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

Hash jadual

Satu lagi jenis pembolehubah asas dalam bahasa PowerShell ialah jadual cincang, juga dikenali sebagai tatasusunan bersekutu. Hashtable adalah serupa dengan objek JSON dan dibina berdasarkan nilai kunci. Tidak seperti tatasusunan biasa, elemen mereka diakses oleh kekunci bernama, yang merupakan sifat objek (anda juga boleh menggunakan pengendali indeks - kurungan segi empat sama).

Jadual cincang kosong diisytiharkan menggunakan simbol @ dan kurungan operator:

$test_hashtable = @{}

Apabila mengisytiharkan, anda boleh segera membuat kunci dan memberikan nilai kepada mereka:

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

Untuk menambah elemen pada jadual cincang, anda mesti menetapkan kunci yang belum wujud padanya atau gunakan kaedah Tambah (). Jika tugasan dibuat kepada kunci sedia ada, nilainya akan berubah. Kaedah Remove() digunakan untuk mengalih keluar elemen daripada jadual cincang.

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

Pembolehubah jenis ini boleh dihantar sebagai hujah kepada fungsi dan cmdlet - dalam artikel seterusnya kita akan mengkaji bagaimana ini dilakukan, dan juga mempertimbangkan jenis lain yang serupa - PSCustomObject.

Fungsi

PowerShell mempunyai semua yang anda perlukan untuk pengaturcaraan prosedur, termasuk fungsi. Untuk menerangkannya, perkataan fungsi Function digunakan, selepas itu anda perlu menentukan nama fungsi dan badan yang disertakan dalam kurungan operator. Jika anda perlu menghantar argumen kepada fungsi, anda boleh menentukannya serta-merta selepas nama dalam kurungan.

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

Fungsi sentiasa mengembalikan hasil - ia adalah tatasusunan keputusan semua pernyataannya, jika terdapat lebih daripada satu. Jika terdapat hanya satu pernyataan, satu-satunya nilai jenis yang sepadan dikembalikan. Pembinaan $value pulangan menambah elemen dengan nilai $value pada tatasusunan hasil dan membatalkan pelaksanaan senarai pernyataan, dan fungsi kosong mengembalikan $null.

Sebagai contoh, mari kita cipta fungsi untuk menduakan nombor:

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

Ambil perhatian bahawa dalam badan fungsi, anda boleh menggunakan mana-mana pembolehubah yang diisytiharkan sebelum memanggilnya dan fungsi panggilan dalam PowerShell mungkin kelihatan luar biasa: hujah (jika ada) tidak disertakan dalam kurungan dan dipisahkan oleh ruang.

sqr 2

atau sebagainya:

sqr -number 2

Kerana cara hujah diluluskan, fungsi itu sendiri kadangkala perlu disertakan dalam kurungan:

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

Apabila menerangkan fungsi, anda boleh menetapkan nilai lalai kepada argumen:

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

Terdapat satu lagi sintaks untuk menerangkan hujah fungsi, sebagai tambahan, parameter boleh dibaca dari saluran paip - semua ini akan berguna dalam artikel seterusnya, apabila kita melihat modul yang dieksport dan mencipta cmdlet kita sendiri.

Ralat pemprosesan

PowerShell mempunyai mekanisme Try...Catch...Akhir sekali untuk mengendalikan pengecualian. Blok Try mengandungi kod di mana ralat mungkin berlaku, dan blok Catch mengandungi pengendalinya. Jika tiada ralat, ia tidak dilaksanakan. Blok Akhirnya dilaksanakan selepas blok Try, tanpa mengira berlakunya ralat, dan mungkin terdapat beberapa blok Catch untuk jenis pengecualian yang berbeza. Pengecualian itu sendiri ditulis kepada pembolehubah lalai yang tidak diisytiharkan ($_) dan boleh diambil dengan mudah. Dalam contoh di bawah, kami melaksanakan perlindungan daripada memasukkan nilai yang tidak sah:

try {

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

} catch {

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

}

Ini menyimpulkan semakan asas pengaturcaraan dalam bahasa PowerShell. Dalam artikel berikut, kami akan mengkaji dengan lebih terperinci bekerja dengan pembolehubah pelbagai jenis, koleksi, ungkapan biasa, mencipta fungsi, modul dan cmdlet tersuai, serta pengaturcaraan berorientasikan objek.

Sumber: www.habr.com

Apakah Windows PowerShell dan dengan apa ia dimakan? Bahagian 2: Pengenalan kepada bahasa pengaturcaraan