जावा प्रोग्रामर के लिए कोटलिन के बारे में

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

परियोजना के बारे में

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

भाषा के बारे में

भाषा सांख्यिकीय रूप से टाइप की गई है। लेकिन जावा की तुलना में, कोटलिन कंपाइलर में नल से जुड़े लिंक की संभावना के बारे में जानकारी टाइप की जाती है, जो टाइपिंग की जाँच को मजबूत करता है और निष्पादन को सुरक्षित बनाता है:

fun foo(text:String) { println(text.toLowerCase()) // NPE? ! } val str:String? = null // String? --   null- foo(str) // <-      -- //  str   String,  //    foo 

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

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

आइए नियंत्रक का एक टुकड़ा देखें:

 path(array("/notes/")) controller class NotesController { private autowired val notesService : NotesService? = null path(array("all")) fun all() = render("notes/notes") { addObject("notes", notesService!!.all) } //... } 

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

यह ध्यान दिया जाना चाहिए कि वसंत लेनदेन प्रबंधन के लिए कोटलिन वर्गों को लपेट नहीं सकता है - मुझे उम्मीद है कि भविष्य में यह संभव होगा।

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

 fun doSomething(thing:()->Unit) { //     // ()->Unit     //     thing() //  } doSomething() { //        // ()->Unit      doShomething //   --  ,  //      println("Hello world") } 

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

 fun <T> List<T>.filter(condition:(T)->Boolean):List<T> { val result = list<T>() for(item in this) { if(condition(item)) result.add(item) } return result } val someList = list(1, 2, 3, 4).filter { it > 2 } // someList==[3, 4] 

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

कक्षाओं और संक्षिप्तता के विषय को समझने के लिए, निम्नलिखित कोड देखें:

 //  bean-  // ,    //     class TimeLord(val name:String) //       class TARDIS(val owner:TimeLord) fun main(args:Array<String>) { val doctor = TimeLord("Doctor") val tardis = TARDIS(doctor) println(tardis.owner.name) } 

कुछ पंक्तियों में, हम दो वर्गों की घोषणा करने में सक्षम थे, दो ऑब्जेक्ट बनाए और TARDIS के मालिक का नाम प्रदर्शित किया! आप देख सकते हैं कि वर्ग अपने एकमात्र संभावित निर्माणकर्ता के मापदंडों के साथ घोषित किया गया है, जो कि इसके गुणों की घोषणा भी है। बहुत कम है, लेकिन एक ही समय में जानकारीपूर्ण। निश्चित रूप से ऐसे लोग हैं जो एक से अधिक कंस्ट्रक्टर घोषित करने में असमर्थता की निंदा करेंगे, लेकिन मुझे ऐसा लगता है कि इसकी अपनी व्यावहारिकता है - आखिरकार, जावा में कई कंस्ट्रक्टर या तो आपको डिफ़ॉल्ट पैरामीटर घोषित करने की अनुमति देते हैं, जो कोटपा भाषा के स्तर पर समर्थन करता है, या एक प्रकार से दूसरे प्रकार में परिवर्तित करता है। जिसके साथ यह वर्ग काम करेगा, और इसे पहले से ही कारखाने की विधि की दया पर सुरक्षित रूप से छोड़ा जा सकता है। "चर" और फ़ील्ड्स की घोषणा पर ध्यान दें। कोटलिन हमें एक विकल्प बनाने के लिए मजबूर करता है: val या var । जहां val - एक अपरिवर्तनीय final लिंक की घोषणा करता है, और var - एक वैरिएबल, जो उत्परिवर्ती लिंक के व्यापक उपयोग से बचने में मदद करता है।

उदाहरण

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

इसलिए मैं चाहूंगा कि इसका उपयोग किया जाए:

 fun main(args: Array<String>) { //    val tree= tree("root") { node("1-1") { node("2-1") node("2-2") } node("1-2") { node("2-3") } } //        tree.traverse { println(it) } } 

अब इसे लागू करने का प्रयास करें। ट्री नोड क्लास बनाएँ:

 /** * @param value   */ class Node<T>(val value:T) { //   private val children:List<Node<T>> = arrayList() /** * ,       * @param value     * @param init    ,  *  */ fun node(value:T, init:Node<T>.()->Unit = {}):Node<T> { val node = Node<T>(value) node.init() children.add(node) return node } /** *          * ,      * @param handler       */ fun traverse(handler:(T)->Unit) { handler(value) children.forEach { child -> child.traverse(handler) } } } 

अब ट्री टॉप बनाने के लिए एक फंक्शन जोड़ें:

 /** *      value   *    init. */ fun <T> tree(value:T, init:Node<T>.()->Unit): Node<T> { val node = Node(value) //   init,   // ,    node.init() return node } 

कोड के दो स्थानों में, फॉर्म के एक निर्माण का उपयोग किया गया था Node.()->Unit, , -, Node. , Node.node(), , .



java , Kotlin java . , .

, , github-, Issue Tracker. , . milestone 3, , , JetBrains, .

Node.()->Unit, , -, Node. , Node.node(), , .



java , Kotlin java . , .

, , github-, Issue Tracker. , . milestone 3, , , JetBrains, .

Node.()->Unit, , -, Node. , Node.node(), , .



java , Kotlin java . , .

, , github-, Issue Tracker. , . milestone 3, , , JetBrains, .