mawk - מקוון בענן

תָכְנִית:

שֵׁם

mawk - שפת סריקת דפוסים ועיבוד טקסט

תַקצִיר

מאוק [-W אוֹפְּצִיָה] [-F ערך] [-v var=ערך] [--] 'טקסט תוכנית' [קובץ ...]
מאוק [-W אוֹפְּצִיָה] [-F ערך] [-v var=ערך] [-f מסמך תוכנית] [--] [קובץ ...]

תיאור

מאוק הוא מתורגמן לשפת התכנות AWK. שפת AWK שימושית עבור
מניפולציה של קבצי נתונים, אחזור ועיבוד טקסט, וכן עבור אב טיפוס ו
להתנסות באלגוריתמים. מאוק הוא חדש awk כלומר הוא מיישם את שפת AWK
כהגדרתם ב-Aho, Kernighan ו-Weinberger, השמיים AWK תכנות שפה, אדיסון-וסלי
הוצאה לאור, 1988. (יקרא להלן ספר AWK.) מאוק תואם את ה-Posix
הגדרה 1003.2 (טיוטה 11.3) של שפת AWK המכילה כמה תכונות שאינן
המתואר בספר AWK, ו מאוק מספק מספר קטן של הרחבות.

תוכנית AWK היא רצף של דפוס {פעולה} זוגות והגדרות פונקציות. קצר
תוכניות מוזנות בשורת הפקודה המוקפת בדרך כלל ב' ' כדי למנוע מעטפת
פרשנות. ניתן לקרוא תוכניות ארוכות יותר מקובץ עם האפשרות -f. נתונים
הקלט נקרא מרשימת הקבצים בשורת הפקודה או מקלט רגיל כאשר
הרשימה ריקה. הקלט מחולק לרשומות כפי שנקבע על ידי מפריד הרשומות
משתנה, RS. בהתחלה, RS = "\n" ורשומות הן שם נרדף לשורות. כל שיא הוא
לעומת כל אחד דפוס ואם זה תואם, טקסט התוכנית עבור {פעולה} is
יצא לפועל.

אפשרויות

-F ערך מגדיר את מפריד השדות, FS, כדי ערך.

-f פילה טקסט התוכנית נקרא פילה במקום משורת הפקודה. מרובות
-f מותרות אפשרויות.

-v var=ערך מקצה ערך לתכנת משתנה היה.

-- מציין את הסוף החד משמעי של אפשרויות.

האפשרויות לעיל יהיו זמינות עם כל מימוש תואם Posix של AWK, ו
מקדימות אפשרויות ספציפיות ליישום -W. מאוק מספק שישה:

-W גרסה מאוק כותב את הגרסה וזכויות היוצרים שלה ל-stdout ומגבלות הידור
stderr ויוצא מ-0.

-W dump כותב אסמבלר כמו רישום של הייצוג הפנימי של
תוכנית ל-stdout ויוצאת מ-0 (בקומפילציה מוצלחת).

-W אינטראקטיבית מגדירה כתיבה לא מאומצת ל-stdout וקריאה מאוחסנת בשורה מ-stdin.
רשומות מ-stdin הן שורות ללא קשר לערך של RS.

-W Exec פילה טקסט התוכנית נקרא פילה וזו האפשרות האחרונה. שימושי על
מערכות התומכות ב #! מוסכמה של "מספר קסם" לקובץ הפעלה
תסריטים.

-W sprintf=NUM מתאים את הגודל של של מאוק מאגר sprintf פנימי ל NUM בתים. יותר מ
שימוש נדיר באפשרות זו מעיד מאוק צריך להידור מחדש.

-W posix_space forces מאוק לא להתייחס ל'\n' כמרחב.

הטפסים הקצרים -W[vdiesp] מזוהים ובמערכות מסוימות -We חובה להימנע
מגבלות אורך שורת הפקודה.

LA AWK שָׂפָה

1. תָכְנִית מִבְנֶה
תוכנית AWK היא רצף של דפוס {פעולה} זוגות והגדרות פונקציות משתמש.

דפוס יכול להיות:
התחל
הסוף
ביטוי
הבעה, הבעה

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

הצהרות מסתיימות בשורות חדשות, נקודה-פסיק או שניהם. קבוצות של הצהרות כגון
פעולות או גופי לולאה נחסמים באמצעות { ... } כמו ב-C. ההצהרה האחרונה בבלוק
לא צריך טרמינטור. לשורות ריקות אין משמעות; הצהרה ריקה מסתיימת
עם נקודה-פסיק. ניתן להמשיך בהצהרות ארוכות עם קו נטוי אחורי, \. הצהרה יכולה
להישבר ללא קו נטוי אחורי לאחר פסיק, סוגר שמאלי, &&, ||, do, אחר, הנכון
סוגריים של א if, בזמן or ל משפט, והסוגריים הימניים של פונקציה
הַגדָרָה. הערה מתחילה ב-# ומתרחבת עד, אך אינה כוללת את סוף השורה.

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

if ( ביטוי ) הצהרה

if ( ביטוי ) הצהרה אחר הצהרה

בזמן ( ביטוי ) הצהרה

do הצהרה בזמן ( ביטוי )

ל ( opt_expr ; opt_expr ; opt_expr ) הצהרה

ל ( היה in מערך ) הצהרה

להמשיך

לשבור

2. נתונים סוגים, המרה ו השוואה
ישנם שני סוגי נתונים בסיסיים, מספרי ומחרוזת. קבועים מספריים יכולים להיות כמו מספרים שלמים
-2, עשרוני כמו 1.08, או בסימון מדעי כמו -1.1e4 או .28E-3. כל המספרים הם
מיוצג פנימי וכל החישובים נעשים באריתמטיקה של נקודה צפה. אז בשביל
לדוגמה, הביטוי 0.2e2 == 20 נכון ו-true מיוצג כ-1.0.

קבועי מחרוזת מוקפים במירכאות כפולות.

"זו מחרוזת עם שורה חדשה בסוף.\n"

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

\\\
\" "
התראה, ascii 7
\b backspace, ascii 8
\t tab, ascii 9
\n שורה חדשה, ascii 10
\v כרטיסייה אנכית, ascii 11
\f formfeed, ascii 12
החזרת כרכרה, ascii 13
\ddd 1, 2 או 3 ספרות אוקטליות עבור ascii ddd
\xhh 1 או 2 ספרות hex עבור ascii hh

אם אתה בורח מכל תו אחר \c, אתה מקבל \c, כלומר, מאוק מתעלם מהבריחה.

יש באמת שלושה סוגי נתונים בסיסיים; השלישי הוא מספר ו מחרוזת שיש בו גם א
ערך מספרי וערך מחרוזת בו-זמנית. משתנים המוגדרים על ידי המשתמש נכנסים
קיום כאשר מתייחסים לראשונה ומאוחלים ל ריק, מספר וערך מחרוזת
בעל ערך מספרי 0 וערך מחרוזת "". נתונים לא טריוויאליים המוקלדים במחרוזת
מגיעים מקלט ומאוחסנים בדרך כלל בשדות. (ראה סעיף 4).

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

y = x + 2; z = x "שלום"

הערך המאוחסן במשתנה y יוקלד מספרי. אם x אינו מספרי, הערך נקרא
מ-x מומר למספרי לפני שהוא מתווסף ל-2 ומאוחסן ב-y. הערך המאוחסן
במשתנה z יוקלד string, והערך של x יומר ל-string if
נחוץ ומשורשר עם "שלום". (כמובן, הערך והסוג המאוחסנים ב-x הם
לא השתנה על ידי המרות כלשהן.) ביטוי מחרוזת מומר למספרי באמצעות הביטוי שלו
הקידומת המספרית הארוכה ביותר כמו עם אטופ(3). ביטוי מספרי מומר למחרוזת על ידי
החלפה ביטוי עם sprintf(CONVFMT, ביטוי), אלא אם כן ביטוי יכול להיות מיוצג על המארח
מכונה כמספר שלם מדויק ואז הוא מומר ספרינטף("%d", ביטוי). Sprintf() הוא
AWK מובנה המשכפל את הפונקציונליות של ספרינטף(3), ו CONVFMT הוא מובנה
משתנה המשמש להמרה פנימית ממספר למחרוזת ומאוחל ל-%6g.
ניתן לכפות המרות מסוג מפורש, ביטוי "" הוא מחרוזת ו ביטוי+0 הוא מספרי.

להעריך, ביטוי1 ניתוח חוזר ביטוי2, אם שני האופרנדים הם מספריים או מספר ומחרוזת אז
ההשוואה היא מספרית; אם שני האופרנדים הם מחרוזת ההשוואה היא מחרוזת; אם אחד
האופרנד הוא מחרוזת, האופרנד הלא-מחרוזת מומר וההשוואה היא מחרוזת. ה
התוצאה היא מספרית, 1 או 0.

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

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

ביטוי ~/r/

הוא ביטוי AWK המוערך ל-1 if ביטוי "התאמות" r, כלומר מחרוזת משנה של
ביטוי נמצא בקבוצת המחרוזות המוגדרות על ידי r. ללא התאמה הביטוי מוערך ל-0;
החלפת ~ באופרטור "לא תואם", !~ , הופכת את המשמעות. כדפוס-פעולה
זוגות,

/r/ { פעולה } ו $0 ~/r/ { פעולה }

זהים, ולכל רשומת קלט התואמת r, פעולה מוצא להורג. למעשה, /r/
הוא ביטוי AWK שמקביל ל($0 ~/r/) בכל מקום מלבד כאשר בצד ימין
צד של אופרטור התאמה או מועבר כארגומנט לפונקציה מובנית שמצפה ל- a
טיעון ביטוי רגיל.

AWK משתמש בביטויים רגולריים מורחבים כמו עם egrep(1). הביטוי הרגולרי
מטא-תווים, כלומר, בעלי משמעות מיוחדת בביטויים רגולריים הם

^ $ . [ ] | ( ) * + ?

ביטויים רגולריים בנויים מתווים באופן הבא:

c מתאים לכל תו שאינו מטא c.

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

. מתאים לכל תו (כולל קו חדש).

^ תואם את החלק הקדמי של מחרוזת.

$ תואם לחלק האחורי של מחרוזת.

[c1c2c3...] מתאים לכל תו במחלקה c1c2c3... . מרווח של
תווים מסומנים c1-c2 בתוך מחלקה [...].

[^c1c2c3...] תואם לכל תו שאינו במחלקה c1c2c3...

ביטויים רגולריים בנויים מביטויים רגולריים אחרים באופן הבא:

r1r2 התאמות r1 ואחריו מיד r2 (שרשור).

r1 | r2 התאמות r1 או r2 (לסירוגין).

r* התאמות r חוזר על אפס או יותר פעמים.

r+ התאמות r חוזר על עצמו פעם אחת או יותר.

r? התאמות r אפס או פעם אחת.

(r) התאמות r, מתן קיבוץ.

העדיפות הגוברת של אופרטורים היא חילופין, שרשור ו-unary (*, + או
?).

לדוגמה,

/^[_a-zA-Z][_a-zA-Z0-9]*$/ ו
/^[-+]?([0-9]+\.?|\.[0-9])[0-9]*([eE][-+]?[0-9]+)?$/

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

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

התחל { מזהה = "[_a-zA-Z][_a-zA-Z0-9]*" }

מזהה $0 ~ "^".

מדפיס את כל השורות שמתחילות במזהה AWK.

מאוק מזהה את הביטוי הרגולרי הריק, //, התואם את המחרוזת הריקה ומכאן
מותאם לכל מיתר בחזית, מאחור ובין כל תו. לדוגמה,

echo abc | mawk { gsub(//, "X"); הדפס }
XaXbXcX

4. רשומות ו שדות
רשומות נקראות אחת בכל פעם, ומאוחסנות ב- שדה משתנה $0. השיא הוא
להתפצל לתוך שדות אשר מאוחסנים ב $1, $2, ..., $NF. המשתנה המובנה NF מוגדר
למספר השדות, ו NR ו FNR מוגדלים ב-1. שדות למעלה $NF נקבעים
"".

משימה ל $0 גורם לשדות ו NF לחשב מחדש. משימה ל NF או אל
גורם שדה $0 לשחזור על ידי שרשור של של $i מופרדים על ידי FSO.
הקצאה לשדה עם אינדקס גדול מ NF, עולה NF וגורמים $0 להיות
מְשׁוּחזָר.

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

echo 24 24E |
mawk '{ print($1>100, $1>"100", $2>100, $2>"100") }'
0 1 1 1

$0 ו $2 הם מחרוזת ו $1 הוא מספר ומחרוזת. ההשוואה הראשונה היא מספרית, ה
השני הוא מחרוזת, השלישי הוא מחרוזת (100 מומר ל-"100"), והאחרון הוא מחרוזת.

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

ביטויים חדשים מורכבים עם האופרטורים הבאים לפי סדר הגדלה
עֲדִיפוּת.

משימה = += -= *= /= %= ^=
מותנה ? :
הגיוני or ||
הגיוני ו &&
מערך חֲבֵרוּת in
תואם ~!~
יחסיות < > <= >= == !=
שרשור (ללא מפעיל מפורש)
להוסיף ops + -
מול ops * /%
יונירי + -
הגיוני לֹא !
אקספוננציה ^
inc ו דצמבר ++ -- (גם פוסט וגם קדם)
שדה $

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

6. מערכים
Awk מספק מערכים חד מימדיים. רכיבי מערך באים לידי ביטוי כ מערך[ביטוי]. מפק
מומר באופן פנימי לסוג מחרוזת, כך, למשל, A[1] ו-A["1"] זהים
אלמנט והאינדקס בפועל הוא "1". מערכים שמוסיפים לאינדקס על ידי מחרוזות נקראים אסוציאטיביים
מערכים. בתחילה מערך ריק; רכיבים קיימים בעת הגישה אליהם לראשונה. ביטוי,
ביטוי in מערך מוערך ל-1 if מערך[ביטוי] קיים, אחרת ל-0.

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

ל ( היה in מערך ) הצהרה

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

ההצהרה, להסיר מערך[ביטוי], גורם ל מערך[ביטוי] לא להתקיים. מאוק תומך ב-
סיומת, להסיר מערך, אשר מוחק את כל הרכיבים של מערך.

מערכים רב מימדיים מסונתזים עם שרשור באמצעות המשתנה המובנה
SUBSEP. מערך[ביטוי1,ביטוי2] שווה ערך ל מערך[ביטוי1 SUBSEP ביטוי2]. בדיקה עבור א
אלמנט רב ממדי משתמש באינדקס בסוגריים, כגון

if ((i, j) ב-A ) הדפס A[i, j]

7. משתנים מובנים
המשתנים הבאים מובנים ומאוחלים לפני הפעלת התוכנית.

ARGC מספר ארגומנטים של שורת הפקודה.

ARGV מערך ארגומנטים של שורת הפקודה, 0..ARGC-1.

CONVFMT פורמט להמרה פנימית של מספרים למחרוזת, בהתחלה = "%.6g".

על אודות מערך באינדקס על ידי משתני סביבה. מחרוזת סביבה, var=ערך
מאוחסן כ- על אודות[היה] = ערך.

שם קובץ שם קובץ הקלט הנוכחי.

FNR מספר השיא הנוכחי ב שם קובץ.

FS מפצל רשומות לשדות כביטוי רגולרי.

NF מספר השדות ברשומה הנוכחית.

NR מספר השיא הנוכחי בזרם הקלט הכולל.

OFMT פורמט להדפסת מספרים; בהתחלה = "%.6g".

FSO הוכנס בין שדות בפלט, בתחילה = " ".

ORS מסיים כל רשומה בפלט, בתחילה = "\n".

RLENGTH אורך שנקבע על ידי הקריאה האחרונה לפונקציה המובנית, התאמה().

RS מפריד רשומות קלט, בהתחלה = "\n".

RSTART אינדקס שנקבע על ידי השיחה האחרונה אל התאמה().

SUBSEP משמש לבניית מערכים מרובים, בתחילה = "\034".

8. Built-in פונקציות
פונקציות מחרוזת

gsub(r,s,t) gsub(ר, ס)
החלפה גלובלית, כל התאמה של ביטוי רגולרי r במשתנה t is
מוחלף במחרוזת s. מספר ההחלפות מוחזר. אם t is
הושמט, $0 משמש. & במחרוזת ההחלפה s מוחלף ב-
מחרוזת משנה תואמת של t. \& ו-\\ מכניסים מילולית & ו-\, בהתאמה
מחרוזת החלפה.

אינדקס(רחוב)
If t הוא תשתית של s, ואז המיקום שבו t מתחילים מוחזרים, אחרת
0 מוחזר. הדמות הראשונה של s נמצא בעמדה 1.

אורך(s)
מחזירה את אורך המחרוזת s.

התאמה(s,r)
מחזירה את האינדקס של ההתאמה הארוכה ביותר של ביטוי רגולרי r in
מחרוזת s. מחזירה 0 אם אין התאמה. בתור תופעת לוואי, RSTART מוגדר ל
ערך החזרה. RLENGTH מוגדר לאורך ההתאמה או -1 אם אין התאמה.
אם המחרוזת הריקה תואמת, RLENGTH מוגדר ל-0, ו-1 מוחזר אם
הגפרור הוא בחזית, ובאורך(s)+1 מוחזר אם ההתאמה היא ב
הגב.

לְפַצֵל(s,A,r) לפצל(ס,א)
מחרוזת s מפוצל לשדות על ידי ביטוי רגולרי r והשדות הם
נטען למערך A. מספר השדות מוחזר. ראה סעיף 11
להלן לפרטים נוספים. אם r מושמט, FS משמש.

sprintf (פורמט, expr-list)
מחזירה מחרוזת הבנויה מ expr-list על פי פוּרמָט. ראה את
תיאור של printf() למטה.

תַת(r,s,t) תת(ר, ס)
החלפה בודדת, זהה ל-gsub() למעט החלפה אחת לכל היותר.

substr(חטא) substr(סִי)
מחזירה את המחרוזת המשנה של המחרוזת s, החל באינדקס i, באורך n. אם n
מושמט, הסיומת של s, מתחיל ב i מוחזר.

להנמיך(s)
מחזיר עותק של s עם כל התווים הגדולים המומרים לאותיות קטנות.

למעלה (s)
מחזיר עותק של s עם כל התווים הקטנים מומרים לאותיות גדולות.

פונקציות אריתמטיות

atan2(y,x) ארקטן של y/x בין -pi ו-pi.

cos (x) פונקציית קוסינוס, x ברדיאנים.

exp (x) פונקציה מעריכית.

int (x) החזרות x קטוע לכיוון אפס.

עֵץ(x) לוגריתם טבעי.

rand() מחזירה מספר אקראי בין אפס לאחד.

חטא(x) פונקציית סינוס, x ברדיאנים.

sqrt(x) מחזירה שורש ריבועי של x.

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

9. קֶלֶט ו תפוקה
ישנן שתי הצהרות פלט, הדפסה ו הדפס.

הדפס כותב $0 ORS לתפוקה רגילה.

הדפסה ביטוי1, ביטוי2,..., ביטויn
כותב ביטוי1 FSO ביטוי2 FSO ... ביטויn ORS לפלט סטנדרטי. מספרי
ביטויים מומרים למחרוזת עם OFMT.

הדפס פוּרמָט, expr-list
משכפל את הפונקציה printf C ספריית כתיבת לפלט סטנדרטי. ה
מפרטי פורמט ANSI C מלאים מזוהים עם המרות %c,
%d, %e, %E, %f, %g, %G, %i, %o, %s, %u, %x, %X ו-%%, והמרה
מוקדמות h ו-l.

רשימת הארגומנטים להדפסה או printf יכולה להיות מוקפת בסוגריים. הדפס
פורמט מספרים באמצעות OFMT או "%d" עבור מספרים שלמים מדויקים. "%c" עם ארגומנט מספרי
מדפיס את התו המתאים של 8 סיביות, עם ארגומנט מחרוזת הוא מדפיס את הראשון
אופי המחרוזת. ניתן להפנות את הפלט של print ו-printf לקובץ או
פקודה על ידי הוספה של > פילה, >> פילה או | הפקודה לסוף ההצהרה המודפסת.
ניתוב מחדש נפתח פילה or הפקודה רק פעם אחת, ההפניות מחדש עוקבות מתווספות ל-כבר
זרם פתוח. לפי המוסכמה, מאוק משייך את שם הקובץ "/dev/stderr"עם stderr אשר
מאפשר הפניית print ו-printf ל-stderr. מאוק משייך גם "-" ו
"/dev/stdout" עם stdin ו-stdout המאפשר להעביר זרמים אלו לפונקציות.

פונקציית הקלט getline יש את הווריאציות הבאות.

getline
קורא לתוך $0, מעדכן את השדות, NF, NR ו FNR.

getline פילה
קורא לתוך $0 החל מ- פילה, מעדכן את השדות ו NF.

getline היה
קורא את הרשומה הבאה לתוך היה, עדכונים NR ו FNR.

getline היה < פילה
קורא את הרשומה הבאה של פילה אל תוך היה.

הפקודה | getline
צינורות רשומה מ הפקודה אל תוך $0 ומעדכן את השדות ו NF.

הפקודה | getline היה
צינורות רשומה מ הפקודה אל תוך היה.

Getline מחזירה 0 בסוף הקובץ, -1 בשגיאה, אחרת 1.

הפקודות בקצה הצינורות מבוצעות על ידי /bin/sh.

הפונקציה close(ביטוי) סוגר את הקובץ או הצינור המשויך אליו ביטוי. סגור מחזיר 0 אם
ביטוי הוא קובץ פתוח, מצב היציאה אם ביטוי הוא פקודה צינורית, ו-1 אחרת. סגור
משמש לקריאה חוזרת של קובץ או פקודה, ודא שהקצה השני של צינור פלט הסתיים
או לחסוך במשאבי קבצים.

הפונקציה לשטוף(ביטוי) מסלק את קובץ הפלט או הצינור המשויך אליו ביטוי. סומק
מחזירה 0 אם ביטוי הוא זרם פלט פתוח אחר -1. סומק ללא ויכוח
stdout. Fflush עם ארגומנט ריק ("") מסלק כל פלט פתוח.

הפונקציה מערכת(ביטוי) שימושים / Bin / sh להוציא להורג ביטוי ומחזירה את מצב היציאה של
הפקודה ביטוי. שינויים שבוצעו ב- על אודות מערך לא מועבר לפקודות המבוצעות עם
מערכת או צינורות.

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

פונקציה שם ( טוען ) { הצהרות }

גוף הפונקציה יכול להכיל הצהרת return

לַחֲזוֹר opt_expr

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

function csplit(s, A, n, i)
{
n = אורך(ים)
for( i = 1 ; i <= n ; i++ ) A[i] = substr(s, i, 1)
לחזור נ
}

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

11. פיצול מחרוזות, רשום ו קבצים
תוכניות Awk משתמשות באותו אלגוריתם כדי לפצל מחרוזות למערכים עם split(), ורשומות
לתוך שדות על FS. מאוק משתמש בעצם באותו אלגוריתם כדי לפצל קבצים לרשומות
on RS.

לְפַצֵל(expr,A,sep) פועל באופן הבא:

(1) אם ספטמבר מושמט, הוא מוחלף ב FS. ספטמבר יכול להיות ביטוי או
הבעה רגילה. אם זה ביטוי מסוג שאינו מחרוזת, זה כן
הומר למחרוזת.

(2) אם ספטמבר = " " (רווח בודד), אז גזוז מלפנים ו
החלק האחורי של ביטוי, ו ספטמבר הופך . מאוק מגדיר כמו הרגיל
ביטוי /[ \t\n]+/. אחרת ספטמבר מתייחסים אליו כאל ביטוי רגיל,
אלא שמתעלמים מתווים מטא עבור מחרוזת באורך 1, למשל,
split(x, A, "*") ו-split(x, A, /\*/) זהים.

(3) אם ביטוי אינו מחרוזת, הוא מומר למחרוזת. אם ביטוי הוא אז הריק
מחרוזת "", split() מחזירה 0 ו A מוגדר ריק. אחרת, כל הלא-
התאמות חופפות, לא אפס והארוך ביותר של ספטמבר in ביטוי, נפרד ביטוי אל תוך
שדות שנטענים לתוכם A. השדות ממוקמים ב-A[1], A[2], ...,
A[n] ו-split() מחזירים את n, מספר השדות שהוא המספר של
התאמות פלוס אחד. נתונים שהוכנסו A שנראה מספרי הוא מוקלד מספר ו
מחרוזת.

פיצול רשומות לשדות עובד אותו הדבר למעט החלקים נטענים $1, $2, ...,
$NF. אם $0 זה ריק, NF מוגדר ל-0 והכל $i ל "".

מאוק מפצל קבצים לרשומות על ידי אותו אלגוריתם, אבל בהבדל הקל
RS הוא באמת מסיים במקום מפריד. (ORS הוא באמת גם טרמינטור).

למשל, אם FS = ":+" ו $0 = "a::b:" , אז NF = 3 ו- $1 = "א", $2 = "b" ו $3 =
"", אבל אם "a::b:" הוא התוכן של קובץ קלט ו RS = ":+", אז יש
שני רשומות "a" ו-"b".

RS = " " אינו מיוחד.

If FS = "", אז מאוק שוברת את השיא לדמויות בודדות, ובדומה,
לְפַצֵל(ס,א,"") ממקם את התווים האישיים של s אל תוך A.

12. רב קו רשום
השאלה היא איך? מאוק מפרש RS כביטוי רגולרי, רשומות מרובות שורות הן קלות. הגדרה RS
= "\n\n+", גורם לשורה ריקות אחת או יותר להפריד בין רשומות. אם FS = " " (ברירת המחדל),
ואז שורות חדשות בודדות, לפי הכללים עבור למעלה, הופכים למרחב ושורות חדשות בודדות הן
מפרידי שדות.

לדוגמה, אם קובץ הוא "ab\nc\n\n", RS = "\n\n+" ו FS = " ", אז יש
רשומה אחת "ab\nc" עם שלושה שדות "a", "b" ו-"c". מִשְׁתַנֶה FS = "\n", נותן
שני שדות "ab" ו-"c"; מִשְׁתַנֶה FS = "", נותן שדה אחד זהה ל-
תקליט.

אם אתה רוצה שקווים עם רווחים או טאבים ייחשבו ריקים, הגדר RS = "\n([ \t]*\n)+".
לתאימות עם awks אחרים, הגדרה RS ="" יש אותו אפקט כמו אם שורות ריקות
מופשטים מהחלק הקדמי והאחורי של קבצים ואז נקבעים רשומות כאילו RS =
"\n\n+". Posix דורש ש"\n" תמיד יפריד בין רשומות כאשר RS = "" ללא קשר ל-
ערך של FS. מאוק אינו תומך באמנה זו, מכיוון שהגדרת "\n" בתור
עושה את זה מיותר.

רוב הזמן כשאתה משתנה RS עבור רשומות מרובות שורות, תרצה גם לשנות
ORS ל-"\n\n" כך שמרווח הרשומות יישמר בפלט.

13. תָכְנִית הוצאת להורג
סעיף זה מתאר את סדר ביצוע התוכנית. ראשון ARGC מוגדר לסך הכל
מספר הארגומנטים של שורת הפקודה שהועברו לשלב הביצוע של התוכנית. ARGV[0] is
הגדר את השם של המתורגמן AWK ו ARGV[1] ... ARGV[ARGC-1] מחזיק את הנותרים
ארגומנטים של שורת הפקודה בלעדי אפשרויות ומקור תוכנית. למשל עם

mawk -f prog v=1 A t=hello B

ARGC = 5 עם ARGV[0] = "מאוק", ARGV[1] = "v=1", ARGV[2] = "א", ARGV[3] = "t=שלום" ו
ARGV[4] = "B".

הבא, כל אחד התחל החסימה מבוצעת לפי הסדר. אם התוכנית מורכבת כולה מ התחל
חוסם, ואז הביצוע מסתיים, אחרת זרם קלט נפתח והביצוע ממשיך.
If ARGC שווה ל-1, זרם הקלט מוגדר ל-stdin, אחרת הארגומנטים של שורת הפקודה
ARGV[1] ... ARGV[ARGC-1] נבדקים עבור ארגומנט קובץ.

הארגומנטים של שורת הפקודה מתחלקים לשלוש קבוצות: ארגומנטים של קובץ, ארגומנטים להקצאה
ומחרוזות ריקות "". למטלה יש את הטופס היה=מחרוזת. כאשר an ARGV[i] נבדקת
כארגומנט קובץ אפשרי, אם הוא ריק הוא מדלג; אם זו משימה
טיעון, המשימה ל היה מתרחש ו i מדלג לטיעון הבא; אַחֵר ARGV[i]
נפתח לקלט. אם הוא לא מצליח להיפתח, הביצוע מסתיים עם קוד יציאה 2. אם לא
ארגומנט שורת הפקודה הוא ארגומנט קובץ, ואז הקלט מגיע מ-stdin. Getline ב א התחל
פעולה פותחת קלט. "-" כארגומנט קובץ מציין stdin.

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

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

בדוגמה, ההקצאה v=1 מתרחשת לאחר ה- התחל פעולות מוצאים להורג, ו
הנתונים הממוקמים ב-v מוקלדים מספר ומחרוזת. הקלט נקרא לאחר מכן מקובץ A. בסוף
של קובץ A, t מוגדר למחרוזת "hello", ו-B נפתח לקלט. בסוף קובץ ב',
מה היא הסוף פעולות מוצאים להורג.

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

הבא
יציאה opt_expr

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

דוגמאות

1. לחקות חתול.

{ הדפס }

2. לחקות את wc.

{ chars += length($0) + 1 # הוסף אחד עבור \n
מילים += NF
}

END{ הדפס NR, מילים, תווים }

3. לספור את מספר ה"מילים האמיתיות" הייחודיות.

התחל { FS = "[^A-Za-z]+" }

{ for(i = 1 ; i <= NF ; i++) word[$i] = "" }

END { מחק מילה[""]
עבור (i במילה) cnt++
הדפס cnt
}

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

$1 ~ /credit|gain/ { sum += $2 }
$1 ~ /חיוב|הפסד/ { sum -= $2 }

END { סכום הדפסה }

5. מיין קובץ, השוואה כמחרוזת

{ line[NR] = $0 "" } # ודא שיש סוג השוואה
# למקרה שחלק מהשורות נראות מספריות

END { isort(line, NR)
for(i = 1 ; i <= NR ; i++) print line[i]
}

#insertion סוג של A[1..n]
function isort( A, n, i, j, hold)
{
for( i = 2 ; i <= n ; i++)
{
החזק = A[j = i]
while ( A[j-1] > החזקה )
{ j-- ; A[j+1] = A[j] }
A[j] = החזקה
}
# sentinel A[0] = "" ייווצר במידת הצורך
}

תְאִימוּת סוגיות

ההגדרה של Posix 1003.2 (טיוטה 11.3) של שפת ה-AWK היא AWK כמתואר ב-AWK
ספר עם כמה הרחבות שהופיעו ב-SystemVR4 nawk. ההרחבות הן:

פונקציות חדשות: toupper() ו-tolower().

משתנים חדשים: ENVIRON[] ו-CONVFMT.

מפרטי המרה של ANSI C עבור printf() ו-sprintf().

אפשרויות פקודה חדשות: -v var=value, אפשרויות -f מרובות ואפשרויות יישום
כטיעונים ל-W.

Posix AWK מכוון לפעול על קבצים שורה בכל פעם. RS ניתן לשנות מ"\n"
לדמות בודדת אחרת, אבל קשה למצוא לזה שימוש - אין
דוגמאות בספר AWK. לפי המוסכמה, RS = "", גורם לשורה ריקות אחת או יותר להפריד
רשומות, המאפשרות רשומות מרובות שורות. מתי RS = "", "\n" הוא תמיד מפריד שדות
ללא קשר לערך ב FS.

מאוק, מצד שני, מאפשר RS להיות ביטוי רגולרי. כאשר "\n" מופיע ב
רשומות, הוא מטופל כמרחב, ו FS תמיד קובע שדות.

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

התחל { RS = "[^A-Za-z]+" }

{ word[ $0 ] = "" }

END { מחק מילה[ "" ]
for(i במילה) cnt++
הדפס cnt
}

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

התוכנית הבאה מחליפה כל הערה ברווח בודד בקובץ תוכנית C,

התחל {
RS = "/\*([^*]|\*+[^/*])*\*+/"
תגובה אחת היא מפריד רשומות
ORS = " "
getline hold
}

{ הדפסת החזקה; החזק = $0 }

END { printf "%s" , החזק }

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

עם מאוק, כולם שווים,

x ~ /a\+b/ x ~ "a\+b" x ~ "a\\+b"

המחרוזות נסרקות פעמיים, פעם אחת כמחרוזת ופעם כביטוי רגולרי. על
סריקת מחרוזת, מאוק מתעלם מהבריחה על דמויות שאינן בריחה בעוד ספר AWK דוגל
\c להיות מוכר כ c מה שמחייב בריחה כפולה של מטא-תווים פנימה
מחרוזות. Posix מסרב במפורש להגדיר את ההתנהגות שכופה באופן פסיבי תוכניות
זה חייב לרוץ תחת מגוון של awks כדי להשתמש נייד יותר אבל פחות קריא, כפול
בריחה.

Posix AWK לא מזהה "/dev/std{out,err}" או \x hex רצפי בריחה במחרוזות.
בניגוד ל-ANSI C, מאוק מגביל את מספר הספרות שאחרי \x לשתיים כזרם
יישום תומך רק בתווים של 8 סיביות. המובנה לשטוף הופיע לראשונה ב-a
לאחרונה (1993) AT&T awk שוחרר ל-netlib, ואינו חלק מתקן posix.
מחיקה מצטברת עם להסיר מערך אינו חלק מתקן posix.

Posix עוזב במפורש את ההתנהגות של FS = "" לא מוגדר, ומזכיר פיצול של
להקליט לתווים כפירוש אפשרי, אבל כרגע השימוש הזה לא
נייד על פני יישומים.

לבסוף, הנה איך מאוק מטפל במקרים חריגים שלא נדונו בספר AWK או ב
טיוטת Posix. זה לא בטוח להניח עקביות על פני awks ובטוח לדלג אל הבא
סָעִיף.

substr(s, i, n) מחזירה את התווים של s בצומת של הסגור
מרווח [1, אורך(ים)] והמרווח החצי פתוח [i, i+n). כשזה
הצומת ריקה, המחרוזת הריקה מוחזרת; so substr("ABC", 1, 0) = ""
ו-substr("ABC", -4, 6) = "A".

כל מחרוזת, כולל המחרוזת הריקה, תואמת את המחרוזת הריקה בחזית כך,
s ~ // ו-s ~ "", הם תמיד 1 כמו התאמה(ים, //) והתאמה(ים, ""). השניים האחרונים
סט RLENGTH אל 0.

אינדקס(ים, t) זהה תמיד להתאמה(ים, t1) כאשר t1 זהה ל-t עם
דמויות מטא ברחו. לפיכך עקביות עם התאמה מחייבת את האינדקס(ים, "")
תמיד מחזיר 1. גם התנאי, index(s,t) != 0 אם ורק t הוא תת מחרוזת
של s, דורש index("","") = 1.

אם getline נתקל בסוף הקובץ, getline var, משאיר את var ללא שינוי. באופן דומה,
בכניסה ל הסוף פעולות, $0, השדות ו NF ערכם ללא שינוי
השיא האחרון.

השתמש ב-mawk באינטרנט באמצעות שירותי onworks.net