बड़ी टीमों के लिए Kotlin का इस्तेमाल करना

किसी नई भाषा पर जाना मुश्किल काम हो सकता है. सफलता का मूल मंत्र यह है कि धीरे-धीरे शुरुआत करें, इसे छोटे-छोटे हिस्सों में बांटें, और नियमित तौर पर टेस्ट करते रहें, ताकि आपकी टीम बेहतर तरीके से काम कर सके. Kotlin की मदद से माइग्रेट करना आसान हो जाता है, क्योंकि यह JVM बाइटकोड में कंपाइल हो जाता है और Java के साथ पूरी तरह से इंटरऑपरेबल है.

टीम बनाना

माइग्रेट करने से पहले पहला कदम यह है कि आपकी टीम. अपनी साइट को तेज़ी से आगे बढ़ाने के लिए, यहां कुछ सलाह दी गई है सीखने के कई तरीक़े हैं.

फ़ॉर्म स्टडी ग्रुप

स्टडी ग्रुप, सीखने-सिखाने की प्रक्रिया को बेहतर बनाने और उपयोगकर्ताओं को अपने साथ जोड़े रखने का एक असरदार तरीका है. स्टडी से मिले सुझाव ग्रुप सेटिंग में सीखी गई बातों को सुनने से इन कामों में मदद मिलती है मदद मिलती है. पाएं Kotlin बुक या अन्य अध्ययन सामग्री का अध्ययन कर सकता है और समूह को कुछ चैप्टर पूरे होते हैं. हर मीटिंग के दौरान, ग्रुप को यह तुलना करनी चाहिए कि तो वे सीख सकते हैं और किसी भी सवाल या निगरानी के बारे में चर्चा कर सकते हैं.

पढ़ाने की संस्कृति का निर्माण करें

हालांकि, हर कोई खुद को शिक्षक नहीं मानता, लेकिन हर कोई पढ़ा सकता है. टेक्नोलॉजी या टीम से लेकर योगदान देने वाले व्यक्ति तक, कोई भी व्यक्ति ये काम कर सकता है सीखने के ऐसे माहौल को बढ़ावा देना जो सफलता पक्का करने में मदद कर सके. एक तरफ़ इसके लिए, समय-समय पर ऐसे प्रज़ेंटेशन बनाए जाएं जिनमें टीम का एक व्यक्ति की मदद से, वे किसी ऐसी बात के बारे में बात कर सकते हैं जो उन्होंने सीखी है या जिसे वे शेयर करना चाहते हैं. आप अपने स्टडी ग्रुप से फ़ायदा पाने के लिए, वॉलंटियर से अनुरोध करें कि वे एक-एक चैप्टर सबमिट करें सप्ताह है, जब तक आप उस बिंदु पर नहीं पहुंच जाते जहां आपकी टीम भाषा.

चैंपियन तय करें

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

धीरे-धीरे इंटिग्रेट करें

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

डेटा मॉडल

आपके डेटा मॉडल में बहुत सारी जानकारी के साथ-साथ कुछ राज्यों की जानकारी भी हो सकती है तरीकों का इस्तेमाल करना होगा. डेटा मॉडल में कुछ तरीके भी हो सकते हैं. जैसे, toString(), equals() और hashcode(). इन तरीकों को आम तौर पर ट्रांज़िशन किया जा सकता है और इकाई आइसोलेशन में आसानी से टेस्ट किया जा सकता है.

उदाहरण के लिए, Java के नीचे दिए गए स्निपेट का मान लें:

public class Person {

   private String firstName;
   private String lastName;
   // ...

   public String getFirstName() {
       return firstName;
   }

   public void setFirstName(String firstName) {
       this.firstName = firstName;
   }

   public String getLastName() {
       return lastName;
   }

   public void setLastName(String lastName) {
       this.lastName = lastName;
   }

   @Override
   public boolean equals(Object o) {
       if (this == o) return true;
       if (o == null || getClass() != o.getClass()) return false;
       Person person = (Person) o;
       return Objects.equals(firstName, person.firstName) &&
               Objects.equals(lastName, person.lastName);
   }

   @Override
   public int hashCode() {
       return Objects.hash(firstName, lastName);
   }

   @Override
   public String toString() {
       return "Person{" +
               "firstName='" + firstName + '\'' +
               ", lastName='" + lastName + '\'' +
               '}';
   }
}

Java क्लास को Kotlin की सिंगल लाइन से बदला जा सकता है, जैसा कि यहां दिखाया गया है:

data class Person(var firstName: String?, var lastName : String?)

इसके बाद, इस कोड की यूनिट की जांच आपके मौजूदा टेस्ट सुइट से की जा सकती है. आइडिया यहां एक बार में एक मॉडल और ऐसे ट्रांज़िशन क्लास के साथ छोटी शुरुआत करना है जो यह उनके व्यवहार के बारे में बताता है, न कि व्यवहार के बारे में. यात्रा के दौरान समय-समय पर जांच करते रहें.

टेस्ट माइग्रेट करें

एक और शुरुआती तरीका है, मौजूदा टेस्ट को बदलना और लिखना शुरू करना Kotlin में नए टेस्ट किए जा सकते हैं. इससे आपकी टीम को यह समझने में मदद मिलती है कि कृपया उस कोड को लिखने से पहले उसकी भाषा का इस्तेमाल करें जिसे आपको ऐप्लिकेशन से शिप करना है.

उपयोगिता विधियों को एक्सटेंशन फ़ंक्शन में ले जाना

कोई भी स्टैटिक यूटिलिटी क्लास (StringUtils, IntegerUtils, DateUtils, YourCustomTypeUtils वगैरह) को इस तरह दिखाया जा सकता है Kotlin के एक्सटेंशन फ़ंक्शन और आपके मौजूदा Java कोड बेस में इसका इस्तेमाल किया जाता है.

उदाहरण के लिए, मान लें कि आपने इन तरीकों से StringUtils क्लास बनाई है:

package com.java.project;

public class StringUtils {

   public static String foo(String receiver) {
       return receiver...;  // Transform the receiver in some way
   }

   public static String bar(String receiver) {
       return receiver...;  // Transform the receiver in some way
   }

}

इसके बाद, इन तरीकों का इस्तेमाल आपके ऐप्लिकेशन में किसी दूसरी जगह किया जा सकता है, जैसा कि नीचे दिया गया उदाहरण:

...

String myString = ...
String fooString = StringUtils.foo(myString);

...

Kotlin एक्सटेंशन फ़ंक्शन का इस्तेमाल करके, आपके पास एक जैसा Utils इंटरफ़ेस उपलब्ध कराने का विकल्प होता है Java कॉलर एक ही समय पर आपके Kotlin कोड बेस बढ़ाना.

ऐसा करने के लिए, इस Utils क्लास को Kotlin में बदलें. इसके लिए, IDE से मिला ऑटोमैटिक कन्वर्ज़न. आउटपुट का उदाहरण ऐसा लग सकता है निम्न:

package com.java.project

object StringUtils {

   fun foo(receiver: String): String {
       return receiver...;  // Transform the receiver in some way
   }

   fun bar(receiver: String): String {
       return receiver...;  // Transform the receiver in some way
   }

}

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

package com.java.project

fun String.foo(): String {
    return this...;  // Transform the receiver in some way
}

fun String.bar(): String {
    return this...;  // Transform the receiver in some way
}

आखिर में, सोर्स फ़ाइल में सबसे ऊपर JvmName एनोटेशन जोड़ें, ताकि आपके ऐप्लिकेशन के बाकी हिस्सों के साथ काम करने वाला, कंपाइल किया गया नाम, जैसा कि यहां दिखाया गया है उदाहरण:

@file:JvmName("StringUtils")
package com.java.project
...

आखिरी वर्शन कुछ ऐसा दिखना चाहिए:

@file:JvmName("StringUtils")
package com.java.project

fun String.foo(): String {
    return this...;  // Transform `this` string in some way
}

fun String.bar(): String {
    return this...;  // Transform `this` string in some way
}

ध्यान दें कि इन फ़ंक्शन को अब Java या Kotlin का इस्तेमाल करके जो हर भाषा से मेल खाते हों.

Kotlin

...
val myString: String = ...
val fooString = myString.foo()
...

Java

...
String myString = ...
String fooString = StringUtils.foo(myString);
...

माइग्रेट करने की प्रोसेस पूरी करें

जब आपकी टीम Kotlin के साथ काम कर लेगी और आप छोटे इलाकों में माइग्रेट कर लेंगे, आपके पास फ़्रैगमेंट, ऐक्टिविटी, ViewModel ऑब्जेक्ट और अन्य क्लास जो Business लॉजिक से जुड़ी होती हैं.

ज़रूरी बातें

Java की एक खास स्टाइल है, जबकि Kotlin की अपनी अलग मुहावरे स्टाइल है जो लेख को छोटा बनाने में मदद मिलती है. हालांकि, शुरुआत में आपको आपकी टीम का बनाया गया Kotlin कोड, काफ़ी हद तक उस Java कोड की तरह दिखता है जो इसकी जगह ले रहा है. समय के साथ जैसे-जैसे आपकी टीम का Kotlin का अनुभव बढ़ता है, इसमें बदलाव होता है. याद रखें, धीरे-धीरे बदलाव ही सफलता पाने का मूल मंत्र है.

अपने Kotlin कोड बेस के तौर पर एक जैसा अनुभव पाने के लिए, यहां कुछ तरीके दिए गए हैं बढ़ता है:

कोडिंग के सामान्य स्टैंडर्ड

यह पक्का कर लें कि अपनाने की शुरुआत में ही, कोडिंग कन्वेंशन का एक स्टैंडर्ड सेट तय कर दिया गया हो प्रोसेस. Android के अलग-अलग प्लैटफ़ॉर्म पर स्विच किया जा सकता है Kotlin की स्टाइल गाइड, जहां यह काम का है.

स्टैटिक विश्लेषण टूल

अपनी टीम के लिए, तय किए गए कोडिंग के स्टैंडर्ड लागू करने के लिए Android लिंट और अन्य स्टैटिक विश्लेषण टूल. klint, तीसरे पक्ष की एक Kotlin linter, Kotlin के लिए अतिरिक्त नियम भी उपलब्ध कराता है.

लगातार इंटिग्रेशन

पक्का करें कि कोडिंग के सामान्य स्टैंडर्ड का पालन किया जा रहा हो और ज़रूरी टेस्ट उपलब्ध कराएं आपके Kotlin कोड के लिए कवरेज. इसे अपने-आप तैयार होने वाली बिल्ड प्रोसेस का हिस्सा बनाना से इन मानकों के पालन को जारी रखने और उनका पालन करने में मदद मिल सकती है.

इंटरऑपरेबिलिटी (दूसरे सिस्टम के साथ काम करना)

Kotlin, ज़्यादातर मामलों में Java के साथ आसानी से इंटरऑपरेट करती है. हालांकि, ध्यान रखें कि फ़ॉलो किया जा रहा है.

शून्य होने की क्षमता

खाली होने का अनुमान लगाने के लिए Kotlin, कंपाइल किए गए कोड में शून्य की सुविधा के एनोटेशन पर निर्भर करती है Kotlin साइड में. अगर एनोटेशन नहीं दिए जाते हैं, तो Kotlin डिफ़ॉल्ट रूप से प्लैटफ़ॉर्म टाइप, जिसे शून्य या शून्य न होने वाले टाइप के तौर पर माना जा सकता है. यह इसका इस्तेमाल न करने पर, रनटाइम NullPointerException की समस्याएं आ सकती हैं. करते हैं.

नई सुविधाएं अपनाना

Kotlin 10 से 10 नई लाइब्रेरी और सिंटैक्ट शुगर से बॉयलरप्लेट को कम किया जा सकता है, जिससे शरीर के विकास को बढ़ाने में मदद मिलती है स्पीड. इसलिए, Kotlin के स्टैंडर्ड का इस्तेमाल करते समय सावधान रहें और सही तरीके से काम करें लाइब्रेरी फ़ंक्शन, जैसे कि कलेक्शन फ़ंक्शन, कोरूटीन, और लैम्बडास.

यह रहा एक आम समस्या, जिसमें नए Kotlin डेवलपर को सामना किया जाता है. मान लें कि Kotlin कोड का इस्तेमाल करना:

val nullableFoo: Foo? = ...

// This lambda executes only if nullableFoo is not null
// and `foo` is of the non-nullable Foo type
nullableFoo?.let { foo ->
   foo.baz()
   foo.zap()
}

इस उदाहरण में, foo.baz() और foo.zap() को एक्ज़ीक्यूट करना है, अगर nullableFoo शून्य नहीं है, इसलिए NullPointerException से बचा जा रहा है. हालांकि, यह कोड उम्मीद के मुताबिक काम करता है. इसे पढ़ना मुश्किल होता है. स्मार्ट कास्ट, जैसा कि नीचे दिए गए उदाहरण में दिखाया गया है:

val nullableFoo: Foo? = null
if (nullableFoo != null) {
    nullableFoo.baz() // Using !! or ?. isn't required; the Kotlin compiler infers non-nullability
    nullableFoo.zap() // from guard condition; smart casts nullableFoo to Foo inside this block
}

टेस्ट करना

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

इस व्यवहार से मॉकिटो जैसे फ़्रेमवर्क के लिए, जानकारी तैयार करने में समस्या आ सकती है. के दौरान व्यवहार बदलने के लिए इंटरफ़ेस लागू करने या इनहेरिटेंस का इस्तेमाल करते हैं टेस्टिंग हो रही है. यूनिट टेस्ट के लिए, मॉक मेकर इनलाइन सुविधा की मदद से, फ़ाइनल क्लास और तरीकों की नकल की जा सकती है. वैकल्पिक रूप से, आप ऑल-ओपन कंपाइलर प्लगिन किसी भी Kotlin क्लास और उसके सदस्यों को खोलने के लिए, जिसे आपको कंपाइलेशन प्रोसेस पूरी होती है. इस प्लग इन का उपयोग करने का मुख्य लाभ यह है कि यह काम करता है परीक्षा की ज़रूरत नहीं होती.

ज़्यादा जानकारी

Kotlin का इस्तेमाल करने के बारे में ज़्यादा जानकारी के लिए, ये लिंक देखें: