הבנה עבור Loops in Go

לולאת for היא משפט זרימת בקרה המשמשת לביצוע שוב ושוב בלוק קוד. ב-Go, לולאת for היא מבנה הלולאה היחיד.

אתה יכול להשתמש בלולאת for כדי לחזור על בלוקים של קוד ולדמות מגוון שלם של לולאות משפות אחרות, כולל עבור...כל, לולאות while, ו-do...while-לולאות.

התקן עבור להתחלה

תוודא שיש לך לך להתקין לעקוב. רוב הדוגמאות הללו דורשות את fmt חבילה, ואתה צריך להשתמש במבנה כולל כמו זה:

חֲבִילָה רָאשִׁי
יְבוּא "fmt"
funcרָאשִׁי() {
// הקוד נכנס לכאן
}

שלושה רכיבים עבור Loop in Go

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

לאתחול; מַצָב; הודעה {
 הצהרות)
}

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

עבור i := 1; אני <= 5; i++ {
fmt.הדפסה(אני)
}

כאן:

• ערכות האתחול אני ל 1
• התנאי הוא אני <= 5
• הצהרת הפוסט היא i++

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

לולאה לכל אחד ב-Go

ל-Go אין לולאה לכל אחד, אבל אתה יכול לשנות לולאת for כדי לעבור אוסף של אלמנטים. הנה התחביר:

עבור אינדקס, ערך := אוסף טווח {
// גוף
}

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

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

עבור _, ערך := פרוסת טווח {}

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

מערך := []מחרוזת{"שלום", "עוֹלָם"}
ל i, j := טווח מַעֲרָך {
fmt.הדפסה(אני, י)
}

A While Loop in Go

אתה יכול להשתמש בלולאת for כדי להשיג תוך פונקציונליות לולאה. בעוד לולאת while, משפט פועל כל עוד התנאי נשאר אמיתי. שקול את הדברים הבאים:

אני := 1
עבורי <= 5 {
	i *= 2
}
fmt.הדפסה(אני)

בקוד זה, בעוד אני קטן או שווה ל-5, הוא מוכפל ב-2 בכל פעם שהלולאה פועלת.

A Do...While Loop in Go

לולאת ה-do...while שונה מלולאת ה-while שכן גוף הלולאה יבוצע לפחות פעם אחת. ישנן שתי גישות ליישם זאת ב-Go.

1. ודא שהתנאי עבור האיטרציה הראשונה מוגדר כ-true.

   אני := 10
   ל הבא := נָכוֹן; הַבָּא; הבא = i <= 5 {
   fmt.הדפסה(אני)
    i++
   }
   // ידפיס 10 
   

   מכיוון שהתנאי ההתחלתי מוגדר כאמת, אני מודפס ולאחר מכן גדל באיטרציה הראשונה. מאז המצב (אני <=5) מוערך ל-false במהלך האיטרציה השנייה, הלולאה יוצאת.
2. בצע את גוף הלולאה פעם אחת לפני בדיקת המצב.

   אני := 10
   ל {
   fmt.הדפסה(אני)
    i++
   אם אני >= 5 {
   לשבור;
    }
   }
   // ידפיס 10
   

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

הצהרות זרימת בקרה אחרות

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

מה חדש ב-Go גרסה 1.18

קרא הבא