लैम्ब्डा उम्मीद के मुताबिक काम करते हैं:
func main() {
inc := func(x int) int { return x+1; }
}
हालाँकि, एक घोषणा के अंदर निम्नलिखित घोषणा की अनुमति नहीं है:
func main() {
func inc(x int) int { return x+1; }
}
किस कारण से नेस्टेड फ़ंक्शन की अनुमति नहीं है?
inc()वास्तविक घोषणा से पहले दूसरे उदाहरण में कॉल कर सकते हैं । परंतु! मैं कारणों की तलाश कर रहा हूं, मुझे गो के बारे में ज्यादा जानकारी नहीं है लेकिन मैं सीखना चाहूंगा कि इस नियम के पीछे तर्क क्या था।
जवाबों:
मुझे लगता है कि इस स्पष्ट सुविधा की अनुमति नहीं देने के 3 कारण हैं
हालांकि वे सिर्फ मेरी राय हैं - मैंने भाषा डिजाइनरों से आधिकारिक घोषणा नहीं देखी है।
निश्चित ही वे हैं। आपको बस उन्हें एक चर में निर्दिष्ट करना है:
func main() {
inc := func(x int) int { return x+1; }
}
var inc func(int) int
अक्सर पूछे जाने वाले प्रश्न (एफएक्यू)
हर भाषा में उपन्यास की विशेषताएं होती हैं और किसी की पसंदीदा विशेषता को छोड़ देती है। गो को प्रोग्रामिंग की फेसेलिटी, संकलन की गति, अवधारणाओं की ऑर्थोगोनलिटी, और कंसीडर और कचरा संग्रह जैसी सुविधाओं का समर्थन करने की आवश्यकता पर ध्यान दिया गया था। आपकी पसंदीदा विशेषता गायब हो सकती है क्योंकि यह फिट नहीं है, क्योंकि यह संकलन की गति या डिजाइन की स्पष्टता को प्रभावित करता है, या क्योंकि यह मूल सिस्टम मॉडल को बहुत मुश्किल बना देगा।
यदि यह आपको परेशान करता है कि Go में सुविधा X गायब है, तो कृपया हमें क्षमा करें और उन सुविधाओं की जांच करें जो Go के पास हैं। आप पा सकते हैं कि वे एक्स की कमी के लिए दिलचस्प तरीकों से क्षतिपूर्ति करते हैं।
नेस्टेड फ़ंक्शंस को जोड़ने की जटिलता और खर्च का क्या औचित्य होगा? क्या आप ऐसा करना चाहते हैं कि आप नेस्टेड कार्यों के बिना नहीं कर सकते हैं? Et cetera।
यहां नेस्टेड फ़ंक्शन और नेस्टेड फ़ंक्शंस को लागू करने का एक तरीका है
package main
import "fmt"
func main() {
nested := func() {
fmt.Println("I am nested")
deeplyNested := func() {
fmt.Println("I am deeply nested")
}
deeplyNested()
}
nested()
}
गो में नेस्टेड फ़ंक्शन की अनुमति है। आपको बस बाहरी फ़ंक्शन के भीतर उन्हें स्थानीय चर असाइन करने की आवश्यकता है, और उन चर का उपयोग करके उन्हें कॉल करें।
उदाहरण:
func outerFunction(iterations int, s1, s2 string) int {
someState := 0
innerFunction := func(param string) int {
// Could have another nested function here!
totalLength := 0
// Note that the iterations parameter is available
// in the inner function (closure)
for i := 0; i < iterations; i++) {
totalLength += len(param)
}
return totalLength
}
// Now we can call innerFunction() freely
someState = innerFunction(s1)
someState += innerFunction(s2)
return someState
}
myVar := outerFunction(100, "blah", "meh")
आंतरिक कार्य अक्सर स्थानीय गोरोइन के लिए उपयोगी होते हैं:
func outerFunction(...) {
innerFunction := func(...) {
...
}
go innerFunction(...)
}
आपको बस ()अंत में जोड़कर तुरंत कॉल करना होगा ।
func main() {
func inc(x int) int { return x+1; }()
}
संपादित करें: फ़ंक्शन का नाम नहीं हो सकता ... इसलिए यह अभी एक लंबोदर फ़ंक है जिसे तुरंत कहा जाता है:
func main() {
func(x int) int { return x+1; }()
}
func main() { func (x int) int { return x+1; }(3) }