La fonction est définie comme suit.
//Une fonction qui incrémente et renvoie des arguments de type Int
fun increment(i: Int): Int {
return i + 1
}
fun function name (ʻargument list): return type`
Ceci est la forme de base.
Quelle valeur correspond à quel argument dans un appel de fonction avec de nombreux arguments Cela peut être difficile à comprendre.
Kotlin a la capacité de résoudre ce problème.
/*
*Je commanderai du takoyaki
*
* @param isKarashiMayo Choix de la mayonnaise Karashi
* @param isPutAonori Mettre ou non de la colle bleue
*
* @return Une instance de Takoyaki est retournée
*/
fun oderTakoyaki(isKarashiMayo: Boolean, isPutAonori: Boolean): Takoyaki {
// ...
}
val takoyaki = oderTakoyaki(true, false)
//Quel drapeau est de la colle bleue?
val takoyaki = oderTakoyaki(isKarashiMayo = true, isPutAonori = false)
//Vous pouvez donner un nom d'argument formel à l'appelant
//Intention de code facile à lire
val takoyaki = oderTakoyaki(isPutAonori = false, isKarashiMayo = true)
//Si vous lui donnez un nom, il n'est pas nécessaire qu'il soit dans l'ordre défini dans la fonction.
Je pense qu'il existe de nombreuses classes qui ont de nombreuses surcharges avec différents nombres d'arguments. Par exemple ...
En utilisant les arguments par défaut dans Kotlin, vous pouvez éviter une telle situation où les variations augmentent.
/*
*Je commanderai du takoyaki
*
* @param isKarashiMayo Choix de la mayonnaise Karashi
* @param isPutAonori Mettre ou non de la colle bleue
*
* @return Une instance de Takoyaki est retournée
*/
fun oderTakoyaki(isKarashiMayo: Boolean = false, isPutAonori: Boolean = true): Takoyaki {
// ...
}
//Les arguments peuvent être omis au moment de l'appel. Si omis, la valeur par défaut est utilisée.
val takoyaki = oderTakoyaki()
Vous pouvez ajouter des fonctions aux classes existantes ultérieurement. Ajoutons une fonction au type String qui analyse dans notre propre format de date.
fun String.toDate(): Date {
val format = SimpleDateFormat("aaaa année MM mois jj jour")
return format.parse(this)
}
val str = "09 mars 2019"
val date = str.toDate()
fun ʻextended type .function name (ʻargument list): return value
Définir comme ↑.
Au fait, la fonction habituelle est ...
fun function name (ʻargument list): return type`
↑ C'était comme ça.
Si vous ajoutez «type de cible d'extension» avant «nom de fonction», cela devient une fonction d'extension.
À propos, cet objet cible d'extension est appelé ** objet récepteur ** dans Kotlin.
Si la fonction se compose d'une seule expression, le «{}» peut être omis. Les fonctions d'expression unique peuvent également omettre le type de retour si le type de retour peut être déduit.
//Fonction normale
fun double(x: Int): Int {
return x * 2
}
//Décrit comme une fonction d'expression unique
fun double(x: Int): Int = x * 2
//Inférer le type de retour avec une seule fonction d'expression
fun double(x: Int) = x * 2
L'expression lambda s'écrit ↓.
val sum = { x: Int, y: Int ->
x + y
}
{ʻArgument list-> Body} Ou s'il n'y a pas d'argument {Corps principal`}
Ce sera.
La variable implicite ʻit` peut être utilisée si l'expression lambda a un paramètre.
val double: (Int)->Int = {
it * 2
}
Le type de fonction est décrit comme suit.
(ʻArgument type) -> Type de retour`
L'expression Lambda est un mécanisme à coût d'exécution élevé. L'expression lambda de Kotlin est implémentée en tant que classe anonyme. Chaque fois qu'une expression lambda qui capture une variable est exécutée, une instance de la classe anonyme est créée.
C'est donc une fonction en ligne. La fonction en ligne est compilée en remplaçant le corps de la fonction où elle est appelée.
inline fun edit(context: DataBaseContext, block: (DataBaseContext.Transaction)->Unit) {
val transaction = context.beginTransaction() // 1.Début de la transaction
block(transaction) // 2.Argument d'exécution lambda
transaction.commit() // 3.Fin de transaction
}
La fonction en ligne est efficace Une fonction qui prend une expression lambda comme argument et l'exécute en interne. La fonction en ligne étend également l'argument expression lambda à l'appelant.
Ceci est un exemple qui appelle la fonction en ligne Ueno ʻedit`.
val dataBaseContext = DataBaseContext()
edit(dataBaseContext) { transaction ->
val newObject = Any()
transaction.add(newObject)
}
La fonction ʻedit` est développée au moment de la compilation et ressemble au code suivant (image)
val dataBaseContext = DataBaseContext()
//La fonction d'édition se développe à partir d'ici
val transaction = dataBaseContext.beginTransaction() // 1.Début de la transaction
val newObject = Any() // 2.Argument expansion lambda
transaction.add(newObject) // 2.Argument expansion lambda
transaction.commit() // 3.Fin de transaction
//La fonction d'édition se développe jusqu'à présent
Les génériques Kotlin perdent les informations de type au moment de l'exécution.
Par exemple, la fonction suivante entraînera une erreur de compilation.
fun <T> mapFilter(list: List<Any>): List<T> {
return list.filter { it is T }
.map { it as T }
}
En effet, le paramètre de type «T» de la fonction «mapFilter» est perdu au moment de l'exécution.
Par conséquent, ajoutez le modificateur reified à la fonction en ligne.
//↓ Ici!
inline fun <reified T> mapFilter(list: List<Any>): List<T> {
return list.filter { it is T }
.map { it as T }
}
En faisant cela, il sera développé tout en conservant les informations de type au moment de l'exécution.
La fonction mapFilter peut maintenant être compilée.
Recommended Posts