לפצל ולאחד קבצים עם split ו cat
רמת קושי: #beginners

מכירים את זה שקבלתם לידכם התקן USB כדי להעביר אליו איזשהו קובץ גדול?
ואז בדיוק ברגע השיא כשפעולת העתקה כמעט מסתיימת אתם מגלים שמערכת הקבצים של הכונן היא FAT, ולכן העתקה נכשלת כי לא ניתן להעתיק קבצים מעל 4GB. לא כיף

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

$ split -b 2G my_file.mp4 my_file_part-

מה בעצם יש לנו כאן?
דגל b- מאפשר לפצל לפי גודל (K/M/G), שם הקובץ עליו אני רוצה לפעול, ומהו השם התחלתי של הקבצים שיפוצלו.
זה נראה כך.

$ ls
my_file.mp4
my_file_part-aa
my_file_part-ab

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

$ split -b 2G my_file.mp4 my_file_part -a 1
$ ls
my_file.mp4
my_file_part-a
my_file_part-b

אפשרויות נוספות הן
חלוקה לפי מספר החלקים ולא לפי גודל הקובץ בעזרת דגל n-.
שימוש במספרים במקום באותיות בעזרת הדגל --numeric-suffixes.
פיצול קבצי טקסט לפי מספר השורות לקובץ (l-).


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

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

$ cat my_file_part-* > my_new_file.mp4
$ ls
my_file.mp4
my_file_part-a
my_file_part-b
my_new_file.mp4

לא מאמינים שזה אותו הקובץ בדיוק בלי שום שינויים?
נוכל לאמת את זה עם גיבוב של md5 לשני הקבצים

$ md5sum my_file.mp4
f86e0306d4c2a4fd3f18edd1a199a840 my_file.mp4

$ md5sum my_new_file.mp4
f86e0306d4c2a4fd3f18edd1a199a840 my_new_file.mp4


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

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

#split
#cat

@bash_tips

צ'יט שיטס
רמת קושי: #beginners

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

כלי מעולה בשם cheat.sh מאפשר לחפש תזכורות וטיפים לאיזה שפת תכנות שתבחרו, יש רשימה יפה מאוד של שפות, dbs, ופקודות שנתמכות והכי נחמד שלא חייבים להתקין כלום.

השירות מאפשר לתשאל את השרת בקשר לפקודות ישירות מהקונסול על ידי בקשת curl פשוטה

$ curl cht.sh/grep

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

$ curl cht.sh/python/grep

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

$ curl cht.sh/:list
$ curl cht.sh/python+print+vertical

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

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

$ echo 'cht() { curl cht.sh/$1; }' >> ~/.bashrc && source ~/.bashrc

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

$ cht ssh
$ cht wget/file

#bashrc
#tools

@bash_tips

להכיר נקודה
רמת קושי: #beginners

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

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

$ . myenv


#source

@bash_tips

לקרוא בשקט read
רמת קושי: #beginners

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

$ read -p "print something: " myvar
print something: something
$ echo $myvar
something

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

$ read -sp "print something: " password
print something:
$ echo $password
invisible text

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

#read
#passwords

@bash_tips

להוציא לפועל מחרוזת
רמת קושי: #beginners

בעבר דיברנו על כלים שבאש מספקת לנו כדי לפרסר תוכן של משתנים בעת הקריאה אליהם היום נפגוש את bash Parameter transformation

להלן המחרוזת שלנו, כמו שרואים היא מכילה תווי בקרה, תווי שליטה בשורת הפקודה (Controlling the Prompt) ומחרוזת עטופה בגרש

$ mystring="\narrow\nice\n\d\n\h\n'qoute'"

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

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

$ echo "${mystring@Q}"
'\narrow\nice\n\d\n\h\n'\''qoute'\'''

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

$ echo "${mystring@E}"

arrow
ice
\d
\h
'qoute'

אופרטור P יציג גם את תווי השליטה של שורת הפקודה, במקרה שלנו הם \d ו \h

player@playground:~$ echo "${mystring@P}"

arrow
ice
Sat Aug 01
playground
'qoute'


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

$ cat myfile.sh
echo "${*@P}"

$ bash myfile.sh "\d" "\h"
Sat Aug 01 playground


#parameter_transformation
#variable
#string

@bash_tips

לספור תווים/שורות/מילים בקובץ wc

הפקודה WC נותנת מידע על תוכן הקובץ כגון כמות תווים, כמות שורות, כמות בייטים, וכו'.

דוגמה:
הקובץ file.txt מכיל

Hello World.
Welcome to my channel.

שימוש:

user@tryit-immortal:~$ wc file.txt
2 6 34 file.txt

כאשר 2 זה מספר השורות, 6 זה מספר המילים, 34 זה מספר התווים, ולסיום שם הקובץ.
כאשר אני אקרא ל wc עם הדגל -w
(או לחילופין words--) אני אקבל 6. שזה כמות המילים.

כאשר אני אקרא ל wc עם הדגל -l או --lines אני אקבל את מספר השורות.

כאשר אני אקרא ל wc עם הדגל -m
(או לחילופין --chars) אני אקבל את מספר התווים

עוד דגלים:
-c, --bytes - לקבלת כמות הבייטים
-L, --max-line-length - לקבלת האורך של השורה הארוכה ביותר.

כמובן אפשר להפנות קלט באמצעות pipe במקום קובץ
ls | wc לדוגמה

📢 קיצורים רבותיי, קיצורים
רמת קושי: #beginners

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

מעלה היסטוריה אבל רק לפרמטרים בלי הפקודות.
Alt+.
או
Esc+.

מעביר את הסמן לתחילת השורה וחזרה לסוף השורה, וחוזר חלילה. להתראות Ctrl + A \ E
Ctrl+XX

פורס את הביטוי שנכתב לשורת הפקודה, כך למשל ניתן לראות מהו ה alias ומהי הפקודה בהיסטוריה שהולכת לרוץ, או להציג את מה ש !$ הולך להעביר.
Ctrl+Alt+e

בגלל כמות האליאסים בזיש הקיצור לתכונה הזאת הוא , Ctrl+x a
בכללי את כל הקיצורים של זיש תוכלו למצוא בפקודה bindkey.


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

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

$ bind -P | grep "can be found" | sort | awk '{printf "%-40s", $1} {for(i=6;i<=NF;i++){printf "%s ", $i}{printf"\n"}}'

abort "\C-g", "\C-x\C-g", "\e\C-g".
accept-line "\C-j", "\C-m".
backward-char "\C-b", "\eOD", "\e[D".
backward-delete-char "\C-h", "\C-?".
backward-kill-line "\C-x\C-?".


רוצים יותר הסברים על כל קיצור ומה הוא יכול לעשות?

$ man bash | awk '/^ Commands for Moving$/{print_this=1} /^ Programmable Completion$/{print_this=0} print_this==1{sub(/^ /,""); print}'

Commands for Moving
beginning-of-line (C-a)
Move to the start of the current line.
end-of-line (C-e)
Move to the end of the line.
forward-char (C-f)
Move forward a character.

#shortcuts
#bind

@bash_tips

נקודה צפה
רמת קושי: #beginners

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

בכדי לבצע פעולות אריתמטיות בבאש ניתן להשתמש בפקודת expr, bc, let או לעטוף את הביטוי ב (())$
$ expr 5 + 4
9
$ let add=5+5 ; echo $add
10
$ echo $((5*3))
15
$ bc <<< '4 * 2'
8

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

$ let float=5/2 ; echo $float
2
$ expr 5 / 2
2
$ echo $((5/2))
2
$ bc <<< '5 / 2'
2

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

פקודת bc יודעת להחזיר ערך בעל נקודה צפה על ידי שימוש בדגל -l רק שהיא מחזירה אותו בצורתו מלאה

$ bc -l  <<< 5/2  
2.50000000000000000000

בכדי לשלוט על אורך השבר שמוצג נוכל להגדיר זאת על ידי שימוש במשתנה scale.

$ bc <<< "scale=2; 5/2"
2.50

את ה awk אנו מכירים וכן הוא יודע חשבון

$ awk "BEGIN {print 5/2}"
2.5

ניתן ליצור מביטוי ההוק alias על ידי השמה של $* וכך להשתמש בו כפקודה לכל דבר.
את אותו רעיון ניתן לעשות כמובן עם כל אינטרפטר אחר שזמין במערכת כמו פייתון, php, node וכו'

$ echo 'calc(){ awk "BEGIN { print $*}"; }' >> ~/.bashrc
$ calc 5/2
2.5

עריכה: תודה לגולן על ההערה, הטריק הבא לא יעבוד בבאש אלא רק בזיש

$ echo $((5.0/2))
2.5

בבאש נעשה זאת כך

$ printf %.2f\\n $((5/2))
2.50

#arithmetic_expression
#expr
#awk
#let
#bc

@bash_tips

# כמה טיפים מדליקים לשימוש בפקודה date
הפקודה date היא האולר השוויצרי של המרות תאריכים. היא תעזור לנו להשתתף בכנסים ואירועי תרבות מכל העולם (כי תמיד נוכל לזהות באיזה שעה הם מתקיימים בשעון המקומי שלנו) ולבצע חישובים עם זמנים בלי לעזוב את שורת הפקודה. הנה כמה מהשימושים שאני אוהב ל date:

## מה השעה עכשיו באיטליה?
מי אמר שעון עולמי ולא קיבל? דייט יודעת להמיר את השעה לכל אזור זמן בעולם ובצורה פשוטה. אם אתם יודעים את קוד איזור הזמן שאתם צריכים פשוט תכתבו אותו לפני date בצורה הבאה:

TZ='Europe/Rome' date

ואם אתם לא יודעים תמיד אפשר להשתמש ב tzselect.

## באיזה שעה לפי שעון ישראל יתקיים אירוע מסוים בזום?
בואו נניח שיש כנס בין לאומי גדול בדיוק על הטכנולוגיה שאתם אוהבים והוא יעבור בשידור חי ביוטיוב. הכנס יתקיים בניו יורק ביום שלישי ה 1/9 בשעה 18:00 בערב. אבל רקע, מתי זה בשעון ישראל? נו, מזל שיש date:

date --date='TZ="America/New_York" 2020-09-01 18:00'

והתוצאה:

Wed 02 Sep 2020 01:00:00 IDT

גדול - עכשיו אפשר לכוון את השעון.

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

הפקודה הבאה מתחילה גיבוי חדש ומתזמנת אותו לפעול בעוד עשר דקות:

echo run job=BackupClient1 when=\"$(date --date @$(( $(date +%s) + 600)) "+%F %T")\"| sudo bconsole

איך זה עובד?

הפקודה הראשונה date +%s מדפיסה את הזמן בשניות מאז ה 1/1/1970. אני מוסיף 600 לפלט שלה (כי 600 שניות זה עשר דקות) ומעביר את התוצאה בתור תאריך קלט ל date. בנוסף אני מבקש מ date להדפיס את התאריך בפורמט ש bconsole מבינה ואת כל זה מעביר לפרמטר when שקובע מתי להתחיל את הגיבוי.

החיבור בין הרצת פקודה בתוך שורת הפקודה ופעולות חשבון בתוך שורת הפקודה עוזר לבצע את החישוב בקלות.

לחזור למקורות alias, command, \
רמת קושי: #beginners

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

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

$ alias date='date +"%d/%m/%Y"'
$ date
30/08/2020

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

$ alias -p
alias fgrep='fgrep --color=auto'
alias grep='grep --color=auto'
alias l='ls -CF'
...

או לראות alias לפקודה ספציפית

$ alias download-mp3
alias download-mp3='youtube-dl -t -c -x --audio-format mp3 '

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

$ date +"%Y/%m/%d"
date: extra operand `+%d/%Y/%m'
Try 'date --help' for more information.

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

$ date +"%d/%m/%Y" +"%Y/%m/%d"

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

הראשונה היא על ידי הוספת תו \ לפני הפקודה

$ date +"%d/%Y/%m"
date: extra operand `+%d/%Y/%m'
Try 'date --help' for more information.

$ \date +"%d/%Y/%m"
30/2020/08

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

$ command date +"%d/%Y/%m"
30/2020/08

כמובן שתמיד אפשר להריץ את הנתיב המלא של הפקודה /bin/date אבל יש לי תחושה שפחות תחשקו בכך.

#date
#alias
#command
#special_characters

@bash_tips

בחזרה לעתיד pushd, popd, dirs
רמת קושי: #advanced

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

player@playground:~$ cd /tmp
player@playground:/tmp$ cd -
/home/player

מקסים זה נהדר בבקשה עוד
במידה וננסה לקחת עוד שלב ולנסות לחזור ל2 תיקיות אחורה נראה שאנו פשוט חוזרים חזרה לתיקייה /tmp שהיא כרגע תפסה את המקום של התיקייה האחרונה שהיינו בה.

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

▷ /tmp $ cd test 
▷ /tmp/test $ cd dir1
▷ /tmp/test/dir1 $ cd ../dir2
▷ /tmp/test/dir2 $ cd ../dir3
▷ /tmp/test/dir3 $ cd ../dir4
▷ /tmp/test/dir4 $ 1
/tmp/test/dir3
▷ /tmp/test/dir3 $ 3
/tmp/test/dir1
▷ /tmp/test/dir1 $ 4
/tmp/test

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

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

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

player@playground:/tmp/test$ pushd dir1
/tmp/test/dir1 /tmp/test
player@playground:/tmp/test/dir1$ pushd ../dir2
/tmp/test/dir2 /tmp/test/dir1 /tmp/test
player@playground:/tmp/test/dir2$ pushd ../dir3
/tmp/test/dir3 /tmp/test/dir2 /tmp/test/dir1 /tmp/test

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

$ dirs -v
0 /tmp/test/dir3
1 /tmp/test/dir2
2 /tmp/test/dir1
3 /tmp/test

פקודת popd
בצורתה הבסיסית פקודת popd היא כמו שהיא נשמעת, הפקודה שולפת ערכים שנמצאים במחסנית בצורת LIFO (האחרון שנכנס הראשון שיוצא) וכך משנה את המיקום שלנו על פי הרשימה שבמחסנית

player@playground:/tmp/test/dir3$ popd
/tmp/test/dir2 /tmp/test/dir1 /tmp/test
player@playground:/tmp/test/dir2$

פקודת dirs
את פקודת dirs כבר פגשנו, היא מציגה את רשימת התיקיות שבמחסנית וכן מאפשרת למחוק את המחסנית על ידי דגל -c

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

player@playground:/tmp/test/dir2$ pushd +2
/tmp/test /tmp/test/dir2 /tmp/test/dir1
player@playground:/tmp/test$ dirs -v
0 /tmp/test
1 /tmp/test/dir2
2 /tmp/test/dir1
player@playground:/tmp/test$ pushd +1
/tmp/test/dir2 /tmp/test/dir1 /tmp/test
player@playground:/tmp/test/dir2$

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

$ alias cd='pushd 1> /dev/null'

ונבדוק איך זה עובד

player@playground:/var$ cd /etc
player@playground:/etc$ cd /var
player@playground:/var$ dirs -v 
 0  /var
 1  /etc
 2  /var
 3  /var
 4  /etc
 5  /tmp/test/dir2
 6  /tmp/test/dir1
 7  /tmp/test

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

player@playground:/var$ alias 1="pushd +1 1> /dev/null"
player@playground:/var$ alias 2="pushd +2 1> /dev/null"
...
player@playground:/var$ 1
player@playground:/var$ 2
player@playground:/tmp/test/dir2$ 3
player@playground:/var$ 4
player@playground:/etc$ 1
player@playground:/tmp/test/dir2$ 

זהו עובד נהדר

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

#directory_stack
#pushd
#popd
#dirs
#cd
#challenge

@bash_tips

אודות :
רמת קושי: #advanced

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

$ help :
:: :
Null command.

No effect; the command does nothing.

Exit Status:
Always succeeds.

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


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

$ : ls /tmp
$ : ls /tm

שימו לב שהיא מעבירה גם את stderr וגם את stdout כך שגם שגיאות לא יוצגו


שרשור פעולות
ראינו מקודם שניתן להריץ פקודות בלי לקבל את הפלט שלהם, כשמכניסים את זה לסקריפט אפשר להשתמש ברעיון הזה בצורה הבאה
$ cat test.sh
: "${1} ####"
printf '%s\n' "#### ${_}"

bash test.sh Title
#### Title ####

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


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

$ echo 1234 > myfile.log
$ du myfile.log
4 myfile.log

$ : > myfile.log
$ du myfile.log
0 myfile.log


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

: << 'DOC'

your code block here

and here

and here

DOC

ברוב המקרים ישנה צורה נוחה ונעימה יותר לבצע את אותן הפעולות, בכל אופן מידי פעם עדין נתקלים בסקריפט שמכיל קוד דומה.
#heredoc
#touch
#null
#true

@bash_tips

לשרשר פקודות && \
רמת קושי: #beginners

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

/tmp/test $ mkdir aa && cd aa
/tmp/test/aa $ cd ..
/tmp/test $ mkdir aa && cd aa
mkdir: cannot create directory `aa': File exists

כפי שניתן לראות לאחר שקיבלנו את השגיאה שהתיקייה כבר קיימת, פקודת ההמשך שהיא cd לא התרחשה.

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


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

mkdir test &&\
touch test/docker_{login,build,push_sha}.sh &&\
chmod +x docker*

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


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

הסיבה לכך היא שאחרי תו ה \&& שמפצל את השורה, אסור שיהיה רווח מפני שבאש מצפה לשורה חדשה שמכילה פקודה וכשהיא נתקלת ברווח היא מנסה להריץ את הרווח כשורה חדשה שמכילה פקודה

$ cat main.sh
test/docker_login.sh &&\
test/docker_build.sh &&\
test/docker_push_sha.sh

$ bash -x main.sh
+ test/docker_login.sh
filename: docker_login.sh
+ ' '
main.sh: line 1: : command not found

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

#lists_of_commands
#special_characters

@bash_tips

📢ערוץ Python Tips
✨רוצים לשפר את הידע שלכם בפייתון? להבין דברים לעומק יותר? ללמוד דברים חדשים?✨

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


קישור לערוץ: t.me/python_israel

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

rails new hello-world

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

rails new --help

וכאן מתחילות הבעיות.

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

rails new --hlep

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

$ ls -l

drwxrwxr-x 2 ynon ynon 4096 Aug 31 20:57 --hlep

אין בעיה חשבתי אני יודע rm פשוט אמחק את התיקיה ואנסה שוב. אבל יוניקס חשב אחרת:

$ rm -rf --hlep

rm: unrecognized option '--hlep'
Try 'rm ./--hlep' to remove the file '--hlep'.
Try 'rm --help' for more information.

הבעיה שהפקודה rm (כמו גם הרבה פקודות יוניקס אחרות) היתה בטוחה ש --hlep הוא בעצם אחד המתגים ולא שם הקובץ ולא הבינה מה אני רוצה ממנה.

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

$ rm -rf -- --hlep

פקודת השמה ו export

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

myvar="some text here"
export my_another_var="another text here"

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

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

/tmp/tests $ myvar="some text here"
/tmp/tests $ bash echo_myvar.sh

/tmp/tests $

בשלב הראשון אני מכריז על משתנה בסשן בשלב השני אני מריץ סקריפט, הסקריפט רץ תחת הסשן שלי אבל כ sub process.

מצד שני אם נשתמש ב export

/tmp/tests $ export myvar="another text here"
/tmp/tests $ bash echo_myvar.sh
another text here
/tmp/tests $

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

#export
#variable
#env_variable
#session
#sub_process

@bash_tips

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

לראות את זה קורה watch
רמת קושי: #beginners

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

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

$ watch 'ls -l | grep yoni'

אוקי זה ממש יפה אבל איך אפשר לדעת אילו תיקיות התווספו או קבצים שהוסרו? שימוש בדגל -d ידגיש את החלקים שהשתנו מהדגימה הקודמת.

$ watch -d ls

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

$ watch -d -n 1 date


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

$ watch -d cat mylog

#watch

@bash_tips

סימניות בטרמינל CDPATH
רמת קושי: #beginners

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

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

user@home /etc $ cd Videos
/home/user/Videos
user@home ~/Videos $ cd gimp
/tmp/gimp
user@home /tmp/gimp $

אז איך עושים את זה בעצם, אנו מעבירים רשימה של מיקומים למשתנה CDPATH והמערכת תתעדף את התיקיות שבאותם המיקומים. כמו שאנו מכירים באש אוהבת נקודותיים (:) כחוצץ בין ערכים והמקרה כאן אינו שונה.

export CDPATH='~:/var/log:/tmp:'

הגדרנו 3 מיקומים במערכת על ידי חוצץ של :
1. תיקיית הבית (~)
2. תיקיית /var/log
3. תיקיית /tmp
כעת ברגע שנרצה להיכנס לאחת מהתיקיות שנמצאות במיקומים שברשימה נוכל פשוט להיכנס אליה מבלי להקליד את הנתיב המלא

user@home /tmp/gimp$ cd Videos
/home/user/Videos
user@home ~/Videos$ cd hp
/var/log/hp
user@home /var/log/hp$ cd Projects
/home/user/Projects

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

user@home /tmp/gimp$ cd P <TAB> <TAB
Pictures/ Projects/

מ ו ש ל ם !

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

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

$ echo $CDPATH
~:/var/log:

user@home /tmp$ tree -d -L 1
/tmp
├── Downloads
├── gimp
...

user@home /tmp$ cd Downloads/
/home/user/Downloads
user@home ~/Downloads$

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

user@home /tmp$ cd .Downloads/
Downloads/
user@home /tmp/Downloads$

#cdpath
#favorite
#env_variable

@bash_tips

להשוות ולפלטר comm
רמת קושי: #advanced

פקודת comm הינה קיצור של compare, פקודה להשוואת רשימות, זה יכול להיות שורות תוכן מקבצים או לפלט של פקודה זאת או אחרת, שימוש הפקודה על קבצים הוא די פשוט קריאה לפקודה ושני הקבצים להשוואה, במידה ונרצה להשוות פלט של פקודה נוכל להשתמש <() כפי שראינו בעבר עם פקודת diff

$ comm file1 file2
$ comm <(ls olddir/) <(ls newdir/)

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

$ touch old/{01..10}
$ touch new/{01..11..2}
$ comm <(ls old) <(ls new)
01
02
03
04
05
06
07
08
09
10
11


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

$ comm -23 <(ls old/ | sort) <(ls new/ | sort)
02
04
06
08

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

$ comm -12 <(ls old/ | sort) <(ls new/ | sort)
01
03
05
07

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

#comm
#diff

@bash_tips