תורת בש

0. מדד

1. דברים שקורים לרוב האנשים
2. מבנה תסריט
3. הדפס על המסך
4. קרא את קלט המשתמש
5. חישובים בבאש
6. תנאים
7. לולאות
8. פונקציות
9. גטופס

1. דברים שקורים לרוב האנשים

/ bin / bash או / bin / sh

אחד הדברים הראשונים שהמכונה עושה בעת ביצוע התסריט שלנו הוא לבדוק באיזה מעטפת היא צריכה לעשות את זה. ברוב מערכות הלינוקס הנוכחיות / Bin / sh הוא קישור ל / bin / bash, אך זה לא תמיד המקרה, למשל בהפצות המשתמשות busybox הם מביאים Sh ובדרך כלל הם גם מביאים לְהַכּוֹת, אבל אם אתה משתמש / Bin / sh, זה לא יפעל עם בש. לכן אני ממליץ להשתמש תמיד / bin / bash.

יוניקוד לעומת ASCII

האם תהית אי פעם מדוע אינך יכול להשתמש בסימני "¿" או "ñ"? או להשתמש במבטאים? זה יכול להיות די מעצבן בסקריפטים אינטראקטיביים. הסיבה לכך היא שקידוד ברירת המחדל של Bash הוא ASCII, או מה זהה, ערכת התווים האנגלית. כדי לשנות את זה, אנחנו רק צריכים להגיד לתסריט שלנו שאנחנו רוצים להשתמש ב- Unicode. לשם כך עליך להוסיף שורה מיד לאחר מתורגמן הפקודה:

# - * - קידוד: UTF-8 - * -

היזהר, חשוב ששורה זו תהיה בתחילת התסריט.

הפוך את התסריט להפעלה

זה מצחיק כמה אנשים מנהלים את התסריטים עם «$ bashscript.sh" במקום "$ ./script.sh'הרי בשביל זה הגדרנו מעטפת.

כדי להוסיף הרשאות ביצוע, עליך לבצע:

sudo + x script.sh

BIN = "תיקיה שבה יש לנו את התסריטים" PATH = "$ BIN $ PATH"

2. מבנה תסריט

1. ראש מיטה
2. הגדרת משתנים גלובליים
3. עזרה
4. פונקציות
5. גוף עיקרי

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

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

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

פונקצית עזרה () {הד "" "טקסט העזרה המעוצב שלנו." "" צא אם [[-z $ 1 || $ 1 == "-h" || $ 1 == "- עזרה"]]; ואז עזרו ל- fi

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

התנאי מציין עזרה בתצוגה על המסך ויציאה אם ​​הסקריפט מופעל ללא פרמטרים או אם מוגדר -h / –help. אם אתה מסתכל על זה, זו ההתנהגות הסטנדרטית של רוב תוכניות הלינוקס.

3. הדפס על המסך

ישנן 2 פקודות עיקריות להדפסה למסך ב- bash: «הד»Wonderfulהדפס«. שניהם מהירים באותה מידה ושניהם חלק מבאס. ההבדל העיקרי למתחילים הוא שהד מוסיף קו חדש בסוף, ואילו «הדפס"לא.

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

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

4. קרא את קלט המשתמש

כל מה שאנחנו כותבים אחרי שם התסריט שלנו ולפני שנלחץ על מקש ENTER נשמר אוטומטית במשתנים מיוחדים. משתנים אלה הם מהסוג $ X כאשר X הוא מספר.

«$0»מציין את שם התסריט שלנו ומתוך«$1»עד אינסוף כל מה שכתבנו מאוחר יותר משתנה. לדוגמה:

חתול << EOF >> test.sh #! / bin / bash # - * - קידוד: UTF-8 - * - printf "\ $ 0 = $ 0 \ n" printf "\ $ 1 = $ 1 \ n" printf "\ $ 2 = $ 2 \ n" EOF chmod + x script.sh ./script.sh my file.txt

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

$ 0 = ./script.sh $ 1 = $ 2 = file.txt שלי

באמצעות ציטוטים יכולנו להעביר את "my file.txt" ל "$ 1".

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

printf "איך קוראים לך? \ n" קרא את NAME printf "שלום, $ NAME. \ n"

5. חישובים בבש

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

בדרך כלל נרצה להקצות את התוצאה של expr למשתנה. אנו יכולים לעשות זאת בשתי דרכים:

VAR2 = `expr $ VAR1 / 10` VAR2 = $ (expr $ VAR1 / 100)

אתה יכול גם לדלג על «ביטוי»שימוש בסוגריים כפולים:

VAR2 = $ (($ VAR1 / 100))

6 תנאים

זה כבר נכתב בצורה נרחבת מאוד על «if«Wonderfulאחר«Wonderfulאליף»ותנאים. אתה יכול לקרוא על כך ב:

• תכנות בבאס: חלק 1
• בש: אם, אם כן, התנאים האחרים
• בדוק אם קובץ או תיקיה קיימים או לא ועוד עם לולאת if
• תכנות בבאס: חלק 2

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

• «&&»עבור ו
• «||»עבור או

להשתמש "&&»Wonderful||»עם סוגריים מרובעים פשוטים, יש להפריד בין כל חלק בסוגריים מרובעים נפרדים. הדוגמה המשמשת עבור החלק של התסריט שנראה אם ​​צריך להיעזר בעזרה תהיה:

אם [-z "$ 1"] || ["$ 1" == "-h"] || ["$ 1" == "- עזרה"]]; ואז עזרו ל- fi

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

אם [$ 1 = 1]; ואז printf "הפרמטר שווה ל- 1."; fi אם ["$ 1" = 1]; ואז printf "הפרמטר שווה ל- 1."; fi אם [[$ 1 = 1]]; ואז printf "הפרמטר שווה ל- 1."; fi

אם script.sh מופעל ללא כל פרמטרים, המקרה הראשון יתן שגיאה:

bash: [: =: צפוי מפעיל unary

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

אם נוסיף «אחר«יהיו לנו גם שני מקרים, אך שני המקרים הללו שונים מהקודמים. מכיוון שעכשיו יהיו שני גושי קוד מותנה, A ו- B, וגוש C, שהוא שאר התוכנית. A או B יבוצעו, ו- C. במקרה הקודם היו A ו- C או רק C.

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

VAR1 = $ 1 אם [[$ VAR1 = 1]]; ואז printf "1 \ n" elif [[$ VAR1 = 2]]; ואז printf "2 \ n" elif [[$ VAR1 = 3]]; ואז printf "3 \ n" אחר printf "none \ n" fi

במקרה של האחרון «אליף»נקרא תנאים רבים. במקרה זה תהליך זה מתייעל:

VAR1 = $ 1 מקרה $ VAR ב- 1) printf "1 \ n" ;; 2) printf "2 \ n" ;; 3 | 4) printf "3 או 4, זה תלוי \ n" ;; *) printf "none \ n" ;; ש- C

משתנה יקרא, במקרה זה VAR1, ונראה אם ​​הוא שווה ערך לכל אחד מהמקרים, אם לא, מקרה ברירת המחדל "*" יבוצע. נקודה-פסיק כפול שווה ערך ל- «לשבור", הם אומרים"מקרה»זה צריך להסתיים.

7. לולאות

מעט מאוד לולאות ידועות בשפת תכנות כלשהי. בבש הם «בזמן«Wonderfulעד»Wonderfulל«. זה כבר נכתב בבלוג על אלה:

• תכנות בבאס: חלק 1
• תכנות ב- Bash: part2

ישנם שני סוגים של לולאות «ל«, אלה מהסוג«$ עבור VAR ב- LOQUESEA»ומה הם מסוג C«$ עבור ((I = 0; I <= 10; I ++))«. הסוג השני של לולאות «ל»מאוד שימושיים, יש לו 3 חלקים בתחילת הלולאה:

• הצהרה והתחלת משתנים (במקרה זה משתנה עזר "I = 0").
• תנאי ביצוע (עד שאני קטן או שווה ל 10).
• הגדלת משתנה העזר

לדעתי זו הלופ הכי חזק מכולם. דוגמה המדפיסה את כל המספרים בין 0 ל -10, כולל:

#! / bin / bash עבור ((I = 0; I <= 10; I ++)); האם printf "$ I \ n" נעשה

8. פונקציות

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

אל תעשה דבר כמו:

#! / bin / bash VAR = 1 printc "$ VAR \ n" פונקציה שלום () {VAR = 2 printf "$ VAR \ n"} שלום printf "$ VAR \ n"

זה מודפס למסך 1, 2 ו -2.

כדי להכריז על משתנים מקומיים, הוסף «מקומי»בעת ההצהרה:

#! / bin / bash VAR = 1 printf "$ VAR1 \ n" פונקציה foo () {local VAR1 = 2 printf "$ VAR1 \ n"} printf "$ VAR1 \ n" foo printf "$ VAR1 \ n"

זה מודפס 1, 1, 2, 1 על המסך.

איך מעבירים פרמטרים לפונקציה?

#! / bin / bash # - * - קידוד: UTF-8 - * - פונקציה שלום () {printf "שלום $ 1 \ n"}

printf "איך קוראים לך? \ n"
קרא VAR1
שלום $ VAR1

כיצד מוחזרים פרמטרים?

#! / bin / bash # - * - קידוד: UTF-8 - * - פונקציה שלום () {printf "שלום הוליטה"} printf "איך קוראים לך? \ n" קרא VAR1 VAR1 = $ (שלום) # הנה זה printf "$ VAR1 $ VAR2 \ n"

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

9. גטופס

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

#! / bin / bash # - * - קידוד: UTF-8 - * - VARC = 0 פונקציה עזרה () {printf "הודעת עזרה \ n" יציאה} אם [[-z $ 1]]; ואז עזור ל- fi בזמן getopts: ha: b: c OPT; לעשות מקרה $ OPT ב- h) עזרה ;; :) עזרה ;; א) VARA = $ OPTARG ;; ב) VARB = $ OPTARG ;; ג) VARC = 1 ;; \?) עזרה ;; esac done # בלוק ראשי של התסריט ש- # עושה דברים עם VARA, VARB ו- VARC

«גטופץ»קורא את האפשרויות אחת אחת, כך שיש צורך בלולאה.

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

• פרמטרים הנקראים דגלים, במקרה זה -c או -h. הם מוגדרים עם האות בה אנו רוצים להשתמש. הם כמו משתנים בוליאניים, «נָכוֹן»(Are) או«שקר"(הם לא כאן).
• פרמטרים עם ויכוחים קשורים, -כל דבר, -ב כל דבר. הם מצוינים באות הרצויה עם נקודתיים למטה. הטיעון נשמר ב- OPTARG (שם זה אינו ניתן לשינוי).

מה התסריט הזה עושה?

מציג את הודעת העזרה כאשר לא עוברת אפשרות, כאשר הפרמטר "-h" מועבר, כאשר פרמטר לא חוקי מועבר (למשל "-x", זה נעשה על ידי "\?") או כאשר א פרמטר חוקי ללא ארגומנט (":"). בשאר המקרים זה שומר את הנוכחות של "-c" כ- 1 ב- VARC, והערכים שעברו עם "-a" ו- "-b" ב- VARA ו- VARB.