Est-il une boucle foreach en Aller?

Est-il un foreach construire dans le langage Go? Puis-je effectuer une itération sur une tranche de tableau ou à l'aide d'un for?

découvrez: groups.google.com/group/golang-nuts/browse_thread/thread/...
L'utilisation de range dans for boucles est également mentionné dans le "Une Parenthèse à propos des Types de la section" (vers la fin) de l'Aller tutoriel.

InformationsquelleAutor tatsuhirosatou | 2011-10-16

foreach go slice

741

http://golang.org/doc/go_spec.html#For_statements

Un "pour" avec une "gamme" de la clause parcourt toutes les entrées
d'un tableau, d'une tranche, d'une chaîne ou d'une carte, ou valeurs reçues sur un canal.
Pour chaque entrée, il attribue itération les valeurs correspondant à l'itération
les variables puis exécute le bloc.

Comme un exemple:
```
for index, element := range someSlice {
    //index is the index where we are
    //element is the element from someSlice for where we are
}
```
Si vous n'avez pas de soins sur l'index, vous pouvez utiliser _:
```
for _, element := range someSlice {
    //element is the element from someSlice for where we are
}
```
Le trait de soulignement, _, est le vide identificateur, un anonyme, un espace réservé.
- Dans cet exemple, element est le valeur de l'élément (une copie) -- il n'est pas l'élément lui-même. Bien que vous pouvez attribuer à element, cela n'affectera pas la sous-jacentes de la séquence.
- Je sais en Python et C, il est fréquent d'utiliser le trait de soulignement comme une fonction de la localisation ( c'est à dire le gettext ). L'utilisation du trait de soulignement la cause des problèmes en Aller ? Ne Vont même utiliser la même bibliothèque pour la localisation ?
- Py docs dit "(gettext) la fonction est généralement alias _() dans l'espace de noms local", qui est juste par convention, il ne fait pas partie de la localisation lib. Le trait de soulignement _ est une étiquette valide, et c'est aussi de la convention dans le jeu de Go (et de Python et de la Scala et d'autres langues) à affecter à _ pour les valeurs de retour vous ne l'utilisez pas. Le champ d'application de _ dans cet exemple est limitée au corps de la for boucle. Si vous avez un paquet dont l'étendue est fonction de _ ensuite, il serait de l'ombre à l'intérieur de la portée de la boucle for. Il y a quelques paquets pour la localisation, je n'ai pas vu toute utilisation _ comme un nom de fonction.
InformationsquelleAutor
121

Itérer sur tableau ou tranche:
```
//index and value
for i, v := range slice {}

//index only
for i := range slice {}

//value only
for _, v := range slice {}
```
Itérer sur un carte:
```
//key and value
for key, value := range theMap {}

//key only
for key := range theMap {}

//value only
for _, value := range theMap {}
```
Itérer sur un canal:
```
for v := range theChan {}
```
Une itération sur un canal est équivalent à la réception d'un canal jusqu'à la fermeture:
```
for {
    v, ok := <-theChan
    if !ok {
        break
    }
}
```
- Bien que l'OP n'a demandé pour la tranche d'utilisation, je préfère cette réponse, parce que la plupart finiront par les autres usages aussi.
- distinction importante à propos de la chan utilisation: allant sur un canal gracieusement sortir de la boucle si l'écrivain ferme le canal à un certain point. Dans le for {v := <-theChan} équivalent, il pas sortie sur le canal à proximité. Vous pouvez le tester via le deuxième ok valeur de retour. TOUR-EXEMPLE
- Pensais la même chose en le lisant, for { ... } est une boucle infinie.
InformationsquelleAutor Moshe Revah
13

L'exemple suivant montre comment utiliser la range opérateur dans un for boucle de mettre en œuvre un foreach boucle.
```
func PrintXml (out io.Writer, value interface{}) error {
    var data []byte
    var err error

    for _, action := range []func() {
        func () { data, err = xml.MarshalIndent(value, "", "  ") },
        func () { _, err = out.Write([]byte(xml.Header)) },
        func () { _, err = out.Write(data) },
        func () { _, err = out.Write([]byte("\n")) }} {
        action();
        if err != nil {
            return err
        }
    }
    return nil;
}
```
L'exemple itère sur un éventail de fonctions d'unifier la gestion des erreurs pour les fonctions. Un exemple complet est à Googles aire de jeux.

PS: il montre également que la pendaison accolades sont une mauvaise idée pour la lisibilité du code. Conseil: la for condition se termine juste avant la action() appel. Évident, n'est-ce pas?
- Ajouter un , et c'est plus clair où la for condition de fin: play.golang.org/p/pcRg6WdxBd - C'est effectivement la première fois que j'ai trouvé un contre-argument à la go fmt style, merci!
- les deux sont aller de l'esf valide; il suffit de choisir le meilleur 🙂
- Ce n'est pas le point si elle est valide. Le point est que, IMO c'est plus clair lorsque l'état se termine dans ce cas particulier ci-dessus.
- À mon avis, cette réponse est trop complexe pour la question ciblée.
- Comment le faire à la place, sans introduire de la redondance?
InformationsquelleAutor ceving
10

Vous pouvez en fait utiliser range sans référencement, c'est les valeurs de retour en utilisant for range contre votre type:
```
arr := make([]uint8, 5)
i,j := 0,0
for range arr {
    fmt.Println("Array Loop",i)
    i++
}

for range "bytes" {
    fmt.Println("String Loop",j)
    j++
}
```
https://play.golang.org/p/XHrHLbJMEd
- Bon à savoir, mais ça ne va pas être utile dans la plupart des cas
- Convenu @Sridhar c'est assez de niche.
InformationsquelleAutor robstarbuck

Qui suit est le code d'exemple de comment utiliser foreach dans golang

package main

import (
    "fmt"
)

func main() {

    arrayOne := [3]string{"Apple", "Mango", "Banana"}

    for index,element := range arrayOne{

        fmt.Println(index)
        fmt.Println(element)        

    }   

}

C'est un exemple https://play.golang.org/p/LXptmH4X_0

InformationsquelleAutor Nisal Edu

3

Oui, Gamme :

La plage de la forme de la boucle for parcourt une tranche ou d'une carte.

En passant sur une tranche, deux valeurs sont renvoyées pour chaque itération. Le premier est l'indice, et le second est une copie de l'élément à l'index.

Exemple :
```
package main

import "fmt"

var pow = []int{1, 2, 4, 8, 16, 32, 64, 128}

func main() {
    for i, v := range pow {
        fmt.Printf("2**%d = %d\n", i, v)
    }

    for i := range pow {
        pow[i] = 1 << uint(i) //== 2**i
    }
    for _, value := range pow {
        fmt.Printf("%d\n", value)
    }
}
```
- Vous pouvez ignorer l'indice ou de la valeur par l'attribution d' _.
- Si vous voulez seulement l'index, de la baisse de la valeur entièrement.
InformationsquelleAutor Amitesh

Ce qui peut être évident, mais vous pouvez insérer le tableau comme suit:

package main

import (
    "fmt"
)

func main() {
    for _, element := range [3]string{"a", "b", "c"} {
        fmt.Print(element)
    }
}

sorties:

abc

https://play.golang.org/p/gkKgF3y5nmt

InformationsquelleAutor jpihl

Vous devez vous connecter pour publier un commentaire.