Apa itu Windows PowerShell dan apa yang dimakannya? Bagian 2: Pengantar bahasa pemrograman

Secara historis, utilitas command-line pada sistem Unix lebih baik dikembangkan daripada pada Windows, namun, dengan munculnya solusi baru, situasinya telah berubah.



Untuk PowerShell, Anda dapat menulis skrip dalam bahasa multi-paradigma yang ditafsirkan yang berisi elemen pemrograman prosedural, berorientasi objek, dan bahkan fungsional: percabangan bersyarat, loop, variabel, array, array, tabel hash, kelas, penanganan kesalahan, serta fungsi, cmdlet, dan saluran pipa . Artikel sebelumnya dikhususkan untuk dasar-dasar bekerja di lingkungan, dan sekarang kami menawarkan pembaca kami panduan kecil untuk programmer.

Daftar Isi:


Komentar
Variabel dan jenisnya
Variabel sistem
Lingkup Variabel
lingkungan (
aritmatika ) Aritmatika dan
operator perbandingan Operator penugasan
Operator logis
Peralihan bersyarat
Loops
Array
Tabel hash
Fungsi
Penanganan kesalahan Anda

dapat menulis kode dalam editor teks apa pun atau menggunakan lingkungan pengembangan terintegrasi - cara termudah untuk mengambil ISE Windows PowerShell disertakan dengan Sistem Operasi Microsoft Server. Ini hanya diperlukan untuk skrip yang cukup kompleks: set pendek perintah lebih mudah untuk dieksekusi secara interaktif.

Komentar


Menggunakan komentar dianggap sebagai bagian dari gaya pemrograman yang baik bersama dengan lekukan dan ruang yang tepat:

#       —     .

<# 

             . 
            .

#>

Variabel dan tipenya


Variabel di PowerShell adalah objek bernama. Nama mereka mungkin termasuk garis bawah, serta huruf dan angka. Simbol $ selalu digunakan sebelum nama, dan untuk mendeklarasikan variabel, cukup menunjukkan kepada penerjemah nama yang valid:

gambar

Untuk menginisialisasi variabel (menetapkan nilai untuk itu), operator penugasan (simbol =) digunakan:

$test = 100

Anda dapat mendeklarasikan variabel dengan menunjukkan jenisnya dalam tanda kurung (operator konversi tipe) sebelum nama atau nilai:

[int]$test = 100

$test = [int]100

Penting untuk memahami bahwa variabel di PowerShell adalah objek penuh (kelas) dengan properti dan metode yang tipenya didasarkan pada yang tersedia di .NET Core. Kami daftar yang utama:
Ketik (.NET class)
Deskripsi
Contoh kode
[string]
System.String
Unicode 
$test = «»
$test = ''
[char]
System.Char
Unicode (16 )
[char]$test = 'c'
[bool]
System.Boolean
( True False)
[bool]$test = $true
[int]
System.Int32
(32 )
[int]$test = 123456789
[long]
System.Int64
(64 )
[long]$test = 12345678910
[single]
System.Single
32
[single]$test = 12345.6789
[double]
System.Double
64 (8 )
[double]$test = 123456789.101112
[decimal]
System.Decimal
Nomor floating-point 128-bit (pastikan untuk memasukkan d di akhir)
[desimal] $ test = 12345.6789d
[DateTime]
System.DateTime
tanggal dan waktu 
$ test = Get-Date
[array]
System.Object []
sebuah array yang indeks elemennya dimulai dari 0
$ test_array = 1, 2, "test", 3, 4
[hashtabel]
System.Collections.Hashtable
tabel hash - array asosiatif dengan kunci bernama, dibangun berdasarkan prinsip: @ {key = "value"}
$ test_hashtable = @ {one = "one"; two = "two"; three = "three"}

PowerShell mendukung konversi tipe implisit, di samping itu, tipe variabel dapat berubah dengan cepat (misalnya, menggunakan operator penugasan) jika tidak ditentukan secara paksa - dalam hal ini, penerjemah akan melakukan kesalahan. Anda dapat menentukan jenis variabel dari contoh sebelumnya dengan memanggil metode GetType ():

$test.GetType().FullName

gambar

Ada sejumlah cmdlet untuk mengelola variabel. Daftar mereka dalam bentuk yang nyaman ditampilkan menggunakan perintah:

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

gambar

Untuk melihat variabel yang dideklarasikan dan nilainya, Anda dapat menggunakan cmdlet khusus:

Get-Variable | more

Metode ini tampaknya terlalu rumit, jauh lebih nyaman untuk bekerja dengan variabel melalui operator atau dengan mengakses properti dan metode mereka secara langsung. Namun, cmdlet memiliki hak untuk ada karena mereka memungkinkan Anda menentukan beberapa parameter tambahan. Penting untuk dipahami bahwa variabel pengguna hanya ditentukan dalam sesi saat ini. Setelah menutup konsol atau menyelesaikan skrip, mereka dihapus.

Variabel sistem


Selain yang dinyatakan oleh pengguna, ada variabel (sistem) bawaan yang tidak dihapus setelah akhir sesi saat ini. Mereka dibagi menjadi dua jenis, sementara data status PowerShell disimpan dalam variabel otomatis, yang tidak dapat ditugaskan dengan nilai sendiri. Ini termasuk, misalnya, $ PWD:

$PWD.Path

gambar

Untuk menyimpan pengaturan pengguna, Anda perlu variabel preferensi yang nilainya dapat diubah. Sebagai contoh, dengan bantuan $ ErrorActionPreference, respons dari juru bahasa perintah untuk terjadinya kesalahan yang tidak kritis diatur.

Selain operator dan cmdlet, Variabel: pseudo-akumulator ada untuk mengakses variabel yang dideklarasikan. Anda dapat bekerja dengannya dengan analogi dengan drive lain, dan variabel dalam kasus ini menyerupai objek sistem file:

Get-ChildItem Variable: | more

atau

ls Variable: | more

gambar

Lingkup


Untuk variabel di PowerShell, ada gagasan tentang Lingkup. Tindakan area global (Global) meluas ke seluruh sesi saat ini - termasuk, misalnya, variabel sistem. Variabel lokal hanya tersedia di area di mana mereka didefinisikan: katakanlah di dalam fungsi. Ada juga konsep ruang lingkup skrip, tetapi untuk perintah skrip, itu pada dasarnya lokal. Secara default, ketika mendeklarasikan variabel, mereka diberi lingkup lokal, dan untuk mengubahnya, kita memerlukan konstruksi khusus dari formulir: $ Global: variable = value.

Misalnya, seperti ini:

$Global:test = 100

Variabel Lingkungan


Env pseudo-drive lain tersedia dari PowerShell, yang dapat digunakan untuk mengakses variabel lingkungan. Ketika shell dimulai, mereka disalin dari proses induk (mis., Dari program yang memulai sesi saat ini) dan biasanya nilai awalnya bertepatan dengan nilai-nilai di panel kontrol. Untuk melihat variabel lingkungan, gunakan cmdlet Get-ChildItem atau aliasnya (liases): ls dan dir.

dir Env:

gambar

Variabel-variabel ini adalah urutan byte (atau karakter, jika Anda suka), interpretasinya hanya bergantung pada program yang menggunakannya. * -Variabel cmdlet tidak bekerja dengan variabel lingkungan. Untuk mengaksesnya, Anda harus menggunakan awalan disk:

$env:TEST = "Hello, World!"

gambar

Operator aritmatika dan pembanding


PowerShell memiliki operator aritmatika berikut: + (penambahan), - (pengurangan), * (perkalian), / (pembagian) dan% (modul atau sisa pembagian). Hasil dari ekspresi aritmatika dihitung dari kiri ke kanan sesuai dengan urutan operasi yang diterima secara umum, dan tanda kurung digunakan untuk mengelompokkan bagian dari ekspresi. Ruang antar operator diabaikan, mereka hanya digunakan untuk memfasilitasi persepsi. Operator + juga menyatukan, dan operator * mengulangi baris. Jika Anda mencoba menambahkan nomor ke string, itu akan dikonversi ke string. Selain itu, PowerShell memiliki banyak operator perbandingan yang memeriksa korespondensi antara dua nilai dan mengembalikan boolean Benar atau Salah:
Operator
Deskripsi
Contoh kode
-eq
Sama dengan (analog = atau == dalam bahasa lain)
$ test = 100
$ test -eq 123 
-satu
Tidak sama (analog <> atau! =)
$ test = 100
$ test -ne 123   
-gt
Lebih besar dari / Lebih banyak (analog>)
$ test = 100
$ test -gt 123
-Beg
Lebih besar dari atau sama / Lebih besar dari atau sama (analog> =)
$ test = 100
$ test -ge 123
-lt
Kurang dari (analog <)
$ test = 100
$ test -lt 123  
-le
Kurang dari atau sama / Kurang dari atau sama (analog <=)
$ test = 100
$ test -le 123

Ada operator serupa lainnya yang memungkinkan, misalnya, membandingkan string dengan karakter wildcard atau menggunakan ekspresi reguler untuk mencocokkan pola. Kami akan mempertimbangkannya secara rinci dalam artikel berikut. Simbol <,> dan = tidak digunakan untuk perbandingan, karena mereka digunakan untuk tujuan lain.

Operator Penugasan


Selain operator paling umum =, ada operator penugasan lainnya: + =, - =, * =, / = dan% =. Mereka mengubah nilai sebelum penugasan. Operator unary ++ dan - berperilaku serupa, yang menambah atau mengurangi nilai variabel - mereka juga berhubungan dengan operator penugasan.

Operator logis


Perbandingan tidak cukup untuk menggambarkan kondisi yang sulit. Anda dapat menuliskan ekspresi logis apa pun menggunakan operator berikut: -dan, -atau -xor, -not dan! .. Mereka bekerja seperti dalam bahasa pemrograman lain, sementara Anda bisa menggunakan tanda kurung untuk menentukan urutan perhitungan:

("" -eq "") -and (100 -eq 100)

-not (123 -gt 321) 

!(123 -gt 321)

Lompat bersyarat


Operator percabangan di PowerShell adalah standar: IF (IF ... ELSE, IF ... ELSEIF ... ELSE) dan SWITCH. Pertimbangkan 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    "}
}

Siklus


Ada beberapa jenis loop di PowerShell: WHILE, DO WHILE, DO UNTIL, FOR, dan FOREACH.

Loop prakondisi berfungsi jika / saat sedang berjalan:

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

Loop dengan postcondition akan bekerja setidaknya sekali, karena kondisi ini diperiksa setelah iterasi. Dalam hal ini, DO WHILE berfungsi saat kondisinya benar, dan DO SAMPAI - sementara itu salah:

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


Jumlah iterasi loop FOR diketahui sebelumnya:

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


Dalam perulangan FOREACH, iterates atas elemen-elemen array atau koleksi (tabel hash):

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

Array


Variabel PowerShell menyimpan tidak hanya objek tunggal (angka, string, dll.), Tetapi juga objek jamak. Variasi paling sederhana dari variabel tersebut adalah array. Array dapat terdiri dari beberapa elemen, satu elemen atau kosong, mis. tidak mengandung elemen. Untuk mendeklarasikannya, gunakan operator @ (), yang akan kita butuhkan di artikel selanjutnya - sangat penting untuk menambahkan array lain ke array (membuat array multidimensi), meneruskan array ke fungsi sebagai argumen, dan tugas serupa:

$test_array = @() #  

Ketika array diinisialisasi, nilainya dicantumkan dengan koma (operator khusus,):

$test_array = @(1, 2, 3, 4) #      

Dalam kebanyakan kasus, operator @ () dapat dihilangkan:

$test_array = 1, 2, 3, 4

Dalam hal ini, array dari satu elemen diinisialisasi sebagai berikut

$test_array = , 1

Untuk mengakses elemen array, indeks integer mulai dari nol dan operator indeks (tanda kurung) digunakan:

$test_array[0] = 1

Anda dapat menentukan beberapa indeks, dipisahkan dengan koma, termasuk duplikat:

$test_array = "", "", "", ""
$test_array[0,1,2,3]
$test_array[1,1,3,3,0]

gambar

Operator ..(dua titik - operator rentang) mengembalikan array bilangan bulat pada segmen yang ditentukan oleh batas atas dan bawah. Misalnya, ekspresi 1..4 menampilkan array dari empat elemen @ (1, 2, 3, 4), dan ekspresi 8..5 menampilkan array @ (8, 7, 6, 5).

gambar

Dengan menggunakan operator jangkauan, Anda dapat menginisialisasi array ($ test_array = 1..4) atau mendapatkan irisan, mis. urutan elemen dalam satu array dengan indeks dari yang lain. Dalam hal ini, angka negatif -1 menunjukkan elemen terakhir array, -2 - kedua dari belakang, dll.

$test_array = "", "", "", ""
$test_array[0..2]
$test_array[2..0]
$test_array[-1..0]
$test_array[-2..1]

Harap perhatikan bahwa nilai array integer mungkin lebih besar dari nilai maksimum indeks array data. Dalam hal ini, semua nilai dikembalikan ke yang terakhir:

$test_array[0..100]

Jika Anda mencoba mengakses elemen array yang tidak ada, $ null dikembalikan.

gambar

Di PowerShell, array dapat berisi elemen dari tipe yang berbeda atau diketik 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 properti $ test_array.count adalah jumlah elemen dalam array.

Contoh membuat array yang sangat diketik:

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

Tabel hash


Tipe dasar lain dari variabel di PowerShell adalah tabel hash, juga disebut array asosiatif. Hashtable mirip dengan objek JSON dan dibangun berdasarkan nilai kunci. Tidak seperti array biasa, akses ke elemen mereka dilakukan menggunakan kunci bernama, yang merupakan properti objek (Anda juga dapat menggunakan operator indeks - tanda kurung siku).

Tabel hash kosong dinyatakan menggunakan simbol layanan @ dan kurung operator:

$test_hashtable = @{}

Saat mendeklarasikan, Anda dapat segera membuat kunci dan memberikan nilai kepadanya:

$test_hashtable = @{one=""; two=""; three=""; "some key"="some value"}

Untuk menambahkan item ke tabel hash, Anda harus menetapkan kunci yang belum ada atau menggunakan metode Tambah (). Jika tugas dilakukan dengan kunci yang ada, nilainya akan berubah. Untuk menghapus item dari tabel hash, gunakan metode Hapus ().

$test_hashtable."some key"
$test_hashtable["some key"]
$test_hashtable.Add("four", "")
$test_hashtable.five = ""
$test_hashtable['five'] = " "
$test_hashtable.Remove("one")

gambar

Variabel jenis ini dapat diteruskan sebagai argumen untuk fungsi dan cmdlet - dalam artikel selanjutnya kita akan belajar bagaimana melakukan ini, dan juga mempertimbangkan jenis lain yang serupa - PSCustomObject.

Fungsi


PowerShell memiliki semua elemen yang diperlukan untuk pemrograman prosedural, termasuk fungsi. Fungsi kata Fungsi digunakan untuk menggambarkan mereka, setelah itu diperlukan untuk menunjukkan nama fungsi dan tubuh terlampir dalam kurung operator. Jika perlu, berikan argumen ke fungsi, Anda dapat menentukannya segera setelah nama dalam tanda kurung.

function - (1, ..., N) 
{ 
        - 
} 

Fungsi selalu mengembalikan hasil - ini adalah larik hasil semua pernyataannya, jika ada lebih dari satu. Jika ada satu pernyataan, nilai tunggal dari jenis yang sesuai dikembalikan. Konstruk $ value return menambahkan elemen dengan nilai $ value ke array hasil dan membatalkan daftar pernyataan, dan fungsi kosong mengembalikan $ null.

Misalnya, buat fungsi untuk mengkuadratkan angka:

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

Perhatikan bahwa di badan fungsi Anda dapat menggunakan variabel apa pun yang dideklarasikan sebelum pemanggilannya, dan fungsi pemanggilan di PowerShell mungkin tampak tidak biasa: argumen (jika ada) tidak tertutup dalam tanda kurung dan dipisahkan oleh spasi.

sqr 2

atau lebih:

sqr -number 2

Karena cara argumen dilewatkan, fungsi itu sendiri kadang-kadang harus dilampirkan dalam tanda kurung:

function test_func ($n) {}
test_func -eq $null     #   
(test_func) -eq $null   #   — $true

gambar

Saat mendeskripsikan suatu fungsi, Anda dapat menetapkan nilai default untuk argumen:

function func ($arg = value) {
         # 
}

Ada sintaks lain untuk menggambarkan argumen fungsi, selain itu, parameter dapat dibaca dari pipeline - semua ini akan berguna dalam artikel berikutnya ketika kita mempertimbangkan modul yang diekspor dan membuat cmdlet Anda sendiri.

Galat saat memproses


PowerShell memiliki Try ... Catch ... Akhirnya mekanisme untuk menangani pengecualian. Blok Coba berisi kode di mana kesalahan dapat terjadi, dan blok Tangkap berisi penangannya. Jika tidak ada kesalahan, itu tidak dijalankan. Blok Akhirnya dijalankan setelah blok Coba, terlepas dari terjadinya kesalahan, dan mungkin ada beberapa blok Penangkapan untuk pengecualian dari berbagai jenis. Pengecualian itu sendiri ditulis ke variabel non-deklarasi default ($ _) dan dapat dengan mudah diambil. Dalam contoh di bawah ini, kami menerapkan perlindungan terhadap memasukkan nilai yang salah:

try {

        [int]$test = Read-Host " "
        100 / $test

} catch {

         Write-Warning " "
         Write-Host $_

}

gambar

Di situlah dasar-dasar pemrograman PowerShell yang bersangkutan. Dalam artikel berikut kita akan mempelajari lebih detail pekerjaan dengan variabel dari berbagai jenis, koleksi, ekspresi reguler, pembuatan fungsi, modul dan cmdlet khusus, serta pemrograman berorientasi objek.

Bagian 1: fitur utama Windows PowerShell
Bagian 3: meneruskan parameter ke skrip dan fungsi, membuat cmdlet
Bagian 4: Bekerja dengan objek, kelas khusus



All Articles