Golang für Schleife

Schleifen sind eines der kritischsten Merkmale bei der Programmierung. Mithilfe von Schleifen können Sie wiederholt einen Codeblock ausführen, ohne ihn immer wieder neu zu schreiben. Schleifen helfen dabei.

Dieser Leitfaden wird uns beibringen, wie man mit Schleifen in der Go -Programmiersprache arbeitet.

Einführung

Im Gegensatz zu anderen Programmiersprachen, die über eine Schleife konstruiert werden und Schleifen machen, bietet Go ein Schleifenkonstrukt: die für die Schleife.

Obwohl es nur begrenzt erscheinen mag, können wir die for -Schleife erweitern, um andere Schleifenoperationen wie unendliche Schleifen, Iterien über Gegenstände, während Schleifen und mehr auszuführen.

Mithilfe eines einzelnen Schleifenkonstrukts können Sie sauberen und lesbaren Code verwalten, ohne sich Sorgen zu machen, welche Schleifenkonstrukte für einen bestimmten Vorgang verwendet werden sollen.

Gehen Sie für Schleifen

Lassen Sie uns diskutieren, wie man mit der für Loop in Go arbeitet. Wir klassifizieren A for Loop als Iterationsanweisung. Auf diese Weise können Sie für die Schleife wiederholt einen Codeblock für die angegebene Häufigkeit ausführen.

Beispiel.

Die Syntax von A for Loop in Go ist wie gezeigt:

für [init]; [Zustand]; [Post]
// Schleifenbetrieb

Das obige Beispiel verwendet den Klassiker für die Schleifensyntax. Wir beginnen mit der Definition einer ersten Aussage, gefolgt von der Schleifenbedingung und schließlich einer Postanweisung oder einer Inkrement- oder Dekrement -Operation.

Nehmen wir ein Beispiel, um Werte von 1 bis 10 zu drucken. Wir können eine einfache Schleife erstellen wie:

für i: = 0; ich <= 10; i++
fmt.Println (i)

Lassen Sie uns Teile der für die Schleife oben analysieren.

Wir beginnen damit, die erste Erklärung zu deklarieren. In unserem Beispiel deklarieren wir eine Variable namens I und weisen ihren Anfangswert als 0 zu.

Der nächste Teil ist der Schleifenzustand. Dadurch wird die Bedingung festgelegt, die überprüft wird und falls wahr ist, den Code in der für eine Schleife bis hin zu falsch ausführen. In unserem Beispiel prüfen wir, ob der Wert von I kleiner oder gleich 10 ist.

Der letzte Teil ist der Postzustand. Dies definiert die nach jeder Iteration der Schleife durchgeführte Aktion. In unserem Beispiel erhöhen wir den Wert von I durch den Einen mit dem Inkrementoperator (++) um eins um einen.

Das vollständige Code -Snippet ist wie gezeigt:

Paket Main
importieren "fmt"
funcmain ()
print_ten ()

funcprint_ten ()
fei: = 0; ich<= 10; i++
fmt.Println (i)

Sobald wir den oben genannten Code ausgeführt haben, sollten wir die Programm -Drucknummern von 1 bis 10 als:

$ go run for_loop.gehen
0
1
--- Ausgang abgeschnitten---
9
10

Die Schleife führt zehnmal aus, wobei jede Iteration den Wert von i um 1 erhöht. Dies geht weiter, bis der Wert von I nicht weniger als 10 beträgt. Sobald die Bedingung falsch ist, verlässt die Schleife.

Hinweis: Sie sind nicht darauf beschränkt, die erste Anweisung auf 0 festzulegen. Sie können alle gewünschten Wertebereich einstellen. Zum Beispiel können wir eine für Schleife erstellen, um die gerade Zahlen zwischen 20 und 50 zu drucken, wie gezeigt eine für die Schleife ist:

FORI: = 20; ich<50; i++
ifi%2 == 0
fmt.Println (i)

Im obigen Beispiel setzen wir den Anfangswert als 20 und eine Schleifenbedingung (wenn der Wert von I weniger als 50 beträgt). Wir nehmen dann den Wert von i und geben ihn an eine IF -Aussage weiter. Wenn ich mod 2 gleich 0 ist, drucken Sie i i.

Der obige Code druckt die geraden Zahlen im Bereich von 20 und 50.

$ go run for_loop.gehen
20
22
--- Code abgeschnitten ---
46
48

Denken Sie daran, dass Sie jede Operation als Post -Anweisung festlegen können, solange sie den Wert der ersten Anweisung pro Iteration ändert.

Zum Beispiel:

funcmodify_interval ()
fei: = 0; ich<100; i += 5
fmt.Println (i)

Im obigen Beispiel erhöhen wir den Wert von i um 5 pro REFOP -Iteration um 5 um 5.

Hinweis: Sie können auch einen Dekrementbetrieb als Post -Anweisung verwenden.

Verwenden Sie eine für eine Weile für Schleife für Schleife

Sie können eine Weile Schleife in Go erstellen, indem Sie eine einzige Komponente des For-Loop-Konstrukts verwenden. Wir können diese Methode auch als Bedingungsschleife bezeichnen.

Zum Beispiel:

I: = 1
FORI<5
fmt.Println (i)
ich++

Hier deklarieren wir die erste Aussage außerhalb des For-Loop-Blocks. In der für Schleife definieren wir die Bedingung, um zu prüfen, ob der Wert von I weniger als 5 liegt. Wenn wir wahr sind, führen wir die Operationen weiterhin innerhalb des For-Loop-Blocks aus.

Wir können das Break -Schlüsselwort verwenden, um die Schleife zu beenden, wenn eine bestimmte Bedingung erreicht ist.

für
ifi == 10
brechen

Verwenden einer für Schleife, um eine unendliche Schleife zu erstellen

Wir können auch eine unendliche Schleife unter Verwendung des For-Loop-Konstrukts erstellen. Wenn wir den Bedingungsteil der für die Schleife überspringen, erstellen wir eine unendliche Schleife, wie im folgenden Beispiel gezeigt:

I: = 0
für
ich++

Im Beispiel -Snippet oben läuft die Schleife für immer, da die Bedingung immer wahr ist.

Verwenden Sie für Schleifen, um Datentypen zu iterieren

Wir können auch eine für die Schleife verwenden, um verschiedene Datentypen wie Zeichenfolgen, Arrays und Scheiben zu iterieren. Diese Arten von Schleifen werden auch als Fachschleifen bezeichnet.

Zum Beispiel iteriert der Code unten über ein Array:

Datenbanken: = [] String "MongoDB", "SQL Server", "SQLite", "Cockroachdb", "Fauna DB"
fei: = 0; ichfmt.Println (Datenbanken [i])

Wenn ich geringer ist als die Länge des Arrays, drucken Sie jedes Element im Array aus und erhöhen Sie den Wert von i.

Wenn wir den obigen Code ausführen, sollten wir wie gezeigt eine Ausgabe erhalten:

$ go run for_loop.gehen
MongoDb
SQL Server
Sqlite
Kakerlachdb
Fauna db

Hier drucken wir jeden Element aus dem Array aus.

Wir können auch Karten iterieren, wie im folgenden Beispiel gezeigt:

my_map: = map [string] string
"ID": "1",
"Name": "Jonh Doe",
"Gehalt": "$ 150000",

Für Schlüssel, Wert: = Bereich my_map
fmt.Println (Schlüssel, Wert)

In diesem Beispiel iterieren wir über jeden Schlüssel und seinen zugeordneten Wert der Karte. Der obige Code sollte die Ausgabe als:

$ go run for_loop.gehen
Gehalt $ 150000
ID 1
Nennen Sie Jonh Doe

Schließen

Dieser Leitfaden untersuchte die Grundlagen der Arbeit mit Schleifen in der Go -Programmiersprache. Mithilfe von Schleifen können Sie wiederholt eine Reihe von Anweisungen ausführen, ohne den Code zu duplizieren.

Vielen Dank fürs Lesen und bleiben Sie auf dem Laufenden, um weitere Go -Tutorials zu erhalten.