Frammento di codice vario

map reduce

Convertire una lista di bit in una lista di stringhe e riassumere la lista di stringhe
in una stringa contenente la concatenazione. Come loggare la richiesta inviata(requestBodyContent:byte[])

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

enum e classi sealed

functional interface e method reference

È possibile trasformare un’entità in un modello di dominio DTO utilizzando un metodo di riferimento (stile funzionale - Java 8)

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

unahttps://stackoverflow.com/a/22245383/837404[buona spiegazione]

Catturare l’output standard

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() }
}

Qual è la differenza in Kotlin tra apply, run, let, also, use e with ?

Confronto delle funzioni Kotlin e utilizzo delle forme lambda Riferimento

applica

Introduzione Le funzioni Kotlin`apply`, run, let, also, use, et `with`offrono diversi modi di trattare gli oggetti. Ciascuna ha i propri casi d’uso e comportamenti. Inoltre, le forme lambda reference consentono di rendere il codice più leggibile e riutilizzabile facendo riferimento a funzioni lambda esistenti.

La funzione`apply`viene utilizzato per configurare un oggetto durante la sua creazione. Restituisce l’oggetto su cui viene chiamata.

Esempio con lambda reference:

val someObject = SomeClass().apply(::configureObject)

Esempio con lambda :

val someObject = SomeClass().apply {
// configuration des propriétés de someObject
}

esegui

La funzione`run`viene utilizzata per eseguire un blocco di codice su un oggetto e restituisce il risultato del blocco di codice.

Esempio con riferimento lambda :

val result = someObject.run(::someFunction)

Esempio con lambda :

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

lascia

La funzione`let`viene utilizzata per eseguire un blocco di codice su un oggetto e restituisce il risultato del blocco di codice.

Esempio con riferimento lambda :

val result = someObject.let(::processObject)

Esempio con lambda :

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

anche

La funzione`also`viene utilizzata per eseguire un’azione aggiuntiva su un oggetto e restituisce l’oggetto su cui viene chiamata

Esempio con riferimento lambda :

someObject.also(::performAdditionalAction)

Esempio con lambda :

someObject.also {
// action additionnelle sur someObject
}

logora

La funzione`use`Viene utilizzata per lavorare con le risorse che devono essere chiuse dopo l’uso. Chiama automaticamente la funzione`close`alla fine del blocco

Esempio con riferimento lambda :

someResource.use(::useResource)

Esempio con lambda :

someResource.use {
// travailler avec la ressource
}

con

La funzione`with`viene utilizzato per chiamare più metodi su un oggetto senza ripetere il suo nome e restituisce il risultato dell’ultima espressione.

Esempio con riferimento lambda :

val result = with(someObject, ::processWithObject)

Esempio con lambda :

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

Utilizzando le forme lambda di riferimento o i blocchi`{}`, puoi incapsulare la logica in funzioni separate, migliorando così la leggibilità e la riutilizzabilità del codice.

let Function in Kotlin

Restituisce let l’oggetto con gli effetti collaterali applicati sopra o nello stato iniziale di ingresso in funzione(let) ?

La funzione`let`In Kotlin è utilizzata per eseguire operazioni su un oggetto e restituire un risultato diverso. Tuttavia, è importante notare che la funzione`let`non modifica lo stato iniziale dell’oggetto su cui viene chiamata

Firma

inline fun <T, R> T.let(block: (T) → R): R

Uso

La funzione`let`è comunemente utilizzata per applicare delle trasformazioni a un oggetto e ottenere un risultato basato su queste trasformazioni.

Risultato

Il valore restituito dalla funzione`let`è il risultato dell’espressione lambda passata come argomento, generalmente il risultato delle operazioni effettuate sull’oggetto.

Effetti di bordo

Sebbene la funzione`let`può avere effetti collaterali sull’oggetto quando viene utilizzata nell’espressione lambda, ma non modifica lo stato iniziale dell’oggetto stesso.

Così, la funzione`let`è un modo elegante per eseguire operazioni su un oggetto ottenendo contemporaneamente un risultato derivato, preservando al contempo l’integrità dell’oggetto originale.

Articoli correlati