Kotlin
कार्य

वाक्य - विन्यास

• मजेदार नाम ( परम ) = ...
• मजेदार नाम ( परम ) {...}
• मजेदार नाम ( परम ): टाइप {...}
• मज़ा < प्रकार तर्क > नाम ( परम ): टाइप {...}
• इनलाइन मजेदार नाम ( परम ): टाइप {...}
• { ArgName : ArgType -> ...}
• { अर्गनाम -> ...}
• { ArgNames -> ...}
• {( ArgName : ArgType ): टाइप -> ...}

पैरामीटर

अन्य कार्य लेना कार्य

जैसा कि "लैंबडा फंक्शंस" में देखा गया है, फ़ंक्शंस पैरामीटर के रूप में अन्य फ़ंक्शन ले सकते हैं। "फ़ंक्शन प्रकार" जिसे आपको उन कार्यों को घोषित करने की आवश्यकता होगी जो अन्य कार्यों को लेते हैं:

# Takes no parameters and returns anything
() -> Any?

# Takes a string and an integer and returns ReturnType
(arg1: String, arg2: Int) -> ReturnType

उदाहरण के लिए, आप अस्पष्ट प्रकार का उपयोग कर सकते हैं, () -> Any? , एक समारोह घोषित करने के लिए जो एक लंबो कार्य को दो बार निष्पादित करता है:

fun twice(x: () -> Any?) {
    x(); x();
}

fun main() {
    twice {
        println("Foo")
    } # => Foo
      # => Foo
}

लंबोदर कार्य

लैंबडा फ़ंक्शंस अनाम फ़ंक्शन हैं जो आमतौर पर फ़ंक्शन कॉल के दौरान फ़ंक्शन पैरामीटर के रूप में कार्य करने के लिए बनाए जाते हैं। वे आसपास के भावों द्वारा {ब्रेसिज़} के साथ घोषित किए जाते हैं - यदि तर्क की आवश्यकता होती है, तो इन्हें एक तीर से पहले रखा जाता है -> ।

{ name: String ->
    "Your name is $name" //This is returned
}

एक लंबो फ़ंक्शन के अंदर अंतिम विवरण स्वचालित रूप से रिटर्न वैल्यू है।

प्रकार वैकल्पिक हैं, यदि आप लैम्ब्डा को ऐसी जगह पर रखते हैं जहां कंपाइलर प्रकारों का अनुमान लगा सकता है।

एकाधिक तर्क:

{ argumentOne:String, argumentTwo:String ->
    "$argumentOne - $argumentTwo"
}

यदि लंबो फ़ंक्शन को केवल एक तर्क की आवश्यकता होती है, तो तर्क सूची को छोड़ दिया जा सकता है और it बजाय it उपयोग करने के लिए एकल तर्क को संदर्भित किया जाना चाहिए।

{ "Your name is $it" }

यदि किसी फ़ंक्शन का एकमात्र तर्क एक लंबो फ़ंक्शन है, तो फ़ंक्शन कॉल से कोष्ठक पूरी तरह से छोड़ा जा सकता है।

# These are identical
listOf(1, 2, 3, 4).map { it + 2 }
listOf(1, 2, 3, 4).map({ it + 2 })

समारोह संदर्भ

हम वास्तव में इसे फ़ंक्शन के नाम के साथ प्रीफ़ाइन करके बुलाए बिना किसी फ़ंक्शन का संदर्भ दे सकते हैं :: । यह तब एक फ़ंक्शन को पास किया जा सकता है जो पैरामीटर के रूप में कुछ अन्य फ़ंक्शन को स्वीकार करता है।

fun addTwo(x: Int) = x + 2
listOf(1, 2, 3, 4).map(::addTwo) # => [3, 4, 5, 6]

एक रिसीवर के बिना कार्य (ParamTypeA, ParamTypeB, ...) -> ReturnType परिवर्तित किया जाएगा (ParamTypeA, ParamTypeB, ...) -> ReturnType जहां ParamTypeA , ParamTypeB ... फ़ंक्शन पैरामीटर के प्रकार हैं और `ReturnType1 फ़ंक्शन रिटर्न मान का प्रकार है।

fun foo(p0: Foo0, p1: Foo1, p2: Foo2): Bar {
    //...
}
println(::foo::class.java.genericInterfaces[0]) 
// kotlin.jvm.functions.Function3<Foo0, Foo1, Foo2, Bar>
// Human readable type: (Foo0, Foo1, Foo2) -> Bar

एक रिसीवर के साथ कार्य (एक एक्सटेंशन फ़ंक्शन या एक सदस्य फ़ंक्शन हो) में एक अलग वाक्यविन्यास है। आपको डबल कोलन से पहले रिसीवर का प्रकार नाम जोड़ना होगा:

class Foo
fun Foo.foo(p0: Foo0, p1: Foo1, p2: Foo2): Bar {
    //...
}
val ref = Foo::foo
println(ref::class.java.genericInterfaces[0]) 
// kotlin.jvm.functions.Function4<Foo, Foo0, Foo1, Foo2, Bar>
// Human readable type: (Foo, Foo0, Foo1, Foo2) -> Bar
// takes 4 parameters, with receiver as first and actual parameters following, in their order

// this function can't be called like an extension function, though
val ref = Foo::foo
Foo().ref(Foo0(), Foo1(), Foo2()) // compile error

class Bar {
    fun bar()
}
print(Bar::bar) // works on member functions, too.

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

object Foo
fun Foo.foo(p0: Foo0, p1: Foo1, p2: Foo2): Bar {
    //...
}
val ref = Foo::foo
println(ref::class.java.genericInterfaces[0]) 
// kotlin.jvm.functions.Function3<Foo0, Foo1, Foo2, Bar>
// Human readable type: (Foo0, Foo1, Foo2) -> Bar
// takes 3 parameters, receiver not needed

object Bar {
    fun bar()
}
print(Bar::bar) // works on member functions, too.

1.1 kotlin के बाद से, समारोह संदर्भ भी एक चर, जो फिर एक घिरे समारोह संदर्भ में कहा जाता है घिरा जा सकता है।

fun makeList(last: String?): List<String> {
    val list = mutableListOf("a", "b", "c")
    last?.let(list::add)
    return list
}

_{ध्यान दें कि यह उदाहरण केवल यह दिखाने के लिए दिया गया है कि फ़ंक्शन संदर्भ संदर्भ कैसे काम करता है। यह अन्य सभी इंद्रियों में बुरा अभ्यास है।}

एक विशेष मामला है, हालांकि। एक सदस्य के रूप में घोषित एक विस्तार समारोह को संदर्भित नहीं किया जा सकता है।

class Foo
class Bar {
    fun Foo.foo() {}
    val ref = Foo::foo // compile error
}

बुनियादी कार्यों

कार्य का उपयोग कर की घोषणा की जाती fun कीवर्ड एक समारोह नाम और कोई पैरामीटर का स्थान है। आप किसी फ़ंक्शन के रिटर्न प्रकार को भी निर्दिष्ट कर सकते हैं, जो Unit चूक करता है। फ़ंक्शन का शरीर ब्रेसिज़ {} में संलग्न है। यदि रिटर्न प्रकार Unit अलावा अन्य है, तो शरीर को शरीर के भीतर हर समाप्ति शाखा के लिए रिटर्न स्टेटमेंट जारी करना चाहिए।

fun sayMyName(name: String): String {
    return "Your name is $name" 
} 

उसी का एक शॉर्टहैंड संस्करण:

fun sayMyName(name: String): String = "Your name is $name" 

और प्रकार को छोड़ा जा सकता है क्योंकि यह अनुमान लगाया जा सकता है:

fun sayMyName(name: String) = "Your name is $name" 

आशुलिपि कार्य

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

fun sayMyName(name: String): String = "Your name is $name" 

इनलाइन कार्य

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

inline fun sayMyName(name: String) = "Your name is $name" 

सी मैक्रोज़ से एक अंतर यह है कि इनलाइन फ़ंक्शंस उस दायरे तक नहीं पहुँच सकते जहाँ से उन्हें बुलाया जाता है:

inline fun sayMyName() = "Your name is $name"

fun main() {
    val name = "Foo"
    sayMyName() # => Unresolved reference: name
}

ऑपरेटर के कार्य

कोटलिन हमें निश्चित प्रतीकात्मक प्रतिनिधित्व (जैसे + या * ) और निश्चित पूर्वता वाले ऑपरेटरों के पूर्वनिर्धारित सेट के लिए कार्यान्वयन प्रदान करने की अनुमति देता है। एक ऑपरेटर को लागू करने के लिए, हम इसी प्रकार के लिए एक निश्चित नाम के साथ एक सदस्य समारोह या एक विस्तार समारोह प्रदान करते हैं। ओवरलोड ऑपरेटरों को operator संशोधक के साथ चिह्नित करने की आवश्यकता है:

data class IntListWrapper (val wrapped: List<Int>) {
    operator fun get(position: Int): Int = wrapped[position]
}

val a = IntListWrapper(listOf(1, 2, 3))
a[1] // == 2

अधिक ऑपरेटर कार्यों को यहां पाया जा सकता है