נעים להכיר Zsh (Z Shell) המוכר בפי העם זיש.

למי שלא מכיר את Zsh מדובר על מעטפת ללינוקס מקבילה ל Bash.
מה היתרון של Zsh? זיש פשוט ידידותי יותר למשתמש ומתיימר להיות כלי עבודה יעיל יותר.

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

הנה מה שהולך אצלי לאחרונה
סקריפטים: באש
טרמינל: זיש

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

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

ניתוח בעיות בעזרת journalctl --follow

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

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

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

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

להרחיב את יכולות Bash על ידי shopt

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

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

באש שומרת לעצמה כלי הגדרה הקרוי shopts, הרצה של הפקודה תציג לכם רשימה נאה של אפשרויות שרובן אינן מאופשרות.
ההרצה הבאה תפעיל את הפיצ'ר הגאוני autocd שמאפשר כניסה לתיקיות רק על ידי רישום השם שלהם בלי להקיש cd כל פעם (s like set-).
shopt -s autocd

והפקודה הבאה שתשלול מהפיצ'ר את החירות שלו (u like unset-)
shopt -u autocd

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

autocd - כניסה אוטומטית לתיקיות
histappend - שמירת פקודות להיסטוריה מכל חלונות הטרמינל שפתוחות
globstar - הפעלת פקודות גם בתתי היררכיה

למשל פקודה כמו זאת ls **/*.py תעלה תוצאות גם מתיקיות בעומק 5 בהיררכיה


.

לקבל את כל הפרמטרים עם *!

בעבר כתבתי על שימוש ב $! כדי להעביר את הפרמטר האחרון שהשתמשתי בו בפקודה מסוימת לפקודה חדשה.

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

$ touch app.js index.html internal.css
$ echo !$
internal.css

במידה ונרצה לקבל את כל הפרמטרים נוכל להריץ *!
והחלק שבאמת כיף הוא שאפשר להכניס את זה כחלק מפרמטרים אחרים

$ touch app.js index.html internal.css
$ zip test.zip !*
zip test.zip app.js index.html internal.css
updating: app.js (stored 0%)
updating: index.html (stored 0%)
updating: internal.css (stored 0%)

לקבל שמות קבצים עם cut

לעיתים בעבודה על קבצים אנו שומרים את הנתיב המלא אל הקובץ יחד עם שמו, במידה ונרצה לקבל רק את שמות הקבצים ועדין לקבל קוד יחסית קריא נוכל להשתמש בפקודות cut וrev

לדוגמה הנתיב אל הקובץ שלי הוא זה
/tmp/some file.py
ואני מעוניין לקבל רק את שם הקובץ
זוהי הפקודה אותה אריץ ולהלן ההסבר.

echo " /tmp/some file.py" | rev | cut -d/ -f1 | rev

הפקודה cut חותכת טקסט לפי תו שמגדירים לה עם d- במקרה שלנו מדובר על תו /, אנו בוחרים איזה "איבר" להציג על ידי דגל f- ואת האינדקס אותו אנו רוצים, f1- יבחר את המילה הראשונה שלפני ה/ f2- יבחר את השניה וכן על זה הדרך.

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

$ echo "/tmp/some file.py" | rev
yp.elif emos/pmt/

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

אז כן יש כאן מספר תהליכים אבל היי זה עדיף מ regex

להישאר מוגנים תמיד עם גרשיים כפולות

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

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

אבל מה זה לעזאזל IFS?
המשתנה שאחראי במערכת על הערך שמפריד בין פרמטרים קרוי IFS שהוא קיצור של internal field separator, ברירת מחדל של הערך הוא רווח, טאב ושורה חדשה (דבר שאפשר לשנות כמו כל השמה למשתנה).

$ printf %s "$IFS" | od -vtc -to1
0000000 \t \n
040 011 012
0000003


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

נכון אפשר להגדיר את את IFS שיפצל על פי שורה חדשה אבל היי למה לא לעבוד קל

למצוא עזרה

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

הפקודה man ישנה יחסית והיא מבוססת על פקודות more | less שיודעות לקחת טקסט ארוך ולחלק אותו לתצוגה על המסך, ומאפשרת לחפש טקסט על ידי / וכתיבת הביטוי החיפוש.

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

ישנם פקודות בסיסיות שלא תמצאו להן תיעוד לא עם man ולא עם info


$ man fg
No manual entry for fg

הסיבה היא שהן פקודות שהן build in של bash, בשביל לקרוא תיעוד על הפקודות הללו יש את פקודה help שגם היא איך לא פקודה מובנת של bash.

$  help fg
fg: fg [job_spec]
    Move job to the foreground.
    
    Place the job identified by JOB_SPEC in the foreground, making it the
    current job.  If JOB_SPEC is not present, the shell's notion of the
    current job is used.
    
    Exit Status:
    Status of command placed in foreground, or failure if an error occurs.

פקודות build in הן פקודות שזמינות גם אם המערכת ריקה לגמרי ושום כלי אחר לא זמין לה, בין הפקודות אפשרי למצוא את cd, shopt, fg, history ועוד, ניתן לראות את הרשימה המלאה על ידי הרצה של
help -d

@bash_tips

לסלול נתיב עם readlink

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

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

$  readlink -m ///tmp///123//Bswap_HPBake/
/tmp/123/Bswap_HPBake

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

@bash_tips

לאחד ניתובים עם <&

קונספט שרץ בלינוקס אומר שיש כמה ערוצי תקשורת למכונה

0 = stdin - ערוץ בו עובר הקלט למכונה
1 = stdout - ערוץ אליו נשלח הפלט הסטנדרטי
2 = stderr -  ערוץ אליו נשלחות השגיאות

המיפוי הזה מיוצג הרבה מהמקרים על ידי תווי redirection בצורה הבאה
< stdin
> stdout
2> stderr
עד כאן הכל ידוע ומוכר
כשכותבים סקריפט הרבה פעמים נרצה לשמור שגיאות במידה והן קיימות על ידי ה-redirection

$ ls directory_that_not_exist 2> error.log

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

$ ls /tmp/ /directory_that_not_exist > /dev/null

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

$ ls /tmp/ &> /dev/null

@bash_tips

עדכון:
1 באפריל שמח לכולם

מי שאהב ורוצה להגיש את זה כהצעה לפיתוח יש עוד פיצ'רים כמו זה שברגע שהפקודה השניה נכשלת אז גם הפקודה הראשונה מבוטלת :-)

הפוסט המקורי
פיצ'ר חדש command brace expansion

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

$ touch deploy_{DEV,PROD}.yml
deploy_DEV.yml
deploy_PROD.yml

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

$ {mkdir,cd} my_new_directory
mkdir my_new_directory
cd my_new_directory

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

@bash_tips

אפשר להמשיך yes

פקודה נחמדה בשם yes מאפשרת לנו להעביר את הערך yes כשמשתמשים בפקודות ששואלות את המשתמש אם הוא מאשר משהו או לא [Y/N]
דוגמה טובה תמחיש את העניין

$ yes | sudo apt-get install ffmpeg

בשלב הזה שהפקודה ממתינה לקלט מהמשתמש יועבר לה הערך yes

After this operation, 2,489 kB of additional disk space will be used.
Do you want to continue? [Y/n]

@bash_tips

לקבל סטטוס הרצה עם ?$ echo

כשמריצים פקודות בטרמינל קל לנו לראות אם הפקודה הצליחה או נכשלה, כשאנו מריצים את הפקודה דרך סקריפט ואנו רוצים חיווי אם התהליך שהרצנו הסתיים בהצלחה אפשרי להשתמש ב echo ?$ ולפי זה לקבוע את המשך ריצת הסקריפט
$ ls /opt/
brother containerd CyberGame
$ echo $?
0
$ ls /aaa
ls: cannot access '/aaa': No such file or directory
$ echo $?
2

סטטוס 0 מייצג תוכנית שהסתיימה בהצלחה סטטוס 1 או 2 מייצגים תוכנית שנכשלה, סטטוס ריק מייצג תוכנית שלא רצה.

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

$ [ 44 -eq 44 ]; echo $?
0
$ [ 44 -eq 60 ]; echo $?
1

@bash_tips

קיצורים ל-Default values

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

exist_variable="some text here"

תעביר את הפלט 123 אם המשתנה לא קיים

$ echo ${not_exist_variable:-123}
123

תעביר את הערך 123 אם המשתנה כן קיים
$ echo ${exist_variable:+123}
123

השמת ערך למשתנה אם הוא לא קיים

$ echo ${exist_variable:=123}
some text here
$ echo ${not_exist_variable:=123}
123

מחזיר ערך כשגיאה אם המשתנה לא קיים

$ echo ${not_exist_variable:?"variable not set"}
bash: not_exist_variable: variable not set

@bash_tips

עבודה עם עם לולאות

ישנם מספר סוגי לולאות בבאש לכל אחת תפקיד שונה
בשביל לרוץ על קבצים ולבצע עליהם פעולה כלשהי אפשר להשתמש בפקודה find אבל אפשר להשתמש בלולאה שמקבלת את הקבצים כאיטרטור

for i in /projects/*.py; do
echo $i
done

החלטתם להשתמש בלולאה על תוכן שצריך להיות מחולק לפי שורות? אולי תרצו להשתמש בלולאת raed while

cat lorem.txt | while read line; do
echo $line
done

סתם יש לכם טווח שאתם רוצים לרוץ עליו?

for i in {1..100}; do
echo "Number $i"
done

אההה עם דילוגים

for i in {1..100..5}; do
echo "steps $i"
done

כן יש גם את לולאה נוסח C like

for ((i = 0 ; i < 100 ; i++)); do
echo $i
done

ובשביל הכיף אפשר להעביר אורך של משתנה כמספר עם {mystring#}$ ולעשות אנימציה מגניבה

mystring="some text here "
for ((i=0; i < ${#mystring}; i++)); do
echo -en "${mystring::i} \r"
sleep 0.2
done

@bash_tips

לעבוד במיקום יחסי עם dirname

כתבנו סקריפט הוא מדהים והוא רץ, הנה כך הוא נראה
$ cat test.sh
#!/bin/bash

touch new_file.txt
נריץ אותו
/tmp/project $ bash test.sh
/tmp/project $ ls
new_file.txt test.sh

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

/tmp/project $ cd /tmp/other_project
/tmp/other_project $ bash /tmp/project/test.sh
/tmp/other_project $ ls
new_file.txt

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

בשביל לקבל את תיקיית הסקריפט ולא משנה מאיפה הסקריפט מורץ אפשר להשתמש בפקודה dirname ובשרשור הפרמטר הראשון שסקריפט שרץ מקבל הלא הוא שמו 0$

$(dirname $0)

אז כרגע כך נראה הקובץ שלנו

/tmp/other_project $ cat /tmp/project/test.sh
#!/bin/bash

touch "$(dirname $0)/new_file.txt"

ונריץ

/tmp/other_project $ bash /tmp/project/test.sh
/tmp/other_project $ ls
/tmp/other_project $ ls /tmp/project
new_file.txt test.sh

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


@bash_tips

תודה לכל המפרגנים
חברים שרוצים לשלוח טיפים מוזמנים לשלוח בקבוצה עם האשתג #bashtips

פייתון ושפות סקריפטים
למידה ועזרה בפייתון ושאר סקריפטים
https://t.me/python_he

לרוץ מקבילי בבאש עם parallel

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

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

sudo apt install parallel

נהדר, אז איך זה עובד

cat links.txt | parallel {}

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

/tmp$ cat links
https://google.com

/tmp$ cat links | parallel "echo {} \| {}"
https://google.com | https://google.com

טוב דוגמה יותר שימושית, יש לי קובץ שמכיל רשימת לינקים להורדת קבצי mp3, אז להוריד אני יודע, משתמשים עם wget יאללה נראה איך זה רץ

cat links | parallel wget {}

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

טוב זה נחמד אבל איך אני הופך את הסקריפט שלי שירוץ מקבילי

parallel -a myscript

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


אופציות שכדאי להכיר

parallel -0 יעביר קלט עם רווחים ותווי בקרה בבטחה
parallel -k ישמור על סדר ההרצה

יש עוד הרבה פיצ'רים לכלי ושווה לקרוא עליו יותר

@bash_tips

🍷🍷 פסח כשר ושמח לכולם 🍷🍷
נחזור ביום ראשון עם פוסטים חדשים
תשמרו על עצמכם

מילונים / מערכים אסוציאטיבים ובאש

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

$ declare -A my_dict
$ my_dict=(["First Name"]="Yossi" ["Last Name"]="Cohen")
$ echo ${my_dict[First Name]}
Yossi
$ echo ${my_dict[Last Name]}
Cohen

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

$ my_dict=(["ListA"]=some text here)
bash: my_dict: text: must use subscript when assigning associative array
bash: my_dict: here: must use subscript when assigning associative array

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

$ my_dict=(["ListA"]="some text here")
$ real_dict=( echo ${my_dict["ListA"]} )
$ echo "${real_dict[0]}"
some
$ echo "${real_dict[1]}"
text
$ echo "${real_dict[2]}"
here

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

ואוו מדהים, מגניב, זה ממש עובד, איזה יופי. רגע מה, רק שניה תעצור הכל
מה בעצם קורה אם אני רוצה מספר מילים כערך אחד?
משהו כזה
[some, text here, more text here]

במקרה כזה נוכל להגדיר חוצץ על פיו נבצע את ההפרדה לאיברים

IFS=","
my_dict=(["ListA"]="some, text here, more text here")
real_dict=(echo ${my_dict["ListA"]})
echo ${real_dict[1]}
echo ${real_dict[2]}
echo ${real_dict[3]}

some
text here
more text here

מה הפתרונות שלכם?
אשמח שתשתפו בתגובות
@bash_tips