למדו על PowerShell Strings: איחוד, פיצול ועוד

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

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

הבנת המחרוזות

לפי ההגדרה של .NET למחרוזת – "מחרוזת היא אוסף רצינלי של תווים המשמש לייצוג טקסט". לסיכום, כל עוד יש רצף של תווים המרכיבים טקסט, ישנה מחרוזת.

הגדרת מחרוזות מערכת ב-PowerShell

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

PS> 'Hello PowerShell - Today is $(Get-Date)'PS> "Hello PowerShell - Today is $(Get-Date)"

מחרוזות הן למעשה מחרוזות מערכת ב-.NET.

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

כדי לאשר את המושג של גרש יחיד נגד גרש כפול, כאשר אתה מדביק את שתי המחרוזות מהדוגמה למעלה ב־PowerShell.

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

התוצאה שמוצגת מדגישה את ההבחנה מתי ראשוני להשתמש בגרשיים יחידים או כפולים בהגדרת מחרוזות.

אובייקט מחרוזת

כפי שנאמר בקטע הקודם, אוסף התווים שיוצרים טקסט הוא מחרוזת. הערך המתקבל של המחרוזת הוא אובייקט המחרוזת String. אובייקט המחרוזת הוא אובייקט .NET של סוג [System.String].

וכיוון ש-System.String הוא אובייקט, יש לו מאפיינים שניתן לגשת אליהם באמצעות פקודת Get-Member. למטה אנו מכניסים משתנה בתוך מחרוזת עם גרשיים כפולים.

PS> "Hello PowerShell - Today is $(Get-Date)" | Get-Member=

התמונה למטה מראה את שם הסוג ורשימה חלקית של המאפיינים של אובייקט המחרוזת.

חיבור מחרוזות בפווש

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

A typical example of using string concatenation in the real world is Active Directory user creation. Perhaps you’re creating a user creation script that takes the first name, last name, and department values from a list.

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

$domain = 'contoso.com'
$firstname = 'Jack'
$lastname = 'Ripper'
$department = 'Health'

עם ערכי המשתנים המופיעים לעיל, המטרה היא לקבל את הערכים הבאים לפי החיבור של מחרוזות אחרות.

• שם = שם פרטי שם משפחה
• שם מוצג = שם פרטי שם משפחה (מחלקה)
• SamAccountName = שם פרטי.שם משפחה
• כתובת דוא"ל = שם פרטי.שם משפחה@contoso.com

בסעיפים הבאים, הערכים שמופיעים לעיל ייצרו באמצעות שיטות החיבור שונות הזמינות בפוורשל.

בואו נתחיל!

באמצעות אופרטור החיבור של PowerShell למחרוזות

שפות תכנות משתמשות באופרטור החיבור האישי שלהן לחיבור מחרוזות. לדוגמה, ב- Visual Basic, שיטת החיבור היא הסימן של אמפרסנד (&). גם ב- PowerShell יש לו שיטת חיבור משלו, שהיא הסימן פלוס (+).

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

## שם
$firstname + ' ' + $lastname
## שם מוצג
$firstname + ' ' + $lastname + ' (' + $department + ')'
## SamAccountName
$firstname + '.' + $lastname
## כתובת הדוא"ל
$firstname + '.' + $lastname + '@' + $domain

שימוש בפעולת גיוס של PowerShell

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

# שימוש בפעולת גיוס של שורות
## שם
"$firstname $lastname"
## שם להציג
"$firstname $lastname ($department)"
## שם משתמש SamAccount
"$firstname.$lastname"
## כתובת דוא"ל
"$firstname.$lastname@$domain"

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

שימוש באופרטור הפורמט של PowerShell

האופרטור לפורמט (-f) בעיקר משמש לפורמט קומפוזיטי. דבר חשוב לזכור הוא שעם אמצעי זה, יש שלושה חלקים לשימוש ב־-f.

עיין בשורה השלישית של הקוד למטה. ה־"{0} {1}" מייצג את הפורמט והמחילות. המספרים בתוך הסוגריים הסלעיים מציינים את אינדקס המחרוזת באוסף לתצוגה במקומה. הציונים יכולים להיות גרשיים יחידים או כפולים.

אוסף המחרוזת כקלט בדוגמה זו מיוצג על ידי $firstname,$lastname. זה אומר שאינדקס המשתנה $firstname הוא 0, בעוד של־$lastname הוא 1.

סוף סוף, -f הוא המקום בין המציין ואוסף המחרוזות המיוצג על ידי (-f).

## שם
"{0} {1}" -f $firstname,$lastname
## שם התצוגה
"{0} {1} ({2})" -f $firstname,$lastname,$department
## SamAccountName
"{0}.{1}" -f $firstname,$lastname
## כתובת האימייל
"{0}.{1}@{2}" -f $firstname,$lastname,$domain

הקוד למעלה יוביל לתוצאות המוצגות למטה.

באמצעות האופרטור PowerShell -Join

האופרטור -Join ניתן לשימוש לחיבור מחרוזות למחרוזת אחת בשני דרכים.

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

-Join <String[]>

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

<String[]> -Join <Delimiter>

בחזרה למטרה של חיבור מחרוזות, הקוד למטה מדגיש איך להשתמש באופרטור -Join כדי לשרשר מחרוזות ליחד.

## שם
$firstname, $lastname -join ' '
## שם התצוגה
$firstname,$lastname,"($department)" -join ' '
## SamAccountName
-join ($firstname,'.',$lastname)
## כתובת האימייל
-join ($firstname,'.',$lastname,'@',$domain)

כאשר אתה מריץ את קוד הדוגמה שמופיע למעלה בפוורשל, תצפה לראות פלט דומה לזה שמוצג למטה.

שיטת .NET String.Format()

השיטה .NET String.Format היא הנגזרת של .NET של אופרטור העיצוב של פוורשל. זה פועל באותו אופן כמו אופרטור העיצוב כאשר העיצוב והמציינים צריכים להיות מוגדרים.

## שם
[string]::Format("{0} {1}",$firstname,$lastname)
## שם תצוגה
[string]::Format("{0} {1} ({2})",$firstname,$lastname,$department)
## שם חשבון Sam
[string]::Format("{0}.{1}",$firstname,$lastname)
## כתובת דוא"ל
[string]::Format("{0}.{1}@{2}",$firstname,$lastname,$domain)

התמונה למטה מציגה את שיטת String.Format בפעולה.

שיטת .NET String.Concat()

שיטה נוספת לקיבוץ מחרוזות היא להשתמש בשיטת .Net String.Concat. שיטת .NET String.Concat היא הנגזרת של .NET של אופרטור החיבור של פוורשל (+). אך במקום להשתמש בסימן + כדי לחבר מחרוזות, אפשר להוסיף את כל המחרוזות בתוך השיטה כמו כן – [string]::Concat(string1,string2...).

## שם
[string]::Concat($firstname,' ',$lastname)
## שם התצוגה
[string]::Concat($firstname,' ',$lastname,' (',$department,')')
## שם החשבון SamAccountName
[string]::Concat($firstname,'.',$lastname)
## כתובת האימייל Email Address
[string]::Concat($firstname,'.',$lastname,'@',$domain)

הלכך, בצילום המסך שלמטה מופיעה התוצאה שנקבלת בקריאה לשיטת String.Concat של .NET. בבירור תוכל לראות ש-PowerShell ממזגת את string1 עם string2.

שיטת .NET String.Join()

שיטת .NET String.Join היא השיטה הדומה ב-.NET לאופרטור Join של PowerShell (-join). הפורמט של השימוש בשיטה זו הוא [string]::Join(<delimiter>,<string1>,<string2>,...).

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

## שם
[string]::Join(' ',$firstname,$lastname)
## שם התצוגה
[string]::Join(' ',$firstname,$lastname,"($department)")
## שם החשבון SamAccountName
[string]::Join('',$firstname,'.',$lastname)
## כתובת האימייל Email Address
[string]::Join('',$firstname,'.',$lastname,'@',$domain)

חלוקת מחרוזות ב-PowerShell

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

אתה יכול לפצל מחרוזות ב-PowerShell בשני דרכים שונות – באמצעות פונקציית/שיטת split() או באמצעות אופרטור split.

פיצול מחרוזות באמצעות פונקציית Split()

אם אתה מחפש דרך פשוטה לפצל מחרוזת כדי ליצור מערך, אין צורך לחפש יותר מדי – יש לך את שיטת split(). שיטת split() קיימת בכל אובייקט מחרוזת ויכולה לפצל מחרוזת למערך על פי תו לא רגולרי.

לדוגמה, אם יש לך מחרוזת כמו green|eggs|and|ham ואתה רוצה ליצור מערך כמו @('green','eggs','and','ham'), תוכל לפצל את המחרוזת הזו לפי סימן הקו האנכי (|) כמו בקטע הקוד הבא.

$string = 'green|eggs|and|ham'
$string.split('|')

אז תראה ש-PowerShell פיצל את המחרוזת למערך הרצוי עם סימן הקו האנכי.

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

אופרטור -split

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

למטה התחברות התחברות -Split להפניה שלך. זכור לשים לב להבחר בין הפרידה האונרית והפרידה הדו-אונרית.

# חלוקת יחידים
-Split <String>
-Split (<String[]>)

# חלוקת בינארית
<String> -Split <Delimiter>[,<Max-substrings>[,"<Options>"]]
<String> -Split {<ScriptBlock>} [,<Max-substrings>]

בדוגמה זו, המשתנה $string מחזיק את ערך המחרוזת של שורה יחידה. לאחר מכן, עם אופרטור ה־-Split, מחרוזת השורה היחידה תחולק למערך מחרוזות של PowerShell. המחרוזת המחולקת התוצאה נשמרת במשתנה $split.

## פיצול מחרוזות לתת־מחרוזות
# הקצה ערך מחרוזת למשתנה $string
$string = 'This sentence will be split between whitespaces'
# לפצל את ערך המחרוזת של $string ולאחסן את התוצאה במשתנה $split
$split = -split $string
# לקבל את מספר המחרוזות התת־מתקבלות
$split.Count
# להציג את המחרוזות התת־מתקבלות
$split

כפי שניתן לראות מהתוצאה לעיל, מה שהיה במקור מחרוזת יחידה חולק ל־7 מחרוזות תת־מחרוזת. זה מדגים איך PowerShell מפצלת מחרוזת למערך.

מפריד התווים

בדוגמה הקודמת, אופרטור ה־-Split פיצל את אובייקט המחרוזת היחיד למספר מחרוזות תת־מחרוזת גם בלי לציין מפריד; זה כי תווי ה־-Split המקורי הוא רווח. אך, מפרידים יכולים גם להיות תווים, מחרוזות, תבניות או קטעי קוד.

בדוגמה זו, המפריד שנמצא בשימוש הוא הנקודה־פסיק ;.

## פיצול מחרוזות למחרוזות משניות עם גורם פרידה
# הקצאת ערך מחרוזת למשתנה $string
$string = 'This;sentence;will;be;split;between;semicolons'
# פיצול ערך המחרוזת של $string ואחסון התוצאה במשתנה $split
$split = $string -split ";"
# קבלת ספירת המחרוזות התוצאתיות
$split.Count
# הצגת המחרוזות התוצאתיות
$split

כשאתה מבצע בדיקה על הקוד לעיל בפוורשל, אתה תקבל את התוצאה הבאה למטה.

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

אם, מסיבה כלשהי, יש צורך לשמור על תו הפרידה, ניתן לשמור על תו הפרידה על ידי לסגור את התו בסוגריים.

$split = $string -split "(;)"
$split.Count
$split

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

התוצאה למעלה מראה שתווי פרידה אינם נשמרים, והם נספרים לתוך המחרוזות התוצאתיות.

תו הפרידה של המחרוזת

ניתן גם לפצל מחרוזות על ידי מחרוזת נוספת כתו הפרידה. בדוגמה זו, המחרוזת "day" משמשת כתו הפרידה.

$daysOfTheWeek= 'monday,tuesday,wednesday,thursday,friday,saturday,sunday'
$daysOfTheWeek -split "day"

תו הפרידה של לשון התסריט

A scriptBlock as the delimiter enables the -Split operator to perform custom or complex splitting of strings.

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

הדוגמה למטה משתמשת בביטוי {$PSItem -eq 'e' -or $PSItem -eq 'y'} שפירושו כי המחרוזת תתחלק אם התו הנכנס הוא 'e' או 'a'.

$daysOfTheWeek= 'monday,tuesday,wednesday,thursday,friday,saturday,sunday'
$daysOfTheWeek -split {$PSItem -eq 'e' -or $PSItem -eq 'y'}

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

הדוגמה הבאה עושה קצת יותר עם בלוק סקריפט. הפעם, הביטוי מעריך אם:

• התו הנכנס עובר כמספר שלם; ו
• שערכו גבוה מ-1

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

$daysOfTheWeek= 'monday1tuesday2wednesday3thursday1friday4saturday8sunday'
$daysOfTheWeek -split {
    try {
        [int]$PSItem -gt 1
    }
    catch {
        # לא לעשות כלום
    }
}

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

המפריד של RegEx

ברירת המחדל, האופרטור -Split משתמש בהתאמת RegEx המתאימה למפריד שצוין. זה אומר שתוכל גם להשתמש ב-RegEx כמפרידים לחלוקת מחרוזות.

בדוגמה הבאה, המחרוזת מכילה תווים מילה ותווים שאינם מילים. המטרה היא לפצל את המחרוזת עם כל התווים שאינם מילים. ברגקס, תווים שאינם מילים מיוצגים על ידי \W, בעוד שתווים שהם מילים שמתאימים לתווים אלה – [a-zA-Z0-9_] מיוצגים על ידי \w.

$daysOfTheWeek= 'monday=tuesday*wednesday^thursday#friday!saturday(sunday'
$daysOfTheWeek -split "\W"

תתי מחרוזת

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

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

<String> -Split <Delimiter>[,<Max-substrings>[,"<Options>"]]

עפ"י התחביר שמעלה, קוד הדוגמה הבא שונה כך שיגביל את מספר התתי-מחרוזות ל-3.

$daysOfTheWeek= 'monday,tuesday,wednesday,thursday,friday,saturday,sunday'
$daysOfTheWeek -split ",",3

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

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

$daysOfTheWeek= 'monday,tuesday,wednesday,thursday,friday,saturday,sunday'
$daysOfTheWeek -split ",",-3

וכתוצאה מהקוד ששונה למעלה, המחרוזת פוצלה החל מהתווים השלושה האחרונים התואמים.

מציאת והחלפת מחרוזות

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

שיטת Replace()

גם לאובייקט המחרוזת יש שיטה מובנית שיכולה לעזור לבצע פעולות חיפוש והחלפה – שיטת ה־replace(). שיטת ה־replace() מקבלת לכל היותר ארבעה טעינות.

סט הטעינות המקובל לשיטת ה־replace() מופיע למטה.

<String>.Replace(<original>, <substitute>[, <ignoreCase>][, <culture>])

הטעינות החובה היחידות הן ה־<original> וה־<substitute>. ה־<ignoreCase> וה־<culture> הם אופציונליים.

בדוגמה למטה, הקוד יחפש את כל המופעים של התו פסיק (,) ויחליף אותם בנקודתיים פסיק (;).

$daysOfTheWeek = 'monday,tuesday,wednesday,thursday,friday,saturday,sunday'
$daysOfTheWeek.Replace(',',';')

מלבד החלפת תו יחיד, תוכל גם להשתמש בשיטת ה־replace() כדי לחפש ולהחליף מחרוזות. הקוד בדוגמה למטה מחליף את המילה "day" במילה "night".

$daysOfTheWeek = 'monday,tuesday,wednesday,thursday,friday,saturday,sunday'
$daysOfTheWeek.Replace('day','NIGHT')

אופרטור ה־-Replace

התחביר של אופרטור ההחלפה מוצג למטה.

<string> -replace <original>, <substitute>

בשימוש בתחביר למעלה, הקוד בדוגמה למטה מחליף את המילה "day" במילה "Night" עם אופרטור ה־-replace.

$daysOfTheWeek = 'monday,tuesday,wednesday,thursday,friday,saturday,sunday'
$daysOfTheWeek -replace 'day','NIGHT'

הדוגמה הבאה משתמשת בהתאמת RegEx כדי להחליף מחרוזות באופרטור -replace. הקוד למטה מחפש בתוך המחרוזת here-string את המחרוזת שמתאימה (#. ) ומחליפה אותן ב-nothing.

$daysOfTheWeek = @'
1. Line 1
2. Line 2
3. Line 3
4. Line 4
5. Line 5
'@
$daysOfTheWeek -replace "\d.\s",""

חילוץ מחרוזות ממחרוזות

לפריט המחרוזת יש שיטה הנקראת SubString(). שיטת SubString() משמשת לחילוץ מחרוזות בתוך מחרוזות במיקומים ספציפיים. התחביר לשיטת SubString() מוצג למטה.

<String>.SubString(<startIndex>[,<length>])

האינדקס startIndex הוא אינדקס המיקום ממנו שיטת SubString() תתחיל את החיפוש. הפרמטר length מציין את מספר התווים שיש להחזיר החל מה-startIndex. הפרמטר length הוא אופציונלי ואם אינו בשימוש, שיטת SubString() תחזיר את כל התווים.

חילוץ מחרוזת מתוך מיקום התחלה ואורך קבוע

הקוד בדוגמה למעלה משיג את חלקו של הערך המחרוזתי של $guid החל מהאינדקס 9 ומחזיר בדיוק את ה-5 תווים שאחריהם.

$guid = 'e957d74d-fa16-44bc-9d72-4bea54952d8a'
$guid.SubString(9,5)

חילוץ מחרוזת ממיקום התחלה דינמי

הדוגמה הבאה מדגימה איך ניתן להשתמש במאפיין אורך המחרוזת של PowerShell כדי להגדיר דינמית אינדקס התחלה.

הקוד למטה עושה את הפעולות הבאות:

• מקבל את אורך אובייקט המחרוזת.
• מקבל את האינדקס של האינדקס האמצעי על ידי חלוקת האורך ב-2.
• משתמש את המפתח האמצעי כמפתח התחלתי של המחרוזת.

$guid = 'e957d74d-fa16-44bc-9d72-4bea54952d8a'
$guid.SubString([int]($guid.Length/2))

מאחר שערך הlength לא צוין, שיטת ה־Substring() החזירה את כל התווים ממפתח ההתחלה.

השוואת מחרוזות ב־PowerShell

ניתן להשתמש ב־PowerShell גם כדי להשוות בין מחרוזות באמצעות שיטות מובנות באובייקט המחרוזת כמו שיטות ה־CompareTo(), Equals(), ו־Contains(). או, באמצעות אופרטורי השוואה של PowerShell.

שימוש בשיטת CompareTo()

שיטת CompareTo() מחזירה ערך של 0 אם שתי המחרוזות הן בעלות אותו ערך. לדוגמה, הקוד למטה משווה בין שני אובייקטים מחרוזתיים.

$string1 = "This is a string"
$string2 = "This is a string"
$string1.CompareTo($string2)

וכפי שהערכים זהים, התוצאה צריכה להיות 0, כפי שמוצג למטה.

שימוש בשיטת Equals() ו־-eq

שיטת Equals() והאופרטור -eq יכולים לשמש לבדיקה האם ערך של שתי המחרוזות הוא שווה.

הדוגמה למטה משתמשת בשיטת Equals() כדי להשוות בין ערכי $string1 ו־$string2.

$string1 = "This is a string"
$string2 = "This is not the same string"
$string1.Equals($string2)

הקוד מעלה צריך להחזיר False מכיוון שערכי $string1 ו־$string2 אינם שווים זה לזה.

הדוגמה הבאה משתמשת ב־-eq במקום כדי להשוות בין ערכי $string1 ו־$string2.

$string1 = "This is a string"
$string2 = "This is not the same string"
$string1 -eq $string2

כפי שניתן לראות מהתוצאה למטה, התוצאה בשימוש ב־-eq ובשיטת Equal() הן זהות.

שימוש בשיטת Contains()

בדוגמה זו, שתי המחרוזות מתבדקות באמצעות בדיקה האם המחרוזת של PowerShell מכילה תת־מחרוזת של מחרוזת אחרת.

הקוד למטה מראה שערכי $string1 ו־$string2 אינם שווים. אך, ערך ה־$string2 הוא תת־מחרוזת של $string1.

$string1 = "This is a string 1"
$string2 = "This is a string"
$string1.Contains($string2)

התוצאה של הקוד למעלה צריכה להיות True, כפי שמוצג למטה.

קריאה נוספת

• למידת תבנית המחרוזת ב־PowerShell והרחבת מחרוזות
• חזרה ליסודות: הבנה של אובייקטים ב־PowerShell
• הבנת PowerShell ופורמט מחרוזות בסיסי
• אודות כללי הציטוטים
• מחלקת מחרוזת
• אודות_הצטרפות
• אודות ביטויים רגולריים