Wikisage is op 1 na de grootste internet-encyclopedie in het Nederlands. Iedereen kan de hier verzamelde kennis gratis gebruiken, zonder storende advertenties. De Koninklijke Bibliotheek van Nederland heeft Wikisage in 2018 aangemerkt als digitaal erfgoed.
- Wilt u meehelpen om Wikisage te laten groeien? Maak dan een account aan. U bent van harte welkom. Zie: Portaal:Gebruikers.
- Bent u blij met Wikisage, of wilt u juist meer? Dan stellen we een bescheiden donatie om de kosten te bestrijden zeer op prijs. Zie: Portaal:Donaties.
Kotlin (programmeertaal)
| Kotlin | |||
| Bestand:Kotlin-logo.png | |||
| Paradigma | Multi-paradigma: functioneel, objectgeorienteerd, [[Imperatief programmeren | imperatief]] | |
| Verschenen in | 2011 | ||
| Ontworpen door | Andrey Breslav | ||
| Ontwikkeld door | JetBrains en open source contributors | ||
| Huidige versie | Kotlin 1.1.2 | ||
| Typesysteem | statisch, sterk met type-ingferentie | ||
| Bestandsextensies | .kt, .kts | ||
Kotlin is een statisch getypeerde multiplatform-programmeertaal, die probeert volledig interoperabel te zijn met de taal van het platform.[1]
Kotlin is ontwikkeld door JetBrains, dat gevestigd is in Sint-Petersburg en vernoemd naar het nabijgelegen eiland Kotlin.[2]
Filosofie
Andrey Breslav (hoofdingenieur van JetBrains) verklaarde dat Kotlin is ontwikkeld om een in industriële object georiënteerd taal te zijn, die "beter" is dan Java, maar toch volledig interoperabel met java, zodat bedrijven een geleidelijke overstap kunnen maken naar Kotlin[1].
Nu wil Kotlin op meerdere platformen zijn, zodat uiteindelijk een heel systeem - van de server back-end tot de mobiele front-end - in Kotlin geschreven kan zijn. Daarnaast wil Kotlin codehergebruik door verschillende platformen mogelijk maken[3].
Platforms
Kotlin is bezig om te compileren naar meer platforms. Hierbij is het uiteindelijke doel dat alle componenten van een ICT-systeem in Kotlin gebouwd kunnen worden. In tegenstelling tot de JVM wil Kotlin compileren naar verschillende talen.
Kotlin wil de API opsplitsen in twee onderdelen. De common modules en de platform specifieke modules. De API van de common modules zou door de compilers van elk platform worden geïmplementeerd. Als iets is gebouwd waarbij alleen gebruik is gemaakt van de common modules, kan dit naar elk platform worden gecompileerd en daar worden gebruikt.
De platform-specifieke functies worden verzameld in de platform-specifieke modules.
Java virtual machine
Kotlin (althans, de geproduceerde bytecode) draait op de Java Virtual Machine. Hierbij kan worden gekozen tussen twee versies van Java: Java 6 en Java 8.
Voor de implementatie van de common modules wordt gebruik gemaakt van de Java Class Library en de Java Collections Framework.
Om te compileren is sinds versie 1.1.2 is wel JDK8 nodig.
Android
Op 17 mei 2017 heeft Android Kotlin als officiële programmeertaal toegevoegd[4].
De bekendste kotlin-framework voor Android is Anko, die ontwikkeld is door Jetbrains.
Javascript
Kotlin/JavaScript wordt getranspileerd naar JavaScript.
Op dit moment is de target ECMAScript 5.1, maar er zijn plannen om ECMAScript 2015 te ondersteunen.
Daarnaast kan TypeScript definities naar Kotlin declaraties worden geconverteerd met ts2kt.
Native
Met de LLVM compiler wordt code direct naar machinecode vertaald. Het Native project is nog in een previewstadium.
De platformen die worden ondersteund omvatten:
- Mac OS X 10.10 and later (x86-64)
- x86-64 Ubuntu Linux (14.04, 16.04 and later), other Linux flavours may work as well
- Apple iOS (arm64), cross-compiled on MacOS X host
- Raspberry Pi, cross-compiled on Linux host
Kotlin/Native kan interfacen met in C geschreven functies.
Syntaxis
In Kotlin komt het datatype na de naam van de variabelen en parameters. Daarnaast is de puntkomma om een statement af te sluiten niet verplicht; meestal is een nieuwe regel voor de compiler al genoeg[5].
Semantiek
Kotlin ondersteund het Object Georiënteerd programmeren door middel van klassen en methodes, maar de methodes kunnen ook worden gebruikt buiten de klassen, waardoor imperatief programmeren met functies ook mogelijk is[6]. Een programma begint net als Java met de functie main met als parameter een array met command-line-argumenten. Type-inferentie is ook mogelijk.
Hello world! voorbeeld:<syntaxhighlight lang="kotlin"> fun main(args: Array<String>) {
val scope = "world"
println("hello, $scope")
} </syntaxhighlight>
Nullable types
Kotlin maakt verschil nullable types en niet-nullable types. alle Nullable types moeten eindigen met een "?":<syntaxhighlight lang="kotlin"> val nullString: String? = null //werkt, want is nullable val notNullString: String = null //werkt niet want is niet nullable </syntaxhighlight>Voor elke aanroep op een nullable type moet worden gekeken of de type null is.
In Kotlin zijn hier twee operatoren voor:
- ?. (veilige-navigatie-operator): Hij geeft null terug als de operand null is en hij voert anders de code achter de operator uit.
- ?: (Elvis-operator) : geeft de waarde voor de operator als die niet null is, anders geeft hij de waarde achter de operator.
Voorbeeld van de veilige-navigatie-operator:<syntaxhighlight lang="kotlin"> // geeft null als foo of bar null zijn en geeft anders de teruggeefwaarde van baz foo ?. bar() ?. baz() </syntaxhighlight>Voorbeeld van de Elvis-operator<syntaxhighlight lang="kotlin"> fun welkom(naam: String?){
val welkomNaam = naam ?: "vreemdeling"
}
fun main(args : Array<String>){
println(welkom(null)) // print "welkom vreemdeling"
println(welkom("gebruiker")) // print "welkom gebruiker"
}
</syntaxhighlight>Om dependency injection mogelijk te maken zonder een nullable type te gebruiken, kan er gebruikt worden gemaakt van lateinit.
Coroutines
Coroutines is Kotlins manier voor multithreading. Het opvallende is dat Kotlin hier maar een keywoord voor gebruikt: Suspend.
Daarnaast wordt er veel gedaan met compiler-magic, waardoor de coroutines veel lichter zijn dan threads.
Op dit moment zijn de coroutines nog in de experimentele fase.
DSL builders
Een van de opvallende regels van Kotlin zijn DSL-builders. Hiermee kan een DSL worden gemaakt.
DSL (Domain specific language) is een taal die ontwikkeld is voor bepaalde domeinen.
Deze DSL-functies bestaan uit extensie-functies en regels voor lambda's die gecombineerd de extensie-lambda vormen.
Extensie-functies
Kotlin kent het concept extensie-functies. Dit zijn functies die een al bestaande klasse kunnen uitbreiden.
Voorbeeld van extensie-functies:<syntaxhighlight lang="kotlin"> class RekenMachine{
fun keer(a: Int, b: Int) : Int{
return a * b
}
}
//voegt keer5 aan RekenMachine toe fun RekenMachine.keer5(a: Int, b: Int){
this.keer(5, a) // we zitten in de RekenMachine, dus this is de RekenMachine // maar this mag worden weggelaten dus: keer(5, a)
}
fun main(args : Array<String>){
// hier wordt een nieuw RekenMachine aangemaakt // (de "new" van Java moet in Kotlin worden weggelaten) // en keer op aangeroepen RekenMachine().keer5(3) // antwoord: 15
} </syntaxhighlight>
Lambda's
Lambda is de naam voor een functie-datatype.In Kotlin, wordt een lambda geschreven als (parameter, parameter) -> returnType. Wanneer lambda's als laatste parameter worden meegegeven aan een functie, mag hij achter de functie worden neergezet. Bovendien mogen als er achter een functie-aanroep wordt gedaan, zonder parameters, mogen de haakjes weggehaald worden.
Voorbeeld met meerdere parameters:<syntaxhighlight lang="kotlin"> // deze functies wil drie parameters // - een integer // - een lambda die een integer vraagt en een integer teruggeeft fun keer(a: Int, keer: (Int)->Int) : a {
return keer(a) // voert de lambda uit op de twee gekregen integers
}
fun main(args: array<String>){
// lambda opgeslagen in veriabele
val keer5 = {a -> a * 5}
keer(3, keer5) // is 15
//lambda direct als parameter
keer(3, {a -> a * 5})
//lambda achter de functie
keer(3) {
a -> a * 5
}
} </syntaxhighlight>Voorbeeld met een parameter:<syntaxhighlight lang="kotlin"> // Unit (void in Java) // vraagt een lambda zonder parameters die Unit (niks) teruggeeft class Rekenmachine{
var a = 3
fun keer(exec: ()-> int): Int{
return exec()
}
}
fun main(args: Array<String>){
//lambda opgeslage in variabele
val keer5 = {
Rekenmachine.a * 5
}
keer(keer5)
//lambda meegegeven als parameter
keer({
Rekenmachine.a * 5
})
//lambda achter de functie
keer(){
Rekenmachine.a * 5
}
// er zijn geen parameters tussen de haakjes,dus de haakjes mogen weg
keer{
Rekenmachine.a * 5
}
} </syntaxhighlight>
Extensie-lambda's
In Kotlin heb je niet alleen extensie-functies maar ook extensie-lambda's. Deze worden meegegeven als een parameter:<syntaxhighlight lang="kotlin"> class Rekenmachine{
var a: Int = 3
fun keer(exec: ()-> int) : Int {
return exec();
}
}
// Rekenmachine.() vraagt om een extension-lambda, die een int returnt fun bereken(berekening: Rekenmachine.()->Int) : Int{
val rm: Rekenmachine = Rekenmachine() //maak Rekenmachine aan. return lambda(rm) // geef rm aan de lambda
}
fun main(args: Array<String>) {
//zonder extension-lambda zie vorig voorbeeld
Rekenmachine().keer{
Rekenmachine.a * 5
}
bereken(//hieronder begint de extension-lambda:
{//this wijst naar rekenmachine, want we zitten in rekenmachie
this.keer{
this.a * 5
}
}
)
bereken(//hieronder begint de extension-lambda:
{//this mag worden weggelaten
keer{a * 5}
}
)
// de extension-lambda was de laatste parameter,dus hetvolgende maag ook:
bereken{
keer{a * 5}
}
// keer geeft 3 * 5 = 15 terug en bereken geeft die door.
val ans = bereken{
keer{a*5}
}
} </syntaxhighlight>
Bronnen, noten en/of referenties
|