Funció

Una funció és com un petit programa que té un nom propi, i es pot executar (invocar) cridant aquest nom des d’una altra funció

Introducció

Una funció combina un grup d’activitats, i és la manera més bàsica d’organitzar els teus programes i de reutilitzar codi.

Pots passar informació a una funció, i la funció utilitza aquesta informació per calcular i produir un resultat.

Crea un projecte amb el nom function amb Amper i Idea.

Utilitza la plantilla “JVM Console Application”.

Funció

Modifica el fitxer src/main.kt declarant la funció add().

Les funcions en Kotlin es declaren amb la paraula clau : fun

fun add(a: Int, b: Int): Int {
    return a + b
}

fun main() {
}

La funció sum() està composta de:

  • a i b són els paràmetres: la informació que passes a la funció.

  • Cada paràmetre té un identificador (a, b) seguit de dos punts i el tipus d’aquest paràmetre.

  • El parèntesi de tancament de la llista de paràmetres va seguit de dos punts i el tipus de resultat que produeix la funció.

  • Les línies de codi del cos de la funció estan tancades entre claus.

  • L’expressió que segueix la paraula clau return és el resultat que la funció produeix quan finalitza.

A continuació modifica el fitxer src/main.kt per cridar la funció add():

fun main() {
    val sum = add(1, 2)
    println(sum)
}

El codi d’una funció s’executa cridant la funció, utilitzant el nom add() com una abreviatura d’aquest codi. Per això les funcions són la forma més bàsica de simplificació i reutilització de codi en la programació.

També pots pensar en una funció com en una expressió amb valors substituïbles (els paràmetres).

println() també és una crida de funció — simplement és proporcionada per Kotlin. Ens referim a les funcions definides per Kotlin com a funcions de biblioteca.

Return Unit

Si la funció no proporciona un resultat significatiu, el seu tipus de retorn és Unit.

Pots especificar Unit explícitament si vols, però Kotlin et permet ometre’l:

fun hello() {
    println("Hello, world!")
}

fun main() {
    hello()
}

La funció main() també retorna Unit.

Expressió única

Si el cos de la funció conté només una expressió, pots ometre les claus i la paraula clau return:

fun add(a: Int, b: Int) = a + b

fun main() {
    require(add(1, 2) == 3)
}

Això és una versió curta d’escriure return a + b dins d’un cos amb blocs.

Kotlin infereix el tipus de retorn d’una funció que té un cos d’expressió:

  • Un cos de funció envoltat per claus s’anomena cos de bloc.
  • Un cos de funció que utilitza la sintaxi amb signe igual s’anomena cos d’expressió.

Kotlin infereix que add() retorna un Int.

Kotlin només pot inferir tipus de retorn per a cossos d’expressió. S una funció té un cos de bloc i n’ometes el tipus, aquella funció retorna Unit.

TODO. exemple

Arguments amb nom i per defecte

Pots proporcionar noms d’argument durant una crida de funció.

Els arguments amb nom milloren la llegibilitat del codi. Això és especialment cert per a llistes d’arguments llargues i complexes: els arguments amb nom poden ser prou clars perquè el lector entengui una crida de funció sense haver de mirar la documentació.

En aquest exemple, tots els paràmetres de areaCylinder() són Double:

fun main() {
    areaCylinder(radius = 5.0, height = 10.0)
}

fun areaCylinder(radius: Double, height: Double) =
    2 * 3.14 * radius * (height + radius)

Els arguments amb nom:

  • Clarifiquen el significat.
  • Permeten canviar l’ordre dels paràmetres.

Aquí especifiquem height primer:

fun main() {
    areaCylinder(height = 10.0, radius = 5.0)
}

Barrejar arguments amb nom i posicionals (per defecte)

A continuació declarem la funció color que codifica un color en un enter:

fun color(red: Int, green: Int, blue: Int) = (red shl 16) or (green shl 8) or blue

fun main() {
    require(color(255, 64, 0) == 0xFF4000)
}

Pots barrejar arguments amb nom i arguments posicionals (per defecte):

fun main() {
    require(color(255, 64, 0) == color(255, blue = 0, green = 64)
    )
}

Si canvies l’ordre dels arguments, hauries d’utilitzar arguments amb nom a tota la crida — no només per llegibilitat, sinó perquè sovint el compilador necessita que li indiquis on va cada argument.

Arguments per defecte

Els arguments amb nom són encara més útils quan es combinen amb arguments per defecte, que són valors per defecte per als arguments, especificats a la definició de la funció:

fun main() {
    require(color(64) == 0x400000)
    require(color(blue = 255) == 0xFF)
    require(color(255, 128) == 0xFF8000)
    require(color(red = 128, blue = 128) == 0x800080)
}

Qualsevol argument que no proporcionis obté el seu valor per defecte, de manera que només cal que passis els arguments que difereixen dels valors per defecte. Si tens una llista d’arguments llarga, això simplifica el codi resultant, fent-lo més fàcil d’escriure i — més important encara — de llegir.

Sobrecàrrega

El terme “sobrecàrrega” fa referència al nom d’una funció: pots utilitzar el mateix nom (“sobrecarregar” aquest nom) per a funcions diferents sempre que les llistes de paràmetres siguin diferents (en nombre o en tipus).

En aquest exemple sobrecarreguem la funció area():

fun area(width: Int, height: Int) = width * height
fun area(radius: Int) = 3.14 * radius * radius

fun main() {

    require(area(10, 20) == 200)
    require(area(10) == 314.0)
}

La signatura d’una funció consta del nom, la llista de paràmetres i el tipus de retorn. Kotlin distingeix una funció d’una altra comparant-ne les signatures. En sobrecarregar funcions, les llistes de paràmetres han de ser úniques — no es pot sobrecarregar només pel tipus de retorn.

Les crides mostren que, en efecte, són funcions diferents.

TODO