Go1.23 रेंज-ओवर-फ़ंक सुविधा लेकर आया है जो वास्तविक रूप से उपयोग करने के लिए go1.22 में एक प्रयोग था। यदि किसी ने नमूना कोड पढ़ा है, तो आपको ऐसा करना पड़ सकता है थोड़ा देर तक ध्यान करें ऐसा मत करो. P'Yod आपको पढ़ने के लिए बहुत ही सरल तरीके से समझाएगा

रेंज क्लॉज वाले फॉर स्टेटमेंट्स की विशिष्टता से शुरू करते हुए, 3 प्रकार के एक्सप्रेशन जोड़े गए हैं:

func(func() bool)
func(func(V) bool)
func(func(K, V) bool)

मैं इस प्रकार समझाने के लिए एक वेरिएबल जोड़ना चाहूंगा

f func(yield func() bool)
f func(yield func(V) bool)
f func(yield func(K, V) bool)

स्पेक कहता है कि जब हम फ़ंक्शन एफ को क्रोध में एक अभिव्यक्ति के रूप में उपयोग करते हैं, तो हर बार जब हम फ़ंक्शन एफ को खत्म करने से पहले उपज फ़ंक्शन को कॉल करते हैं, तो हमें प्रत्येक लूप में परिणाम मिलता है। हमारे द्वारा उपज में डाले गए मूल्य के बराबर, जब मैं इसे समझाता हूं तब भी मैं भ्रमित हो जाता हूं। बेहतर कोड लिखें

func main() {
    for range loop {
        fmt.Println("-")
    }
}

func loop(yield func() bool) {
    yield()
    yield()
}

आउटपुट:

-
-

यदि हम इस तरह कोड लिखते हैं, तो हमें 2 पूर्ण लूप मिलेंगे क्योंकि हम स्पेक के अनुसार एफ में यील्ड को 2 बार कॉल करते हैं, यहां हम इसे लूप नाम देते हैं और यह हमें कुछ भी वापस नहीं करेगा। क्योंकि हम ऐसे पैटर्न का उपयोग करना चुनते हैं जो किसी भी तर्क को स्वीकार नहीं करता है

एक अन्य उदाहरण

func main() {
    for i := range loop {
        fmt.Println(i)
    }
}

func loop(yield func(int) bool) {
    yield(3)
    yield(7)
}

आउटपुट:

3
7

इस तरह हमें 2 राउंड भी मिलेंगे क्योंकि हम एक बार यील्ड कहते हैं और अब रेंज 2 मान लौटाएगा जो 3 और 7 हैं जिनका उपयोग हम हर बार यील्ड कॉल करने के लिए करते हैं

एक अन्य उदाहरण

func main() {
    for i := range loop {
        fmt.Println(i)
    }
}

func Loop(yield func(int, string) bool) {
    yield(3, "three")
    yield(5, "five")
    yield(7, "seven")
}

आउटपुट:

3 three
5 five
7 seven

हर बार हम जो यील्ड में डालते हैं उसके अनुसार हमें 3 लूप मिलेंगे और प्रति लूप 2 मान मिलेंगे
और हम किसी भी प्रकार के तर्क जैसे
डालकर यील्ड भी कह सकते हैं

func loop(yield func(string, bool) bool) {
    yield("three", true)
    yield("five", false)
    yield("seven", false)
}

अब हम इसके तंत्र को समझते हैं। जब हम कठिन उदाहरण पढ़ते हैं, तो हम और अधिक समझेंगे, जैसे कि गो विकी: रेंजफंक प्रयोग में उदाहरण

package slices

func Backward[E any](s []E) func(func(int, E) bool) {
    return func(yield func(int, E) bool) {
        for i := len(s)-1; i >= 0; i-- {
            if !yield(i, s[i]) {
                return
            }
        }
    }
}

मुख्य

s := []string{"hello", "world"}
for i, x := range slices.Backward(s) {
    fmt.Println(i, x)
}

पढ़ना बहुत आसान है, है ना? अंत में, इसे कैसे लागू करना है यह आप पर निर्भर है। हम सिर्फ यह देखते हैं कि यील्ड को कितनी बार बुलाया जाता है. यह आपको तभी मिलेगा जब आप इसे दायरे में रखेंगे
जो मूल्य निकलेगा वह उपज अंत में गिरा हुआ मूल्य है।