אופרטור דומה ל-PowerShell ועוד: שפר את משחק התסריט שלך

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

קשור: הבנת כוחות הפקודה של PowerShell -Eq -Ne ועוד אופרטורים

בדיקת שוויון עם אופרטורי eq ו־ceq

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

לאופרטור -eq נדרשים שני ערכים להשוואה. נניח שאתה משווה מחרוזת למשתנה בשם $string. אתה רוצה להשוות את ערך המשתנה הזה לערך המחרוזת "PowerShell" כדי לוודא שהם שווים.

קשור: שרשור, הרחבה, עיצוב וכל דברי המחרוזות ב־PowerShell

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

PS> $string = "PowerShell"
PS> $string -eq "powershell"
True

שים לב ש-= הוא אופרטור הקצאה ולא אופרטור השוואה. אי אפשר להשתמש ב-= כדי להשוות ערך אחד לערך אחר ב-PowerShell.

בדיקת רגישות תיקיות עם אופרטור ceq

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

אפשר לראות דוגמה לשימוש ב-ceq בקטע הקוד שלמטה. כעת שים לב ש-PowerShell רואה את ההבחנה התלויה ברישיות.

PS> $string -ceq "PowerShell"
True 
PS> $string -ceq "powershell"
False

בדיקת אי שוויון עם אופרטורים ne ו-cne

כפי ש-eq ו-ceq בודקים לכל דבר, PowerShell מציע זוג של אופרטורים העושים את ההפך הדי מדויק בשם ne ו-cne. כמו תחומיהם, שני האופרטורים הללו מבצעים את אותו הפעולה רק בהיפך.

PS> $string = "PowerShell"
PS> $string -ne "PowerShell"
False
PS> $string -cne "PowerShell"
False
PS> $string -cne "powershell"
True

בדיקת פריטים באוסף

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

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

PS> $array =@(1,2,3,4,5,6,7,8,9,9,9,9)
PS> $array -eq 9
9
9
9
9
PS> ($array -eq 9).Count
4

בדיקת מערכים לכלול ערכים

מאחר שלמדת עכשיו על השימוש באופרטור eq למציאת מופעים במערכים, בוא נקדם קצת יותר ונציג את האופרטורים "הכלול" או "הכלאה". אלו הם האופרטורים contains, notcontains, in ו- notin. אלו אופרטורים מחזירים ערך בוליאני של True או False אם האוסף מכיל או לא מכיל את המופע.

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

PS> $array = @(2,4,5,6,8,8,9,9,9)
PS> $array -contains 9
True
PS> $array -notcontains 9
False
PS> $array -contains 5

באופן דומה, יש לך את האופרטורים in ו- notin. אלו אופרטורים דומים בצורה כמעט זהה ל- contains ו- notcontains עם יוצא מן הכלל: הערך להשוואה נמצא בצד שמאל במקום בצד ימין.

$array = @(2,4,5,6,8,8,9,9,9)
9 -in $array
True
9 -notin $array
False

בדיקת "גדול מ-" עם אופרטורים gt ו- ge

מה קורה אם יש צורך לבדוק האם מספר (מספר שלם) הוא גדול ממספר אחר או אולי גדול או שווה למספר אחר? תשתמש באופרטורים gt ו־ge. אלו האופרטורים השווים בין מספרים שלמים.

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

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

PS> 7 -gt 5
True
PS> 7 -gt 7
False
PS> 7 -ge 7
True

דומה לאופרטור eq המאפשר לך למצוא אינסטנסיה באוסף, תוכל לעשות זאת גם עם אופרטורי ge ו־gt. PowerShell עובר דרך כל פריט באוסף ומשווה ערך כלשהו לזה שסיפקת. תוכל לראות דוגמה טובה לכך למטה.

PS> $array =@(1,2,3,4,5,6,7,8,9,9,9,9)
PS> $array -gt 5
6
7
8
9
9
9
9
PS> $array -ge 5
5
6
7
8
9
9
9
9

בדיקת "פחות מ" עם אופרטורים lt ו־le

בדיוק כמו האופרטורים gt ו־ge, האופרטורים lt ו־le מבצעים את אותה הפעולה אך בהפך. האופרטורים lt ו־le משווים בין שני ערכים ובודקים אם המספר בצד שמאל הוא פחות מהמספר בצד ימין או פחות או שווה לו.

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

PS> $array =@(1,2,3,4,5,6,7,8,9,10)
PS> $array -lt 5
1
2
3
4
PS> $array -le 5 
1
2
3
4
5

התאמה על פי תווים כלליים עם אופרטור Like של PowerShell

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

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

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

תוכל לראות מקרה נוסף של השוואת-like ב-PowerShell ואחיו התלוי-תיק כאן למטה.

PS> $string = "PowerShell"
PS> $string -like "*Shell"
True
PS> $array = @("PowerShell","Microsoft")
PS> $array -like "*Shell"
PowerShell
PS> $array -clike "*Shell"
PowerShell

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

$string = "PowerShell" 
$string -notlike "*Shell"
False
$array = @("PowerShell","Microsoft")
$array -notlike "*Shell"
Microsoft
$array -cnotlike "*shell"
PowerShell
Microsoft

התאמה על סמך ביטוי רגולרי

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

דומה לאופרטור דומה ב-PowerShell, match ושותפו הנגדי, notmatch, משווים שני מחרוזות ומחזירים ערך בוליאני של True או False. כמו גם כאופרטורים אחרים, אותה התנהגות יכולה להיחלף לאוסף כמו שהדוגמה למטה מדגימה.

PS> $string = "PowerShell"
PS> $string -match "ow"
True 

PS> $array = @("PowerShell","Microsoft")
PS> $array -match "ow"
PowerShell

PS> $string = "PowerShell"
PS> $string -cmatch "po"
False
PS> $string -cmatch "Po"
True

PS> $array = @("PowerShell","Microsoft")
PS> $array -cmatch "Po"
PowerShell

סיכום

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

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