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

ישנם מספר סוגי לולאות בבאש לכל אחת תפקיד שונה
בשביל לרוץ על קבצים ולבצע עליהם פעולה כלשהי אפשר להשתמש בפקודה 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

קסמים ו subshell

תכונה מדהימה יש לבאש שנקראת pipe שמאפשרת לשרשר stdout של פקודה אחת ל stdin של פקודה אחרת לדוגמה פקודת ls מעבירה רשימה לפקודת wc שהיא בתורה סופרת כמה שורות (קבצים או תקיות) יש.
$ ls | wc -l
3

כשמנסים להשתמש באפשרות הזאת בכתיבת סקריפטים אנו עשויים לגלות תופעה מעניינת ואפילו קצת מתסכלת, נניח שכך נראה הקוד שלי בסקריפט
count_files=0
ls | while read -r; do (( count_files++ )); done
echo $count_files

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

$ count_files=0
$ ls | while read -r; do ((count_files++)); done
$ echo $count_files
3
$ ./test.sh
0


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

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

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

@bash_tips

מספר דרכים לדבג סקריפט באש

במידה והסקריפט לא ארוך אפשרי להריץ אותו משורת הפקודה עם דגל -x כך
$ /bin/bash -x myscript.sh

או פשוט להוסיף -x לשאבאנג שבראש הסקריפט שלנו
#!/bin/bash -x

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

set -x
bad code
more bad code
set +x

@bash_tips

מלכודות ואירועים trap ו signals

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

בשביל המצב הזה יש לנו את הכלי trap, מדובר על פקודה שמגיעה כחלק מה bash buildin וכל תפקידה הוא לבצע את הפקודות שמעבירים לה על-פי אירוע (signal) שמתרחש.
קוד לדוגמה
clean() {
echo Remove files...
echo Remove Directories...
}

trap clean EXIT

האירוע שיש לנו הוא EXIT והוא מתרחש מתי שהתוכנית מסיימת לרוץ או אז
מופעלת הפונקציה clean כדי לסדר יציאה מהסקריפט בצורה מסודרת.
מה קורה במידה ותוך כדי ריצה של הסקריפט המשתמש לחץ Ctrl+C? במקרה הזה הפונקציה clean לא תרוץ כי האירוע (signal) שהתרחש הוא לא מסוג EXIT אלא SIGINT.

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

HAHA() {
printf "\nsleeping ...zZZ "
}

trap HAHA SIGINT

while true;
do
sleep 10
done

אוקי אבל מאיפה אני משיג את רשימת האירועים שזמינים?
בשביל לקבל את רשימת האירועים שזמינים ניתן להריץ את הפקודה trap -l

$ trap -l
1) SIGHUP 2) SIGINT ...

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

$ man 7 signal

@bash_tips

לקרוא תיעוד לפי קטגוריות man ו whatis

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

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

1 Executable programs or shell commands
2 System calls (functions provided by the kernel)
3 Library calls
4 Special files (usually found in /dev)
5 File formats and conventions eg /etc/passwd
6 Games
7 Miscellaneous
8 System administration commands
9 Kernel routines [Non standard]

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

man 7 signal

כעת נוכל לקרוא תיעוד שקשור לקטגוריה השביעית

אפשר לקרוא את כל דפי התיעוד אחד אחרי השני על ידי הרצה של man -a command וכך ברגע שדף התיעוד הראשון נסגר המערכת תציע לנו להמשיך לקרוא את שאר התיעוד מהקטגוריות האחרות שקיימות לאותה פקודה

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

$ whatis signal
signal (7) - overview of signals
signal (2) - ANSI C signal handling

נ.ב. המלצה מאוד חמה לעבור לקרוא את התיעוד של man man

@bash_tips

עבודה עם nano ומספר קבצים

עורך הטקסט nano הפך להיות עורך ברירת מחדל בלא מעט הפצות (אפילו יותר מvim), יש ברשת לא מעט קיצורי מקשים איך עובדים איתו,
טיפ נחמד ש-nano מאפשרת זה לפתוח מספר קבצים במקביל על ידי העברת שמות הקבצים כפרמט או על ידי שימוש ב wildcard למשל כך

$ touch /tmp/test{1..3}.txt
$ nano /tmp/test*

מה שיקרה זה שכל הקבצים שמתאים לתיאור יפתחו ב-nano
מעבר בין קובץ לקובץ נעשה על ידי >+Alt לקובץ הבא ו <+Alt לקובץ הקודם

@bash_tips

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

בהקשר של באש
https://devhints.io/bash

סו sed

בשביל למנוע שורות כפולות בשימוש עם sed משתמשים עם דגל -n שמוריד את ה stdout.
sed -n
בהרצה רגילה sed לא משכתב לקובץ את העריכת התוכן שהוא ביצע, בכדי שהוא יערוך את הקובץ עליו הוא רץ מוסיפים את הדגל -i, ניתן להוסיף לפרמטר i שם קובץ חדש כדי שפלט יועבר לקובץ חדש ולא ידרוס את הקובץ הישן
$ sed -i.backupfile 'any/filter/here' myfile.conf

אפשר להשתמש ביותר מביטוי אחד בכל פעם עם sed על ידי שימוש ב ; בין ביטוי לביטוי כך שלמשל אפשרי גם לפלטר שורה שבהערה וגם להסיר שורות ריקות
$ sed ' /^#/d ; /^$/d'

@bash_tips

אליאס (alias)

אליאס זו הגדרה שנותנת לנו אופציה להגדיר קיצור לפקודה אחרת
איך זה עוזר לנו ? מקל על חיינו בהרבה !
לדוגמה מהיום אני רוצה ליצור משתמשים במקום
בפקודת sudo adduser אני אקצר ל sudo AU .
כדי לעשות אותם קבועים נשמור אותם בקובץ .bashrc שנמצא בתקיית הבית.
מגדירים כך:

~$ alias <short command> <custom command>

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

מה הפתרון?

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

איך מתקינים?
נתחיל בהתקנה של bash-completion
apt install bash-completion

נעבור להתקנת הסקריפט
נוריד את את תקיית הrepo
נכנס אליה ונכתוב כך
cat complete_alias >> ~/.bash_completion

זהו, מהיום כל alias שנגדיר כדי להפעיל לו השלמה אוטומטית כל מה שנעשה זה נכתוב אחרי ההגדרה בbashrc
complete -F _complete_alias <alias name>

לקבל מידע על החומרה שבמחשב dmidecode, lshw

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

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

להלן דוגמאות

$ sudo dmidecode -s chassis-manufacturer 
ASUSTeK COMPUTER INC.

$ sudo dmidecode -s processor-version 
Intel(R) Core(TM) i5-7200U CPU @ 2.50GHz

$ sudo dmidecode -t bios     
# dmidecode 3.2
Getting SMBIOS data from sysfs.
SMBIOS 3.0.0 present.

Handle 0x0000, DMI type 0, 24 bytes
BIOS Information
 Vendor: American Megatrends Inc.
...

כלי נוסף שמציג מידע על המערכת הוא lswh, בשביל לא לטבוע בכמות המידע אפשר לפלטר את הפלט על ידי שימוש בקטגוריה (Class) של החלק שמעניין אותנו, לדוגמה
$ sudo lshw -C CPU
*-cpu
description: CPU
product: Intel(R) Core(TM) i5-7200U CPU @ 2.50GHz
vendor: Intel Corp.
physical id: 11

או להשתמש עם דגל -short שיציג תצוגה מקוצרת שמחולקת לפי קטגוריות
$ sudo lshw -short
H/W path Device Class Description
======================================================
system X556URK
/0 bus X556URK
/0/0 memory 64KiB BIOS

תקציר sed


לפקודה sed לא מעט יכולות ופרמטרים הפעם תקראו על sed ויש מצב שגם תזכרו, למה? בגלל ש-sed ספידה (s.p.i.d.a)
להלן הבסיס של sed עם hint לזיכרון

כל שיש לזכור הוא s.p.i.d.a
למי שרוצה SS שהוא sed spida

s (substitute) - בכדי להחליף תוכן תחת מיקום ספציפי במסמך
sed 's/regex/replace to/g' myfile

p (print) - בכדי לערוך קובץ ולהדפיס למסך
sed '/regex/p' myfile

i (insert) - בכדי להוסיף תוכן מעל מיקום ספציפי במסמך
sed '/regex/ i some text to add above the match' myfile

d (delete) - בכדי למחוק תוכן מהמסמך
sed '/regex/d ' myfile

a (append) - בכדי להוסיף תוכן תחת מיקום ספציפי במסמך
sed '/regex/ a some text to add below match' myfile

להרחיב מעט את הבסיס ולבצע כמה פעולות ויחד לדוגמה, לעשות חיפוש והחלפה
$ sed '{
/regex/ a some text here
/regex/ d
}' myfile

בשביל שזה באמת כיף אפשרי להכניס את רצף הפקודות לקובץ כל פקודת עריכה בשורה חדשה ופשוט לקרוא לו שיחיל את רצף העריכות על הקובץ שלנו
$ sed -f myedits myfile

כמו שאמרנו לא לשכוח להשתמש ב-i לפני שעושים עריכות על קובץ אמיתי

@bash_tips

להריץ פקודות עם sed

פיצ'ר נחמד ש-sed מאפשר זה להריץ פקודות על תוכן שהוא מפלטר, מבנה הפקודה הוא כזה

sed 'action/regex/command /e' file

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

$ cat mypath 
# directories for test
/tmp/tests/first
/tmp/tests/second
# any text here
/tmp/tests/mytest

אני רוצה לקבל רק את הנתיבים שקיימים בקובץ ולהריץ עליהם mkdir שיצור לי את רצף התיקיות שברשימה
$ sed 's/ ^\/ /mkdir -p /e ' mypath

אני משתמש ב substitute כדי לקבל רק את השורות שמתחילות ב / ואז מריץ עליהם את פקודת mkdir שתיצור לי תיקייה, כדי להגדיר ל-sed שמדובר על פקודה שאני רוצה להריץ יש לאחר הפקודה e/

וקיבלתי את שבקשתי

tmp/
└── tests
    ├── first
    ├── mytest
    └── second

@bash_tips

אחסון smarctl, lsblk

בכדי לקבל רשימה ויזואלית של התקני האחסון שקיימים במערכת ותצוגת המחיצות שלהם ניתן להריץ את lsblk, כך ניתן לדעת איזה התקן מעוגן לאיזה סוקט
$ lsblk
...
sda 8:0 0 238.5G 0 disk
├─sda1 8:1 0 260M 0 part /boot/efi
├─sda2 8:2 0 16M 0 part
├─sda3 8:3 0 79.4G 0 part
...

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

דגל -i יתן מידע על החומרה עצמה ואם היא תומכת ב SMART
$ sudo smartctl -i /dev/sda

תגית short מסמלת טסט מקוצר

$ sudo smartctl -t short /dev/sda

ניתן לחזור לבדוק תוצאות לאחר הבדיקה על ידי -l
לייבל devstat יחזיר נתונים חשובים על הדיסק, טמפרטורה, כמות reboots שהדיסק עשה ועוד
$ sudo smartctl -l devstat /dev/sda

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

$ sudo smartctl -l xerror /dev/sda

לייבל selftest יציג סיכום של הבדיקה
$ sudo smartctl -l selftest /dev/sda

להתחיל ברגל ימין Awk

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

$ awk -f myawk.txt  any_file
$ echo “any text here” | awk -f myawk.txt

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

$ echo any text here | awk 'BEGIN {print "Title" } 
pipe quote> END {print "\nTotal: ", NR}'

Title
======
======
Total 1

אז מה שהיה לנו כאן היה די פשוט BEGIN ו-END אלו משפטי ההוראה איפה לכתוב ואז יש בלוק של { print "text" } שאומר מה להדפיס או איזה פעולה לבצע באותו מקום, משתנה NR מחזיק את מספר הרשומות שפקודת awk קיבלה לעבד מה שיוצר לנו סיכום נחמד בסוף הפלט, כמו שאתם רואים עטפתי את את משפטי ההוראה בגרש בודד, הוראות שנכתבים לקובץ אינן צריכות להיות מגורגשות, פשוט וקל יאללה בואו נכניס קצת תוכן משמעותי יותר.

$ cat /etc/passwd
root:x:0:0:root:/root:/bin/bash
daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin
…

$ awk 'BEGIN {FS=":" ; print "Users\n======" }
pipe quote> { print $1, $6}
pipe quote> END {print "======\nTotal:" NR}' /etc/passwd

Users
======
root /root
daemon /usr/sbin
...
======
Total:46

כפי שבטח הבחנתם כמו בסקריפטינג כל מילה (field) מקבלת איבר משלה שמיוצג על ידי $, בחרנו באיבר הראשון והשישי של כל שורה על ידי $1, $6, וכן כמו בבאש ברירת מחדל התו שמוגדר לחלוקה של מילים לפרמטרים הוא רווח, בשביל להגדיר תו אחר יש את משתנה FS שכפי שרואים מוגדר בשורה הראשונה לחלק על פי תו ":", אפשר להכניס יותר מהוראה אחת בכל סוגריים על ידי נקודה פסיק.
ניתן להשתמש בפקודת printf כדי לעצב טקסט בצורה חכמה יותר.

$ awk 'BEGIN {FS=":";print "Title\n====="}
pipe quote> { printf "%-20s %s \n" ,$1, $6 }
pipe quote> END {print "======\nTotal:" NR}' /etc/passwd

Title
======
root                 /root 
daemon               /usr/sbin 
...
======
Total:46

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

$ awk 'BEGIN {FS=":";print "Users\n===="}
pipe quote> 

$3 > 999 { printf "%-20s %s \n" ,$1, $6}


pipe quote> 

END {print "====\nTotal:" NR}' /etc/passwd

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

Users
======
green           /home/green 
someone         /home/someone 
======
Total:46

רגע מה, 46 רשומות???
יאפ משתנה NR שומר את כל הרשומות שהוא מקבל ולא את החלקים שפלטרנו, במידה ונרצה את מספר הרשומות שתכלס פלטרנו פשוט נוסיף לשורת התוכן שלנו מונה שהוא בעצם משתנה כלשהו כמו a++ או עם שם יותר מסביר count++ ונחליף את NR במונה שיצרנו

$ awk 'BEGIN {FS=":";print "Users\n===="}

pipe quote> 

$3 > 999 { printf "%-20s %s \n" ,$1, $6 ; count++}


pipe quote> 

END {print "====\nTotal:" count}' /etc/passwd



Users
====
green           /home/green 
someone         /home/someone  
====
Total:2

@bash_tips