你也可以退房 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)    
    }
}

如果你只是想在一个w/o范围内使用和索引或其他东西进行迭代，这个代码样本对我来说很好。不需要额外的声明，没有_。不过，还没有检查性能。

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

附注:在戈朗的第一天。如果这是一种错误的方法，请进行批评。

虽然我很同情您对缺少这个语言特性的担忧，但您可能只想使用普通的for循环。当你编写更多的Go代码时，你可能会比你想象的更能接受这一点。

我编写了这个iter包——它由一个简单的、习惯的for循环支持，该循环通过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运行的3个方法的比较。放进我的包里

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

在这个过程中，这个基准测试还显示了与内置的for子句相比，对于大小为10的循环，bradfitz解决方案的性能如何不佳。

简而言之，到目前为止，似乎还没有发现一种方法可以复制内置for子句的性能，同时为[0,n)提供一种简单的语法，就像在Python和Ruby中发现的那样。

这是一个遗憾，因为Go团队可能很容易向编译器添加一个简单的规则来更改一行，如

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

与I:= 0相同的机器代码;I < 10;我+ +。

然而，公平地说，在我自己写完iter之后。N(但在对其进行基准测试之前)，我回顾了最近编写的程序，以查看所有可以使用它的地方。实际上并不多。在我的代码的非重要部分中，只有一个地方不需要使用更完整的default for子句。

因此，虽然从原则上看，这对语言来说是一个巨大的失望，但您可能会发现——就像我所做的那样——实际上在实践中并不真正需要它。就像Rob Pike所说的泛型一样，您可能不会像您想象的那样想念这个特性。

我用Golang写了一个包，它模仿了Python的range函数:

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

注意:我只是为了好玩才写的!顺便说一下，有时候可能会有帮助

问题不在于范围，而在于如何计算切片的末端。 对于固定的数字10，简单的for循环是可以的，但是对于像bfl.Size()这样的计算大小，你在每次迭代时都得到一个函数调用。大于int32的简单范围会有所帮助，因为这只计算bfl.Size()一次。

type BFLT PerfServer   
  func (this *BFLT) Call() {
    bfl := MqBufferLCreateTLS(0)                                                                                   
    for this.ReadItemExists() {                                                                                    
      bfl.AppendU(this.ReadU())                                                                                    
    }
    this.SendSTART()
    // size := bfl.Size() 
    for i := int32(0); i < bfl.Size() /* size */; i++ {                                                                             
      this.SendU(bfl.IndexGet(i))                                                                                  
    }
    this.SendRETURN()
  }