Existe-t-il un moyen d'itérer sur une plage d'entiers?

La plage de Go peut itérer sur des cartes et des tranches, mais je me demandais s'il existe un moyen d'itérer sur une plage de nombres, quelque chose comme ceci:

for i := range [1..10] {
    fmt.Println(i)
}

Ou y a-t-il un moyen de représenter une plage d'entiers dans Go comme le fait Ruby avec la classe Range ?

Vous pouvez, et devriez, simplement écrire une boucle for. Un code simple et évident est la voie à suivre.

for i := 1; i <= 10; i++ {
    fmt.Println(i)
}

Voici un programme pour comparer les deux méthodes suggérées jusqu'à présent

import (
    "fmt"

    "github.com/bradfitz/iter"
)

func p(i int) {
    fmt.Println(i)
}

func plain() {
    for i := 0; i < 10; i++ {
        p(i)
    }
}

func with_iter() {
    for i := range iter.N(10) {
        p(i)
    }
}

func main() {
    plain()
    with_iter()
}

Compilez comme ça pour générer le désassemblage

go build -gcflags -S iter.go

Voici clair (j'ai supprimé les instructions non de la liste)

installer

0035 (/home/ncw/Go/iter.go:14) MOVQ    $0,AX
0036 (/home/ncw/Go/iter.go:14) JMP     ,38

boucle

0037 (/home/ncw/Go/iter.go:14) INCQ    ,AX
0038 (/home/ncw/Go/iter.go:14) CMPQ    AX,$10
0039 (/home/ncw/Go/iter.go:14) JGE     $0,45
0040 (/home/ncw/Go/iter.go:15) MOVQ    AX,i+-8(SP)
0041 (/home/ncw/Go/iter.go:15) MOVQ    AX,(SP)
0042 (/home/ncw/Go/iter.go:15) CALL    ,p+0(SB)
0043 (/home/ncw/Go/iter.go:15) MOVQ    i+-8(SP),AX
0044 (/home/ncw/Go/iter.go:14) JMP     ,37
0045 (/home/ncw/Go/iter.go:17) RET     ,

Et voici avec_iter

installer

0052 (/home/ncw/Go/iter.go:20) MOVQ    $10,AX
0053 (/home/ncw/Go/iter.go:20) MOVQ    $0,~r0+-24(SP)
0054 (/home/ncw/Go/iter.go:20) MOVQ    $0,~r0+-16(SP)
0055 (/home/ncw/Go/iter.go:20) MOVQ    $0,~r0+-8(SP)
0056 (/home/ncw/Go/iter.go:20) MOVQ    $type.[]struct {}+0(SB),(SP)
0057 (/home/ncw/Go/iter.go:20) MOVQ    AX,8(SP)
0058 (/home/ncw/Go/iter.go:20) MOVQ    AX,16(SP)
0059 (/home/ncw/Go/iter.go:20) PCDATA  $0,$48
0060 (/home/ncw/Go/iter.go:20) CALL    ,runtime.makeslice+0(SB)
0061 (/home/ncw/Go/iter.go:20) PCDATA  $0,$-1
0062 (/home/ncw/Go/iter.go:20) MOVQ    24(SP),DX
0063 (/home/ncw/Go/iter.go:20) MOVQ    32(SP),CX
0064 (/home/ncw/Go/iter.go:20) MOVQ    40(SP),AX
0065 (/home/ncw/Go/iter.go:20) MOVQ    DX,~r0+-24(SP)
0066 (/home/ncw/Go/iter.go:20) MOVQ    CX,~r0+-16(SP)
0067 (/home/ncw/Go/iter.go:20) MOVQ    AX,~r0+-8(SP)
0068 (/home/ncw/Go/iter.go:20) MOVQ    $0,AX
0069 (/home/ncw/Go/iter.go:20) LEAQ    ~r0+-24(SP),BX
0070 (/home/ncw/Go/iter.go:20) MOVQ    8(BX),BP
0071 (/home/ncw/Go/iter.go:20) MOVQ    BP,autotmp_0006+-32(SP)
0072 (/home/ncw/Go/iter.go:20) JMP     ,74

boucle

0073 (/home/ncw/Go/iter.go:20) INCQ    ,AX
0074 (/home/ncw/Go/iter.go:20) MOVQ    autotmp_0006+-32(SP),BP
0075 (/home/ncw/Go/iter.go:20) CMPQ    AX,BP
0076 (/home/ncw/Go/iter.go:20) JGE     $0,82
0077 (/home/ncw/Go/iter.go:20) MOVQ    AX,autotmp_0005+-40(SP)
0078 (/home/ncw/Go/iter.go:21) MOVQ    AX,(SP)
0079 (/home/ncw/Go/iter.go:21) CALL    ,p+0(SB)
0080 (/home/ncw/Go/iter.go:21) MOVQ    autotmp_0005+-40(SP),AX
0081 (/home/ncw/Go/iter.go:20) JMP     ,73
0082 (/home/ncw/Go/iter.go:23) RET     ,

Ainsi, vous pouvez voir que la solution iter est considérablement plus chère même si elle est entièrement intégrée dans la phase de configuration. Dans la phase de boucle, il y a une instruction supplémentaire dans la boucle, mais ce n'est pas trop mal.

J'utiliserais la simple boucle for.

Il a été suggéré par Mark Mishyn d'utiliser slice, mais il n'y a aucune raison de créer un tableau avec makeet de l'utiliser dans la fortranche renvoyée de celui-ci lorsqu'un tableau créé via un littéral peut être utilisé et qu'il est plus court

for i := range [5]int{} {
        fmt.Println(i)
}

iter est un tout petit package qui fournit juste une manière syntantiquement différente d'itérer sur des entiers.

for i := range iter.N(4) {
    fmt.Println(i)
}

Rob Pike (un auteur de Go) l' a critiqué :

Il semble que presque chaque fois que quelqu'un trouve un moyen d'éviter de faire quelque chose comme une boucle for de manière idiomatique, car cela semble trop long ou trop encombrant, le résultat est presque toujours plus de frappes que ce qui est censé être plus court. [...] Cela laisse de côté tous les frais généraux fous que ces "améliorations" apportent.

Voici un benchmark pour comparer une forinstruction Go avec une ForClause et une rangeinstruction Go à l'aide du iterpackage.

iter_test.go

package main

import (
    "testing"

    "github.com/bradfitz/iter"
)

const loops = 1e6

func BenchmarkForClause(b *testing.B) {
    b.ReportAllocs()
    j := 0
    for i := 0; i < b.N; i++ {
        for j = 0; j < loops; j++ {
            j = j
        }
    }
    _ = j
}

func BenchmarkRangeIter(b *testing.B) {
    b.ReportAllocs()
    j := 0
    for i := 0; i < b.N; i++ {
        for j = range iter.N(loops) {
            j = j
        }
    }
    _ = j
}

// It does not cause any allocations.
func N(n int) []struct{} {
    return make([]struct{}, n)
}

func BenchmarkIterAllocs(b *testing.B) {
    b.ReportAllocs()
    var n []struct{}
    for i := 0; i < b.N; i++ {
        n = iter.N(loops)
    }
    _ = n
}

Production:

$ go test -bench=. -run=.
testing: warning: no tests to run
PASS
BenchmarkForClause      2000       1260356 ns/op           0 B/op          0 allocs/op
BenchmarkRangeIter      2000       1257312 ns/op           0 B/op          0 allocs/op
BenchmarkIterAllocs 20000000            82.2 ns/op         0 B/op          0 allocs/op
ok      so/test 7.026s
$

Bien que je compatisse avec votre inquiétude concernant l'absence de cette fonctionnalité de langue, vous allez probablement vouloir simplement utiliser un for boucle . Et vous serez probablement plus d'accord avec cela que vous ne le pensez en écrivant plus de code Go.

J'ai écrit ce package iter - qui est soutenu par une simple forboucle idiomatique qui renvoie des valeurs sur a chan int- dans le but d'améliorer la conception trouvée dans https://github.com/bradfitz/iter , qui a été signalée comme ayant des problèmes de mise en cache et de performances, ainsi qu'une implémentation intelligente, mais étrange et peu intuitive. Ma propre version fonctionne de la même manière:

package main

import (
    "fmt"
    "github.com/drgrib/iter"
)

func main() {
    for i := range iter.N(10) {
        fmt.Println(i)
    }
}

Cependant, l'analyse comparative a révélé que l'utilisation d'un canal était une option très coûteuse. La comparaison des 3 méthodes, qui peuvent être exécutées à partir iter_test.gode mon package en utilisant

go test -bench=. -run=.

quantifie à quel point ses performances sont médiocres

BenchmarkForMany-4                   5000       329956 ns/op           0 B/op          0 allocs/op
BenchmarkDrgribIterMany-4               5    229904527 ns/op         195 B/op          1 allocs/op
BenchmarkBradfitzIterMany-4          5000       337952 ns/op           0 B/op          0 allocs/op

BenchmarkFor10-4                500000000         3.27 ns/op           0 B/op          0 allocs/op
BenchmarkDrgribIter10-4            500000      2907 ns/op             96 B/op          1 allocs/op
BenchmarkBradfitzIter10-4       100000000        12.1 ns/op            0 B/op          0 allocs/op

Dans le processus, ce test de bradfitzperformance montre également comment la solution sous-performante par rapport à la forclause intégrée pour une taille de boucle de 10.

En bref, il ne semble y avoir aucun moyen découvert jusqu'à présent de dupliquer les performances de la forclause intégrée tout en fournissant une syntaxe simple pour[0,n) comme celle trouvée dans Python et Ruby.

Ce qui est dommage car il serait probablement facile pour l'équipe Go d'ajouter une règle simple au compilateur pour changer une ligne comme

for i := range 10 {
    fmt.Println(i)
}

au même code machine que for i := 0; i < 10; i++.

Cependant, pour être honnête, après avoir écrit le mien iter.N(mais avant de le comparer), je suis revenu sur un programme récemment écrit pour voir tous les endroits où je pouvais l'utiliser. Il n'y en avait pas beaucoup. Il n'y avait qu'un seul endroit, dans une section non vitale de mon code, où je pourrais me débrouiller sans la forclause par défaut plus complète .

Donc, même si cela peut sembler être une énorme déception pour la langue en principe, vous pouvez constater - comme je l'ai fait - que vous n'en avez pas vraiment besoin dans la pratique. Comme Rob Pike est connu pour le dire pour les génériques, vous ne manquerez peut-être pas cette fonctionnalité autant que vous le pensez.

Si vous souhaitez simplement itérer sur une plage sans utiliser d'index et ou quoi que ce soit d'autre, cet exemple de code a très bien fonctionné pour moi. Aucune déclaration supplémentaire nécessaire, non _. Je n'ai pas vérifié les performances, cependant.

for range [N]int{} {
    // Body...
}

PS Le tout premier jour à GoLang. S'il vous plaît, faites une critique si c'est une mauvaise approche.

Vous pouvez également consulter github.com/wushilin/stream

C'est un flux paresseux comme le concept de java.util.stream.

// It doesn't really allocate the 10 elements.
stream1 := stream.Range(0, 10)

// Print each element.
stream1.Each(print)

// Add 3 to each element, but it is a lazy add.
// You only add when consume the stream
stream2 := stream1.Map(func(i int) int {
    return i + 3
})

// Well, this consumes the stream => return sum of stream2.
stream2.Reduce(func(i, j int) int {
    return i + j
})

// Create stream with 5 elements
stream3 := stream.Of(1, 2, 3, 4, 5)

// Create stream from array
stream4 := stream.FromArray(arrayInput)

// Filter stream3, keep only elements that is bigger than 2,
// and return the Sum, which is 12
stream3.Filter(func(i int) bool {
    return i > 2
}).Sum()

J'espère que cela t'aides

package main

import "fmt"

func main() {

    nums := []int{2, 3, 4}
    for _, num := range nums {
       fmt.Println(num, sum)    
    }
}

J'ai écrit un package dans Golang qui imite la fonction range de Python:

Paquet https://github.com/thedevsaddam/iter

package main

import (
    "fmt"

    "github.com/thedevsaddam/iter"
)

func main() {
    // sequence: 0-9
    for v := range iter.N(10) {
        fmt.Printf("%d ", v)
    }
    fmt.Println()
    // output: 0 1 2 3 4 5 6 7 8 9

    // sequence: 5-9
    for v := range iter.N(5, 10) {
        fmt.Printf("%d ", v)
    }
    fmt.Println()
    // output: 5 6 7 8 9

    // sequence: 1-9, increment by 2
    for v := range iter.N(5, 10, 2) {
        fmt.Printf("%d ", v)
    }
    fmt.Println()
    // output: 5 7 9

    // sequence: a-e
    for v := range iter.L('a', 'e') {
        fmt.Printf("%s ", string(v))
    }
    fmt.Println()
    // output: a b c d e
}

Remarque: j'ai écrit pour le plaisir! Btw, parfois cela peut être utile