हम नई प्रोग्रामिंग भाषाओं में महारत हासिल करते हैं, जो पहले से सीखे गए पर निर्भर हैं

नमस्कार साथियों!



जेनी मार्विन स्नैपशॉट अनसप्लाश से

आज हमने आपके लिए एक उदाहरण के रूप में रूबी और सी # का उपयोग करते हुए कई प्रोग्रामिंग भाषाओं की मौलिक समानता पर एक लेख का अनुवाद तैयार किया है। हम आशा करते हैं कि सम्मानित सेवरिन पेरेस के विचार आप में से बहुत से लोगों को जल्दी से एक नई प्रोग्रामिंग भाषा सीखने में मदद करेंगे, और चीजें वास्तविक भावना और खुशी के साथ चलेंगी।

क्या प्रोग्रामर से दूर नहीं ले जाता है - वह कभी भी सीखना बंद नहीं करता है। आपके पास एक पसंदीदा भाषा, या एक ढांचा, या एक पुस्तकालय हो सकता है, लेकिन इसमें कोई संदेह नहीं है कि आप उनके साथ विशेष रूप से नहीं कर सकते हैं। आप जावास्क्रिप्ट को पसंद कर सकते हैं, लेकिन जिस परियोजना पर आप वर्तमान में काम कर रहे हैं, उसमें अजगर की आवश्यकता हो सकती है। आप पर्ल में निपुण हो सकते हैं, लेकिन आपकी कंपनी का कोड आधार C ++ में लिखा जा सकता है। एक धोखेबाज़ डेवलपर के लिए, एक नई भाषा सीखने का विचार कठिन लग सकता है, खासकर अगर समय सीमा आ रही है। यह बुरी खबर है। हालांकि, एक अच्छा है: एक नई भाषा सीखना आमतौर पर उतना मुश्किल नहीं है। यदि हम मौजूदा मानसिक मॉडल के आधार के रूप में लेते हैं, तो आप देखेंगे कि एक नई भाषा सीखना मूल रूप से मौजूदा ज्ञान का विस्तार है, और खरोंच के लिए काम नहीं करता है।

उनके पास क्या आम है

अधिकांश प्रोग्रामिंग भाषाएं मूल सिद्धांतों के एक ही सेट पर आधारित होती हैं। कार्यान्वयन अलग है, लेकिन शायद ही दो भाषाएं इतनी भिन्न हैं कि उनके बीच समानताएं खींचना संभव नहीं होगा। एक नई भाषा सीखने और समझने के लिए, सबसे महत्वपूर्ण बात यह है कि यह पहचानें कि यह कैसा दिखता है जैसा कि आप पहले से ही जानते हैं, और तब नया ज्ञान प्राप्त करते हैं, जब / यदि आवश्यक हो तो इसके बारे में अपनी समझ का विस्तार करना। उदाहरण के लिए, डेटा प्रकार और चर पर विचार करें। हर भाषा में, डेटा को परिभाषित करने और संग्रहीत करने का एक तरीका है - पूरे कार्यक्रम में समान रूप से। इसलिए, जब एक नई भाषा सीखते हैं, तो आपको सबसे पहले यह समझने की जरूरत है कि चर को कैसे परिभाषित किया जाता है और यहां उपयोग किया जाता है। उदाहरण के रूप में दो अलग-अलग भाषाओं को लें: रूबी को डायनामिक टाइपिंग के साथ व्याख्या की गई और स्थिर टाइपिंग के साथ C # संकलित किया गया।

my_int = 8 my_decimal = 8.5 my_string = "electron" puts "My int is: #{my_int}" puts "My float is: #{my_decimal}" puts "My string is: #{my_string}" 

एक समान उदाहरण:

 using System; public class Program { public static void Main() { int myInt = 8; double myDecimal = 8.5; string myString = "electron"; Console.WriteLine("My int is: {0}", myInt); Console.WriteLine("My float is: {0}", myDecimal); Console.WriteLine("My string is: {0}", myString); } } 

कहते हैं कि आप एक अनुभवी रूबी डेवलपर हैं और C # सीखना चाहते हैं। निम्नलिखित कोड के स्निपेट हैं, जिनमें से एक में आप रूबी को आसानी से पहचान सकते हैं। वहां आपको बस कई वेरिएबल्स को परिभाषित करने और उन्हें कंसोल में प्रदर्शित करने की आवश्यकता है। अब दूसरे टुकड़े पर ध्यान दें। क्या आप कुछ सीखते हैं? वाक्य रचना अलग है, लेकिन इसमें कोई संदेह नहीं है कि दूसरा कोड पहले की तरह बहुत काम करता है। = ऑपरेटर को कई बार सामना करना पड़ता है, जो संभवतः असाइनमेंट ऑपरेशन के प्रतीक के रूप में हड़ताली है। फिर एक निश्चित Console.WriteLine() कहा जाता है, जिसका अर्थ है कि कंसोल में मान प्रदर्शित किए जाएंगे। यहाँ कुछ पंक्तियाँ भी हैं जो संदेशों की रचना करने के लिए प्रक्षेप का उपयोग करती प्रतीत होती हैं। वैचारिक रूप से, यहाँ कुछ भी आश्चर्यजनक नहीं है - असाइनमेंट, इंटरपोलेशन, कंसोल को आउटपुट, ये सभी ऑपरेशन आपको रूबी के साथ काम करने में पहले से ही ज्ञात हैं।

आप बिना किसी C # ज्ञान के दूसरे कोड के टुकड़े को समझ सकते हैं, लेकिन निश्चित रूप से आपके मानसिक मॉडल के विस्तार की गुंजाइश है। उदाहरण के लिए, हर कोई खुद को Main() पद्धति में क्यों लपेटता है? ये int , double और string कीवर्ड क्या हैं? इसके साथ ही प्रशिक्षण शुरू होता है। आप पहले से ही सामान्य शब्दों में समझते हैं कि यहां क्या हो रहा है (असाइनमेंट, इंटरपोलेशन, आउटपुट), अब यह विवरण पर आगे बढ़ने का समय है:

• Main() : स्थिति में थोड़ा गहरा होने के बाद, हमें पता चलता है कि Main() विधि वह प्रवेश बिंदु है जहां से कार्यक्रम शुरू होता है। अब हम जानते हैं कि सभी C # प्रोग्राम्स में हमें Main () विधि की आवश्यकता होती है।
• चर: C # में हमारे टुकड़े के पहले भाग में किसी प्रकार का असाइनमेंट निश्चित रूप से होता है। नामकरण को देखते हुए, आप शायद अनुमान लगाते हैं कि int कीवर्ड का अर्थ पूर्णांक चर है, double एक डबल-सटीक फ़्लोटिंग-पॉइंट संख्या है, और string एक स्ट्रिंग चर है। लगभग तुरंत, आपको पता चलता है कि C # में, रूबी के विपरीत, वैरिएबल के स्थिर टाइपिंग की आवश्यकता होती है, क्योंकि वैरिएबल को अन्य डेटा प्रकारों के लिए भिन्न रूप से घोषित किया जाता है। प्रलेखन पढ़ने के बाद, आप समझेंगे कि यह कितना अलग है।
• Console.WriteLine() : अंत में, प्रोग्राम को चलाने पर, आप देखेंगे कि Console.WriteLine() कंसोल में मान प्रदर्शित करता है। रूबी से, आप जानते हैं कि puts वैश्विक $stdout ऑब्जेक्ट की एक विधि है, और यदि आप Console.WriteLine() लिए प्रलेखन को देखते हैं। Console.WriteLine() , तो आप पाएंगे कि Console System नामस्थान से एक वर्ग है, और WriteLine() इस में परिभाषित विधि है। वर्ग। यह न केवल puts तरह बहुत दिखता है, बल्कि यह भी बताता है कि रूबी की तरह, सी # एक वस्तु-उन्मुख भाषा है। यहां आपके पास एक और मानसिक मॉडल है जो आपको नए समानताओं का पता लगाने में मदद करेगा।

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

मतभेद खोजें

एक नई भाषा में कोड को कैसे पढ़ना और लिखना है, इस पर प्रयास करना शुरू करने के लिए, पहली बात यह है कि आपको यह जानने की जरूरत है कि कौन सी चीजें पहले से ही ज्ञात हैं और सीखने के लिए आधार के रूप में काम कर सकती हैं। अगला, मतभेदों पर आगे बढ़ें। आइए रूबी से C # के हमारे संक्रमण पर वापस जाएं और कुछ और जटिल देखें।

 particles = ["electron", "proton", "neturon"] particles.push("muon") particles.push("photon") particles.each do |particle| puts particle end 

इस रूबी के टुकड़े में, हम particles नामक एक सरणी को परिभाषित करते हैं, जिसमें कई लाइनें होंगी, और फिर इसमें कुछ और लाइनें जोड़ने के लिए Array#push का उपयोग करें, और Array#each को Array#each पर पुनरावृत्त करें और प्रत्येक व्यक्ति लाइन को कंसोल में आउटपुट करें। लेकिन C # में समान कैसे करें? थोड़ा गुगली करने पर, हमें पता चलता है कि C # ने टाइप किया है सरणियाँ (टाइपिंग आपको अब और आश्चर्यचकित नहीं करना चाहिए, यह देखते हुए कि आपने पहले क्या सीखा था), और एक SetValue तरीका भी है जो थोड़ा सा push से मिलता-जुलता है, लेकिन सूचकांक में मूल्य और स्थिति को पैरामीटर के रूप में लेता है। इस मामले में, C # में रूबी कोड को फिर से लिखने का पहला प्रयास इस परिणाम में हो सकता है:

 using System; using System.Collections.Generic; public class Program { public static void Main() { string[] particles = new string[] { "electron", "proton", "neturon" }; particles.SetValue("muon", 3); //    ( 11):      particles.SetValue("photon", 4); foreach (string particle in particles) { Console.WriteLine(particle); } } } 

दुर्भाग्य से, यह कोड Run-time exception को फेंक देगा जब आप सरणी में एक नया मान जोड़ने के लिए SetValue का उपयोग करने का प्रयास करेंगे। फिर से, हम प्रलेखन को देखते हैं और पता लगाते हैं कि C # में सरणियाँ गतिशील नहीं हैं, और इन्हें सभी मानों के साथ या लंबाई के संकेत के साथ या तो तुरंत शुरू किया जाना चाहिए। एक बार फिर रूबी कोड को पुन: पेश करने की कोशिश कर रहा है, इस पर विचार करें और निम्नलिखित विकल्प प्राप्त करें:

 using System; using System.Collections.Generic; public class Program { public static void Main() { string[] particles = new string[] { "electron", "proton", "neturon", null, null }; particles.SetValue("muon", 3); particles.SetValue("photon", 4); foreach (string particle in particles) { Console.WriteLine(particle); } } } 

यह स्निपेट वास्तव में रूबी स्रोत कोड की सभी कार्यक्षमता को पुन: पेश करता है, लेकिन एक बड़े खिंचाव के साथ: यह सिर्फ कंसोल के समान मूल्यों को प्रदर्शित करता है। यदि आप दोनों टुकड़ों की सावधानीपूर्वक जांच करते हैं, तो एक समस्या का जल्द पता चलता है: कणों के सरणी में C # में एक टुकड़ा में 5 से अधिक मान नहीं हो सकते हैं, जबकि रूबी में एक टुकड़े में उन्हें आपके जितने की अनुमति है। फिर यह स्पष्ट हो जाता है कि रूबी और सी # में सरणियाँ मौलिक रूप से भिन्न हैं: पूर्व में गतिशील आकार है, जबकि उत्तरार्द्ध नहीं है। ठीक से # में रूबी स्निपेट कार्यक्षमता को पुन: उत्पन्न करने के लिए, आपको इस कोड की अधिक आवश्यकता है:

 using System; using System.Collections.Generic; public class Program { public static void Main() { List<String> particles = new List<String>(); particles.Add("electron"); particles.Add("proton"); particles.Add("neutron"); particles.Add("muon"); particles.Add("photon"); foreach (string particle in particles) { Console.WriteLine(particle); } } } 

यह गतिशील रूप से मूल्यों को इकट्ठा करने के लिए List डेटा संरचना का उपयोग करता है। इस मामले में, हम वास्तव में C # में मूल रूबी कोड को पुन: पेश करते हैं, लेकिन, अधिक महत्वपूर्ण बात, यहां हम दो भाषाओं के बीच महत्वपूर्ण अंतर की सराहना कर सकते हैं। यद्यपि दोनों भाषाओं में "सरणी" शब्द का उपयोग किया जाता है और ऐसा लग सकता है कि ये सरणियाँ एक हैं और एक ही हैं, व्यवहार में वे काफी भिन्न हैं। यहाँ एक और बात है जो मानसिक मॉडल का विस्तार करने में मदद करती है, यह समझने के लिए कि "सरणी" क्या है और इसे कैसे व्यवस्थित किया जाता है। सी # में, डेटा संरचना के रूप में एक सरणी उन परिस्थितियों में उपयुक्त हो सकती है या नहीं हो सकती है जहां रूबी में आप सरणियों का सहारा लेंगे; हम उन स्थितियों के बारे में बात कर रहे हैं जहां किसी सरणी का डायनामिक आकार बदलना महत्वपूर्ण है। अब आपको पहले से इस बात का ध्यान रखना होगा और अपने कोड के अनुसार सोचना होगा।

प्रमुख सिद्धांतों पर वापस लौटना

नई भाषाओं को सीखना शुरू करना, पहले से ही ज्ञात भाषाओं की तुलना में उनकी समानता और अंतर की खोज करना बहुत सुविधाजनक है; हालाँकि, कुछ मामलों में सार्वभौमिक सिद्धांतों के साथ शुरू करना अधिक उचित है। ऊपर, हमने तार्किक रूप से निष्कर्ष निकाला कि C # एक ऑब्जेक्ट-ओरिएंटेड भाषा थी जब हमने एक बिल्ट-इन क्लास और उसके तरीकों में से एक, System.Console.WriteLine() के साथ काम किया, जिसके साथ हमने एक एक्शन किया। यह मानना ​​तर्कसंगत है कि सी # में, अन्य ऑब्जेक्ट-ओरिएंटेड भाषाओं की तरह, एक वर्ग को परिभाषित करने और उसमें से वस्तुओं को त्वरित करने के लिए एक तंत्र है। यह ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग का एक बुनियादी सिद्धांत है, इसलिए आपको हमारी धारणा की शुद्धता के बारे में थोड़ा संदेह हो सकता है। सबसे पहले, आइए देखें कि यह ऑपरेशन परिचित रूबी भाषा में कैसे दिख सकता है।

 class Element attr_accessor :name, :symbol, :number def initialize(name, symbol, number) self.name = name self.symbol = symbol self.number = number end def describe puts "#{self.name} (#{self.symbol}) has atomic number #{self.number}." end end hydrogen = Element.new("Hydrogen", "H", 1) hydrogen.describe 

यहां हमारे पास एक साधारण Element वर्ग है, जिसमें मूल्यों को स्वीकार करने और उन्हें तात्कालिक वस्तुओं को प्रदान करने के लिए एक निर्माता विधि है, जो मूल्यों को स्थापित करने और प्राप्त करने के लिए एक्सेस विधियों का एक सेट है, और इन मूल्यों को आउटपुट करने के लिए एक उदाहरण विधि भी है। इस मामले में, प्रमुख अवधारणाएं एक वर्ग का विचार, एक रचनाकार विधि का विचार, गेटर्स / सेटर का विचार और एक उदाहरण विधि का विचार हैं। ऑब्जेक्ट-ओरिएंटेड भाषाओं में क्या किया जा सकता है, इस बारे में हमारे विचारों पर लौटते हुए, हम C # में समान करने के लिए देखेंगे।

 using System; public class Program { public static void Main() { Element hydrogen = new Element("Hydrogen", "H", 1); hydrogen.Describe(); } public class Element { public string Name { get; set; } public string Symbol { get; set; } public int Number { get; set; } public Element(string name, string symbol, int number) { this.Name = name; this.Symbol = symbol; this.Number = number; } public void Describe() { Console.WriteLine ( "{0} ({1}) has atomic number {2}.", this.Name, this.Symbol, this.Number ); } } } 

सी # में इस टुकड़े का अध्ययन करने के बाद, हम देखते हैं कि वास्तव में, यह रूबी संस्करण से अलग नहीं है। हम क्लास को परिभाषित करते हैं, कंस्ट्रक्टर का उपयोग करते हुए निर्दिष्ट करते हैं कि क्लास ऑब्जेक्ट्स को कैसे इंस्टेंट करेगा, गेटर्स / सेटर को परिभाषित करेगा, और उदाहरण विधि का निर्धारण करेगा जिसे हम निर्मित ऑब्जेक्ट्स में कॉल करेंगे। स्वाभाविक रूप से, दो टुकड़े दिखने में काफी अलग हैं, लेकिन सबसे अप्रत्याशित तरीके से नहीं। C # संस्करण में, हम तात्कालिक वस्तु को संदर्भित करने के लिए इसका उपयोग this , जबकि रूबी में हम इसके लिए self उपयोग करते हैं। C # संस्करण को विधि स्तर और पैरामीटर स्तर दोनों पर टाइप किया जाता है, जबकि रूबी में यह नहीं है। हालांकि, प्रमुख सिद्धांतों के स्तर पर, दोनों टुकड़े लगभग समान हैं।

इस विषय को विकसित करते हुए, हम विरासत के विचार पर विचार कर सकते हैं। यह ज्ञात है कि विरासत और उपवर्ग ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग के प्रमुख बिंदु हैं, इसलिए यह समझना आसान है कि C # में रूबी की तरह ही सफलता मिली है।

 class Element attr_accessor :name, :symbol, :number def initialize(name, symbol, number) self.name = name self.symbol = symbol self.number = number end def describe puts "#{self.name} (#{self.symbol}) has atomic number #{self.number}." end end class NobleGas < Element attr_accessor :category, :type, :reactivity def initialize(name, symbol, number) super(name, symbol, number) self.category = "gas" self.type = "noble gas" self.reactivity = "low" end def describe puts "#{self.name} (#{self.symbol}; #{self.number}) is a #{self.category} " + "of type #{self.type}. It has #{self.reactivity} reactivity." end end argon = NobleGas.new("Argon", "Ar", 18) argon.describe 

रूबी संस्करण में, हम NobleGas एक उपवर्ग को परिभाषित करते हैं जो हमारे Element वर्ग से विरासत में मिला है; इसका निर्माणकर्ता सुपर कीवर्ड का उपयोग करता है, जो मूल वर्ग के निर्माता का विस्तार करता है और फिर नए व्यवहार को परिभाषित करने के लिए describe विधि को ओवरराइड describe है। वही C # में किया जा सकता है, लेकिन एक अलग वाक्यविन्यास के साथ:

 using System; public class Program { public static void Main() { NobleGas argon = new NobleGas("Argon", "Ar", 18); argon.Describe(); } public class Element { public string Name { get; set; } public string Symbol { get; set; } public int Number { get; set; } public Element(string name, string symbol, int number) { this.Name = name; this.Symbol = symbol; this.Number = number; } public virtual void Describe() { Console.WriteLine ( "{0} ({1}) has atomic number {2}.", this.Name, this.Symbol, this.Number ); } } public class NobleGas : Element { public string Category { get; set; } public string Type { get; set; } public string Reactivity { get; set; } public NobleGas(string name, string symbol, int number) : base(name, symbol, number) { this.Category = "gas"; this.Type = "noble gas"; this.Reactivity = "low"; } public override void Describe() { Console.WriteLine ( "{0} ({1}; {2}) is a {3} of type {4}. It has {5} reactivity.", this.Name, this.Symbol, this.Number, this.Category, this.Type, this.Reactivity ); } } } 

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

टीएल, डॉ

यदि आप इसे खरोंच से करते हैं, तो एक नई भाषा सीखना बहुत मुश्किल हो सकता है। हालांकि, अधिकांश प्रोग्रामिंग भाषाएं एक ही मूल सिद्धांतों पर आधारित हैं, जिसके बीच समानताएं आकर्षित करना, महत्वपूर्ण अंतर नोटिस करना और कई भाषाओं में लागू करना आसान है। मौजूदा मानसिक मॉडलों पर एक नई भाषा की कोशिश करते हुए, आप पा सकते हैं कि यह पहले से अध्ययन की गई भाषाओं से अलग नहीं है, और जहां आपको वास्तव में कुछ स्पष्ट करने की आवश्यकता है। समय के साथ अधिक से अधिक भाषाओं का अध्ययन करते हुए, आप अपने मानसिक मॉडल का विस्तार करते हैं, और इस तरह के शोधन की आवश्यकता कम और कम होती है - आप शीट से विभिन्न भाषाओं में विभिन्न कार्यान्वयनों को पहचान लेंगे।