कोटलिन हुड के नीचे - विघटित bytecode देखें

जावा में विघटित कोटलिन बायटेकोड को देखना शायद यह समझने का सबसे अच्छा तरीका है कि यह अभी भी कैसे काम करता है और कुछ भाषा निर्माण प्रदर्शन को कैसे प्रभावित करते हैं। कई लोगों ने लंबे समय तक ऐसा किया है, इसलिए यह लेख शुरुआती लोगों के लिए विशेष रूप से प्रासंगिक होगा और जिनके पास लंबे समय तक जावा में महारत हासिल है और उन्होंने हाल ही में कोटलिन का उपयोग करने का फैसला किया है।

मैं जानबूझकर काफी हैक किए गए और जाने-माने पलों को याद कर रहा हूं, शायद, यह सौवें समय के लिए वेरिएंट और इसी तरह की चीजों के लिए गेटर्स / सेटर की पीढ़ी के बारे में लिखने का कोई मतलब नहीं है। तो चलिए शुरू करते हैं।

इंटेलीज आइडिया में विघटित बायोटेक को कैसे देखें?

बहुत सरल - बस वांछित फ़ाइल खोलें और मेनू टूल्स में चुनें -> कोटलिन -> शो कोटलीन बायटेकोड



अगला, दिखाई देने वाली विंडो में, बस Decompile पर क्लिक करें



देखने के लिए, कोटलिन 1.3-आरसी के संस्करण का उपयोग किया जाएगा।
अब, अंत में, मुख्य भाग पर चलते हैं।

वस्तु

Kotlin

object Test 

विघटित जावा

 public final class Test { public static final Test INSTANCE; static { Test var0 = new Test(); INSTANCE = var0; } } 

मुझे लगता है कि कोटलिन के साथ व्यवहार करने वाले सभी लोग जानते हैं कि ऑब्जेक्ट एक सिंगलटन बनाता है। हालांकि, यह स्पष्ट रूप से हर किसी से दूर है कि कौन सा सिंगलटन बनाया गया है और क्या यह धागा सुरक्षित है।

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

एक्सटेंशन

Kotlin

 fun String.getEmpty(): String { return "" } 

विघटित जावा

 public final class TestKt { @NotNull public static final String getEmpty(@NotNull String $receiver) { Intrinsics.checkParameterIsNotNull($receiver, "receiver$0"); return ""; } } 

यहां, सामान्य तौर पर, सबकुछ स्पष्ट है - एक्सटेंशन केवल सिंटैक्टिक चीनी हैं और नियमित स्थैतिक विधि में संकलित हैं।

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

 public static void checkParameterIsNotNull(Object value, String paramName) { if (value == null) { throwParameterIsNullException(paramName); } } 

यदि आप फ़ंक्शन नहीं, बल्कि एक्सटेंशन प्रॉपर्टी लिखते हैं, तो क्या विशिष्ट है

 val String.empty: String get() { return "" } 

फिर, परिणामस्वरूप, हमें वही चीज़ मिलती है जो हमें String.getEmpty () पद्धति के लिए मिली थी

इनलाइन

Kotlin

 inline fun something() { println("hello") } class Test { fun test() { something() } } 

विघटित जावा

 public final class Test { public final void test() { String var1 = "hello"; System.out.println(var1); } } public final class TestKt { public static final void something() { String var1 = "hello"; System.out.println(var1); } } 

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

इनबैंक की सारी शक्ति उस समय सामने आती है जब लंबोदर तर्कों में दिखाई देता है:

Kotlin

 inline fun something(action: () -> Unit) { action() println("world") } class Test { fun test() { something { println("hello") } } } 

विघटित जावा

 public final class Test { public final void test() { String var1 = "hello"; System.out.println(var1); var1 = "world"; System.out.println(var1); } } public final class TestKt { public static final void something(@NotNull Function0 action) { Intrinsics.checkParameterIsNotNull(action, "action"); action.invoke(); String var2 = "world"; System.out.println(var2); } } 

निचले हिस्से में, स्टैटिक्स फिर से दिखाई देता है, और ऊपरी हिस्से में यह स्पष्ट है कि फ़ंक्शन तर्क में लैम्ब्डा भी इनबिल्ड है, और अतिरिक्त अनाम वर्ग नहीं बनाता है, जैसा कि कोटलिन में लैम्बडा के साथ होता है।

इसके आसपास, कोटलिन के कई इनलाइन ज्ञान समाप्त हो जाते हैं, लेकिन 2 और दिलचस्प बिंदु हैं, जैसे कि नामांकित और क्रॉसिनलाइन। ये ऐसे कीवर्ड हैं जिन्हें लैम्बडा को सौंपा जा सकता है जो इनलाइन फ़ंक्शन में एक तर्क है।

Kotlin

 inline fun something(noinline action: () -> Unit) { action() println("world") } class Test { fun test() { something { println("hello") } } } 

विघटित जावा

 public final class Test { public final void test() { Function0 action$iv = (Function0)null.INSTANCE; action$iv.invoke(); String var2 = "world"; System.out.println(var2); } } public final class TestKt { public static final void something(@NotNull Function0 action) { Intrinsics.checkParameterIsNotNull(action, "action"); action.invoke(); String var2 = "world"; System.out.println(var2); } } 

इस तरह के रिकॉर्ड के साथ, आईडीई यह संकेत देना शुरू कर देता है कि इस तरह की एक इनलाइन पूरी तरह से बेकार है। और यह जावा के समान ही संकलित करता है - फ़ंक्शन 0 बनाता है। क्यों अजीब (समारोह 0) अशक्तता के साथ विघटित; - मुझे कोई अंदाजा नहीं है, सबसे अधिक संभावना है कि यह डीकॉम्पिलर बग हो।

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

यहां here वापसी ’की अनुमति नहीं है

हालांकि, क्रॉसिनलाइन बायटेकोड डिफ़ॉल्ट इनलाइन से अलग नहीं है - कीवर्ड केवल कंपाइलर द्वारा उपयोग किया जाता है।

इन्फ़िक्स

Kotlin

 infix fun Int.plus(value: Int): Int { return this+value } class Test { fun test() { val result = 5 plus 3 } } 

विघटित जावा

 public final class Test { public final void test() { int result = TestKt.plus(5, 3); } } public final class TestKt { public static final int plus(int $receiver, int value) { return $receiver + value; } } 

Infix फ़ंक्शंस नियमित स्टेटिक्स के एक्सटेंशन की तरह संकलित किए जाते हैं

tailrec

Kotlin

 tailrec fun factorial(step:Int, value: Int = 1):Int { val newValue = step*value return if (step == 1) newValue else factorial(step - 1,newValue) } 

विघटित जावा

 public final class TestKt { public static final int factorial(int step, int value) { while(true) { int newValue = step * value; if (step == 1) { return newValue; } int var10000 = step - 1; value = newValue; step = var10000; } } // $FF: synthetic method public static int factorial$default(int var0, int var1, int var2, Object var3) { if ((var2 & 2) != 0) { var1 = 1; } return factorial(var0, var1); } } 

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

reified

Kotlin

 inline fun <reified T>something(value: Class<T>) { println(value.simpleName) } 

विघटित जावा

 public final class TestKt { private static final void something(Class value) { String var2 = value.getSimpleName(); System.out.println(var2); } } 

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

आपको इस तथ्य पर ध्यान देना चाहिए कि निजी एक्सेस स्तर के साथ एक स्थिर फ़ंक्शन बायटेकोड में संकलित है, जिसका अर्थ है कि यह जावा से बाहर काम नहीं करेगा। वैसे, कोटलिन के विज्ञापन में "जावा और एंड्रॉइड के साथ 100% इंटरऑपरेबल" के कारण , कम से कम अशुद्धि प्राप्त होती है।



शायद सभी 99% के बाद?

init

Kotlin

 class Test { constructor() constructor(value: String) init { println("hello") } } 

विघटित जावा

 public final class Test { public Test() { String var1 = "hello"; System.out.println(var1); } public Test(@NotNull String value) { Intrinsics.checkParameterIsNotNull(value, "value"); super(); String var2 = "hello"; System.out.println(var2); } } 

सामान्य तौर पर, init के साथ, सब कुछ सरल है - यह एक सामान्य इनलाइन फ़ंक्शन है, जो स्वयं कंस्ट्रक्टर के कोड को कॉल करने से पहले काम करता है।

डेटा वर्ग

Kotlin

 data class Test(val argumentValue: String, val argumentValue2: String) { var innerValue: Int = 0 } 

विघटित जावा

 public final class Test { private int innerValue; @NotNull private final String argumentValue; @NotNull private final String argumentValue2; public final int getInnerValue() { return this.innerValue; } public final void setInnerValue(int var1) { this.innerValue = var1; } @NotNull public final String getArgumentValue() { return this.argumentValue; } @NotNull public final String getArgumentValue2() { return this.argumentValue2; } public Test(@NotNull String argumentValue, @NotNull String argumentValue2) { Intrinsics.checkParameterIsNotNull(argumentValue, "argumentValue"); Intrinsics.checkParameterIsNotNull(argumentValue2, "argumentValue2"); super(); this.argumentValue = argumentValue; this.argumentValue2 = argumentValue2; } @NotNull public final String component1() { return this.argumentValue; } @NotNull public final String component2() { return this.argumentValue2; } @NotNull public final Test copy(@NotNull String argumentValue, @NotNull String argumentValue2) { Intrinsics.checkParameterIsNotNull(argumentValue, "argumentValue"); Intrinsics.checkParameterIsNotNull(argumentValue2, "argumentValue2"); return new Test(argumentValue, argumentValue2); } // $FF: synthetic method @NotNull public static Test copy$default(Test var0, String var1, String var2, int var3, Object var4) { if ((var3 & 1) != 0) { var1 = var0.argumentValue; } if ((var3 & 2) != 0) { var2 = var0.argumentValue2; } return var0.copy(var1, var2); } @NotNull public String toString() { return "Test(argumentValue=" + this.argumentValue + ", argumentValue2=" + this.argumentValue2 + ")"; } public int hashCode() { return (this.argumentValue != null ? this.argumentValue.hashCode() : 0) * 31 + (this.argumentValue2 != null ? this.argumentValue2.hashCode() : 0); } public boolean equals(@Nullable Object var1) { if (this != var1) { if (var1 instanceof Test) { Test var2 = (Test)var1; if (Intrinsics.areEqual(this.argumentValue, var2.argumentValue) && Intrinsics.areEqual(this.argumentValue2, var2.argumentValue2)) { return true; } } return false; } else { return true; } } } 

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

विनाशकारी घोषणा

एक उदाहरण के लिए, हम पिछले उदाहरण से दिनांक वर्ग का उपयोग करेंगे और निम्नलिखित कोड जोड़ेंगे:

Kotlin

 class DestructuringDeclaration { fun test() { val (one, two) = Test("hello", "world") } } 

विघटित जावा

 public final class DestructuringDeclaration { public final void test() { Test var3 = new Test("hello", "world"); String var1 = var3.component1(); String two = var3.component2(); } } 

आमतौर पर यह सुविधा एक शेल्फ पर धूल इकट्ठा कर रही है, लेकिन कभी-कभी यह उपयोगी हो सकता है, उदाहरण के लिए, जब मानचित्र सामग्री के साथ काम करना।

ऑपरेटर

Kotlin

 class Something(var likes: Int = 0) { operator fun inc() = Something(likes+1) } class Test() { fun test() { var something = Something() something++ } } 

विघटित जावा

 public final class Something { private int likes; @NotNull public final Something inc() { return new Something(this.likes + 1); } public final int getLikes() { return this.likes; } public final void setLikes(int var1) { this.likes = var1; } public Something(int likes) { this.likes = likes; } // $FF: synthetic method public Something(int var1, int var2, DefaultConstructorMarker var3) { if ((var2 & 1) != 0) { var1 = 0; } this(var1); } public Something() { this(0, 1, (DefaultConstructorMarker)null); } } public final class Test { public final void test() { Something something = new Something(0, 1, (DefaultConstructorMarker)null); something = something.inc(); } } 

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

इनलाइन वर्ग

Kotlin

 inline class User(internal val name: String) { fun upperCase(): String { return name.toUpperCase() } } class Test { fun test() { val user = User("Some1") println(user.upperCase()) } } 

विघटित जावा

 public final class Test { public final void test() { String user = User.constructor-impl("Some1"); String var2 = User.upperCase-impl(user); System.out.println(var2); } } public final class User { @NotNull private final String name; // $FF: synthetic method private User(@NotNull String name) { Intrinsics.checkParameterIsNotNull(name, "name"); super(); this.name = name; } @NotNull public static final String upperCase_impl/* $FF was: upperCase-impl*/(String $this) { if ($this == null) { throw new TypeCastException("null cannot be cast to non-null type java.lang.String"); } else { String var10000 = $this.toUpperCase(); Intrinsics.checkExpressionValueIsNotNull(var10000, "(this as java.lang.String).toUpperCase()"); return var10000; } } @NotNull public static String constructor_impl/* $FF was: constructor-impl*/(@NotNull String name) { Intrinsics.checkParameterIsNotNull(name, "name"); return name; } // $FF: synthetic method @NotNull public static final User box_impl/* $FF was: box-impl*/(@NotNull String v) { Intrinsics.checkParameterIsNotNull(v, "v"); return new User(v); } @NotNull public static String toString_impl/* $FF was: toString-impl*/(String var0) { return "User(name=" + var0 + ")"; } public static int hashCode_impl/* $FF was: hashCode-impl*/(String var0) { return var0 != null ? var0.hashCode() : 0; } public static boolean equals_impl/* $FF was: equals-impl*/(String var0, @Nullable Object var1) { if (var1 instanceof User) { String var2 = ((User)var1).unbox-impl(); if (Intrinsics.areEqual(var0, var2)) { return true; } } return false; } public static final boolean equals_impl0/* $FF was: equals-impl0*/(@NotNull String p1, @NotNull String p2) { Intrinsics.checkParameterIsNotNull(p1, "p1"); Intrinsics.checkParameterIsNotNull(p2, "p2"); throw null; } // $FF: synthetic method @NotNull public final String unbox_impl/* $FF was: unbox-impl*/() { return this.name; } public String toString() { return toString-impl(this.name); } public int hashCode() { return hashCode-impl(this.name); } public boolean equals(Object var1) { return equals-impl(this.name, var1); } } 

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

परिणाम

यह मत भूलो कि, सबसे पहले, कोड हमेशा सही ढंग से विघटित नहीं होगा, और दूसरी बात, हर कोड विघटित नहीं हो सकता है। हालांकि, कोटलिन डिकम्पोज्ड कोड को अपने आप में देखने की क्षमता बहुत दिलचस्प है और बहुत कुछ स्पष्ट कर सकती है।