ווי צו שרייַבן אַ BASH "פֿאַר" לופּ

ווי צו נוצן די BASH "for" loop in shell scripts

BASH (וואָס שטייט פֿאַר Bourne Again Shell) איז אַ סקריפּטינג שפּראַך יוטאַלייזד דורך רובֿ לינוקס און יוניקס באזירט אַפּערייטינג סיסטעמס.

איר קענען לויפן געלט קאַמאַנדז ין אַ וואָקזאַל פֿענצטער איינער נאָך דעם אנדערן אָדער איר קענען לייגן די קאַמאַנדז צו אַ טעקסט טעקע צו פּראָדוצירן אַ שאָל שריפט.

די גרויס זאַך וועגן שרייַבן שאָל סקריפּס איז אַז איר קענען לויפן זיי ווידער און ווידער. פֿאַר בייַשפּיל ימאַגינע איר דאַרפֿן צו לייגן אַ באַניצער צו אַ סיסטעם, שטעלן זייער פּערמישאַנז און פירן זייער סטאַרטינג סוויווע. איר קענען אָדער שרייַבן די קאַמאַנדז אויף אַ שטיק פון פּאַפּיר און לויפן זיי ווי איר לייגן נייַע ניצערס אָדער איר קענען שרייַבן אַ איין שריפט און פּונקט פאָרן פּאַראַמעטערס אין דעם שריפט.

סקריפּטינג שפּראַכן אַזאַ ווי BASH האָבן ענלעך פּראָגראַממינג קאַנסטראַקץ ווי אנדערע שפּראַכן. פֿאַר בייַשפּיל, איר קענען נוצן ימפּאָרט פּאַראַמעטערס צו באַקומען אַרייַנשרייַב פון די קלאַוויאַטור און קראָם זיי ווי וועריאַבאַלז. איר קענען דעריבער באַקומען די שריפט צו דורכפירן אַ זיכער קאַמף באזירט אויף די ווערט פון די אַרייַנשרייַב פּאַראַמעטערס .

א שליסל טייל פון קיין פּראָגראַממינג און סקריפּטינג שפּראַך איז די פיייקייַט צו לויפן די זעלבע שטיק פון קאָד ווידער און ווידער.

עס זענען אַ נומער פון וועגן צו איבערחזרן קאָד (אויך באקאנט ווי לופּס). אין דעם פירער, איר וועט זיין געוויזן ווי צו שרייַבן אַ "פֿאַר" שלייף.

א פֿאַר שלייף ריפּיץ אַ זיכער אָפּטיילונג פון די קאָד איבער און איבער. זיי זענען נוציק אַזוי אַז אַ סעריע פון ​​קאַמאַנדז קענען האַלטן פליסנדיק ביז אַ באַזונדער צושטאַנד איז באגעגנט, נאָך וואָס זיי וועלן האַלטן.

אין דעם וועגווייַזער, איר וועט זיין געוויזן פינף וועגן צו נוצן דעם פֿאַר שלייף ין אַ באַשולדיקן שריפט.

איידער געטינג סטאַרטעד

איידער איר אָנהייבן מיט די פֿאַר שלייף ביישפילן, איר דאַרפֿן צו עפענען אַ וואָקזאַל פֿענצטער און נאָכפאָלגן די טריט:

1. אַרייַן מקדיר סקריפּס ( לערן מער וועגן מקדיר דאָ )
2. אַרייַן קד סקריפּס (דאָס ענדערט די Directory צו סקריפּס )
3. אַרייַן nano examplen.sh (ווו n איז דער בייַשפּיל איר 'רע ארבעטן אויף)
4. אַרייַן די שריפט
5. דרוק קטרל + אָ צו ראַטעווען און קטרל + X צו אַרויסגאַנג
6. לויף באַס examplen.sh (ווידער, מיט n זייַענדיק דער בייַשפּיל איר 'רע ארבעטן מיט)

ווי צו לופּ דורך אַ רשימה

#! / בין / באַש
פֿאַר נומער אין 1 2 3 4 5
טאָן
echo $ number
געטאן
אַרויסגאַנג 0

די BASH וועג פון ניצן "פֿאַר" לופס איז עפּעס אַנדערש צו די וועג פון רובֿ אנדערע פּראָגראַממינג און סקריפּטינג שפּראַכן שעפּן "פֿאַר" לופס. זאל ס ברעכן די שריפט אַראָפּ ...

אין אַ זעץ "פֿאַר" שלייף אַלע, די סטייטמאַנץ צווישן טאָן און געטאן זענען געטאן אַמאָל פֿאַר יעדער פּאָזיציע אין דער רשימה.

אין דער אויבן בייַשפּיל, די רשימה איז אַלץ וואָס קומט נאָך די וואָרט אין (ד"ה 1 2 3 4 5).

יעדער מאָל די שלייף יטערייץ, דער ווייַטער ווערט אין דער רשימה איז ינסערטאַד אין די וועריאַבלי ספּעסאַפייד נאָך דעם וואָרט "פֿאַר" . אין די אויבן שלייף, די בייַטעוודיק איז גערופן נומער .

דער אפקלאנג דערקלערונג איז געניצט צו ווייַזן אינפֿאָרמאַציע צו די פאַרשטעלן.

דעריבער, דעם בייַשפּיל נעמט די נומערן 1 דורך 5 און רעזולטאַט זיי איינער דורך איינער צו די פאַרשטעלן:

• 1
• 2
• 3
• 4
• 5

ווי צו שלייף צווישן אַ אָנהייב און סוף פונט

די קאָנפליקט מיט דעם אויבן בייַשפּיל איז אַז אויב איר ווילן צו פּראָצעס אַ גרעסערער רשימה (זאָגן 1-500), עס וואָלט נעמען עלטער צו טיפּ אַלע נומערן אין דער ערשטער אָרט.

דאָס ברענגט אונדז צו די צווייטע משל וואָס ווייזט ווי צו ספּעציפיצירן אַ אָנהייב און סוף פונט:

#! / בין / באַש
פֿאַר נומער אין {1..10}
טאָן
עקאָ "$ נומער"
געטאן
אַרויסגאַנג 0

די כּללים זענען בייסיקלי די זעלבע. די וואַלועס נאָך דעם וואָרט " אין" מאַכן אַרויף די רשימה צו יטעראַטע דורך און יעדער ווערט אין דער רשימה איז געשטעלט אין די בייַטעוודיק (ד"ה נומער), און יעדער מאָל די שלייף יטערייץ, די סטייטמאַנץ צווישן טאָן און געטאן זענען געטאן.

דער הויפּט חילוק איז די וועג די רשימה איז געשאפן. די קורלי בראַקאַץ {} בייסיקלי דינאַמייד אַ קייט, און די קייט, אין דעם פאַל, איז 1-10 (די צוויי דאַץ באַזונדער די אָנהייב און סוף פון אַ קייט).

דעם בייַשפּיל, דעריבער, לויפט דורך יעדער נומער צווישן 1 און 10 און רעזולטאַט די נומער צו די פאַרשטעלן ווי גייט:

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10

דער זעלביקער שלייף קען האָבן געווען געשריבן ווי דאָס, מיט סינטאַקס יידעניקאַל צו דער ערשטער בייַשפּיל:

פֿאַר נומער אין 1 2 3 4 5 6 7 8 9 10

ווי צו האָפּקען נומבערס אין אַ קייט

די פרייַערדיק בייַשפּיל געוויזן ווי צו שלייף צווישן אַ אָנהייב און סוף פונט, אַזוי איצט מיר קוק אין ווי צו שפּרינגען נומערן אין די קייט.

ימאַגינע איר ווילן צו שלייף צווישן 0 און 100 אָבער נאָר ווייַזן יעדער צענט נומער. די פאלגענדע שריפט ווייזט ווי צו טאָן דאָס:

#! / בין / באַש
פֿאַר נומער אין {0..100..10}
טאָן
עקאָ "$ נומער"
געטאן
אַרויסגאַנג 0

די כּללים זענען בייסיקלי די זעלבע. עס איז אַ רשימה, אַ בייַטעוודיק, און אַ סכום פון סטייטמאַנץ צו זיין געטאן צווישן טאָן און געטאן . די רשימה דאָס מאָל קוקט ווי דאָס: {0..100..10}.

דער ערשטער נומער איז 0 און דער סוף נומער איז 100. די דריט נומער (10) איז די נומער פון זאכן אין דער רשימה וואָס עס וועט אַרויסלאָזן.

דער אויבן בייַשפּיל, דעריבער, דיספּלייז די ווייַטערדיק רעזולטאַט:

• 0
• 10
• 20
• 30
• 40
• 50
• 60
• 70
• 80
• 90
• 100

א מער טראדיציאנעלן קוקן פֿאַר לופּ

די בוש וועג פון שרייבן פֿאַר לופּס איז אַ ביסל מאָדנע ווען קאַמפּערד מיט אנדערע פּראָגראַממינג שפּראַכן.

איר קענען, אָבער, שרייַבן אַ פֿאַר שלייף אין אַ ענלעך נוסח צו די C פּראָגראַממינג שפּראַך, ווי דאָס:

#! / בין / באַש
פֿאַר ((נומער = 1, נומער <100, נומער + +))
{
אויב (($ נומער 5 == 0))
then
עקאָ "$ נומער איז דיוויזאַבאַל דורך 5"
פי
}
אַרויסגאַנג 0

דער שלייף סטאַרץ דורך באַשטעטיקן די בייַטעוודיק נומער צו 1 (נומער = 1 ). דער שלייף וועט האַלטן יטעראַטינג ווייל די ווערט פון אַ נומער איז ווייניקער ווי 100 ( נומער <100 ). די ווערט פון נומער ענדערונגען דורך אַדינג 1 צו עס נאָך יעדער יטעראַטיאָן ( נומער + + ).

אַלץ צווישן די געגרייַזלט בראַסעס איז געטאן דורך יעדער יטעראַטיאָן פון די שלייף.

די ביסל צווישן די ברייסאַז טשעקס די ווערט פון אַ נומער , דעפּאַזירן עס דורך 5, און קאַמפּערז די רעשט צו 0. אויב די רעשט איז 0 דעמאָלט די נומער איז דיוויזאַבאַל דורך 5 און איז דעמאָלט געוויזן אויף דעם עקראַן.

פֿאַר בייַשפּיל:

• 5 איז דיוויזאַבאַל דורך 5
• 10 איז דיוויזאַבאַל דורך 5
• 15 איז דיוויזאַבאַל דורך 5

אויב איר ווילן צו טוישן די טריט גרייס פון די יטעראַטיאָן, איר קענען ענדערן די נומער ++ אָפּטיילונג צו זיין נומער = נומער + 2 , נומער = נומער + 5 , אָדער נומער = נומער + 10 עטק.

דעם קענען זיין ווייַטער רידוסט צו נומער + = 2 אָדער נומער + = 5 .

א פּראַקטיש בייַשפּיל

פֿאַר לופּס קענען טאָן מער ווי יטעראַט רשימה פון נומערן. איר קענען פאקטיש נוצן די רעזולטאַט פון אנדערע קאַמאַנדז ווי די רשימה.

די ווייַטערדיק בייַשפּיל ווייזט ווי צו גער אַודיאָ טעקעס פון mp3 צו וואַוו :

#! / בין / באַש

דער רשימה אין דעם בייַשפּיל איז יעדער טעקע מיט די. מפּ 3 פאַרלענגערונג אין דעם קראַנט טעקע און די בייַטעוודיק איז אַ טעקע .

דער מפּג באַפֿעל קאַנווערץ די mp3 טעקע אין וואַוו. אָבער, איר מיסטאָמע דאַרפֿן צו ינסטאַלירן דאָס ניצן דיין פּעקל פאַרוואַלטער ערשטער.