Phạm vi của Go có thể lặp lại trên các bản đồ và lát, nhưng tôi đã tự hỏi liệu có cách nào để lặp lại trên một phạm vi số hay không, đại loại như thế này:
for i := range [1..10] {
fmt.Println(i)
}Hoặc có cách nào để biểu thị phạm vi số nguyên trong Go như cách Ruby thực hiện với Phạm vi lớp không?
Câu trả lời:
Bạn có thể, và nên, chỉ cần viết một vòng lặp for. Mã đơn giản, rõ ràng là cách đi.
for i := 1; i <= 10; i++ {
fmt.Println(i)
}Đây là một chương trình để so sánh hai cách được đề xuất cho đến nay
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()
}Biên dịch như thế này để tạo ra sự tháo gỡ
go build -gcflags -S iter.goĐây là đơn giản (Tôi đã xóa các hướng dẫn không có trong danh sách)
thiết lập
0035 (/home/ncw/Go/iter.go:14) MOVQ $0,AX
0036 (/home/ncw/Go/iter.go:14) JMP ,38vòng
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 ,Và đây là with_iter
thiết lập
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 ,74vòng
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 ,Vì vậy, bạn có thể thấy rằng giải pháp iter đắt hơn đáng kể mặc dù nó được hoàn toàn nội tuyến trong giai đoạn thiết lập. Trong giai đoạn vòng lặp có một hướng dẫn bổ sung trong vòng lặp, nhưng nó không quá tệ.
Tôi sẽ sử dụng vòng lặp đơn giản.
runtime.makeslicevà giải pháp khác thì không - Tôi không cần điểm chuẩn để biết rằng sẽ chậm hơn rất nhiều!
runtime.makesliceđủ thông minh để không phân bổ bất kỳ bộ nhớ nếu bạn yêu cầu phân bổ kích thước bằng không. Tuy nhiên, ở trên vẫn gọi nó, và theo điểm chuẩn của bạn sẽ mất 10nS lâu hơn trên máy của tôi.
Mark Mishyn đã đề xuất sử dụng lát cắt nhưng không có lý do gì để tạo mảng với makevà sử dụng trong forlát cắt trả về của nó khi mảng được tạo qua nghĩa đen có thể được sử dụng và nó ngắn hơn
for i := range [5]int{} {
fmt.Println(i)
}for range [5]int{} {
5ở đây là một nghĩa đen và không thể được xác định tại thời điểm chạy.
iter là một gói rất nhỏ chỉ cung cấp một cách tổng hợp khác nhau để lặp qua các số nguyên.
for i := range iter.N(4) {
fmt.Println(i)
}Rob Pike (một tác giả của Go) đã chỉ trích nó :
Dường như hầu như mỗi khi ai đó nghĩ ra một cách để tránh làm điều gì đó như vòng lặp theo cách thành ngữ, bởi vì nó quá dài hoặc cồng kềnh, kết quả gần như luôn luôn là nhiều lần nhấn phím hơn so với điều được cho là ngắn hơn. [...] Điều đó đã bỏ qua tất cả những chi phí điên rồ mà những "cải tiến" này mang lại.
iterphiên bản thực sự sử dụng ít tổ hợp phím hơn rangevà itersẽ tự động hoàn tất.
forcác vòng lặp không phải là công dân hạng nhất của Unix giống như họ đang đi. Bên cạnh đó, không giống như for, seqluồng đến đầu ra tiêu chuẩn một chuỗi số. Có hay không lặp đi lặp lại trên chúng là tùy thuộc vào người tiêu dùng. Mặc dù for i in $(seq 1 10); do ... done là phổ biến trong Shell, nhưng đó chỉ là một cách để thực hiện một vòng lặp for, mà bản thân nó chỉ là một cách để tiêu thụ đầu ra seq, mặc dù là một cách rất phổ biến.
i in range(10)chính xác như thế nào i := 0; i < 10; i++.
Đây là một điểm chuẩn để so sánh một Go for câu lệnh với câu lệnh ForClause và Go rangebằng cách sử dụng itergói.
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
}Đầu ra:
$ 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
$Trong khi tôi đồng ý với mối quan tâm của bạn về việc thiếu tính năng ngôn ngữ này, có lẽ bạn sẽ chỉ muốn sử dụng một ngôn ngữ bình thường for vòng lặp . Và có lẽ bạn sẽ ổn với điều đó hơn bạn nghĩ khi bạn viết nhiều mã Go hơn.
Tôi đã viết gói iter này - được hỗ trợ bởi một forvòng lặp đơn giản, thành ngữ trả về các giá trị trên a chan int- trong nỗ lực cải thiện thiết kế được tìm thấy trong https://github.com/bradfitz/iter , được chỉ ra là có các vấn đề về bộ nhớ đệm và hiệu năng, cũng như một cách thực hiện thông minh, nhưng lạ và không trực quan. Phiên bản của riêng tôi hoạt động theo cùng một cách:
package main
import (
"fmt"
"github.com/drgrib/iter"
)
func main() {
for i := range iter.N(10) {
fmt.Println(i)
}
}Tuy nhiên, điểm chuẩn cho thấy việc sử dụng kênh là một lựa chọn rất tốn kém. Việc so sánh 3 phương thức có thể được chạy iter_test.gotrong gói của tôi bằng cách sử dụng
go test -bench=. -run=.định lượng hiệu suất của nó kém như thế nào
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/opTrong quá trình, điểm chuẩn này cũng cho thấy bradfitzgiải pháp hoạt động kém hơn so với formệnh đề tích hợp cho kích thước vòng lặp là10 .
Nói tóm lại, cho đến nay dường như không có cách nào được phát hiện để nhân đôi hiệu suất của formệnh đề tích hợp trong khi cung cấp một cú pháp đơn giản cho[0,n) giống như tìm thấy trong Python và Ruby.
Thật là xấu hổ vì có lẽ sẽ dễ dàng cho nhóm Go thêm một quy tắc đơn giản vào trình biên dịch để thay đổi một dòng như
for i := range 10 {
fmt.Println(i)
}để mã máy giống như for i := 0; i < 10; i++.
Tuy nhiên, để công bằng, sau khi tự viết iter.N(nhưng trước khi điểm chuẩn nó), tôi đã quay lại một chương trình được viết gần đây để xem tất cả những nơi tôi có thể sử dụng nó. Thật sự không có nhiều. Chỉ có một vị trí, trong một phần không quan trọng trong mã của tôi, nơi tôi có thể nhận được mà không cần mặc định đầy đủ hơnfor mệnh đề .
Vì vậy, mặc dù có vẻ như đây là một sự thất vọng lớn đối với ngôn ngữ về nguyên tắc, bạn có thể thấy - giống như tôi đã làm - rằng bạn thực sự không cần nó trong thực tế. Giống như Rob Pike được biết là nói về thuốc generic, bạn có thể không thực sự bỏ lỡ tính năng này nhiều như bạn nghĩ.
Nếu bạn muốn chỉ lặp đi lặp lại trong một phạm vi sử dụng và chỉ mục hoặc bất cứ điều gì khác, mẫu mã này hoạt động tốt với tôi. Không cần khai báo thêm, không _. Mặc dù không kiểm tra hiệu suất.
for range [N]int{} {
// Body...
}PS Ngày đầu tiên ở GoLang. Xin vui lòng, phê bình nếu đó là một cách tiếp cận sai.
non-constant array boundvào tôi.
Bạn cũng có thể kiểm tra github.com/wushilin/stream
Nó là một luồng lười biếng như khái niệm về 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()Hi vọng điêu nay co ich
package main
import "fmt"
func main() {
nums := []int{2, 3, 4}
for _, num := range nums {
fmt.Println(num, sum)
}
}Tôi đã viết một gói trong Golang bắt chước hàm phạm vi của Python:
Gói 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
}
Lưu ý: Tôi đã viết cho vui! Btw, đôi khi nó có thể hữu ích