Existe-t-il un moyen d'itérer sur une tranche en sens inverse en Go ?

Question

Il serait pratique de pouvoir dire quelque chose comme :

for _, element := reverse range mySlice {
        ...
}

Answer 1

Je suppose que c'est la façon la plus simple d'inverser des tableaux.. :

package main

import "fmt"

// how can we reverse write the array
func main() {

    arr := [...]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
    revArr := [len(arr)]int{} // making empty array for write reverse

    for i := range arr {
        revArr[len(arr)-1-i] = arr[i]
    }

    fmt.Println(revArr)
}

https://play.golang.org/p/QQhj26-FhtF

Answer 2

Une méthode élégante pour reverse range :

Si votre tranche est transitoire : Bouclez tant que le nombre d'éléments est supérieur à zéro, utilisez le dernier élément, puis supprimez-le. La tranche sera vide après le traitement du premier élément :

s := []int{1, 2, 3, 4}
for len(s) > 0 {
    item := s[len(s)-1]
    fmt.Printf("Reverse item: %+v\n", item)
    s = s[:len(s)-1]
}

Sortie :

Reverse item: 4
Reverse item: 3
Reverse item: 2
Reverse item: 1

Go Playground : https://play.golang.org/p/XKB43k7M9j3

Answer 3

Lorsque j'ai besoin d'extraire des éléments d'une tranche et d'une plage inversée, j'utilise quelque chose comme ce code :

// reverse range
// Go Playground: https://play.golang.org/p/gx6fJIfb7fo
package main

import (
    "fmt"
)

type Elem struct {
    Id   int64
    Name string
}

type Elems []Elem

func main() {
    mySlice := Elems{{Id: 0, Name: "Alice"}, {Id: 1, Name: "Bob"}, {Id: 2, Name: "Carol"}}
    for i, element := range mySlice {
        fmt.Printf("Normal  range: [%v] %+v\n", i, element)
    }

    //mySlice = Elems{}
    //mySlice = Elems{{Id: 0, Name: "Alice"}}
    if last := len(mySlice) - 1; last >= 0 {
        for i, element := last, mySlice[0]; i >= 0; i-- {
            element = mySlice[i]
            fmt.Printf("Reverse range: [%v] %+v\n", i, element)
        }
    } else {
        fmt.Println("mySlice empty")
    }
}

Sortie :

Normal  range: [0] {Id:0 Name:Alice}
Normal  range: [1] {Id:1 Name:Bob}
Normal  range: [2] {Id:2 Name:Carol}
Reverse range: [2] {Id:2 Name:Carol}
Reverse range: [1] {Id:1 Name:Bob}
Reverse range: [0] {Id:0 Name:Alice}

Terrain de jeux : https://play.golang.org/p/gx6fJIfb7fo

Answer 4

Vous pouvez utiliser le funk.ForEachRight méthode de go-funk :

results := []int{}

funk.ForEachRight([]int{1, 2, 3, 4}, func(x int) {
    results = append(results, x)
})

fmt.Println(results) // []int{4, 3, 2, 1}