问题不在于范围，而在于如何计算切片的末端。 对于固定的数字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()
  }

package main

import "fmt"

func main() {

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

以下是一个紧凑的动态版本，不依赖于iter(但工作方式类似):

package main

import (
    "fmt"
)

// N is an alias for an unallocated struct
func N(size int) []struct{} {
    return make([]struct{}, size)
}

func main() {
    size := 1000
    for i := range N(size) {
        fmt.Println(i)
    }
}

通过一些调整，大小可以是uint64类型(如果需要)，但这是要点。

Mark Mishyn建议使用slice，但是没有理由使用make和use in来创建数组，因为通过literal创建的数组可以被使用，而且它更短

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

问题不在于范围，而在于如何计算切片的末端。 对于固定的数字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()
  }

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

希望这能有所帮助