Apakah ada cara untuk mengulangi berbagai bilangan bulat?

Rentang Go dapat beralih di atas peta dan irisan, tetapi saya bertanya-tanya apakah ada cara untuk beralih ke rentang angka, seperti ini:

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

Atau adakah cara untuk merepresentasikan rentang bilangan bulat di Go seperti yang dilakukan Ruby dengan Range kelas ?

Anda dapat, dan harus, hanya menulis untuk loop. Kode sederhana dan jelas adalah cara Go.

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

Berikut adalah program untuk membandingkan dua cara yang disarankan sejauh ini

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

Kompilasi seperti ini untuk menghasilkan pembongkaran

go build -gcflags -S iter.go

Ini jelas (saya telah menghapus instruksi dari daftar)

mempersiapkan

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

lingkaran

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     ,

Dan di sini adalah with_iter

mempersiapkan

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

lingkaran

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     ,

Jadi, Anda dapat melihat bahwa solusi iter jauh lebih mahal meskipun sepenuhnya inline pada fase setup. Pada fase loop ada instruksi tambahan di loop, tetapi itu tidak terlalu buruk.

Saya akan menggunakan sederhana untuk loop.

Disarankan oleh Mark Mishyn untuk menggunakan slice tetapi tidak ada alasan untuk membuat array dengan makedan digunakan dalam forslice yang dikembalikan ketika array yang dibuat melalui literal dapat digunakan dan itu lebih pendek

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

iter adalah paket yang sangat kecil yang hanya menyediakan cara yang berbeda secara sintetik untuk beralih lebih dari bilangan bulat.

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

Rob Pike (penulis Go) mengkritiknya :

Tampaknya hampir setiap kali seseorang menemukan cara untuk menghindari melakukan sesuatu seperti for loop dengan cara idiomatis, karena rasanya terlalu lama atau rumit, hasilnya hampir selalu lebih banyak penekanan tombol daripada hal yang seharusnya lebih pendek. [...] Yang mengesampingkan semua overhead gila ini "perbaikan" membawa.

Berikut ini adalah tolok ukur untuk membandingkan forpernyataan Go dengan ForClause dan rangepernyataan Go menggunakan iterpaket.

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
}

Keluaran:

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

Sementara saya bersimpati dengan kekhawatiran Anda tentang kekurangan fitur bahasa ini, Anda mungkin hanya ingin menggunakan forloop normal . Dan Anda mungkin akan lebih oke dengan itu daripada yang Anda pikirkan saat Anda menulis lebih banyak kode Go.

Saya menulis paket iter ini - yang didukung oleh forloop idiomatik sederhana yang mengembalikan nilai lebih dari chan int- dalam upaya untuk memperbaiki desain yang ditemukan di https://github.com/bradfitz/iter , yang telah ditunjukkan memiliki caching dan masalah kinerja, serta implementasi yang cerdas, aneh, dan tidak intuitif. Versi saya sendiri beroperasi dengan cara yang sama:

package main

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

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

Namun, pembandingan menunjukkan bahwa penggunaan saluran adalah pilihan yang sangat mahal. Perbandingan 3 metode, yang dapat dijalankan dari iter_test.godalam paket saya menggunakan

go test -bench=. -run=.

mengukur seberapa buruk kinerjanya

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

Dalam prosesnya, tolok ukur ini juga menunjukkan bagaimana bradfitzsolusi berkinerja buruk dibandingkan dengan forklausa bawaan untuk ukuran loop 10.

Singkatnya, sejauh ini tidak ada cara yang ditemukan untuk menduplikasi kinerja forklausa built-in sambil memberikan sintaksis sederhana untuk [0,n)seperti yang ditemukan di Python dan Ruby.

Yang memalukan karena mungkin akan mudah bagi tim Go untuk menambahkan aturan sederhana ke kompiler untuk mengubah garis seperti

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

ke kode mesin yang sama dengan for i := 0; i < 10; i++.

Namun, agar adil, setelah menulis sendiri iter.N(tetapi sebelum membuat tolok ukur), saya kembali melalui program yang baru ditulis untuk melihat semua tempat yang bisa saya gunakan. Sebenarnya tidak banyak. Hanya ada satu tempat, di bagian non-vital dari kode saya, di mana saya bisa bertahan tanpa forklausa default yang lebih lengkap .

Jadi walaupun mungkin terlihat seperti ini adalah kekecewaan besar untuk bahasa pada prinsipnya, Anda mungkin menemukan - seperti saya - bahwa Anda sebenarnya tidak benar-benar membutuhkannya dalam praktik. Seperti yang diketahui oleh Rob Pike sebagai generik, Anda mungkin tidak benar-benar melewatkan fitur ini sebanyak yang Anda kira akan terjadi.

Jika Anda ingin hanya mengulangi rentang tanpa menggunakan dan indeks atau apa pun, contoh kode ini berfungsi dengan baik untuk saya. Tidak perlu deklarasi tambahan, tidak _. Belum memeriksa kinerjanya.

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

PS Hari pertama di GoLang. Tolong, lakukan kritik jika itu pendekatan yang salah.

Anda juga dapat melihat github.com/wushilin/stream

Ini adalah aliran malas seperti konsep 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()

Semoga ini membantu

package main

import "fmt"

func main() {

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

Saya telah menulis sebuah paket di Golang yang meniru fungsi jangkauan Python:

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
}

Catatan: Saya telah menulis untuk bersenang-senang! Btw, kadang-kadang mungkin bermanfaat