Чи є спосіб перебрати цілий спектр цілих чисел?

Діапазон Go може повторювати карти та фрагменти, але мені було цікаво, чи є спосіб перебрати ряд діапазонів, як-от так:

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

Або є спосіб представити діапазон цілих чисел у Go, як Ruby робить з класом Range ?

Можна, і слід, просто написати цикл. Простий, очевидний код - це шлях.

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

Ось програма для порівняння двох запропонованих способів

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

Складіть так, щоб створити демонтаж

go build -gcflags -S iter.go

Ось звичайно (я не видалив інструкції зі списку)

налаштування

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

петля

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     ,

І ось з_iter

налаштування

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

петля

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     ,

Таким чином, ви можете бачити, що рішення ітера значно дорожче, хоча воно повністю вбудоване у фазі налаштування. У циклі циклу є додаткова інструкція щодо циклу, але це не дуже погано.

Я б використав простий для циклу.

Марк Мішин запропонував використовувати фрагмент, але немає причин створювати масив makeі використовувати у forповерненому фрагменті його, коли масив, створений за допомогою літералу, може бути використаний, і він коротший

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

iter - це дуже маленький пакет, який просто забезпечує синтаксично інший спосіб перебору чисел.

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

Роб Пайк (автор Go) критикував це :

Здається, що майже кожен раз, коли хтось придумує спосіб уникнути щось подібне до циклу ідіоматичним способом, тому що він відчуває себе занадто довгим або громіздким, в результаті майже завжди є більше натискань на клавіші, ніж річ, яка нібито коротша. [...] Це залишає осторонь усі божевільні накладні витрати, які ці "покращення" приносять.

Ось орієнтир для порівняння forоператора Go з форматом ForClause та Go rangeза допомогою iterпакета.

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
}

Вихід:

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

Хоча я схвалюю ваше занепокоєння з приводу відсутності цієї мовної функції, ви, мабуть, просто захочете використовувати звичайний forцикл. І вам, мабуть, буде з цим все гаразд, ніж ви думаєте, коли пишете більше Go-коду.

Я написав цей пакет iter - який підтримується простим, ідіоматичним forциклом, який повертає значення за a chan int- у спробі покращити дизайн, знайдений у https://github.com/bradfitz/iter , на який було зазначено, проблеми кешування та продуктивності, а також розумна, але дивна та неінтуїтивна реалізація. Моя власна версія працює так само:

package main

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

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

Однак бенчмаркінг виявив, що використання каналу було дуже дорогим варіантом. Порівняння трьох методів, за допомогою яких можна запустити iter_test.goв моєму пакеті

go test -bench=. -run=.

кількісно визначає, наскільки низькі його показники

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

У цьому процесі цей показник також показує, як bradfitzрішення має низькі результати порівняно з вбудованим forпунктом для розміру циклу 10.

Коротше кажучи, видається, що поки що не знайдено способу дублювання продуктивності вбудованого forпункту, надаючи простий синтаксис на [0,n)зразок того, що знайдений у Python та Ruby.

Що шкода, тому що, мабуть, команді Go було б легко додати до компілятора просте правило, щоб змінити рядок типу

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

до того ж машинного коду, що і for i := 0; i < 10; i++.

Однак, щоб бути справедливим, після написання свого власного iter.N(але перед порівняльним оцінкою) я повернувся через нещодавно написану програму, щоб побачити всі місця, де я міг би її використати. Насправді їх було не так багато. У нежиттєвому розділі мого коду було лише одне місце, куди я міг обійтись без більш повного за замовчуванням for.

Тож, хоча це може здатися, це величезне розчарування для мови в принципі, ви можете виявити - як і я, - що ви насправді цього не потребуєте на практиці. Як відомо, що Роб Пайк говорить про дженерики, ви, можливо, насправді не пропустите цю функцію настільки, наскільки думаєте, що хочете.

Якщо ви хочете просто повторити діапазон без використання та індексів чи чогось іншого, цей зразок коду для мене спрацював чудово. Ніякої додаткової декларації не потрібно, ні _. Хоча не перевірили продуктивність.

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

PS Найперший день у GoLang. Будь ласка, робіть критику, якщо це неправильний підхід.

Ви також можете перевірити github.com/wushilin/stream

Це ледачий потік, як концепція 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()

Сподіваюся, це допомагає

package main

import "fmt"

func main() {

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

Я написав пакет у Golang, який імітує функцію діапазону Python:

Пакет 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
}

Примітка: я написав для задоволення! Btw, іноді це може бути корисно