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 ?
Réponses:
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.goVoici 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 ,38boucle
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 ,74boucle
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.
runtime.makesliceet l'autre pas - je n'ai pas besoin d'un benchmark pour savoir que ça va être beaucoup plus lent!
runtime.makesliceest suffisamment intelligent pour ne pas allouer de mémoire si vous demandez une allocation de taille nulle. Cependant, ce qui précède l'appelle toujours, et selon votre benchmark, cela prend 10 nS de plus sur ma machine.
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)
}for range [5]int{} {
5s'agit d'un littéral et ne peut pas être déterminé au moment de l'exécution.
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.
iterversion utilise en fait moins de frappes, car rangeet iterse complétera automatiquement.
forboucles ne sont pas des citoyens de premier ordre d'Unix comme elles le sont. En outre, à la différence for, les seqflux de sortie standard d' une séquence de nombres. Il appartient au consommateur de décider ou non de les parcourir. Bien que ce for i in $(seq 1 10); do ... done soit courant dans Shell, ce n'est qu'une façon de faire une boucle for, qui n'est en soi qu'une façon de consommer la sortie de seq, bien que très courante.
i in range(10)exactement comme i := 0; i < 10; i++.
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/opDans 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.
non-constant array boundsur moi.
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