1 / 59

תרגול מס' 6

תרגול מס' 6. תכניות סטנדרטיות ב UNIX שרשור פקודות באמצעות Pipeline עבודה ב- bash. Pipeline. הרכבת פקודות Pipeline. הרכבת פקודות. נניח שברצוננו להדפיס את התוכן של תיקיה המכילה הרבה קבצים לא נוכל במצב זה לראות את כל הקבצים נוכל להשתמש בהפנית

ross-curry
Download Presentation

תרגול מס' 6

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  1. תרגול מס' 6 תכניות סטנדרטיות ב UNIX שרשור פקודות באמצעות Pipeline עבודה ב-bash

  2. Pipeline הרכבת פקודות Pipeline מבוא לתכנות מערכות - 234122

  3. הרכבת פקודות • נניח שברצוננו להדפיס את התוכן של תיקיה המכילה הרבה קבצים • לא נוכל במצב זה לראות את כל הקבצים • נוכל להשתמש בהפנית פלט הפקודה ls לקובץ זמני ולאחר מכן שימוש ב-more: > ls -l > tmp > more < tmp > rmtmp מבוא לתכנות מערכות - 234122

  4. Pipeline • כדי לחסוך את הבלגן שבטיפול בקבצים זמניים ניתן להשתמש ב-pipeline המחבר את הפלט של פקודה אחת לקלט של פקודה שניה ישירות • כדי לחבר שתי פקודות כך נרשום אותן אחת אחרי השניה כאשר ביניהן מפריד התו ‘|’ • על מנת לראות בשלבים את התוכן של תיקיה גדולה נוכל לרשום כעת: > ls -l | more • ניתן לשלב מספר תכניות בבת אחת: > command1| command2| command3 command1 command2 command3 stdout stdin stdout stdin מבוא לתכנות מערכות - 234122

  5. Pipeline - סיכום • ניתן להשתמש בתו ‘|’ כדי לחבר את הפלט של תכנית א' עם הקלט של תכנית ב' • בעזרת pipeline נוכל להרכיב פקודות מורכבות בעבודה בטרמינל מתכניות פשוטות מבוא לתכנות מערכות - 234122

  6. עבודה ב-Bash מהו bash? תכונות מתקדמות של bash עבודת ה-bash מבוא לתכנות מערכות - 234122

  7. Shell • Shell (קליפה) הוא כינוי לתוכנה המקשרת בין המשתמש לבין גרעין מערכת ההפעלה • בדרך כלל המונח בשימוש עבור shell טקסטואלי • עבודת ה-Shell מתבצעת על ידי קבלת פקודה מהמשתמש, ביצוע החלפות טקסט בפקודה בהתאם לתכונות ה-Shell ולבסוף שליחת הפקודה המעובדת למערכת ההפעלה • דוגמאות ל-shell: • Bash(ברירת המחדל ברוב הפצות הלינוקס) • C-Shell(ברירת המחדל עבור מחשב ה stud) • Powershell(shell מתקדם עבור windows) • בקורס זה נלמד את Bash • מלבד מנשק בסיסי לביצוע פקודות ה-Shellמקל עלינו את העבודה בעזרת תכונות מתקדמות, לדוגמה ההשלמה האוטומטית המתבצעת ע"י לחיצה על Tab • ה-Shell יאפשר לנו להגדיר קיצורים, לחזורעל פקודות, להתייחס למספר קבצים בנוחות ולהגדיר משתניםאשר נוכל להשתמש בהם בפקודות מבוא לתכנות מערכות - 234122

  8. החלפת ה-Shell • ניתן להשתמש בפקודה הבאה כדי לקבל את שם ה-Shell הנוכחי ב-Unix > echo $0 tcsh • במחשבים בהם Bash אינה Shell ברירת המחדל (כמו בשרת ה-stud לדוגמה), ניתןלהשתמש בפקודה chsh (change shell)כדי לשנות את ברירת המחדל: • חשוב להקפיד לכתוב את שם ה-Shell (הייחוס אליו) נכון, אחרת החשבון נהרס • מלבד החלפת ה-Shell המשמש כברירת מחדל, ניתן תמיד להריץ Shell אחר כמו כל פקודה אחרת > chsh Changing shell for mtm. old shell: /bin/tcsh New shell: /bin/bash Shell will be changed for mtm in approximately 5 minutes > מבוא לתכנות מערכות - 234122

  9. הפקודה echo • במקרים רבים נרצה להדפיס לפלט מחרוזת, לשם כך ניתן להשתמש בפקודה echo • הפקודה echoמדפיסה את הפרמטרים שקיבלה > echo [-n] [words] • -n: מדפיס ללא ירידת שורה > echo Hello world! Hello world! > > echo –n Hello world! Hello world! > מבוא לתכנות מערכות - 234122

  10. נתינת כינויים לפקודות - alias • הפקודה alias מאפשרת להגדיר קיצורים ב-Shell > alias <new name>="<command + parameters>" • אסור לשים רווחים בסמוך לתו '=' • לאחר הרצת הפקודה נוכל לרשום את הפקודה <new name> כקיצור לפקודה <command> עם הפרמטרים שהוספנו. • ה-Shell יבדוק בשלב עיבור הפקודה האם המילה הראשונה היא alias ואם כן יבצע החלפה מתאימה • כדי לבטל alias ניתןלהשתמש בפקודה unalias <alias> < alias ll="ls –l" > ll -rw-r--r-- 1 user staff 0 Nov 13 15:14 a.c > alias cdex2="cd ~/mtm/ex2" > cdex2 > alias GCC="gcc -std=c99 -Wall -Werror -pednatic-errors" > GCC hello.c -o hello > unalias GCC > GCC hello.c -o hello -bash:GCC: Command not found. מבוא לתכנות מערכות - 234122

  11. Filename Expansion • ניתן לרשום בפקודה תבנית המתייחסת למספר קבצים. במקרה זה bash יחליף את מחרוזת התבנית בפקודה ברשימת הקבצים המתאימים לתבנית • הסימן * מתאים למחרוזת כלשהי (כולל ריקה) • הסימן ? מתאים לתו כלשהו יחיד • ניתן להתייחס למספר תווים אפשריים על ידי שימוש ב-[ ] • ניתן לרשום את התווים האפשרייםאחד אחרי השני במפורש • ניתן לרשום טווח של תווים, למשל a-z • ניתן להתייחס למספר מחרוזות שונות בעזרת { } • אפשרות זו אינה מתחשבת בקבצים קיימים <ls axb.c a3b.c cab.txt a4b.txt > echo files: * files: axb.ca3b.c cab.txt a4b.txt > echo The source files are *.c The source files are axb.c a3b.c > echo a[0-9]b.* a3b.c a4b.txt > echo a3b.{c,txt} a3b.c a3b.txt מבוא לתכנות מערכות - 234122

  12. משתנים • ניתן להציב ערך למשתנה ב-bash על ידי השמה ישירה > <varname>=<value> • אין צורך להכריז על משתנים ב- bash, לאחר ביצוע השמה למשתנה הוא מוגדר אוטומטית • ניתן להחליףערך של משתנה על ידי השמה נוספת • אסור לשים רווח בין סימן ההשמה לשם המשתנה והערך • אם יהיה כזה רווח ה-Shell ינסה להריץ פקודה ששמה כשם המשתנה • ניתן לקרוא משתנים על ידי שימוש באופרטור $, למשל: > echo $<varname> • השימוש במשתנה הוא פשוט החלפת הקריאה למשתנה בערך השמור בו מבוא לתכנות מערכות - 234122

  13. משתנים • ניתן לבטל הגדרה של משתנה על ידי הפקודה unset <varname> < unset my_variable • בדרך כלל אין צורך בכך • אם מנסים לקרוא משתנה שאינו מוגדר אז לא מודפס כלום • ניתן להשתמש ב-{} כדי לסמן מהו שם המשתנה לאופרטור $ • מועיל כאשר השימוש במשתנה צמוד למחרוזת נוספת > a=Hell > echo $ao > echo ${a}o Hello מבוא לתכנות מערכות - 234122

  14. משתנים - מערכים • ניתן לשמור במשתנה יחיד מערךשל מחרוזות על ידי שימוש בסוגריים > arr=(1 2 3) • קריאת משתנה שקולה לקריאת האיבר הראשון (אינדקס 0) מהרשימה > echo $arr1 • קריאת כל המערך ניתנת מתבצעת על ידי שימוש ב-[*] ובסוגריים מסולסלים: > echo ${arr[*]{1 2 3 > echo $arr[*]1[*] • ניתן לגשת לאיבר יחיד בעזרת אופרטור [ ] • ניתן להוסיף איברים חדשים למערך בשיטה זו > arr[3] = 4> echo ${arr[*]{1 2 3 4 מבוא לתכנות מערכות - 234122

  15. משתנים - מערכים • ניתן לקבל את מספר האיברים במערך בעזרת {#<varname>[*]}$: > echo ${#arr[*]}4 • ניתן לגשת לתחומים של איברים במערך במערך > echo A:${arr[*]:0:2} A:1 2 > echo B:${arr[*]:1} B:2 3 4 > echo C:${arr[*]:2:1}C:3 • המספר הראשון מציין את אינדקס ההתחלה של התחום • המספר השני מציין את מספר האיסרים בתחום • אם הוא אינו מופיע יודפסו כל האיברים החל מהאינדקס המבוקש מבוא לתכנות מערכות - 234122

  16. משתנים - מחרוזות • ניתן לשמור מחרוזות המכילות רווחים בעזרת שימוש בגרשיים כפולים > list=(Matam "Hello world" 17) > echo ${#list[*]} : ${list[*]} 3 : Matam Hello world 17 > echo ${list[1]} Hello world • קריאת משתנה שערכו מכיל רווחים תגרום לאיבוד הרווחים המדויקים שהיו בין המילים קודם לכן > str=" Very crazy spaces " > echo $str Very crazy spaces מבוא לתכנות מערכות - 234122

  17. משתנים - מחרוזות • ניתן להשתמש בגרשיים כפולים כדי לשמור על הרווחים בזמן ההחלפה > echo "$str" Very crazy spaces • ניתן לקבל את מספר התווים במשתנה ע"י שימוש ב-#, בדומה לקבלת אורכו של מערך > echo ${#str} 29 מבוא לתכנות מערכות - 234122

  18. משתנים - מערכים • ניתן להתייחס למשתנה רגיל כאל רשימה בעלת איבר יחיד > a=Hello > echo ${a[0]} Hello > str="Hello world" > echo ${str[1]} > list=(Hello world) > echo ${list[1]} world • בעזרת unset נוכל לבטל את הרשימה או איבר אחד מתוך הרשימה > unset list[1] > echo ${list[*]}Hello מבוא לתכנות מערכות - 234122

  19. משתנים - חישוב ביטויים • בניגוד לשפת C, למשתנים ב-bash אין טיפוס. כל המשתנים הם מסוג מערך של מחרוזות • ניתן להחליף ביטוי אריתמטי בערכו על ידי $((<expression>)) • הערך המספרי של המחרוזות ישמש בחישוב הביטוי • משתנים יוחלפו בערכם (גם ללא $) • אם אחד הארגומנטים אינו מספר, ערכו יהיה 0 בחישוב • משתנה שאינו מוגדר, או ערכו אינו מספר יחושב כ-0 > echo $((3 + 4)) 7 > n=$((3 * 7 + 4)) > echo $n 25 > a=5 > b=7 > sum=$(($a + $b)) > echo $sum 12 > echo $(( Hello )) 0 > a=4 > echo $(( 2 + a )) 6 > str="Hello world!" > num=17 > echo $(( $str * $num )) 0 מבוא לתכנות מערכות - 234122

  20. משתנים - פעולות חשבוניות • ניתן לבצע את פעולות חשבוניות שונות בדומה לשפת C: • פעולות חשבוניות פשוטות: +, -, * ו-/ • השמות: = • הגדלות והקטנות: =+, =-, -- ו-++ • ניתן לבצע פעולות חשבוניות רק על מספרים שלמים • ניתן להשתמש גם בפקודה letכדי לבצע פעולה חשבונית • נוח כאשר רוצים להשתמש ב-++ ואין צורך בערך ההחזרה > let n=3+4 > let n++ > echo $n 8 > $((n++))-bash: 9: command not found Bash מנסה לבצע פקודה בשם "9" ונכשל מבוא לתכנות מערכות - 234122

  21. היסטוריה • Bash שומר את הפקודות האחרונות שהתבצעו ומאפשר ביצוען מחדש • הדרך הכי פשוטה לגשת להיסטוריה היא על ידי שימוש ב-↑ ו-↓ • ניתן לראות את הפקודות האחרונות שבוצעו על ידי הפקודה history • ניתן לבצע את האחרונה על ידי !! • ניתן לבצע את פקודה מספר על ידי ! • ניתן לבצע את הפקודה האחרונה שהתחילהב-<string> על ידי !<string> • ניתן לבצע את הפקודה האחרונה שמכילה<string> על ידי !?<string> • אפשר להחליף str1במחרוזת str2בפקודה האחרונה ע"י ^str1^str2^ . > history 1 17:20 let a = 3 2 17:21 let b = 4 3 17:22 @ n = $b + $a 4 17:24 echo $n 5 17:28 history > !4 echo $n 7 > !! echo $n 7 > !let let b = 4 > ls/it/is/avery/long/path > ^ls^cat^ cat /it/is/avery/long/path החלפות המתבצעות בגלל גישה להיסטוריה מודפסות בזמן ביצוען ולפני ביצוע הפקודה מבוא לתכנות מערכות - 234122

  22. Command Substitution • ניתן "לשרשר" פקודות על ידי שימוש בגרשיים הפוכים ` • באנגלית: backticks או backquotes • Bash יבצע תחילה את הפקודה בתוך ` ` ויחליף אותה בפלט שלה > echo The length of $str is `echo -n $str | wc -c` The length of Hello is 5 > grep –c cow `cat farms_list.txt` farm1:3 farm2:2 > set a ="there are `ls | wc -l` files in `pwd` " > echo $a there are 662 files in /usr/bin farms_list.txt farm1 farm2 מבוא לתכנות מערכות - 234122

  23. סוגי גרשיים • גרשיים כפולים, " ", משמשים לשמירה על רווחים • משתמשים ב-" " כאשר יש צורך לשמור מחרוזות שלמות במדויק > sentence="The dingo ate your baby" • בתוך גרשיים אלו לא מתבצעות החלפות של תבניות בשמות הקבצים המתאימים > echo "*.c" : *.c *.c : main.capp.chello.c • גרשיים בודדים ' ', מונעים את כל ההחלפות בתחומם > echo lets make some '$$' lets make some $$ • גרשיים הפוכים (backticks) מבצעים command substitution מבוא לתכנות מערכות - 234122

  24. עבודת ה-shell • עבודת ה-Shell מתבצעת בלולאה: • הצגת prompt • המתנה לפקודה • עיבוד הפקודה עד לקבלת פקודה פשוטה • ביצוע הפקודה • לשם כך Bash מנהל מבני נתונים פנימיים אשר שומרים את ההיסטוריה, המשתנים וה-aliasesשהוגדרו • הטיפול בפקודה מתבצע בשלושה שלבים עיקריים • ניתוח הפקודה: הפקודה מופרדת למילים על פי רווחים וטאבים. התווים |,< ו-> מפרידים בין פקודות • עיבוד הפקודה:ביצוע החלפות מחרוזות הפקודה עד לקבלת פקודה פשוטה • ביצוע הפקודה: שליחת הפקודה הפשוטה שהתקבלה לביצוע על ידי מערכת ההפעלה מבוא לתכנות מערכות - 234122

  25. עיבוד הפקודה • בשלב זה מבצע bash החלפות במחרוזת הפקודה עד לקבלת פקודה פשוטה: • אם הפקודה מכילה שימוש בפקודות קודמות (ע"י שימוש בסימן !) מתבצעת החלפה מההיסטוריה ומודפסת שורת הפקודה שנבחרה מההיסטוריה • אם המילה הראשונה בפקודה הינה aliasמתבצעת החלפה לפי ה-alias המוגדר • החלפת ביטויים המתחילים ב-$ בערכי המשתנים המתאימים • החלפת תבניות של שמות קבצים ברשימת הקבצים המתאימה • החלפת פקודות המופיעות בתוך גרשיים הפוכים בתוצאת הפקודה מבוא לתכנות מערכות - 234122

  26. ביצוע הפקודה • לאחר שהתקבלה פקודה סופית על bash להפעיל את הפקודה המתאימה, הפקודות מתחלקות שני סוגים: • פקודות פנימיות של ה-Shell, למשל cd, let, unset,... • פקודות חיצוניות - שמות קבצי הרצה, למשל ls, gcc, cat, sort... • אם שם הפקודה מתאים לפקודה פנימית היא תיבחר • אחרת ה-Shell יחפש בכל התיקיות המופיעות במשתנה pathקובץ הרצה בשם המתאים, • אם נרצה לאפשר ל-Shell להריץ תכניות מהתיקיה הנוכחית ללא שימוש ב-‘.’ניתן להוסיף את התיקיה הנוכחית ל-PATH. • התיקיות מופרדות ע"י סימן ":" . • ניתן להשתמש בפקודה whichכדי לגלותאיזו תכנית תופעל עבור שם פקודה מסוים > PATH=${PATH[*]}:. > hello Hello world! > which hello ./hello > which gcc /usr/bin/gcc < which cd Which: no cd in (…content of PATH…) מבוא לתכנות מערכות - 234122

  27. עבודה ב-Bash - סיכום • ל-Bash מגוון תוכנות מתקדמות המאפשרות למשתמש מתקדם לבצע פעולות מסובכות בקלות • ניתן להתייחס למספר קבצים בבת אחת על ידי שימוש בתבניות • ניתן להגדיר כינויים לפקודות ופרמטרים שכיחים בעזרת alias • ניתן לקרוא לפקודות שהתבצעו בעבר הקרוב בעזרת ההיסטוריה • ניתן לשמור ערכים במשתנים ולנצלם לפקודות ב-Bash • כל המשתנים ב-bash הם מסוג רשימות של מחרוזות • ניתן להשתמש ב-` ` כדי לבצע החלפת פקודה בפלט שלה בשורות פקודה ב- bash • כל התכונות של bash מבוצעות על ידי החלפת מחרוזות פשוטה בשלב עיבוד הפקודה מבוא לתכנות מערכות - 234122

  28. תסריטים הרצת תסריטים מבני בקרה ב-bash דוגמאות השוואה בין C ו-bash מבוא לתכנות מערכות - 234122

  29. אוטומטיזציה • נניח (מקרה היפותטי לחלוטין) שברשותנו קבצי בדיקה ופלט לתכנית שלנו וברצוננו לבדוק את נכונות התכנית מול קבצים אלו • צריך לכתוב 3 פקודות לכל בדיקה • גם עם שימוש במנגנון ההיסטוריה הרצת הבדיקותמעיקה ולוקחת הרבה זמן מיותר • הפתרון:אוטומטיזציהשל הרצת הפקודות. ניצור קובץ אשר יכיל "תסריט" לפיו יורצו כל הפקודות לפי הסדר > mtm_rentals< test1.in > tmpout 2> tmperr > diff expout1 tmpout > diff experr1 tmperr מבוא לתכנות מערכות - 234122

  30. הרצת תסריט בעזרתsource • ניתן להריץ קובץ המכיל פקודות Bash (להלן תסריט - script) על ידי הפקודה source • הפקודות יבוצעו ב-Shell הנוכחי כאילו נכתבו בשורת הפקודה אחת אחרי השניה > source run_tests Running test 1 Running test 2 Running test 3 run_tests echo Running test 1 mtm_rentals< test1.in > tmpout 2> tmperr diff expout1 tmpout diff experr1 tmperr echo Running test 2 mtm_rentals< test2.in > tmpout 2> tmperr diff expout2 tmpout diff experr2 tmperr echo Running test 3 mtm_rentals< test3.in > tmpout 2> tmperr diff expout3 tmpout diff experr3 tmperr מבוא לתכנות מערכות - 234122

  31. תסריטי אתחול • בהתחברות של משתמש למערכת מורץ התסריט .login אשר בתיקית הבית של המשתמש • בפתיחת Shell חדש של Bash מורץ התסריט .bashrc • הרצות תסריטי האתחול מתבצעות באמצעות source, ולכן הן משפיעות על מצב ה-Shell .bashrc .login PATH=$PATH:. alias ll="ls -l" alias cdex2="cd ~mtm/public/1011a/ex2" alias GCC="gcc -std=c99 -Wall \ -pedantic-errors -Werror" # welcome message echo ------ Welcome `whoami` !-------- echo You are in `pwd` directory of \ `hostname` echo OS is `uname -s` # echo disk usage is `du -sh | cut -f1` echo `who | wc -l` users are logged in echo Today is `date` מבוא לתכנות מערכות - 234122

  32. הרצת תסריט כקובץ הרצה • ניתן להריץ תסריט כפקודה: • בתחילת התסריט יש להוסיף את השורה #!/bin/bash • #! מסמן ל-Unix שהשורה הראשונה בקובץ מגדירה את התכנית לביצוע שאר הפקודות בקובץ • /bin/bashהוא שם התכנית לביצוע הפקודות, במקרה שלנו Bash • בנוסף יש להוסיף הרשאת ריצה לקובץ • כעת ניתן להריץ את התסריט כמו תכנית רגילה • בניגוד להרצה באמצעות פקודת source התסריט יבוצע בתהליך Shell חדש אשר יסתיים בסוף ריצת התסריט מבוא לתכנות מערכות - 234122

  33. הרצת תסריט כקובץ הרצה • נמיר את תסריט הרצת הבדיקות שלנו לקובץ הרצה: • בעיה חדשה: התסריטמתחיללהסתבך, הוספת בדיקות נוספותמשכפלת קוד בתסריט ולא נוחה (ייתכנו אלפי בדיקות) • פתרון: נשתמש במבני בקרה (תנאים ולולאות) בדומה לשפת C > chmoda+xrun_tests > ./run_tests Running test 1 Running test 2 Running test 3 run_tests #!/bin/bash echo Running test 1 mtm_rentals < test1.in > tmpout 2> tmperr diff expout1 tmpout diff experr1 tmperr echo Running test 2 mtm_rentals < test2.in > tmpout 2> tmperr diff expout2 tmpout diff experr2 tmperr echo Running test 3 mtm_rentals < test3.in > tmpout 2> tmperr diff expout3 tmpout diff experr3 tmperr מבוא לתכנות מערכות - 234122

  34. מבני בקרה • Bash מאפשרת שימוש במבני בקרה (למשל whileו-if) בתסריטים ובשורת הפקודה • מבני הבקרה משתמשים בתנאיםבדומה למבני הבקרה שבשפת C • השוואת ערכי מספרים • השוואת מחרוזות • ועוד... • נעבור על מספר מבני בקרהותנאים שימושיים > for ((i = 1; $i < 10; i++ )); do > if (($i % 3 == 0)); then > echo 3 divides $i > fi > done 3 divides 3 3 divides 6 3 divides 9 מבוא לתכנות מערכות - 234122

  35. while • ניתן ליצור לולאות whileב-bash: while <expression>; do<command1><command2>...done • הפקודות בגוף הלולאה יבוצעו כל עוד <expression> ממשיך להתקיים • לולאות while כמו שאר מבני הבקרה ניתנות לביצוע ישירותמהטרמינל > i=1 > while ((i <= 3)); do > echo $i > let i++ > done 1 2 3 run_tests > ./run_tests Running test 1 Running test 2 Running test 3 #!/bin/bash i=1 while ((i <= 3)); do echo Running test $i mtm_rentals< test${i}.in \ > tmpout 2> tmperr diff expout${i} tmpout diff experr${i} tmperr let i++ done מבוא לתכנות מערכות - 234122

  36. for • שימוש נוסף ב-for הוא מעבר על על איברי המערך: for <varname> in <array> ; do <command1> <command2> ...done • <varname> הוא שם המשתנה שיכיל בכל פעם איבר מהרשימה • <array>היא רשימה של מחרוזות • העדיפו להשתמש בשיטה זו על פני שימוש מפורש באינדקסים מבוא לתכנות מערכות - 234122

  37. for • לולאת for משמשת בדומה לשפת C למעבר נוח יותר על תחום מספרים > ./run_tests Running test1.in Running test2.in Running test3.in run_tests #!/bin/bash for ((i = 1; i <= 3; i++)); do echo Running test$i mtm_rentals < test${i}.in > tmpout 2> tmperr diff expout$itmpout diff experr$itmperr done מבוא לתכנות מערכות - 234122

  38. if • ניתן להגדיר ב-bash משפטי תנאי בשתי גרסאות if <expression>; then <command1> <command2> ... fi • ניתן להוסיף else ופקודות אשר יתבצעו אם התנאי אינו מתקיים if<expression>; then <commands> else <commands>fi > i=1 > if (( $i> 0 )); then > echo POSITIVE > else > echo NEGATIVE > fi POSITIVE מבוא לתכנות מערכות - 234122

  39. ביטויים אפשריים ב-if ו-while • קיימות מספר אפשרויות לכתיבת התנאים בלולאות ומשפטי תנאי • ניתן לרשום תנאים בתוך [[ ]]: • האופרטורים ==, > ו-< משווים מחרוזות (לפי סדר לקסיקוגרפי) • ניתן לבצע השוואת על ערכי מספרים בעזרת דגלים כגון -eq, -gt, -le • חשוב להקפיד על תו הרווח בין הסוגריים לתוכן התנאי כדי למנוע שגיאות ב-bash > str1=Hello > if [[ $str1 == Hello ]]; then echo true; fi true > if [[ hello == Hello ]]; then echo true; fi > if [[ 11 < 7 ]]; then echo true; fi true > if [[ 11 -le 7 ]]; then echo true; fi > if [[ 11 -eq 11 ]]; then echo true; fi true > if [[ 0 -eq Hello ]]; then echo true; fi true זו אינה השוואת ערכים מספריים עבור ערך שאינו מייצג מספר משתמשים ב-0 לחישוב מבוא לתכנות מערכות - 234122

  40. ביטויים אפשריים ב-if ו-while • בתוך [[ ]] ניתן להשתמש בתנאים מועילים נוספים, למשל: • התנאי -f <filename> בודק האם קיים קובץ בשם <filename> • התנאי -d <dirname> בודק האם קיימת תיקייה בשם <dirname> • ניתן לבדוק תנאים מורכבים יותר: • ניתן להשתמש באופרטורים &&, ||, ו-! כמו בשפת C • הקפידו להשאיר רווח אחרי ! כדי להימנע משגיאות בגלל מנגנון ההיסטוריה • ניתן להשתמש בסוגריים כדי לקבוע את הקדימויות > if [[ -f a.txt ]]; then echo file exists; fi > cat > a.txt Hello world! > if [[ -f a.txt ]]; then echo file exists; fi file exists > mkdirmtm > if [[ ! (-f b.txt && -d mtm) ]]; then echo yes; fi yes מבוא לתכנות מערכות - 234122

  41. התאמת מחרוזות • בתוך תנאי מהצורה [[ ]], האופרטור = מאפשר התאמת מחרוזת לתבנית • הארגומנט השמאלי הוא מחרוזת רגילה • הארגומנט הימני הוא תבנית אשר יכולה לכלול את הסימנים *, ? ו-[ ] כמו שתואר עבור תבניות של שמות קבצים • האופרטור =! הוא השלילה של אופרטור ההתאמה = • שימו לב שהמשמעות של = ו-== שונה > end_with_z="some string with z" > if [[ "$end_with_z" = *[zZ] ]]; then echo match; fi match > if [[ "this string start with t" = t* ]]; then echo true; fi true > if [[ "this string doesn't start with t" = [^t]* ]]; then echo true; fi > file=test4.in > if [[ $file = test*.in]]; then echo test file; fi test file > if [[ "string doesn't start with t" != t* ]]; then echo true; fi true מבוא לתכנות מערכות - 234122

  42. ביטויים אפשריים ב-if ו-while • ניתן להגדיר תנאי בתוך (()) • בתוך (()) האופרטורים ==, =!, > ו- < מתייחסים לערכים מספריים • אין צורך לרשום $ לפני שם משתנה • ניתן לבצע פעולות חשבוניות • תנאים המוגדרים בעזרת (())מתנהגים כמו ביצוע פעולות חשבוניות בעזרת (())$ > if (( 11 < 7 )); then echo true; fi > i=5 > if (( i >= 0 && i <= 10 )); then echo true; fi true > if [[ 11 -eq 11 ]]; then echo true; fi true > if (( 0 == Hello )); then echo true; fi true > if (( ++i == 6 )); then echo true; fi true > if (( ++i == 6 )); then echo true; fi מבוא לתכנות מערכות - 234122

  43. העברת פרמטרים בשורת הפקודה • כמו ב-C ניתן לגשת לפרמטרים המועברים בשורת הפקודה לתסריט • הפרמטר ה-n לתסריט נקרא פשוט n, וניתן לקרוא אותו על ידי $n • $* יוחלף ברשימת כל הארגומנטים לתסריט • אם ייתכנו רווחים בתוך הארגומנטים ניתן להשתמש ב-"$@" כדי לשמור על מספר האגומנטים הנכון • $0 יוחלף בשם התסריט • $# יוחלף במספר הארגומנטים echo_script > echo_scriptaaabbbccc command: echo_script 3 arguments parameter 1 : aaa parameter 2 : bbb parameter 3 : ccc #!/bin/bash echo command: $0 echo $# arguments let number=1 for paramin $*; do echo parameter $((number++)) : $param done מבוא לתכנות מערכות - 234122

  44. פונקציות • ניתן להגדיר ב-bash פונקציות בצורה כזו: function <name> { <commands> } • פונקציה חייבת להכיל לפחות פקודה אחת • השימוש בפונקציה יכול להתבצע רק אחרי הגדרתה • אפשר להעביר לפונקציה ארגומנטים • הפונקציה משתמשת בהם בדומה לשימושבארגומנטים המועברים לתסריט • הפונקציה אינה יכולה לגשת לארגומנטיםשל התסריט שקרא לה מבוא לתכנות מערכות - 234122

  45. פונקציות • כדי ליצור משתנה מקומי בפונקציה יש להכריז עליו תחילה עם local: > using_local original_aoriginal_b original_asurprise_b using_local #!/bin/bash function surprise { local a=surprise_a b=surprise_b } a=original_a b=original_b echo $a $b surprise echo $a $b מבוא לתכנות מערכות - 234122

  46. פונקציות • ניתן "להחזיר" ערכים מפונקציה בעזרת command subsitution (backticks): > sum_numbers1 2 3 4 5 15 sum_numbers #!/bin/bash function sum { local result=0 for num in $*; do let result+=$num done echo $result } n=`sum $*` echo $n ביטוי זה יוחלף בסכום הרצוי מבוא לתכנות מערכות - 234122

  47. קריאת קלט • ניתן לקרוא שורה מהקלט הסטנדרטי על ידי read <flags> <variable name> • השורה תיקלט לתוך שם המשתנה שהוגדר • הדגל -a יחלק את השורה לפי מילים לתוך מערך • הביטוי read יוחלףעל ידי bash בשורת קלט שתיקלט מהקלט הסטנדרטי > read line Hello world > echo $line Hello world > read -a line Hello world > echo $line Hello > echo ${line[*]} Hello world מבוא לתכנות מערכות - 234122

  48. עבודה עם קבצים • דרך פשוטה לקריאת קובץ היא על ידי שימוש בהפניית קלט ושימוש ב-read: • דרך פשוטה לקרוא קובץ שורה אחר שורה היא כך: > cat hello.txt Hello world! > read line < hello.txt > echo $line Hello world! > cat lines.txt first line second line > lines_counterlines.txt first line second line 2 #!/bin/bash counter=0 while read line; doecho $line let counter++ done < "$1" echo $counter lines_counter מבוא לתכנות מערכות - 234122

  49. חלוקה פונקציונלית של תסריטים • שימו לב שניתן להשתמש ב-bash כדי לערבב תסריטים עם תכניות שנכתבו בשפות שונות בקלות • מכאן מגיע כוחן של שפות תסריטים - scripting languages • ניתן להעביר פרמטרים לתסריטי עזר • בעזרת פרמטרים בשרות הפקודה • בעזרת pipeline • בעזרת קבצים זמניים • ניתן לקבל ערכים חזרה מתסריטי עזר • בעזרת פלט מתסריט העזר מבוא לתכנות מערכות - 234122

  50. העברת והחזרת ערכים • החזרת ערכים מתסריטי העזר יכולה להתבצע בעזרת • שימוש ב-backticks set result = `helper_script` • העברה לתסריט אחר ב-pipeline helper_script | another_script • דרך קובץ זמני helper_script > temp • העברת פרמטרים לתסריטי עזר יכולה להתבצע בדרכים הבאות • בשורת הפקודה helper_script $arg1 $arg2 • בעזרת pipeline echo $arg1 $arg2 | helper_script • דרך קובץ זמני echo $arg1 $arg2 > temp helper_script < temp מבוא לתכנות מערכות - 234122

More Related