Golang pour Loop

Les boucles sont l'une des fonctionnalités les plus critiques de la programmation. À l'aide de boucles, vous pouvez exécuter à plusieurs reprises un bloc de code sans le réécrire encore et encore. Les boucles aident à réduire les erreurs de code et à améliorer la lisibilité en supprimant la nécessité de dupliquer un morceau de code plusieurs fois dans le même programme.

Ce guide nous apprendra à travailler avec des boucles dans le langage de programmation Go.

Introduction

Contrairement à d'autres langages de programmation qui figurent sur une construction de boucle tels que While and Make Loops, Go fournit une construction de boucle: la boucle pour.

Bien que cela puisse sembler limité, nous pouvons étendre la boucle pour effectuer d'autres opérations de boucle telles que des boucles infinies, itérer sur les éléments, tandis que les boucles, et plus.

L'utilisation d'une seule construction en boucle vous permet de maintenir un code propre et lisible sans souci que les constructions de boucle à utiliser pour une opération spécifique.

Faire une boucle

Discutons de la façon de travailler avec la boucle pour aller. Nous classons une boucle pour une déclaration d'itération. Cela signifie qu'une boucle pour vous permet d'exécuter à plusieurs reprises un bloc de code pour le nombre spécifié de fois.

Par exemple, vous pouvez exécuter imprimer quelque chose x nombre de fois ou lire le processus un nombre spécifique de fois.

La syntaxe d'une boucle pour GO est comme indiqué:

pour [init]; [condition]; [poste]
// Fonctionnement de la boucle

L'exemple ci-dessus utilise le classique pour la syntaxe de boucle. Nous commençons par définir une déclaration initiale suivie de la condition de boucle, et enfin une déclaration de poste ou une augmentation ou une opération de décrémentation.

Prenons un exemple pour imprimer des valeurs de 1 à 10. Nous pouvons créer une boucle simple pour:

pour i: = 0; je <= 10; i++
fmt.Println (i)

Laissez-nous disséquer les parties de la boucle pour.

Nous commençons par déclarer l'énoncé initial. Dans notre exemple, nous déclarons une variable appelée I et attribuons sa valeur initiale comme 0.

La partie suivante est la condition de boucle. Cela définit la condition à vérifier et, si elle est vraie, continuez à exécuter le code à l'intérieur de la boucle pour une boucle jusqu'à ce que FAUX. Dans notre exemple, nous vérifions si la valeur de i est inférieure ou égale à 10.

La dernière partie est que le poste indique. Cela définit l'action à effectuer après chaque itération de la boucle. Dans notre exemple, nous augmentons la valeur de I par un en utilisant l'opérateur d'incrément (++).

L'extrait de code complet est comme indiqué:

package principal
Importer "FMT"
funcmain ()
print_ten ()

funcprint_ten ()
fori: = 0; je<= 10; i++
fmt.Println (i)

Une fois que nous exécutons le code ci-dessus, nous devrions voir les numéros d'impression du programme de 1 à 10 comme:

$ va courir pour_loop.aller
0
1
--- sortie tronquée---
9
dix

La boucle s'exécute 10 fois, où chaque itération augmente la valeur de i par 1. Cela continue jusqu'à ce que la valeur de i ne soit pas inférieure à 10. Une fois la condition fausse, la boucle sort.

Remarque: vous n'êtes pas limité à la définition de l'instruction initiale sur 0. Vous pouvez définir n'importe quelle plage de valeurs souhaitée. Par exemple, nous pouvons créer une boucle pour une boucle pour imprimer les nombres pair entre 20 et 50 en utilisant une boucle pour une boucle comme indiqué:

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

Dans l'exemple ci-dessus, nous définissons la valeur initiale comme 20 et une condition de boucle (si la valeur de i est inférieure à 50). Nous prenons ensuite la valeur de I et le transmettons à une déclaration IF. Si je mod 2 est égal à 0, alors imprimez I.

Le code ci-dessus imprime les nombres pair dans la plage de 20 et 50.

$ va courir pour_loop.aller
20
22
--- code tronqué ---
46
48

Gardez à l'esprit que vous pouvez définir n'importe quelle opération comme l'énoncé de poste tant qu'il modifie la valeur de l'énoncé initial par chaque itération.

Par exemple:

funcmodify_interval ()
fori: = 0; je<100; i += 5
fmt.Println (i)

Dans l'exemple ci-dessus, nous incrémentons la valeur de I par 5 par chaque boucle itération.

Remarque: vous pouvez également utiliser une opération de décrémentation comme instruction POST.

Utilisation d'une boucle pour une boucle

Vous pouvez créer une boucle de temps en utilisant en utilisant un seul composant de la construction en boucle pour. Nous pouvons également faire référence à cette méthode comme une boucle de condition.

Par exemple:

i: = 1
fori<5
fmt.Println (i)
je++

Ici, nous déclarons la déclaration initiale en dehors du bloc de boucle pour. À l'intérieur de la boucle FOR, nous définissons la condition pour vérifier si la valeur de i est inférieure à 5. Si c'est vrai, nous continuons à effectuer les opérations à l'intérieur du bloc de boucle pour.

Nous pouvons utiliser le mot-clé Break pour terminer la boucle lorsqu'une condition spécifique est atteinte.

pour
ifi == 10
casser

Utilisation d'une boucle pour créer une boucle infinie

Nous pouvons également créer une boucle infinie en utilisant la construction de boucle pour. Si nous ignorons la partie de condition de la boucle FOR, nous créons une boucle infinie comme indiqué dans l'exemple ci-dessous:

i: = 0
pour
je++

Dans l'exemple de l'extrait ci-dessus, la boucle fonctionnera pour toujours car la condition est toujours vraie.

En utilisant pour les boucles pour itérer sur les types de données

Nous pouvons également utiliser une boucle pour itérer sur divers types de données tels que les chaînes, les tableaux et les tranches. Ces types de boucles sont également connues sous le nom de boucles à portée de main.

Par exemple, le code ci-dessous itère sur un tableau:

Bases de données: = [] String "MongoDB", "SQL Server", "SQLite", "Cockroachdb", "Fauna DB"
fori: = 0; jefmt.Println (bases de données [i])

Si je suis inférieur à la longueur du tableau, imprimez chaque élément dans le tableau et augmentez la valeur de i.

Si nous exécutons le code ci-dessus, nous devons obtenir une sortie comme indiqué:

$ va courir pour_loop.aller
Mongodb
serveur SQL
Sqlite
Cafrachdb
Fauna DB

Ici, nous imprimons chaque élément du tableau.

Nous pouvons également parcourir les cartes, comme indiqué dans l'exemple ci-dessous:

my_map: = map [string] String
"id": "1",
"Nom": "Jonh Doe",
"Salaire": "150000 $",

pour la clé, valeur: = plage my_map
fmt.Println (clé, valeur)

Dans cet exemple, nous itérons sur chaque clé et sa valeur associée de la carte. Le code ci-dessus doit renvoyer la sortie comme suit:

$ va courir pour_loop.aller
salaire 150000 $
ID 1
Nom Jonh Doe

Fermeture

Ce guide a exploré les bases du travail avec des boucles dans le langage de programmation Go. À l'aide de boucles, vous pouvez exécuter à plusieurs reprises un ensemble d'instructions sans dupliquer le code.

Merci d'avoir lu et restez à l'écoute pour plus de tutoriels Go.