כיצד לעבד קו קובץ על ידי קו בתוך סקריפט לינוקס Bash

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

קבצים, טקסט, וניבים

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

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

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

קריאת שורות מתוך קובץ: אניה-One

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

 ינואר
פברואר
מרץ
.
.
אוֹקְטוֹבֶּר
נוֹבֶמבֶּר
בדצמבר 

בנות שורה אחת פשוטה שלנו היא:

 ואילו קו קריאה; לעשות קו $ הד; בוצע & lt; data.txt 

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

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

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

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

 n \ ינואר
n \ פבואר
n \ במרץ
.
.
n \ אוקטובר
n \ נובמבר
דצמבר \ n 

בואו נשתמש בנות השורה האחת שלנו על הקובץ החדש שלנו.

 ואילו קו קריאה; לעשות קו $ הד; בוצע & lt; data2.txt 

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

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

קוראים שורות מקובץ באמצעות סקריפט

הנה התסריט שלנו. זה נקרא "script1.sh."

    #! / Bin / bash  
 
  מונה =  0 
 
  בעוד   IFS =   ''   לקרוא   -r   LinefromFile  [116 ] ||   [[  -n   "  $ {LinefromFile}  "  ] ];   לעשות  
 
  ((  נגד   ++  ))  
  הד   "גישה לקו   מונה $  :   $ {LinefromFile}  " [9 ] 
 
  עשה   & lt;   "  1 $  "    

קבענו משתנה בשם דֶלְפֵּק לאפס, אז אנחנו מגדירים שלנו בזמן לוּלָאָה.

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

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

אנחנו הולכים לקרוא שורת טקסט לתוך משתנה בשם LinefromFile . אנו משתמשים -r (לקרוא מהלך סרק כמו נורמלי אופי) אפשרות להתעלם backslashes. הם יטופלו כמו כל דמות אחרת ולא יקבל שום יחס מיוחד.

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

• לקרוא -r LinefromFile : כאשר שורת טקסט נקראת בהצלחה המקובצת, את לקרוא הפקודה שולחת אות הצלחה אל בזמן , וה בזמן הלולאה עוברת את זרימת ביצוע לגוף של הלולאה. הערה כי לקרוא הפקודה צריכה לראות אופי שורה חדש בסוף שורת הטקסט כדי לשקול אותו לקרוא מוצלח. אם הקובץ אינו POSIX קובץ טקסט תואם את השורה האחרונה לא תכלול אופי שורה חדש . אם לקרוא הפקודה רואה את סימון סוף הקובץ (EOF) לפני הקו הסתיים בעקבות שורה חדשה, זה יהיה לֹא להתייחס אליו כאל קריאה מוצלחת. אם זה יקר, את השורה האחרונה של טקסט לא תועבר לגוף של הלולאה לא תטופל.
• [-N "$ {LinefromFile}"] : אנחנו צריכים לעשות קצת עבודה נוספת כדי להתמודד עם קבצים תואמים שאינם POSIX. השוואה זו בודקת את הטקסט כי הוא לקרוא מהקובץ. אם זה לא נסתיים עם אופי שורה חדש, השוואה זו עדיין תחזור הצלחה אל בזמן לוּלָאָה. מבטיחה זה שכל שברי קו נגרר מעובדים על ידי הגוף של הלולאה.

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

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

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

העתק והדבק את הסקריפט לתוך עורך ולשמור אותו עם הקובץ "script1.sh." להשתמש ב chmod פקודה כדי לעשות את זה הפעלה .

 chmod + x script1.sh 

בואו לראות מה התסריט שלנו הופך את קובץ הטקסט data2.txt ואת backslashes הכיל בתוכו.

 ./ script1.sh data2.txt 

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

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

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

הנה איך אנחנו יכולים לעשות את זה. זהו "script2.sh."

אנו מגדירים שלנו דֶלְפֵּק משתנה כמו קודם, ולאחר מכן אנו מגדירים פונקציה שנקראת process_line () . ההגדרה של פונקציה חייבת להופיע לפני הפונקציה נקראת הראשונה בתסריט.

הפונקציה שלנו הולכת להיות עברה את הקו החדש לקריאה של טקסט בכול איטרציה של בזמן לוּלָאָה. אנחנו יכולים לגשת הערך כי בתוך הפונקציה על ידי שימוש $ 1 מִשְׁתַנֶה. אם היו שני משתנים מועברים לפונקציה, נוכל לגשת ערכים אלה באמצעות $ 1 ו $ 2 , וכן הלאה עבור משתנה יותר.

ה- W hile לולאה היא בעיקר אותו. יש רק שינוי אחד בתוך הגוף של הלולאה. ה הֵד קו הוחלף קריאה process_line () פוּנקצִיָה. שים לב שאתה לא צריך להשתמש "()" בסוגריים בשם הפונקציה כאשר אתם קוראים לזה.

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

כי דֶלְפֵּק הוכרז בגוף העיקרי של התסריט ולא בתוך פונקציה, ניתן להפנות אותו בתוך process_line () פוּנקצִיָה.

העתק או הקלד את התסריט הנ"ל לתוך עורך ולשמור אותו עם הקובץ "script2.sh." תעשה את זה הפעלה עם chmod -

 chmod + x script2.sh 

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

 ינואר
פברואר
מרץ
.
.
אוֹקְטוֹבֶּר
טקסט נובמבר \ n עוד "בסוף השורה"
דצמבר 

הפקודה שלנו היא:

 ./ script2.sh data3.txt 

הקווים הם לקרוא מהקובץ ועבר אחד אחד אל process_line () פוּנקצִיָה. כל הקווים מוצגים כראוי, כולל אחד מוזר עם backspace, במרכאות, ומילים רבות בה.

אבני הבניין שימושי

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