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

איך משתמשים?
echo "hi" | tee file1 file2 file1000

וכמובן אפשר להשתמש בwildcard כדי לכתוב למספר קבצים עם אותו סייומת
echo 'print("hi")' | tee {file1,file2}.py

אמת או שקר

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

$ bool=true
$ declare -p bool
declare -- bool="true"

כפי שאפשר לראות משתנה bool מסומן עם ערך — שזה מקביל לשום ערך מיוחד, מה שמאפיין מחרוזות מה שאומר שהתנאי הבא לא יוכל להתקיים כי ערך של מחרוזת הוא תמיד true
if [[ $bool ]];
then echo print true
fi
print true

$ bool=false
if [[ $bool ]];
then echo print true
fi
print true

בשביל להשוות בוליאן ההשוואה תצטרך להיות או מספרית או של מחרוזת.

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

$ bool=true
$ if ${bool};
> then echo some text here
> fi
some text here
וכמובן תנאי שלילי שלא יציג כלום
$ bool=false
$ if ${bool};
> then echo some text here
>fi

@bash_tips

לצמצם עם truncate
רמת קושי: #beginners

פקודת truncate מאפשרת לנו להגדיר משקל מוגדר לכל קובץ, אם לגומה יש לי לוג ששוקל 10MB ואני רוצה לשמור רק את 2 MB החדשים ביותר של הלוג

$ du -h myapp.log
10M myapp.log
$ truncate --size=2M myapp.log
$ du -h myapp.log
2.0M myapp.log

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

$ cat long_song.mp3 > shrink.mp3
$ du -h shrink.mp3
15M shrink.mp3

$ truncate --size=2M shrink.mp3
$ du -h shrink.mp3
2.0M shrink.mp3


#truncate
#cat
#du

@bash_tips

רצפים ופורמטים עם seq
רמת קושי: #beginners

כפי שאנו מכירים באש מאפשרת ליצור רצפים של מספרים על ידי שימוש ב Brace expansion (הביטוי שמתאר את הפעולה הבאה {10..1} ) וזה עובד יפה מאוד כשמשתמשים בזה עם מספרים
cat myscript.sh
for i in {1..10}; do
echo $i
done

$ bash myscript.sh
1
2
3
...

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

$ cat myscript.sh
start=1
end=10
for i in {$start..$end}; do
echo $i
done

$ bash myscript.sh
{1..10}

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


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

$ cat myscript.sh
start=1
end=10
for i in $(seq $start $end); do
echo $i
done

$ bash myscript.sh
1
2
3
...

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

$ seq 0 2 20
0
2
4
6

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

$ seq -w 100
001
002
003
...
010
011
012
...
099
100


#seq
#brace_expansion

@bash_tips

מעקב אחר שינויים במספר קבצים בזמן אמת עם tail
רמת קושי: #beginners

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

$ tail blender_collector.sh
blend_dest=$(readlink -m "$dest/${file_name%.*}/")
mkdir -p "$blend_dest"
mv "$BLEND_FILES" "$blend_dest"
Organize_files
done
echo "Finished, files exist in: $dest"

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

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

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

$ tail -f *
==> blender_collector.sh <==
blend_dest=$(readlink -m "$dest/${file_name%.*}/")
mkdir -p "$blend_dest"
blender -b "$BLEND_FILES" --python-expr "import bpy; bpy.ops.file.pack_all()" > /dev/null 2>&1
mv "$BLEND_FILES" "$blend_dest"
Organize_files
done
echo "Finished, files exist in: $dest"
exit 0



==> README.md <==
├── House(Texturing).blend
└── textures
├── 1725 Sun Clouds.jpg
├── studio024.hdr
├── style_cottage_Flanagan_IMG1.jpg
├── wood06.jpg
├── WoodFine0024_M.jpg
└── WoodFine0042_5_L.jpg


#tail
#journalctl

@bash_tips

לקבל קלט מהמשתמש עם read
רמת קושי: #beginners

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

$ cat test.sh
echo "Insert text here"
read myvar
echo "#### $myvar ####"

$ bash test.sh
Insert text here
GOD
#### GOD ####

אפשרי לכתוב את אותו הקוד בצורה קצרה יותר על ידי שימוש בדגל -p של פקודת read
$ cat test.sh
read -p "Insert text here " myvar
echo "#### $myvar ####"

$ bash test.sh
Insert text here GOD
#### GOD ####

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

$ cat test.sh
read -t 30 -p "press any key to continue (or wait)" myvar
echo "#### $myvar ####"


#read

@bash_tips

קריאת שורות מקובץ 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