מה זה Windows PowerShell ועם מה אוכלים אותו? חלק 2: מבוא לשפת התכנות

מבחינה היסטורית, כלי עזר של שורת הפקודה במערכות Unix מפותחים יותר מאשר ב-Windows, אך עם הופעתו של פתרון חדש, המצב השתנה.

ניתן לכתוב את PowerShell בשפה מפורשת, מרובת פרדיגמות, הכוללת אלמנטים של תכנות פרוצדורלי קלאסי, מונחה עצמים ואפילו פונקציונלי: הסתעפות מותנית, לולאות, משתנים, מערכים, טבלאות גיבוב, מחלקות, טיפול בשגיאות, כמו גם פונקציות, cmdlets וצינורות . מאמר קודם הוקדש ליסודות העבודה בסביבה, וכעת אנו מציעים לקוראינו ספר עיון קטן למתכנתים.

אופציות:

תגובות
משתנים וסוגיהם
משתני מערכת
היקפים
משתני סביבה (סביבה)
אופרטורים של חשבון והשוואה
מפעילי מטלות
פעולות לוגיות
קפיצה מותנית
מחזורים
מערכים
טבלאות חשיש
פונקציות
שגיאה בעיבוד

ניתן לכתוב קוד בכל עורך טקסט או באמצעות סביבת פיתוח משולבת - הדרך הקלה ביותר היא לקחת את Windows PowerShell ISE שמגיע עם מערכות ההפעלה של שרתים של Microsoft. זה הכרחי רק עבור סקריפטים מורכבים למדי: קבוצות קצרות של פקודות קלות יותר לביצוע באופן אינטראקטיבי.

תגובות

השימוש בהערות נחשב לחלק מסגנון תכנות טוב יחד עם הזחה ורווחים מתאימים:

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

<# 

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

#>

משתנים וסוגיהם

משתנים ב- PowerShell נקראים אובייקטים. השמות שלהם יכולים לכלול את תו הקו התחתון, כמו גם אותיות ומספרים. הסמל $ משמש תמיד לפני השם, וכדי להכריז על משתנה, מספיק לתת למתורגמן שם חוקי:

כדי לאתחל משתנה (להקצות לו ערך), נעשה שימוש באופרטור ההקצאה (סמל =):

$test = 100

אתה יכול להכריז על משתנה על ידי ציון הסוג שלו בסוגריים מרובעים (אופרטור ליהוק סוג) לפני השם או הערך:

[int]$test = 100

$test = [int]100

חשוב להבין שמשתנים ב-PowerShell הם אובייקטים (מחלקות) מלאים עם מאפיינים ושיטות שהסוגים שלהם מבוססים על אלו שב-.NET Core. אנו מציגים את העיקריים שבהם:

סוג (.NET class)

תיאור

דוגמה לקוד

[מחרוזת] System.String

מחרוזת Unicode 

$test = "מבחן"
$test = 'מבחן'

[char]System.Char

תו Unicode (16 סיביות)

[char]$test = 'c'

[bool] System.Boolean

סוג בוליאני (בוליאני נכון או לא נכון)

[bool]$test = $true

[int] System.Int32

מספר שלם של שלושים ושתיים סיביות (32 סיביות)

[int]$test = 123456789

[ארוך] System.Int64

מספר שלם של שישים וארבע סיביות (64 סיביות)

[long]$test = 12345678910

[סינגל] מערכת.סינגל

נקודה צפה מספר באורך 32 ביטים

[Single]$test = 12345.6789

[כפול]System.Double

מספר נקודה צפה באורך 64 סיביות (8 בתים)

[double]$test = 123456789.101112

[עשרוני]מערכת.עשרונית

מספר נקודה צפה של 128 סיביות (נדרש להסתיים ב-d)

[עשרוני]$test = 12345.6789d

[DateTime]System.DateTime

תאריך ושעה 

$test = GetDate

[מערך] System.Object[]

מערך שמדד האלמנטים שלו מתחיל ב-0

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

[hashtable] System.Collections.Hashtable

טבלאות hash הן מערכים אסוציאטיביים עם מפתחות בעלי שם, שנבנו על פי העיקרון: @{key = "value"}

$test_hashtable = @{one="one"; two="two"; three="three"}

PowerShell תומך בהמרת סוג מרומז, בנוסף, ניתן לשנות את סוג המשתנה תוך כדי (לדוגמה, באמצעות אופרטור הקצאה), אם הוא לא מצוין בכוח - במקרה זה, המתורגמן ייתן שגיאה. אתה יכול לקבוע את סוג המשתנה מהדוגמה הקודמת על ידי קריאה לשיטת GetType():

$test.GetType().FullName

ישנם מספר cmdlets למניפולציה של משתנים. הרשימה שלהם בצורה נוחה מוצגת באמצעות הפקודה:

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

כדי להציג משתנים מוצהרים והערכים שלהם, אתה יכול להשתמש ב-cmdlet מיוחד:

Get-Variable | more

שיטה זו נראית מסורבלת מדי, הרבה יותר נוח לעבוד עם משתנים דרך אופרטורים או על ידי גישה ישירה למאפיינים ולשיטות שלהם. עם זאת, ל-cmdlets יש זכות קיום מכיוון שהם מאפשרים לך להגדיר כמה פרמטרים נוספים. חשוב להבין שמשתני משתמש מוגדרים רק בתוך ההפעלה הנוכחית. כשהמסוף נסגר או שהסקריפט מסתיים, הם נמחקים.

משתני מערכת

בנוסף לאלו המוצהרים על ידי המשתמש, ישנם משתנים מובנים (מערכתיים) שאינם נמחקים לאחר סיום הפגישה הנוכחית. הם מחולקים לשני סוגים, בעוד שנתוני מצב PowerShell מאוחסנים במשתנים אוטומטיים שלא ניתן להקצות להם ערכים שרירותיים בעצמם. אלה כוללים, למשל, $PWD:

$PWD.Path

יש צורך במשתני העדפה כדי לאחסן העדפות משתמש, שאת ערכיהן ניתן לשנות. לדוגמה, באמצעות $ErrorActionPreference, נקבעת התגובה של מתורגמן הפקודות להתרחשות של שגיאות לא קטלניות.

בנוסף לאופרטורים ו-cmdletים לגישה למשתנים מוצהרים, ישנו Variable: pseudo-accumulator. אתה יכול לעבוד איתו באנלוגיה עם כוננים אחרים, והמשתנים במקרה זה דומים לאובייקטים של מערכת קבצים:

Get-ChildItem Variable: | more

או

ls Variable: | more

היקפים

עבור משתנים ב-PowerShell, יש את הרעיון של scope (Scope). הפעולה של ההיקף הגלובלי (Global) חלה על כל הפגישה הנוכחית - היא כוללת, למשל, משתני מערכת. משתנים מקומיים (מקומיים) זמינים רק בהיקף שבו הם הוגדרו: נניח בתוך פונקציה. יש גם את הרעיון של היקף התסריט (סקריפט), אבל עבור פקודות סקריפט, זה בעצם מקומי. כברירת מחדל, בעת הצהרת משתנים, הם מקבלים היקף מקומי, וכדי לשנות זאת, אתה צריך מבנה מיוחד כמו: $Global: משתנה = ערך.

לדוגמה, כך:

$Global:test = 100

משתני סביבה (סביבה)

כונן פסאודו נוסף, Env:, זמין מ-PowerShell וניתן להשתמש בו כדי לגשת למשתני סביבה. כאשר המעטפת מתחילה, הם מועתקים מתהליך האב (כלומר, מהתוכנית שיזמה את ההפעלה הנוכחית) ובדרך כלל הערכים ההתחלתיים שלהם זהים לערכים בלוח הבקרה. כדי להציג משתני סביבה, השתמש ב-cmdlet Get-ChildItem או בכינויים שלו (כינויים): ls ו-dir.

dir Env:

משתנים אלה הם רצפים של בתים (או תווים, אם תרצו), שהפירוש שלהם תלוי רק בתוכנית המשתמשת בהם. ה-cmdlets *-Variable לא עובדים עם משתני סביבה. כדי לגשת אליהם, עליך להשתמש בקידומת הכונן:

$env:TEST = "Hello, World!"

אופרטורים של חשבון והשוואה

PowerShell מספקת את האופרטורים האריתמטיים הבאים: + (חיבור), - (חיסור), * (כפל), / (חלוקה) ו-% (מודולו או מודול). התוצאה של ביטוי אריתמטי מוערכת משמאל לימין בהתאם לסדר הפעולות המקובל, וסוגריים משמשים לקיבוץ חלקים מהביטוי. מתעלמים מרווחים בין אופרטורים, הם משמשים רק כדי להקל על הקריאה. גם האופרטור + משרשר, והאופרטור * חוזר על מחרוזות. אם תנסה להוסיף מספר למחרוזת, הוא יומר למחרוזת. בנוסף, לשפת PowerShell יש אופרטורים רבים להשוואה הבודקים התאמה בין שני ערכים ומחזירים את הערך הבוללי של True או False:

מפעיל

תיאור

דוגמה לקוד

-eq

שווה / שווה (בדומה ל-= או == בשפות אחרות)

$test = 100
$test -eq 123 

-נה

לא שווה / לא שווה (בדומה ל<> או !=)

$test = 100
$test -ne 123   

-גמ '

גדול מ/יותר (אנלוגי >)

$test = 100
$test -gt 123

-ge

גדול מ- או שווה / גדול מ- או שווה (בדומה ל->=)

$test = 100
$test -ge 123

-לט

פחות מ/פחות (בדומה ל<)

$test = 100
$test -lt 123  

-לה

פחות או שווה / פחות או שווה (בדומה ל-<=)

$test = 100
$test -le 123

ישנם אופרטורים דומים אחרים המאפשרים לך, למשל, להשוות מחרוזות על סמך תו כללי או להשתמש בביטויים רגולריים כדי להתאים דפוס. נעסוק בהם בפירוט במאמרים הבאים. הסמלים <, > ו-= אינם משמשים להשוואה מכיוון שהם משמשים למטרות אחרות.

מפעילי מטלות

בנוסף לאופרטור = הנפוץ ביותר, ישנם אופרטורים נוספים להקצאה: +=, -=, *=, /= ו-%=. הם משנים את הערך לפני ההקצאה. האופרטורים האנריים ++ ו-, המגדילים או מקטינים את הערך של משתנה, מתנהגים באופן דומה - הם חלים גם על אופרטורים של הקצאה.

פעולות לוגיות

השוואה לבדה אינה מספיקה כדי לתאר מצבים מורכבים. אתה יכול לכתוב כל ביטוי לוגי באמצעות האופרטורים: -and, -or, -xor, -not and! .. הם עובדים כמו בשפות תכנות אחרות, בעוד שאתה יכול להשתמש בסוגריים כדי לציין את סדר ההערכה:

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

-not (123 -gt 321) 

!(123 -gt 321)

קפיצה מותנית

מפעילי סניפים ב-PowerShell הם סטנדרטיים: IF(IF…ELSE, IF…ELSEIF…ELSE) ו-SWITCH. בואו נסתכל על השימוש בהם עם דוגמאות:

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

מחזורים

ל-PowerShell יש כמה סוגים של לולאות: WHILE, DO WHILE, DO TILL, FOR ו- FOREACH.

לולאה עם תנאי מוקדם פועלת אם/כל עוד היא נכונה:

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

לולאות עם postcondition יפעלו לפחות פעם אחת, מכיוון שהתנאי נבדק לאחר האיטרציה. במקביל, DO WHILE פועל בזמן שהתנאי הוא אמיתי, ו-DO TILL פועל כאשר הוא שקר:

[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 ידוע מראש:

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

בלולאת FOREACH, חוזר על הרכיבים של מערך או אוסף (טבלת גיבוב):

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

מערכים

משתני PowerShell מאחסנים לא רק אובייקטים בודדים (מספר, מחרוזת וכו'), אלא גם אובייקטים מרובים. הסוג הפשוט ביותר של משתנים כאלה הם מערכים. מערך יכול להיות מורכב מכמה אלמנטים, אלמנט אחד, או להיות ריק, כלומר. לא מכילים אלמנטים. הוא מוכרז באמצעות האופרטור @() שנצטרך במאמר הבא - חשוב מאוד להוספת מערכים נוספים למערך (יצירת מערכים רב מימדיים), העברת מערכים לפונקציות כארגומנט ומשימות דומות:

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

כאשר מערך מאותחל, הערכים שלו מופיעים מופרדים בפסיקים (אופרטור מיוחד,):

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

ברוב המקרים, ניתן להשמיט את האופרטור @():

$test_array = 1, 2, 3, 4

במקרה זה, מערך של אלמנט אחד מאותחל באופן הבא

$test_array = , 1

הגישה לרכיבי מערך מתבצעת באמצעות אינדקס שלם מבוסס אפס ואופרטור האינדקס (סוגריים מרובעים):

$test_array[0] = 1

ניתן לציין מספר אינדקסים מופרדים בפסיקים, כולל. מַחזוֹרִי:

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

מפעיל .. (שתי נקודות - אופרטור טווח) מחזיר מערך של מספרים שלמים בתוך הגבול העליון והתחתון שצוינו. לדוגמה, ביטוי 1..4 מוציא מערך של ארבעה אלמנטים @(1, 2, 3, 4), וביטוי 8..5 מוציא מערך @(8, 7, 6, 5).

באמצעות אופרטור הטווח, ניתן לאתחל מערך ($test_array = 1..4) או לקבל פרוסה (פרוסה), כלומר. רצף של אלמנטים ממערך אחד עם מדדים ממערך אחר. במקרה זה, מספר שלילי -1 מציין את האלמנט האחרון של המערך, -2 - הלפני אחרון וכן הלאה.

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

שים לב שערכי מערך שלמים יכולים להיות גדולים מערך האינדקס המרבי של מערך הנתונים. במקרה זה, כל הערכים מוחזרים עד האחרון:

$test_array[0..100]

אם תנסה לגשת לרכיב מערך יחיד שאינו קיים, $null מוחזר.

ב-PowerShell, מערכים יכולים להכיל אלמנטים מסוגים שונים או להיות מוקלדים בצורה חזקה:

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

כאשר המאפיין $test_array.count הוא מספר רכיבי המערך.

דוגמה ליצירת מערך בעל הקלדה חזקה:

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

טבלאות חשיש

סוג בסיסי נוסף של משתנים בשפת PowerShell הם טבלאות hash, הידוע גם בתור מערכים אסוציאטיביים. טבלאות Hashtable דומות לאובייקטי JSON ובנויים על בסיס מפתח-ערך. בניגוד למערכים רגילים, הגישה לאלמנטים שלהם מתבצעת באמצעות מפתחות בעלי שם, שהם מאפיינים של האובייקט (ניתן להשתמש גם באופרטור האינדקס - סוגריים מרובעים).

טבלת גיבוב ריקה מוכרזת באמצעות הסמל @ וסוגריים של אופרטור:

$test_hashtable = @{}

בעת ההצהרה, אתה יכול מיד ליצור מפתחות ולהקצות להם ערכים:

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

כדי להוסיף אלמנט לטבלת hash, עליך להקצות לו מפתח שעדיין לא קיים, או להשתמש בשיטת Add () . אם מתבצעת הקצאה למפתח קיים, ערכו ישתנה. השיטה Remove() משמשת להסרת אלמנט מטבלת hash.

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

ניתן להעביר משתנים מסוג זה כארגומנטים לפונקציות ו-cmdlet - במאמר הבא נלמד כיצד זה נעשה, ונבחן גם סוג דומה נוסף - PSCustomObject.

פונקציות

ל-PowerShell יש את כל מה שאתה צריך עבור תכנות פרוצדורלי, כולל פונקציות. כדי לתאר אותם, משתמשים במילת הפונקציה Function, שלאחריה צריך לציין את שם הפונקציה ואת הגוף המוקף בסוגריים של מפעיל. אם אתה צריך להעביר ארגומנטים לפונקציה, אתה יכול לציין אותם מיד אחרי השם בסוגריים.

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

הפונקציה תמיד מחזירה תוצאה - היא מערך של התוצאות של כל ההצהרות שלה, אם יש יותר מאחת. אם יש רק משפט אחד, הערך היחיד מהסוג המתאים מוחזר. המבנה של החזר $value מוסיף אלמנט עם הערך $value למערך התוצאה ומבטל את הביצוע של רשימת ההצהרות, והפונקציה הריקה מחזירה $null.

לדוגמה, בואו ניצור פונקציה לריבוע מספר:

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

שים לב שבגוף הפונקציה, אתה יכול להשתמש בכל משתנים שהוכרזו לפני הקריאה שלה, וקריאה לפונקציות ב-PowerShell עשויה להיראות יוצאת דופן: הארגומנטים (אם יש) אינם מוקפים בסוגריים ומופרדים ברווחים.

sqr 2

או כך:

sqr -number 2

בגלל האופן שבו ארגומנטים מועברים, לפעמים הפונקציה עצמה צריכה להיות מוקפת בסוגריים:

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

בעת תיאור פונקציה, אתה יכול להקצות ערכי ברירת מחדל לארגומנטים:

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

ישנו תחביר נוסף לתיאור ארגומנטים של פונקציות, בנוסף, ניתן לקרוא פרמטרים מה-pipeline - כל זה יהיה שימושי במאמר הבא, כאשר נסתכל על מודולים מיוצאים ויוצרים cmdlets משלנו.

שגיאה בעיבוד

ל-PowerShell יש מנגנון Try...Catch...סוף סוף להתמודד עם חריגים. בלוק ה-Try מכיל את הקוד שבו עלולה להתרחש שגיאה, ובלוק ה-Catch מכיל את המטפל שלו. אם לא הייתה שגיאה, היא לא מבוצעת. הבלוק Finally מבוצע לאחר הבלוק Try, ללא קשר להתרחשות של שגיאה, ויכולים להיות מספר בלוקים של Catch לסוגים שונים של חריגים. החריג עצמו נכתב למשתנה ברירת מחדל לא מוצהר ($_) וניתן לאחזר אותו בקלות. בדוגמה שלהלן, אנו מיישמים הגנה מפני הזנת ערך לא חוקי:

try {

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

} catch {

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

}

בכך מסתיימת הסקירה של יסודות התכנות בשפת PowerShell. במאמרים הבאים, נלמד ביתר פירוט עבודה עם משתנים מסוגים שונים, אוספים, ביטויים רגולריים, יצירת פונקציות, מודולים ו-cmdlets מותאמים אישית, כמו גם תכנות מונחה עצמים.

מקור: www.habr.com