कॉटलिन ज्ञापन

----
tasks.register<JavaExec>("bake") {
    mainClass.set("org.jbake.launcher.Main")
    classpath = configurations["jbake"]
    args = listOf(projectDir.absolutePath, "$buildDir/jbake")
}


== अच्छे लिंक

https://play.kotlinlang.org/[kotlinlang प्लेग्राउंड](No output)

https://arrow-kt.io/[तीर.kt]+

https://arkivanov.github.io/MVIKotlin/[MVI:मॉडल व्यू इंटेंट]+

https://github.com/arkivanov/Essenty[Essenty]+

https://arkivanov.github.io/Decompose/[विघटित](No output)

== Bout de code divers

=== मानचित्र घटाना

बाइट की सूची को स्ट्रिंग की सूची में बदलें और स्ट्रिंग की सूची का सारांश दें +
एक स्ट्रिंग जिसमें संयोजन होता है। कैसे request भेजे गए requestBodyContent:byte[] की लॉग करें

[source,kotlin]
----
log.info(
    requestBodyContent!!.map { it.toInt().toChar().toString() }
        .reduce { request: String, s: String -> request + s }
)
----

=== enum और सील्ड क्लासेस

[No output]link:0038_training_kotlin_enum_sealed_class_post[प्रशिक्षण kotlin enum सील्ड क्लास, window="_blank]

=== functionnal interface और method reference

एक इकाई को DTO डोमेन मॉडल में परिवर्तित किया जा सकता है, एक विधि संदर्भ (फ़ंक्शनल शैली - Java 8) के साथ।

[source,kotlin]
----
fun findAllByLoginNot(
        pageable:Pageable,
        login:String)
    :Page<UserDto> {
    return userDao.findAllByLoginNot(
                    pageable,
                    login).map(::fromEntity)
}
----

एकhttps://stackoverflow.com/a/22245383/837404[अच्छी व्याख्या]

=== मानक आउटपुट को कैप्चर करें

[source,kotlin]
----
package functional

import java.io.ByteArrayOutputStream
import java.io.PrintStream
import java.lang.System.out
import java.lang.System.setOut
import kotlin.test.AfterTest
import kotlin.test.BeforeTest
import kotlin.test.Test
import kotlin.test.assertEquals


class BasicsHOF {
    private val standardOut: PrintStream? = out
    private val outputStreamCaptor = ByteArrayOutputStream()

    @BeforeTest
    fun setUp() = setOut(PrintStream(outputStreamCaptor))

    @AfterTest
    fun tearDown() = setOut(standardOut)

    @Test
    fun `three times dope`() {

        3.times { println("Hello") }

        assertEquals(
            buildString {
                repeat(3) { append("Hello\n") }
                deleteAt(length - 1)
            }, outputStreamCaptor
                .toString()
                .trim()
        )
    }

    fun Int.times(fn: () -> Unit) = (1..this).forEach { _ -> fn() }
}
----

=== Kotlin में apply, run, let, also, use और with के बीच क्या अंतर है?

Kotlin फ़ंक्शनों की तुलना और लैम्ब्डा फ़ॉर्म का उपयोग संदर्भ

.परिचय Kotlin फ़ंक्शन`apply`, `run`, `let`, `also`, `use`, et `with`वस्तुओं को संभालने के विभिन्न तरीके प्रदान करते हैं। प्रत्येक का अपना उपयोग केस और व्यवहार होता है। इसके अलावा, लैम्ब्डा रेफरेंस रूपों से मौजूदा लैम्ब्डा कार्यों को संदर्भित करके कोड को अधिक पढ़ने योग्य और पुन: प्रयोज्य बनाया जा सकता है।

== लागू करना ==

फ़ंक्शन`apply`इसे ऑब्जेक्ट को उसकी सृजन के दौरान कॉन्फ़िगर करने के लिए उपयोग किया जाता है। यह उस ऑब्जेक्ट को लौटाता है जिस पर इसे कॉल किया जाता है।

उदाहरण लैम्ब्डा संदर्भ :

[source,kotlin]
----
val someObject = SomeClass().apply(::configureObject)
----

उदाहरण लैम्ब्डा के साथ :

[source,kotlin]
----
val someObject = SomeClass().apply {
// configuration des propriétés de someObject
}
----

== चलना ==

फ़ंक्शन`run`एक ऑब्जेक्ट पर कोड के एक ब्लॉक को निष्पादित करने और कोड ब्लॉक का परिणाम लौटाने के लिए उपयोग की जाती है।

लैम्ब्डा संदर्भ का उदाहरण :

[source,kotlin]
----
val result = someObject.run(::someFunction)
----

लैम्ब्डा के साथ उदाहरण :

[source,kotlin]
----
val result = someObject.run {
// bloc de code à exécuter sur someObject
// la dernière expression est renvoyée
}
----

== अनुमति दें ==

फ़ंक्शन`let`इसका उपयोग एक ऑब्जेक्ट पर कोड के ब्लॉक को निष्पादित करने और कोड ब्लॉक का परिणाम लौटाने के लिए किया जाता है।

उदाहरण के साथ लैम्ब्डा संदर्भ :

[source,kotlin]
----
val result = someObject.let(::processObject)
----

लैम्बडा के साथ उदाहरण:

[source,kotlin]
----
val result = someObject.let {
// bloc de code à exécuter sur someObject
// la dernière expression est renvoyée
}
----

== भी ==

फ़ंक्शन`also`इसे किसी वस्तु पर अतिरिक्त क्रिया करने के लिए उपयोग किया जाता है और यह उसी वस्तु को लौटाता है जिस पर इसे बुलाया जाता है।

लैम्ब्डा संदर्भ के साथ उदाहरण :

[source,kotlin]
----
someObject.also(::performAdditionalAction)
----

उदाहरण lambda के साथ :

[source,kotlin]
----
someObject.also {
// action additionnelle sur someObject
}
----

== उपयोग करें =|

कार्य`use`इसका उपयोग उन संसाधनों के साथ काम करने के लिए किया जाता है जिन्हें उपयोग के बाद बंद किया जाना चाहिए। यह स्वचालित रूप से फ़ंक्शन को बुलाती है`close`ब्लॉक के अंत में।

लैम्ब्डा संदर्भ के साथ उदाहरण:

[source,kotlin]
----
someResource.use(::useResource)
----

उदाहरण के साथ lambda :

[source,kotlin]
----
someResource.use {
// travailler avec la ressource
}
----

== के साथ ==

फ़ंक्शन`with`यह कई विधियों को एक ऑब्जेक्ट पर उसके नाम को दोहराए बिना कॉल करने के लिए उपयोग की जाती है और अंतिम अभिव्यक्ति का परिणाम लौटाती है।

उदाहरण लैम्ब्डा संदर्भ :

[source,kotlin]
----
val result = with(someObject, ::processWithObject)
----

लैम्ब्डा के साथ उदाहरण :

[source,kotlin]
----
val result = with(someObject) {
// appeler des méthodes sur someObject
// la dernière expression est renvoyée
}
----

लैम्ब्डा संदर्भ रूपों या ब्लॉकों का उपयोग करके`{}`, आप विभिन्न कार्यों में तर्क को समेट सकते हैं, इस प्रकार कोड की पढ़ने योग्यता और पुन: उपयोगिता में सुधार होता है।

.क्या let उस ऑब्जेक्ट को उसके पर किए गए साइड इफ़ेक्ट्स के साथ लौटाता है या इनपुट की प्रारंभिक अवस्था में function(let) में ?

== let Function en Kotlin ==

फ़ंक्शन`let`Kotlin में एक ऑब्जेक्ट पर ऑपरेशन करने और अलग परिणाम वापस करने के लिए उपयोग की जाती है। हालांकि, यह ध्यान रखना महत्वपूर्ण है कि फ़ंक्शन`let`यह विधि जिस ऑब्जेक्ट पर इसे बुलाया जाता है, उसके प्रारम्भिक स्थिति को संशोधित नहीं करती।

|===
|**हस्ताक्षर** |`inline fun <T, R> T.let(block: (T) -> R): R`
|===

|===
|**उपयोग** |फ़ंक्शन`let`इसे सामान्यतः किसी ऑब्जेक्ट पर परिवर्तन लागू करने और इन परिवर्तनों पर आधारित परिणाम प्राप्त करने के लिए उपयोग किया जाता है।
|===

|===
|**परिणाम** |फ़ंक्शन द्वारा लौटाया गया मान`let`यह लैम्ब्डा अभिव्यक्ति का परिणाम है जो तर्क के रूप में पारित की गई है, सामान्यतया वस्तु पर किए गए संचालन का परिणाम होता है।
|===

|===
|**पार्श्व प्रभावों** |भले ही फ़ंक्शन`let`जब इसे लैम्ब्डा अभिव्यक्ति में उपयोग किया जाता है, तो यह ऑब्जेक्ट पर साइड इफ़ेक्ट्स डाल सकती है, लेकिन यह ऑब्जेक्ट की प्रारंभिक स्थिति को संशोधित नहीं करती।
|===

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