গো-এর পরিসীমা মানচিত্র এবং টুকরোগুলির মাধ্যমে পুনরাবৃত্তি করতে পারে তবে আমি ভাবছিলাম যে এই ধরণের কিছু সংখ্যার উপরে পুনরাবৃত্তি করার কোনও উপায় আছে কিনা:
for i := range [1..10] {
fmt.Println(i)
}
বা গো-র মধ্যে পূর্ণসংখ্যাগুলির পরিসীমা উপস্থাপন করার কোনও উপায় আছে কীভাবে রুবি ক্লাস রেঞ্জের সাথে করে ?
উত্তর:
আপনি করতে পারেন, এবং করা উচিত, লুপ জন্য একটি লিখুন। সরল, সুস্পষ্ট কোড হ'ল গো পথ।
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 ,
এবং এখানে with_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 ,সুতরাং আপনি দেখতে পারেন যে এটির সমাধানটি সেটআপ পর্যায়ে পুরোপুরি linedোকানো থাকা সত্ত্বেও এটি যথেষ্ট ব্যয়বহুল। লুপ পর্যায়ে লুপটিতে একটি অতিরিক্ত নির্দেশনা রয়েছে তবে এটি খুব খারাপ নয়।
আমি লুপের জন্য সহজটি ব্যবহার করব।
runtime.makesliceএবং অন্যটি করে না - আমার কাছে একটি বেঞ্চমার্কের দরকার নেই তা জানতে যে এটি অনেক ধীর হতে চলেছে!
runtime.makesliceযদি আপনি শূন্য আকারের বরাদ্দ চেয়ে থাকেন তবে কোনও মেমরি বরাদ্দ না করার জন্য হ্যাঁ যথেষ্ট চালাক। তবে উপরেরটি এখনও এটি কল করে এবং আপনার মাপদণ্ড অনুসারে আমার মেশিনে 10nS বেশি সময় নেয়।
এটি মার্ক মিশিনের দ্বারা স্লাইস ব্যবহার করার পরামর্শ দেওয়া হয়েছিল তবে আক্ষরিক মাধ্যমে তৈরি অ্যারে ব্যবহার করা যেতে পারে এবং এটি সংক্ষিপ্ত করে যখন এটির সাথে অ্যারে তৈরি করার makeএবং forএটির ফেরত স্লাইসে ব্যবহার করার কোনও কারণ নেই
for i := range [5]int{} {
fmt.Println(i)
}for range [5]int{} {
5এখানে আক্ষরিক এবং রান-টাইমে নির্ধারণ করা যায় না।
রাউটার একটি খুব ছোট প্যাকেজ যে শুধু পূর্ণসংখ্যার পুনরুক্তি উপর একটি syntantically অন্যভাবে প্রদান করে।
for i := range iter.N(4) {
fmt.Println(i)
}রব পাইক (গো এর লেখক) এটি সমালোচনা করেছেন :
দেখে মনে হয় যে প্রতিবারই কেউ মুশকিলভাবে লুপের জন্য কিছু করা এড়াতে কোনও উপায় নিয়ে আসে কারণ এটি খুব দীর্ঘ বা জটিল বলে মনে হয়, ফলটি প্রায় সবসময়ই সংক্ষিপ্ত আকারের চেয়ে বেশি কী-স্ট্রোক হয় is [...] এই সমস্ত "উন্নতি" আনা সমস্ত উন্মাদ ওভারহেডকে একপাশে ফেলেছে।
iterসংস্করণ বাস্তবে তার চেয়ে কম কীস্ট্রোকগুলি ব্যবহার কারণ rangeএবং iterস্বয়ংসম্পূর্ণ হবে।
forলুপগুলি ইউনিক্সের প্রথম শ্রেণির নাগরিক নয় যেমন তারা চলছে। এছাড়াও, বিপরীতে for, seqস্ট্যান্ডার্ডগুলি আউটপুটে সংখ্যার ক্রম হয়। তাদের উপর পুনরাবৃত্তি করা বা না করা গ্রাহকের উপর নির্ভর করে। যদিও for i in $(seq 1 10); do ... done শেলের মধ্যে প্রচলিত, লুপের জন্য এটি করার একমাত্র উপায়, এটি seqখুব সাধারণ উপায় সত্ত্বেও, আউটপুট গ্রাস করার একমাত্র উপায় ।
i in range(10)ঠিক ঠিক মতো আচরণের জন্য তৈরি করা যেতে পারে i := 0; i < 10; i++।
প্যাকেজটি ব্যবহার করে forএকটি ফোর ক্লাউজ এবং একটি গো rangeবিবৃতি দিয়ে Go স্টেটমেন্টের তুলনা করার জন্য একটি বেঞ্চমার্ক এখানে রয়েছে 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লুপ ব্যবহার করতে চান । আপনি আরও গো কোড লিখেছেন বলে আপনি যা ভাবেন তার চেয়ে আপনি সম্ভবত এটির চেয়ে আরও ভাল থাকবেন।
আমি এই ইটার প্যাকেজটি লিখেছি - যা একটি সাধারণ, আইডোমেটিক 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)
}
}তবে, বেঞ্চমার্কিং থেকে জানা গেছে যে একটি চ্যানেল ব্যবহার করা খুব ব্যয়বহুল বিকল্প ছিল। 3 টি পদ্ধতির তুলনা, যা 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)যায় নি।
যা লজ্জাজনক কারণ সম্ভবত গো দলের পক্ষে একটি লাইন পরিবর্তন করার জন্য সংকলকটিতে একটি সাধারণ নিয়ম যুক্ত করা সহজ হবে
for i := range 10 {
fmt.Println(i)
}হিসাবে একই মেশিন কোড for i := 0; i < 10; i++।
তবে, সত্যি কথা বলতে গেলে আমার নিজের লেখার পরে iter.N(তবে এটি বেঞ্চমার্ক করার আগে), আমি এটি ব্যবহার করতে পারি এমন সমস্ত জায়গাগুলি দেখতে সম্প্রতি একটি লিখিত প্রোগ্রামের মধ্য দিয়ে ফিরে গিয়েছিলাম। আসলে অনেক ছিল না। আমার কোডের একটি অ-জীবনী বিভাগে কেবল একটি স্পট ছিল, যেখানে আমি আরও সম্পূর্ণ, ডিফল্ট forধারা ছাড়াই পেতে পারি ।
নীতিগতভাবে ভাষার পক্ষে এটি হতাশার মতো দেখতে পাওয়া গেলেও আপনি খুঁজে পেতে পারেন - যেমন আমি করেছি - বাস্তবে আপনার বাস্তবে এটির প্রয়োজন নেই। রব পাইক যেমন জেনারিকদের জন্য বলা হিসাবে পরিচিত, আপনি সম্ভবত এই বৈশিষ্ট্যটি ততটা মিস করতে পারবেন না যতটা আপনি ভাবেন নিজের মতো করে।
আপনি যদি কেবল ডাব্লু / ও ব্যবহার করে এবং সূচকগুলি বা অন্য কোনও কিছুর উপর দিয়ে পুনরাবৃত্তি করতে চান তবে এই কোডের নমুনাটি আমার পক্ষে ঠিক কাজ করেছে। কোনও অতিরিক্ত ঘোষণার দরকার নেই, না _। যদিও পারফরম্যান্সটি পরীক্ষা করে দেখেনি।
for range [N]int{} {
// Body...
}পিএস GoLang প্রথম দিন। দয়া করে, যদি এটি কোনও ভুল পদ্ধতির হয় তবে সমালোচনা করুন।
non-constant array boundআমার দিকে ছুড়ে মারছে ।
আপনি 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)
}
}আমি গোলংয়ে একটি প্যাকেজ লিখেছি যা পাইথনের পরিসীমা কার্যকরী করে:
প্যাকেজ 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
}
দ্রষ্টব্য: আমি মজা করার জন্য লিখেছি! বিটিডব্লিউ, কখনও কখনও এটি সহায়ক হতে পারে