Kotlin Academy · Lezione

Dichiarazioni destrutturate

Scomponga i dati in variabili

Dichiarazioni destrutturate è una lezione Kotlin Academy gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Kotlin Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Kotlin Academy include 4 lezioni in totale.

Destrutturare gli oggetti

A volte desidera estrarre contemporaneamente diverse proprietà da un oggetto.

Le dichiarazioni di destrutturazione di Kotlin consentono di assegnare più variabili a partire da un unico oggetto, tutto in una sola riga.

Destrutturazione di base

Inserisca i nomi tra parentesi a sinistra di =. Kotlin assegna loro i componenti dell'oggetto nell'ordine.

Le data class lo supportano automaticamente.

data class User(val name: String, val age: Int)

fun main() {
    val user = User("Alice", 30)
    val (name, age) = user
    println(name)
    println(age)
}

Come funziona

Dietro le quinte, la destrutturazione chiama component1(), component2() e così via, generati automaticamente.

La posizione di ciascuna variabile corrisponde alla funzione component corrispondente.

data class Point(val x: Int, val y: Int)

fun main() {
    val p = Point(3, 7)
    println(p.component1())
    println(p.component2())
}

L'ordine è importante

Le variabili vengono associate in base alla posizione, non al nome.

La prima variabile riceve sempre la prima proprietà del costruttore, indipendentemente dal nome che le assegna.

data class Pair2(val first: Int, val second: Int)

fun main() {
    val (a, b) = Pair2(10, 20)
    println(a) // first property
    println(b) // second property
}

Saltare i componenti

Usi un carattere di sottolineatura _ per saltare un componente di cui non ha bisogno.

In questo modo il codice rimane pulito quando sono importanti solo alcuni valori.

data class User(val name: String, val age: Int, val city: String)

fun main() {
    val (name, _, city) = User("Mia", 28, "Paris")
    println(name)
    println(city)
}

Destrutturazione nei cicli

La destrutturazione è particolarmente utile quando si itera su raccolte di oggetti.

Può spacchettare direttamente ogni elemento nell'intestazione del ciclo for.

data class User(val name: String, val age: Int)

fun main() {
    val users = listOf(User("A", 20), User("B", 25))
    for ((name, age) in users) {
        println(name + " is " + age)
    }
}

Destrutturare le entry di una Map

Le Map supportano la destrutturazione perché le loro entry forniscono i componenti chiave e valore.

Questo rende molto leggibile l'iterazione su una Map.

fun main() {
    val scores = mapOf("Alice" to 90, "Bob" to 85)
    for ((name, score) in scores) {
        println(name + ": " + score)
    }
}

Restituire più valori

Una funzione può restituire una data class e il chiamante può destrutturare il risultato.

Questa è un'alternativa chiara ai parametri di output.

data class MinMax(val min: Int, val max: Int)

fun minMax(nums: List<Int>): MinMax {
    return MinMax(nums.min(), nums.max())
}

fun main() {
    val (low, high) = minMax(listOf(3, 1, 8, 5))
    println(low)
    println(high)
}

Destrutturare Pair e Triple

Anche Pair e Triple della libreria standard supportano la destrutturazione.

Sono utili per raggruppamenti rapidi senza dover definire una classe.

fun main() {
    val pair = Pair("x", 1)
    val (label, value) = pair
    println(label)
    println(value)
}

Destrutturazione dei parametri delle lambda

Può destrutturare i parametri direttamente nell'elenco dei parametri di una lambda.

È comune quando si esegue il mapping su entry o coppie.

fun main() {
    val map = mapOf(1 to "one", 2 to "two")
    val text = map.map { (key, value) -> "" + key + "=" + value }
    println(text)
}

Mettere tutto insieme

La destrutturazione scompone gli oggetti in variabili:

Usi le parentesi a sinistra di =
I componenti vengono associati in base alla posizione
Salti un componente con _
Funziona nei cicli, nelle lambda e nei valori restituiti

data class Result(val ok: Boolean, val message: String)

fun main() {
    val (ok, message) = Result(true, "done")
    println(ok)
    println(message)
}

Verifica rapida

Verifichi la Sua comprensione delle dichiarazioni con destrutturazione.

Riepilogo

Ha imparato a usare le dichiarazioni con destrutturazione:

Scompongono un oggetto in più variabili
L'associazione avviene in base alla posizione tramite componentN()
_ salta i componenti non necessari
Funzionano nei cicli, nelle Map, nelle lambda e nei valori restituiti

Ora userà le data class all'interno di raccolte come set e Map.

Domande Frequenti

La lezione «Dichiarazioni destrutturate» è gratuita?

Sì — il testo completo di «Dichiarazioni destrutturate» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Kotlin Academy, passa a CoddyKit PRO. Il corso Kotlin Academy include 4 lezioni in totale.

Cosa imparerò in «Dichiarazioni destrutturate»?

Scomponga i dati in variabili Eserciti Kotlin Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Kotlin Academy?

Non è richiesta alcuna esperienza precedente. Kotlin Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.

Quanto tempo richiede la lezione «Dichiarazioni destrutturate»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Kotlin Academy?

Sì. Ogni lezione Kotlin Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Kotlin Academy