למצוא את הדרך
רמת קושי: #beginners

כאשר אנחנו מריצים פקודה כגון

$ curl example.com

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

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

/usr/bin/curl example.com

הדרך שבה PATH עובד הוא שאם מוגדר לנו

PATH="/foo:/bar"

ואנחנו מנסים להריץ משהו שנקרא curl, אז המערכת תחפש את הבינארי curl קודם בfoo ואחר"כ בbar, במידה והיא מצאה בfoo את הבינארי, המערכת תריץ את curl שבתוך foo, ואפילו לא תחפש את curl בתוך bar.

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

curl: command not found

אפשרי להוסיף תקיות משלנו ע"י לשים שורה כזאת בתוך .bashrc

export PATH="/path/to/my/scripts/dir:$PATH"

ככה אנחנו יכולים להוסיף לPATH תקיות מבלי לפגום בשימוש הסדיר של המערכת


#env_variable
#path

@bash_tips

שבאנג!
רמת קושי: #beginners

כאשר אנחנו מריצים סקריפט שכתבנו ע"י:

$ ./some_ambiguous _script

בברירת המחדל המערכת תריץ את הקובץ באמצעות bash (יש כמה מקרים שבהם זה לא קורה, אבל זה מחוץ לscope של הפוסט), והדרך לשנות את ההתנהגות הדיפולטיבית היא שימוש במשהו שנקרא shebang, הshebang תמיד יופיע בתחילת הקובץ והוא יראה כך:

#!/path/to/interpreter

אפשרי להסתכל על זה בצורה הבאה:
אם יש לנו קובץ ששמו הוא "cool_script" והתוכן שלו הוא:

#!/usr/bin/python3
print("This script was executed via python3")

ואנחנו מריצים אותו ע"י:

$ ./cool_script

מה שבעצם מורץ מאחורי הקלעים זה:

$ /usr/bin/python3 cool_script

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

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

#!/bin/bash -x

אשר תגרום לסקריפט להדפיס כל דבר שהוא עושה (עוזר לדיבוג).

עוד "סוג" של shebang נפוץ הוא הshebang:

#!/usr/bin/env foo

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

#!$(which foo)

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

#!/usr/bin/env bash -x

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


קרדיט: תודה לשחר @bananabun האלוף!

#shebang
#execute_script

@bash_tips

להעביר שגיאות ב pipe
רמת קושי: #beginners

דבר קטן וחשוב שכדאי להכיר
כולנו מכירים את השימוש ב pipe בבאש, להעביר פלט של פקודה אחת לפקודה אחרת, מה שלא כולם יודעים זה שpipe מעביר רק stdout ולא stderr

$ ls /not_exist | wc -l
ls: cannot access /not_exist: No such file or directory
0

כפי שרואים השגיאה הודפסה ישירות לטרמינל ופקודת wc לא קיבלה שום פלט (ערך 0)

איך כן?
בכדי להעביר גם את stderr וגם את stdout דרך ה pipe צריך להריץ את ה pipe בצורה הבאה עם &

$ ls /not_exist |& wc
1 9 50


#pipe
#redirection

@bash_tips

לאגד ולכווץ, tar
רמת קושי: #beginners

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

כדי להכין קובץ tar (שלפעמים מכנים אותו "tarball"):

$ tar -c -f output.tar path/to/dir/

כדי לחלץ את המידע:

$ tar -x -f output.tar

הסיבה לכך שtar כלכך שימושי, היא שכיווץ פועל על קבצים ולא על תיקיות, מה שאומר שכן אפשרי לכווץ את קובץ הtar.

בגלל שהמטרה העיקרית של tar היא לאפשר לכווץ תיקיות, המפתחים של tar הכניסו בפנים את האפשרות לכווץ את ה tarball עם אלגוריתמים נפוצים כגון Bzip, Zstd ועוד. כך שבמקום לכתוב:

$ tar -c -f output.tar path/to/file path/to/dir && gzip output.tar

אפשר לכתוב:

$ tar -z -c -f output.tar.gz path/to/file path/to/dir

וכדי לחלץ את ה tarball המכווץ אפשר לעשות:

$ tar -z -x -f output.tar.gz


קרדיט: תודה לשחר @bananabun האלוף על הפוסט.

#tar
#archives
#compression

@bash_tips

לכתוב תנאים
רמת קושי: #beginners

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

if [[ 1 -eq 1 ]]
then
echo "I'm in"
fi

התנאי בודק את הביטוי ואם הוא true מה שבתוך התנאי יתממש.

חשוב לציין, תנאי בבאש לא מחזיר true או false אלא 0 ששוה בעצם לtrue ו 1 ששוה ערך ל false. התנהגות זו שונה מרוב שפות התכנות והסיבה לכך היא שרוב העבודה בבאש היא שימוש בהרבה תוכניות קטנות לבצע מטלה גדולה יותר כך שהתנאי בעצם בודק את הסטטוס קוד שהתוכנית מחזירה, סטטוס קוד 0 שווה לתוכנית שהסתיימה בהצלחה.
(למען הנוחות מכאן והלאה אתייחס ל 0 כ true ו 1 כ false)


קיצורים רבותיי
ישנה דרך מקוצרת לכתוב תנאי

[[ 1 -eq 1 ]] && echo "do it"

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

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

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

if [[ 1 -eq 0 ]]
then
echo "I'm in"
fi
echo $?

$ bash /tmp/test.sh
$ echo $?
0

שימוש בתנאי מקוצר מחזיר סטטוס קוד 1 במידה והביטוי החזיר false

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

[[ 1 -eq 0 ]] && echo "Do it"

$ bash /tmp/test.sh
$ echo $?
1

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


#if
#exit_code
#conditions

@bash_tips

לכתוב תנאים - הרחבה
רמת קושי: #beginners

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

סוגריים עגולים כפולים (( ))
סוג תנאי שעובד רק על מספרים ומתאים לבדיקת פעולות חשבוניות.

if (( 1 == 1 )); then
...

פקודת test
פקודה הבודקת ביטויי השוואה ממש כמו if, מחזירה true ל0 וfalse לכל מה שאינו 0

test 1 -ne 0
test string1 = string2
test -n string
...

סוגרים מרובעים בודדים [ ]
פקודה המבצעת בדיוק את את אותן פעולת שמבצעת פקודת test, ההבדל היחידי בין השניים הוא שפקודת test תגיב לדגלי --help, ו --version



if [ 1 -ne 0 ]
if [ string1 = string2 ]
if [ -n string ]

סוגריים מרובעים כפולים [[ ]]
חשוב לשים לב שמשתמשים ותיקים עלולים לתהות מה ההבדל בין [ ל‏ [[.
ובכן, בעוד הראשון הוא לעתים פקודה בפני עצמה (מקבילה ל־test)

$ whereis [


[: /usr/bin/[ /usr/share/man/man1/[.1.gz 

השנייה היא רק פקודה מובנית ב‏־shell ונותנת לנו יכולות מתקדמות יותר.
למשל, במקום -eq כדי לבחון שיוויון, אפשר להשתמש בסימן שיוויון נורמלי.

if [[ 1 -eq 1 ]]
לעומת
if [[ 1 = 1 ]]

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

if [ -f "$filename" ]
לעומת
if [[ -f $filename ]]

כבונוס, ישנו את האופרטור החשוב =~ המאפשר להשתמש בביטויים רגולריים ישירות מתנאי ההשוואה, וכך לחסוך ביטויים לוגיים מורכבים.

אופרטור =~ מה חשוב לדעת?
חשוב רק לציין שבמידה ומשתמשים באופרטור ההשוואה =~ יש הבדל בין משתנה העטוף בגרשיים (להלן מגורגש) לכזה שאינו, ברגע שמעבירים לתנאי משתנה מגורגש הביטוי מחפש את כל מחרוזת הטקסט שבמשתנה בצורה גולמית ולא מנסה להשוות את המשתנה כביטוי regex

$ cat file.txt


111+.*pdf{}[]$

$ [[ $(cat file.txt) =~ "pdf{}" ]] && echo match


match

$ [[ $(cat file.txt) =~ pdf{} ]] && echo match
$ echo $?


1

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


קרדיט: תודה רבה לתומר @tomer מקבוצת @linux_il על הפוסט! (אז מה אם הוא השתנה מעט)
למי שלא מכיר קבוצת לינוקס ישראל היא אחת הקבוצות היותר טובות והיותר פעילות בטלגרם (כל עוד לא מדברים על קאלי).


#[
#if
#test
#regex
#conditions

@bash_tips

שימוש בsed עם extended regex
רמת קושי: #beginners

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


בכדי לאפשר extended regex לsed ניתן להשתמש בדגל -E או -r



$ sed -E 's/something_(aaa|bbb|ccc)//g

#sed
#regex
#extended_regex

@bash_tips

מפות ומערכים
רמת קושי: #beginners

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

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

$ mapfile < myfile
$ echo ${MAPFILE[@]}
one
two
three

במידה ונעביר שם של משתנה התוכן יכניס למשתנה אותו העברנו

$ mapfile mylist < myfile
$ echo ${mylist[@]}
one
two
three

כפי שניתן להעביר קובץ, ניתן גם להעביר תוכן של משתנה למערך על ידי שימוש ב here-string

$ mapfile mylist <<< "$myvar"

$ echo ${mylist[@]}
one
two
three


#array
#mapfile
#readarray

@bash_tips

מערכים ומפות read
רמת קושי: #beginners

בפוסט הקודם דיברנו על פקודת mapfile / readarray ואיך יהיה נכון יותר ליצור מערך של שורות מקובץ מבלי לבצע פעולות שלא אליהן התכוונו, מה אם מה שאנו צריכים זה ליצור מערך של מילים משורה בודדת?

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

$ myline="one two three"
$ read -a mylist <<< "${myline}"
$ declare -p mylist
declare -a mylist='([0]="one" [1]="two" [2]="three")'

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


#read
#array

@bash_tips

פוסט יפה ומפורט מאוד של טל בן שושן על באש
רמת קושי: #beginners

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

@bash_tips

לחפש כשמכווץ zgrep
רמת קושי: #beginners

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

$ zgrep crash /var/log/syslog*
/var/log/syslog.4.gz ...
/var/log/syslog.5.gz ...
/var/log/syslog.9.gz ...
...

#archives
#zgrep
#grep
#zip

@bash_tips

סומסום היפתח
רמת קושי: #beginners

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

$ code myfile.log

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

$ k get pod/lala -o yaml | code -

כעת העורך מחבר את הstdin לפקודה והתוכן אפילו יכול להתעדכן בזמן אמת
(לא לשכוח Ctrl+C כשרוצים לסגור את החיבור)

$ journalctl -f | code -


#clipboard
#vscode
#code
#stdin

@bash_tips

להעתיק
רמת קושי: #beginners

בלא מעט מערכות יש כלי שורת הפקודה שמאפשר להעתיק פלט בטרמינל ישירות לתוך ה clipboard.
בווינדוס למשל ניתן להשתמש ב clip

c:\> dir | clip 

ובמאק יש את פקודת pbcopy

$ echo bla bla bla | pbcopy

מה קורה אם כך בלינוקס?
משתמשי זיש יכולים להשתמש בפקודת clipcopy

$ cat ~/.ssh/id_rsa.pub| clipcopy

משתמשי באש לעומת זאת שרוצים לממש יכולת דומה צריכים להגדיר את ה alias הבא (שזה אגב בדיוק מה שעושה זיש)

$ alias clipcopy="xclip -selection clipboard"

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

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

$ alias clipcopy="tee >(xclip -selection clipboard)"

נ.ב. בכל מה שקשור ללינוקס ישנה תלות של כלי xclip שצריך להיות מותקן במערכת


#copy
#xclip
#clipboard

@bash_tips

טיפ קצר וחביב להתנהלות בטרמינל
רמת קושי: #beginners

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

לשם כך ישנו הקיצור Alt + Shift + # שכל מה שהוא עושה זה לקחת את הפקודה שרשמנו ולהריץ אותו כהערה כך שלאחר מכן ניתן יהיה לשלוף את ההערה מההיסטוריה ולהריץ אותה כפקודה.


#terminal
#shortcuts
#comments

@bash_tips

יותר less
רמת קושי: #beginners

פקודת less מאפשרת להדפיס קבצים למסך, זהו בערך השימוש הבסיסי שכולם מכירים, מה שלא ממש מכירים אלו הפיצ'רים הנוספים שהכלי מביא איתו

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

הקשה על !ls יריץ את הפקודה בטרמינל ויחזיר אותנו חזרה לקובץ שפתוח ב less


מומלץ להריץ less --help כדי להכיר אלו עוד אפשרויות ופיצ'רים הכלי מאפשר


תודה לליאור קיסוס האלוף על הטיפ


#less
#vim

@bash_tips

איך לכתוב באש ומתי
רמת קושי: #beginners

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

לדוגמה

# Use this

if (( my_var > 3 )); then
do_something
fi

if [[ "${my_var}" -gt 3 ]]; then
do_something
fi


# Instead of this
# Probably unintended lexicographical comparison.
if [[ "${my_var}" > 3 ]]; then
# True for 4, false for 22.
do_something
fi

הדף מופיע כחלק מפרויקט רחב יותר של גוגל בשם Google Style Guides שם תוכלו למצוא עוד המון הערות בקשר לשפות אחרות כמו go, python, c וכו'


#shellguide
#scripting
#rules

@bash_tips

לחלק נכון, awk
רמת קושי: #beginners

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

one two three
one two three
one two three

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

$ cat output | cut -d " " -f2
two
two
two
אחלה, עובד מעולה

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

docker ps | cut -d " " -f 2

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

איך כן?
בכדי לפתור את הבעיה הזאת יהיה קל יותר להשתמש ב awk כדי לפצל פלט

docker ps | awk '{print $2}'

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


#cut
#awk

@bash_tips

לשרשר ולספור PIPESTATUS
רמת קושי: #beginners

הזכרנו בעבר ששימוש ב pipe מתסיר את הקוד יציאה של הפקודה שרצה לפני הpipe
לדוגמה הפקודה הבאה תחזיר קוד יציאה 0 למרות שהפקודה הראשונה נכשלה

$ ls /not/exist/path | echo 123
123
ls: cannot access '/not/exist/path': No such file or directory

$ echo $?
0 

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

$ ls /not/exist/path | echo 123 | grep -o 2 
ls: cannot access '/not/exist/path': No such file or directory
2

$ declare -p PIPESTATUS 
declare -a PIPESTATUS=([0]="2" [1]="0" [2]="0")

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


#pipe
#env_variable
#exit_code

@bash_tips

לסדר ולהשוות כמו בן אדם sort
רמת קושי: #beginners

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

$ {
echo 2
echo 3
echo 0
} | sort

והפלט

0
2
3

להלן 2 דברים חביבים ממש שהפקודה מאפשרת

פילטור בשפה של בני אדם
לפלטר לפי מספרים או אותיות זה קל, מה קורה אם רוצים לפלטר מידע שמבוסס על נפח של קובץ / מקום?
בדומה לפקודות אחרות שימוש בדגל -h יאפשר לפלטר תוכן שמבוסס על נפח כמו K M G T P וכו' (aka human-readable)

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

$ du -h | sort -h

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

$ df -h | sort -hk2

לצורך הדוגמה הסרתי את שאר הטבלה אך כעת ניתן לראות שהתוכן של פקודת df יוצג לנו מפולטר על פי העמודה השניה היא עמודת Size

Size
497M
2.7G
14G
86G
200G

למה זה חביב ממש?
כי כרגע ניתן ליצור פונקציית השוואה לפי משקל קובץ, מבלי להמיר את הערכים למספרים אלא פשוט להשוות 3M < 9G, אכן לא ככה כותבים קוד אבל היי, זה עובד.


#sort
#human_readable

@bash_tips