קריאת שורות מקובץ while read

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

$ test.sh
cat script.py | while read -r line;
do 
    echo "[*] $line"
done

$ bash test.sh
[*] #!/usr/bin/python3
[*] # -*- coding: utf-8 -*-
[*] 
[*] import os
...

אנו משרשרים קובץ אל הלולאה ומכאן read לוקח פיקוד, כהתחלה הוא מקבל את הקלט בצורה גולמית על ידי שימוש בדגל r- ולאחר מכן הוא מפצל את הקלט על פי התו n\ מה שאומר שכל שורה היא יחידה אחת.

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

$ test.sh
cat script.py | while IFS=$'\t' read -r line;
do 
    echo "[*] $line"
done

@bash_tips

פריסת ערכים למספר משתנים while read

בכדי לעשות אנפאקינג למספר משתנים עם באש ניתן להשתמש עם while read
הקוד שלי
my_text="Lorem Ipsum is
simply dummy text
of the printing
and typesetting industry."

echo "$my_text" | while read -r one two three;
do
echo "[*] $one $two $three"
done

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

$ bash test.sh
[*] Lorem Ipsum is
[*] simply dummy text
[*] of the printing
[*] and typesetting industry.

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

$ cat test.sh
my_text="Lorem Ipsum is simply dummy text
of the printing and typesetting industry."

echo "$my_text" | while read -r one two three;
do
echo "[*] $one $two [last variable] $three"
done

$ bash test.sh
[*] Lorem Ipsum [last variable] is simply dummy text
[*] of the [last variable] printing and typesetting industry.

@bash_tips

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

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

~/snap $ tree
.
├── audacity
│ └── current -> 532
├── blender
│ ├── 38
│ ├── common
│ └── current -> 38
├── code
│ ├── 33
│ ├── common
│ └── current -> 33
...

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

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

$ tree -I 'node_modules|npm|test_*'

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

להגדיר עומק
ישנה אפשרות להגדיר כמה עומק רוצים להציג בעץ התיקיות על ידי שימוש בדגל 3 L- שאומר בעצם תציג לי עד עומק של 3 תיקיות.

להציג רק תיקיות

$ tree -d
.
├── charts-external
│ ├── yoyo
│ │ ├── docker
│ │ │ └── postgres-postgis
│ │ └── templates
│ ├── cluster-admin.
├── charts-external
│ ├── yoyo
...

להציג תוכן על ידי תבנית

$ tree -P '*.sh'
...
├── force_update.sh
├── functions.sh
├── helm_healthcheck.sh
├── helm_lint_all.sh
...
הצגת הרשאות בדומה לls

$ tree -p
...
├── [-rwxrwxr-x] force_update.sh
├── [-rw-rw-r--] functions.sh
├── [-rwxrwxr-x] helm_healthcheck.sh
├── [-rwxrwxr-x] helm_lint_all.sh
...

ואפילו לקבל משקל של כל קובץ

$ tree —du
...
├── [ 532] helm_healthcheck.sh
├── [ 971] helm_lint_all.sh
├── [ 1730] helm_lint_external_chart.sh
├── [ 1673] helm_update_values.sh
├── [ 300] helm_upgrade_all.sh
...

אה רגע רצינו את זה בשפה קריאה לבני אנוש

$ tree —du -h
...
├── [ 532] helm_healthcheck.sh
├── [ 971] helm_lint_all.sh
├── [1.7K] helm_lint_external_chart.sh
├── [1.6K] helm_update_values.sh
├── [ 300] helm_upgrade_all.sh
...


#tree

@bash_tips

לטעון עם source
רמת קושי: #beginners

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

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

$ my_var=123

כעת אם נקרא למשתנה הזה נקבל את הערך שלו

$ echo $my_var
123

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

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

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

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

$ nano ~/.bashrc && source ~/.bashrc

#source
#bashrc

@bash_tips

📢 ערוץ Bash Tips

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

אהמ טוב נסחפתי מעט

בערוץ Bash Tips תמצאו אוסף טיפים ב-Bash
הכרות עם כלים שונים שעשויים לחסוך לכם המון זמן ומאמץ.

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

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

לינק לערוץ https://t.me/bash_tips

⠀

לפצל וידאו עם MP4Box
רמת קושי: #beginners

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

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

מתחילים
פקודת MP4Box מספקת לנו מספר אופציות לפיצול הקובץ, אפשר לראות את כל אפשרויות הפיצול שזמינות על ידי הרצה של
$ MP4Box -h general

חלוקה לפי משקל
הקובץ שברשותי שוקל כ 3GB אני רוצה לפצל אותו ל2 חלקים של 1.5GB

$ MP4Box -split-size 1500000 myfile.mp4

אז מה זה המספר הארוך הזה בפקודה?
אנו משתמשים בדגל -split-size (אפשרי גם לכתוב רק splits-) הפרמטר שהוא מקבל הוא משקל הקובץ שנרצה שיהיה לכל חלק, העניין הוא שהפקודה מצפה לקבל את הערך ב-KB לא הדבר הכי נח להסתכל עליו ומאוד קל לטעות.
אבל היי הכל עניין של הסתכלות תחשבו ב MB ופשוט תוסיפו 3 אפסים בסוף
1500 + 000 = 1500000

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

$ MP4Box -split 60 myfile.mp4

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

$ MP4Box -split $(( 60*21 )) myfile.mp4

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

#mp4_box
#gpac

@bash_tips

לפצל ולאחד קבצים עם 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