🥇Apa itu Windows PowerShell dan dimakan dengan apa? Bagian 2: Pengenalan Bahasa Pemrograman

Secara historis, utilitas baris perintah pada sistem Unix dikembangkan lebih baik daripada di Windows, tetapi dengan munculnya solusi baru, situasinya telah berubah.

PowerShell dapat ditulis dalam bahasa multi-paradigma yang ditafsirkan yang memiliki elemen pemrograman prosedural klasik, berorientasi objek, dan bahkan fungsional: percabangan bersyarat, loop, variabel, 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 panduan kecil untuk pemrogram.

contoh:

Komentar
Variabel dan jenisnya
Variabel sistem
Cakupan
Variabel lingkungan (lingkungan)
Operator aritmatika dan perbandingan
Operator penugasan
Operator logika
Lompatan Bersyarat
Siklus
Array
Tabel hash
Fungsi
Menangani kesalahan

Anda dapat menulis kode di editor teks apa pun atau menggunakan lingkungan pengembangan terintegrasi - cara termudah adalah menggunakan ISE Windows PowerShell yang disertakan dengan sistem operasi server Microsoft. Ini hanya diperlukan untuk skrip yang cukup rumit: kumpulan perintah pendek lebih mudah dijalankan secara interaktif.

Komentar

Menggunakan komentar dianggap sebagai bagian dari gaya pemrograman yang baik bersama dengan indentasi dan spasi yang tepat:

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

<# 

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

#>

Variabel dan jenisnya

Variabel di PowerShell diberi nama objek. Nama mereka dapat menyertakan karakter garis bawah, serta huruf dan angka. Simbol $ selalu digunakan sebelum nama, dan untuk mendeklarasikan variabel, cukup memberikan nama yang valid kepada juru bahasa:

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

$test = 100

Anda dapat mendeklarasikan variabel dengan menentukan tipenya dalam tanda kurung siku (operator pengecoran tipe) sebelum nama atau nilainya:

[int]$test = 100

$test = [int]100

Penting untuk dipahami bahwa variabel di PowerShell adalah objek (kelas) lengkap dengan properti dan metode yang jenisnya didasarkan pada yang ada di .NET Core. Kami daftar yang utama:

Ketik (kelas .NET)

Описание

Contoh Kode

[string] Sistem.String

Untaian kode uni

$tes = "tes"
$tes = 'tes'

[char]Sistem.Char

Karakter Unicode (16 bit)

[char]$tes = 'c'

[bool] Sistem.Boolean

tipe boolean (boolean Benar atau Salah)

[bool]$tes = $benar

[int] Sistem.Int32

tiga puluh dua bit bilangan bulat (32 bit)

[int]$tes = 123456789

[panjang] System.Int64

enam puluh empat bit integer (64 bit)

[panjang]$tes = 12345678910

[tunggal] Sistem.Tunggal

angka floating point sepanjang 32 bit

[tunggal]$tes = 12345.6789

[ganda]Sistem.Double

angka floating point dengan panjang 64 bit (8 byte)

[ganda]$tes = 123456789.101112

[desimal]System.Decimal

Nomor floating point 128-bit (harus diakhiri dengan d)

[desimal]$test = 12345.6789d

[DateTime]System.DateTime

tanggal dan waktu

$test = GetDate

[array] Sistem.Objek[]

array yang indeks elemennya dimulai dari 0

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

[hashtable] System.Collections.Hashtable

tabel hash adalah array asosiatif dengan kunci bernama, dibangun berdasarkan prinsip: @{key = "nilai"}

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

PowerShell mendukung konversi tipe implisit, selain itu, tipe variabel dapat diubah dengan cepat (misalnya, menggunakan operator penugasan), jika tidak ditentukan secara paksa - dalam hal ini, juru bahasa akan memberikan kesalahan. Anda dapat menentukan tipe variabel dari contoh sebelumnya dengan memanggil metode GetType() :

$test.GetType().FullName

Ada sejumlah cmdlet untuk memanipulasi variabel. Daftar mereka dalam bentuk yang mudah ditampilkan menggunakan perintah:

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

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

Get-Variable | more

Metode ini tampaknya terlalu rumit, jauh lebih mudah untuk bekerja dengan variabel melalui operator atau dengan mengakses properti dan metodenya secara langsung. Namun, cmdlet memiliki hak untuk ada karena memungkinkan Anda menyetel beberapa parameter tambahan. Penting untuk dipahami bahwa variabel pengguna hanya ditentukan dalam sesi saat ini. Saat konsol ditutup atau skrip berakhir, mereka akan dihapus.

Variabel sistem

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

$PWD.Path

Variabel preferensi diperlukan untuk menyimpan preferensi pengguna, yang nilainya dapat diubah. Misalnya, menggunakan $ErrorActionPreference , reaksi dari penerjemah perintah terhadap terjadinya kesalahan non-fatal diatur.

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

Get-ChildItem Variable: | more

или

ls Variable: | more

Cakupan

Untuk variabel di PowerShell, ada konsep ruang lingkup (Scope). Tindakan lingkup global (Global) berlaku untuk seluruh sesi saat ini - termasuk, misalnya, variabel sistem. Variabel lokal (Lokal) hanya tersedia dalam ruang lingkup di mana mereka didefinisikan: katakanlah di dalam suatu fungsi. Ada juga konsep ruang lingkup skrip (Script), tetapi untuk perintah skrip pada dasarnya adalah lokal. Secara default, ketika mendeklarasikan variabel, mereka diberi ruang lingkup lokal, dan untuk mengubahnya, Anda memerlukan konstruksi khusus seperti: $Global: variabel = nilai.

Misalnya, ini:

$Global:test = 100

Variabel lingkungan (lingkungan)

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

dir Env:

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

$env:TEST = "Hello, World!"

Operator aritmatika dan perbandingan

PowerShell menyediakan operator aritmatika berikut: + (penjumlahan), - (pengurangan), * (perkalian), / (pembagian), dan % (modulo atau modulo). Hasil ekspresi aritmatika dievaluasi dari kiri ke kanan sesuai dengan urutan operasi yang diterima secara umum, dan tanda kurung digunakan untuk mengelompokkan bagian ekspresi. Spasi antar operator diabaikan, hanya digunakan agar lebih mudah dibaca. Operator + juga menggabungkan, dan operator * mengulangi string. Jika Anda mencoba menambahkan nomor ke string, itu akan diubah menjadi string. Selain itu, bahasa PowerShell memiliki banyak operator perbandingan yang memeriksa kecocokan antara dua nilai dan mengembalikan boolean Benar atau Salah:

Operator

Описание

Contoh Kode

-persamaan

Sama / Sama (mirip dengan = atau == dalam bahasa lain)

$tes = 100
$uji -persamaan 123

-satu

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

$tes = 100
$tes -ne 123

-gt

Lebih besar dari / Lebih (analog>)

$tes = 100
$tes -gt 123

-ge

Lebih besar dari atau sama / Lebih besar dari atau sama (mirip dengan >=)

$tes = 100
$tes -ge 123

-lt

Kurang dari / Kurang (mirip dengan <)

$tes = 100
$tes -lt 123

-NS

Kurang dari atau sama / Kurang dari atau sama (mirip dengan <=)

$tes = 100
$tes -le 123

Ada operator serupa lainnya yang memungkinkan Anda, misalnya, membandingkan string berdasarkan karakter pengganti atau menggunakan ekspresi reguler untuk mencocokkan pola. Kami akan membahasnya secara rinci di artikel mendatang. Simbol <, > dan = tidak digunakan untuk perbandingan karena digunakan untuk tujuan lain.

Operator penugasan

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

Operator logika

Perbandingan saja tidak cukup untuk menggambarkan kondisi yang kompleks. Anda dapat menulis ekspresi logis apa pun menggunakan operator: -and, -or, -xor, -not and!.. Mereka bekerja seperti dalam bahasa pemrograman lain, sementara Anda dapat menggunakan tanda kurung untuk menentukan urutan evaluasi:

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

-not (123 -gt 321) 

!(123 -gt 321)

Lompatan Bersyarat

Operator cabang di PowerShell adalah standar: 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 или значение не определено"}
}

Siklus

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

Sebuah loop dengan prasyarat berfungsi jika/selama itu benar:

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

Perulangan dengan postcondition akan dijalankan setidaknya sekali, karena kondisi diperiksa setelah iterasi. Pada saat yang sama, DO WHILE berfungsi saat kondisinya benar, dan LAKUKAN SAMPAI saat ini 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 perulangan FOR diketahui sebelumnya:

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

Dalam loop FOREACH, beriterasi pada elemen array atau koleksi (tabel hash):

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

Array

Variabel PowerShell tidak hanya menyimpan objek tunggal (angka, string, dll.), tetapi juga banyak objek. Jenis variabel yang paling sederhana adalah array. Array dapat terdiri dari beberapa elemen, satu elemen, atau kosong, mis. tidak mengandung unsur. Itu dideklarasikan menggunakan operator @(), yang akan kita perlukan di artikel berikutnya - sangat penting untuk menambahkan larik lain ke larik (membuat larik multidimensi), meneruskan larik ke fungsi sebagai argumen, dan tugas serupa:

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

Saat array diinisialisasi, nilainya dicantumkan dipisahkan 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

Elemen array diakses menggunakan indeks bilangan bulat berbasis nol dan operator indeks (kurung siku):

$test_array[0] = 1

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

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

Operator .. (dua titik - operator rentang) mengembalikan array bilangan bulat dalam batas atas dan bawah yang ditentukan. Misalnya, ekspresi 1..4 menghasilkan larik empat elemen @(1, 2, 3, 4), dan ekspresi 8..5 mengeluarkan larik @(8, 7, 6, 5).

Menggunakan operator rentang, Anda dapat menginisialisasi array ($test_array = 1..4) atau mendapatkan irisan (irisan), mis. urutan elemen dari satu array dengan indeks dari yang lain. Dalam hal ini, angka negatif -1 menunjukkan elemen terakhir dari array, -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]

Perhatikan bahwa nilai larik bilangan bulat bisa lebih besar dari nilai indeks maksimum larik data. Dalam hal ini, semua nilai dikembalikan ke yang terakhir:

$test_array[0..100]

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

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 array.

Contoh membuat array yang diketik dengan kuat:

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

Tabel hash

Jenis variabel dasar lainnya dalam bahasa PowerShell adalah tabel hash, juga dikenal sebagai array asosiatif. Hashtable mirip dengan objek JSON dan dibuat berdasarkan nilai kunci. Tidak seperti array biasa, elemennya diakses dengan kunci bernama, yang merupakan properti dari objek (Anda juga dapat menggunakan operator indeks - tanda kurung siku).

Tabel hash kosong dideklarasikan menggunakan simbol @ dan tanda kurung operator:

$test_hashtable = @{}

Saat mendeklarasikan, Anda dapat langsung membuat kunci dan memberikan nilai padanya:

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

Untuk menambahkan elemen ke tabel hash, Anda harus menetapkan kunci yang belum ada padanya, atau gunakan metode Tambah (). Jika penetapan dibuat untuk kunci yang sudah ada, nilainya akan berubah. Metode Remove() digunakan untuk menghapus elemen dari tabel hash.

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

Variabel jenis ini dapat diteruskan sebagai argumen ke fungsi dan cmdlet - di artikel berikutnya kita akan mempelajari bagaimana hal ini dilakukan, dan juga mempertimbangkan jenis serupa lainnya - PSCustomObject.

Fungsi

PowerShell memiliki semua yang Anda butuhkan untuk pemrograman prosedural, termasuk fungsi. Untuk mendeskripsikannya, kata fungsi Fungsi digunakan, setelah itu Anda perlu menentukan nama fungsi dan badan yang disertakan dalam tanda kurung operator. Jika Anda perlu meneruskan argumen ke fungsi, Anda dapat menentukannya segera setelah nama dalam tanda kurung.

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

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

Misalnya, mari 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 memanggilnya, dan memanggil fungsi di PowerShell mungkin tampak tidak biasa: argumen (jika ada) tidak diapit tanda kurung dan dipisahkan oleh spasi.

sqr 2

atau lebih:

sqr -number 2

Karena cara argumen diteruskan, fungsi itu sendiri terkadang perlu diapit dalam tanda kurung:

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

Saat menjelaskan suatu fungsi, Anda dapat menetapkan nilai default ke argumen:

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

Ada sintaks lain untuk mendeskripsikan argumen fungsi, selain itu, parameter dapat dibaca dari pipeline - semua ini akan berguna di artikel berikutnya, saat kita melihat modul yang diekspor dan membuat cmdlet kita sendiri.

Menangani kesalahan

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

try {

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

} catch {

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

}

Ini menyimpulkan tinjauan dasar-dasar pemrograman dalam bahasa PowerShell. Dalam artikel berikut, kita akan mempelajari lebih detail bekerja dengan variabel dari berbagai jenis, koleksi, ekspresi reguler, membuat fungsi, modul, dan cmdlet khusus, serta pemrograman berorientasi objek.

Sumber: www.habr.com

Apa itu Windows PowerShell dan dimakan dengan apa? Bagian 2: Pengenalan bahasa pemrograman