Gibt es eine Möglichkeit, über einen Bereich von Ganzzahlen zu iterieren?

Der Bereich von Go kann über Karten und Slices iterieren, aber ich habe mich gefragt, ob es eine Möglichkeit gibt, über einen Bereich von Zahlen zu iterieren, etwa so:

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

Oder gibt es eine Möglichkeit, den Bereich von Ganzzahlen in Go so darzustellen, wie Ruby es mit der Klasse Range macht ?

Sie können und sollten einfach eine for-Schleife schreiben. Einfacher, offensichtlicher Code ist der Go-Weg.

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

Hier ist ein Programm zum Vergleich der beiden bisher vorgeschlagenen Methoden

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()
}

Kompilieren Sie wie folgt, um eine Demontage zu generieren

go build -gcflags -S iter.go

Hier ist klar (ich habe die Nicht-Anweisungen aus der Liste entfernt)

Konfiguration

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

Schleife

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     ,

Und hier ist with_iter

Konfiguration

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

Schleife

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     ,

Sie sehen also, dass die Iter-Lösung erheblich teurer ist, obwohl sie in der Einrichtungsphase vollständig integriert ist. In der Schleifenphase gibt es eine zusätzliche Anweisung in der Schleife, aber es ist nicht so schlimm.

Ich würde die einfache for-Schleife verwenden.

Es wurde von Mark Mishyn vorgeschlagen, Slice zu verwenden, aber es gibt keinen Grund, ein Array mit makeund ein forzurückgegebenes Slice davon zu erstellen , wenn ein über Literal erstelltes Array verwendet werden kann und es kürzer ist

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

iter ist ein sehr kleines Paket, das nur eine syntantisch andere Möglichkeit bietet, über ganze Zahlen zu iterieren.

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

Rob Pike (ein Autor von Go) hat es kritisiert :

Es scheint, dass fast jedes Mal, wenn jemand einen Weg findet, um zu vermeiden, dass so etwas wie eine for-Schleife auf idiomatische Weise ausgeführt wird, weil es sich zu lang oder umständlich anfühlt, das Ergebnis fast immer mehr Tastenanschläge sind als das, was angeblich kürzer ist. [...] Abgesehen von all dem verrückten Aufwand, den diese "Verbesserungen" mit sich bringen.

Hier ist ein Benchmark zum Vergleichen einer Go- forAnweisung mit einer ForClause- und einer Go- rangeAnweisung unter Verwendung des iterPakets.

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
}

Ausgabe:

$ 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
$

Obwohl ich Ihre Besorgnis über das Fehlen dieser Sprachfunktion bedauere, möchten Sie wahrscheinlich nur eine normale forSchleife verwenden. Und Sie werden wahrscheinlich mehr damit einverstanden sein, als Sie denken, wenn Sie mehr Go-Code schreiben.

Ich habe dieses Iter-Paket geschrieben, das von einer einfachen, idiomatischen forSchleife unterstützt wird, die Werte über a zurückgibt chan int, um das Design in https://github.com/bradfitz/iter zu verbessern, auf das hingewiesen wurde Caching- und Leistungsprobleme sowie eine clevere, aber seltsame und nicht intuitive Implementierung. Meine eigene Version funktioniert genauso:

package main

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

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

Das Benchmarking ergab jedoch, dass die Verwendung eines Kanals eine sehr teure Option war. Der Vergleich der 3 Methoden, die iter_test.goin meinem Paket mit ausgeführt werden können

go test -bench=. -run=.

quantifiziert, wie schlecht seine Leistung ist

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

Dabei zeigt dieser Benchmark auch, wie bradfitzschlecht die Lösung im Vergleich zur integrierten forKlausel für eine Schleifengröße von ist 10.

Kurz gesagt, es scheint bisher keine Möglichkeit zu geben, die Leistung der integrierten forKlausel zu duplizieren und gleichzeitig eine einfache Syntax für bereitzustellen[0,n) wie in Python und Ruby bereitzustellen.

Das ist eine Schande, denn für das Go-Team wäre es wahrscheinlich einfach, dem Compiler eine einfache Regel hinzuzufügen, um eine Zeile wie zu ändern

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

auf den gleichen Maschinencode wie for i := 0; i < 10; i++.

Um fair zu sein, habe ich nach dem Schreiben meines eigenen iter.NProgramms (aber vor dem Benchmarking) ein kürzlich geschriebenes Programm durchgesehen, um alle Stellen zu sehen, an denen ich es verwenden konnte. Es waren eigentlich nicht viele. Es gab nur eine Stelle in einem nicht wichtigen Abschnitt meines Codes, an der ich ohne die vollständigere Standardklausel auskommen konnte for.

Während es so aussieht, als wäre dies im Prinzip eine große Enttäuschung für die Sprache, werden Sie - wie ich - feststellen, dass Sie es in der Praxis eigentlich nicht wirklich brauchen. Wie Rob Pike für Generika bekannt ist, verpassen Sie diese Funktion möglicherweise nicht so sehr, wie Sie denken.

Wenn Sie nur über einen Bereich ohne Verwendung von und Indizes oder irgendetwas anderem iterieren möchten, hat dieses Codebeispiel für mich gut funktioniert. Keine zusätzliche Erklärung erforderlich, nein _. Ich habe die Leistung jedoch nicht überprüft.

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

PS Der allererste Tag in GoLang. Bitte kritisieren Sie, wenn es ein falscher Ansatz ist.

Sie können auch github.com/wushilin/stream besuchen

Es ist ein fauler Stream wie das Konzept von 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()

Hoffe das hilft

package main

import "fmt"

func main() {

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

Ich habe in Golang ein Paket geschrieben, das die Bereichsfunktion von Python nachahmt:

Paket 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
}

Hinweis: Ich habe zum Spaß geschrieben! Übrigens kann es manchmal hilfreich sein