गो पर कार्यात्मक प्रतिमान: बुनियादी तकनीकें

सभी को नमस्कार, हम आपको याद दिलाते हैं कि ओटस में इस महीने एक नया सेट गोलंग डेवलपर पाठ्यक्रम पर शुरू होगा। गोलंग पर पिछले लेख के कुछ नफरत के बावजूद, हमारे स्वतंत्र लेखक ने इस भाषा के लिए समर्पित लेखों की एक श्रृंखला जारी रखने का जोखिम उठाने का फैसला किया। हम इस पतली बर्फ के माध्यम से फिर से जाने की कोशिश करेंगे, जिस पर भरोसा करते हुए कि गोलंग को भरोसा है - कार्यात्मक प्रतिमान।

---

हम आपको याद दिलाते हैं कि यह लेख "पाठ्येतर पठन" के लिए एक प्रकार की सामग्री है और पाठ्यक्रम से संबंधित नहीं है, जो यहां पाया जा सकता है ।

यह स्पष्ट है कि अन्य भाषाओं में पेशेवर प्रोग्रामर गोलंग कॉल करते हैं
जलन एक वयस्क संकलित भाषा की तरह है, लेकिन वर्गों और विरासत की अवधारणा सिद्धांत में अनुपस्थित है (हालांकि ओओपी भाषा में लागू किया गया है, हालांकि एक असामान्य तरीके से, संरचनाओं और इंटरफेस की एक प्रणाली के माध्यम से)। हालांकि, आज हम कार्यात्मक प्रतिमान में परिचित निर्माणों के मुख्य कार्यान्वयन को देखते हैं और उन्हें और भाषा वाक्य दोनों को ही समझाने की कोशिश करते हैं।



अब कार्यात्मक प्रतिमान (एफपी) के आसपास बहुत अधिक प्रचार है। हालाँकि, यह सभी समस्याओं के लिए भी रामबाण नहीं है, और इसके पक्ष और विपक्ष भी हैं।

एक कार्यात्मक प्रतिमान क्या है के बारे में संक्षेप में

कार्यात्मक प्रतिमान गणित से प्रोग्रामिंग के लिए आया था। यह कार्यक्रम के लिए निम्नलिखित आवश्यकताओं को बनाता है:

• मौजूदा डेटा में कोई बदलाव नहीं।
• कोई छिपी हुई अवस्था नहीं है।

यह हमें क्या देता है?

हमारे कार्य तृतीय-पक्ष प्रभाव के बिना काम करते हैं। दूसरे शब्दों में, फ़ंक्शन को केवल एक मूल्य वापस करना चाहिए और किसी भी बाहरी डेटा को प्रभावित नहीं करना चाहिए।

शुद्ध सुविधाओं का उपयोग करना। वे आने वाले डेटा की परवाह किए बिना कार्यों की सबसे अधिक विश्वसनीयता बढ़ाते हैं - दूसरे शब्दों में, परीक्षण के लिए कार्यक्रम अधिक विश्वसनीय हो जाते हैं और उनके परिणाम अधिक अनुमानित हो जाते हैं।

तो, गोलंग के कार्यात्मक प्रतिमान को लागू करने के लिए क्या संभावनाएं हैं:

प्रथम श्रेणी के कार्य

कई प्रोग्रामिंग भाषाओं में प्रथम श्रेणी के कार्य उपलब्ध हैं। इस लेख के पाठक को सबसे पहले इस तरह के व्यापक जावास्क्रिप्ट से उनकी अवधारणा पता है, लेकिन मैं इसे फिर से दोहराऊंगा। प्रथम श्रेणी (उच्च क्रम फ़ंक्शन) के कार्य ऐसे फ़ंक्शन हैं जो ज्ञान के रूप में किसी अन्य फ़ंक्शन को वापस कर सकते हैं, एक फ़ंक्शन को तर्क के रूप में ले सकते हैं, और फ़ंक्शन के मूल्य को दूसरे चर में पास कर सकते हैं।

चलिए शुरू से ही सहमत हैं : अंतरिक्ष को बचाने के लिए, मैंने कोड की पहली दो पंक्तियों को यहां प्रस्तुत किया है: 'पैकेज मुख्य' और 'आयात' fmt '' आयात करें। लेकिन अपनी मशीन पर कोड चलाने के लिए, उन्हें जोड़ना याद रखें)।

func main() { var list = []int{15, 16, 45, 34} //      var out = forEach(list, func(it int) int { //      //forEach   ""  return (it * it) //      }) fmt.Println(out) // [225, 256, 2025, 1156] fmt.Println(list) //      } func forEach(arr []int, fn func(it int) int) []int { //      ,   ,     var newArray = []int{} //     ""   for _, it := range arr { newArray = append(newArray, fn(it)) //      for } return newArray } 

वास्तव में, अपने स्वयं के map का आविष्कार करना या स्क्रैच से foreach करना बिल्कुल भी आवश्यक नहीं है। कई पुस्तकालय हैं जो इसे लागू करते हैं, यह केवल उन्हें जोड़ने के लिए रहता है। उदाहरण के लिए, यह एक ।

क्लोजर और करी कार्य

कई आधुनिक प्रोग्रामिंग भाषाओं में शॉर्ट सर्किट हैं। क्लोज़र एक फ़ंक्शन है जो अपने मूल फ़ंक्शन के मुक्त क्षेत्र चर को संदर्भित करता है। फंक्शन करीपिंग फंक्शन func(a,b,c) से फॉर्म func(a)(b)(c) फंक्शन का बदलाव है।

यहां गो में करीबी और करीने का एक उदाहरण है:

 //  func multiply(x int) func(y int) int { //    return func(y int) int { //   ,       JS return x * y } } func main() { //     var mult10 = multiply(10) var mult15 = multiply(15) fmt.Println(mult10(5)) //50 fmt.Println(mult15(15))//225 } 

शुद्ध कार्य

जैसा कि हमने पहले कहा, शुद्ध कार्य वे हैं जो मान लौटाते हैं जो केवल उन तर्कों से जुड़े होते हैं जो वैश्विक स्थिति को प्रभावित करते हैं और प्रभावित नहीं करते हैं।

यहाँ एक असफल, गंदे कार्य का एक उदाहरण दिया गया है:

 var arrToSave = map[string]int{} //map -    -   Golang func dirtySum(a, b int) int { c := a + b arrToSave[fmt.Sprintf("%d", a, b)] = c //   ,  "%d" -       return c } 

यहाँ, हमारे कार्य को यथासंभव यथासंभव कार्य करने के लिए स्वीकार करना चाहिए:

 func simpleSum(x, y int) int { return x + y } func main() { fmt.Printf("%v", dirtySum(13, 12)) //      //   ""      fmt.Printf("%v", simpleSum(13, 12)) } 

"किसी भी तरह बार बार प्रवेश होता है, और कोई भी बार में प्रवेश नहीं करता है"
निराधार चुटकुलों के संग्रह से।

प्रत्यावर्तन

एक कार्यात्मक प्रतिमान में, पुनरावृत्ति को वरीयता देने के लिए प्रथागत है - शुद्धता और पारदर्शिता के लिए, इसके माध्यम से सरल पुनरावृत्ति का उपयोग करने के बजाय।

यहाँ अनिवार्य और घोषणात्मक प्रतिमान का उपयोग कर फैक्टरियल की गणना करने का एक उदाहरण है:

 func funcFactorial(num int) int { if num == 0 { return 1 } return num * funcFactorial(num-1) } func imperativeFactorial(num int) int { var result int = 1 for ; num > 0; num-- { //    for result *= num } return result } func main() { fmt.Println(funcFactorial(20)) //        fmt.Println(imperativeFactorial(20)) //      } 

अब पुनरावृत्ति फ़ंक्शन काफी अक्षमता से काम करता है। आइए इसकी गणना की गति को अनुकूलित करने के लिए इसे फिर से लिखने का प्रयास करें:

 func factTailRec(num int) int { return factorial(1, num) //    ""  } func factorial(accumulator, val int) int { if val == 1 { return accumulator } return factorial(accumulator*val, val-1) } func main() { fmt.Println(factTailRec(20)) // 2432902008176640000 } 

हमारी तथ्यात्मक कंप्यूटिंग गति थोड़ी बढ़ गई है। मैं बेंचमार्क नहीं दूंगा)।

दुर्भाग्य से, गो बॉक्स से बाहर रिकर्सन ऑप्टिमाइज़ेशन को लागू नहीं करता है, इसलिए आपको रिकर्सियन टेल को स्वयं ऑप्टिमाइज़ करना होगा। हालांकि, इसमें कोई संदेह नहीं है, इस विषय पर एक उपयोगी पुस्तकालय निश्चित रूप से पाया जा सकता है। उदाहरण के लिए, इस विषय पर कूल "गोलंग के लिए लोडश" है।

आलसी कंप्यूटिंग

प्रोग्रामिंग सिद्धांत में, आलसी कंप्यूटिंग (जिसे "आस्थगित कंप्यूटिंग" के रूप में भी जाना जाता है) कंप्यूटिंग की प्रक्रिया को तब तक जारी रखने की आवश्यकता है जब तक इसकी आवश्यकता नहीं है। गोलांग के पास बॉक्स के ठीक बाहर आलसी कंप्यूटिंग के लिए कोई समर्थन नहीं है, इसलिए हम केवल इसे अनुकरण कर सकते हैं:

 func mult(x, y int) int { fmt.Println(" ") return x * x. } func divide(x, y int) int { fmt.Println(" ") return x / y //    -  } func main() { fmt.Println(multOrDivide(true, mult, divide, 17, 3)) //   ""   ,   1  , //         fmt.Println(multOrDivide(false, mult, divide, 17, 3)) } //  if - else    ""  func multOrDivide(add bool, onMult, onDivide func(t, z int) int, t, z int) int { if add { return onMult(t, z) } return onDivide(t, z) } 

सबसे अधिक बार, "उत्सर्जित" आलसी अभिव्यक्ति इसके लायक नहीं होती है क्योंकि वे कोड को बहुत अधिक जटिल करते हैं, लेकिन यदि आपके कार्यों का प्रबंधन करना काफी कठिन है, तो आपको इस पद्धति का उपयोग करना चाहिए। लेकिन आप अन्य समाधानों की ओर मुड़ सकते हैं, उदाहरण के लिए, इन तक ।



वह सब है। हमें केवल गोलंग पर कार्यात्मक प्रतिमान का परिचय मिला। दुर्भाग्य से, संभावनाओं का हिस्सा नकली होना था। भाग, पूरी तरह से विकसित कार्यात्मक तकनीक, जैसे कि भिक्षु, यहां शामिल नहीं थे, क्योंकि हब पर गो में उनके बारे में बहुत सारे लेख हैं बहुत कुछ अभी भी भाषा में ही सुधार किया जा सकता है, उदाहरण के लिए अगले बड़े संस्करण (GO 2) जेनेरिक भाषा में दिखाई देने की उम्मीद है। खैर, हम इंतजार करेंगे और उम्मीद करेंगे)।