1.1.50.22. fejezet, Függvények

Beküldte pzoli - 2024, április 25 - 8:20du

Belső függvények

// No return value
fun foo() {
  return
}
 
// With return value
fun foo(): Int {
  return 10
}
 
 
// No return value
fun bar():Unit {
  return
}

Belső függvények

fun foo(count:Int): Int {
    fun bar(i:Int): Int {
        return i + 10
    }
    return bar(count)
}
 
println(foo(10)) // 20

Alapértelmezett paraméter értékek

fun read(
    b: ByteArray,
    off: Int = 0,
    len: Int = b.size,
) { /*...*/ }

Egyszerű kifejezés

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

Nevesített paraméterek

fun sum(a: Int = 11, b: Int = 22) = a + b
println(sum(a=23)) // 45

Változó számú argumentum átadása

fun foo(vararg strings: String) { /*...*/ }
foo(strings = *arrayOf("a", "b", "c"))
 
val a = arrayOf(1, 2, 3)
val list = asList(-1, 0, *a, 4)

Használjuk a * (spread) operátor a változó számú paraméterek átadásához.

Infix funkciók

class MyStringCollection {
    infix fun add(s: String) { /*...*/ }
 
    fun build() {
        this add "abc"   // Correct
        add("abc")       // Correct
        //add "abc"        // Incorrect: the receiver must be specified
    }
}

Alapértelmezett paraméter értékek felülírása osztály függvényben

open class A {
    open fun foo(i: Int = 10) { /*...*/ }
}
 
class B : A() {
    override fun foo(i: Int) { /*...*/ }  // No default value is allowed.
}

Operátor függvények

class Beef: Meat {
    operator fun plus(beef:Beef): Beef {
        return Beef(this.barCode, this.price + beef.price)
    }
}
 
operator fun String.times(count: Int) :String {
    var result = ""
    for(i:Int in 1..count) {
        result += this
    }
    return result
}
 
println("test" * 3) // testtesttest

Tobbi operátorhoz leírás itt

Anonim függvény mint érték

val sum = fun (a:Int,b:Int):Int { return a+b }
val calSum = sum(1,2) // 3
 
fun main() {
    val sum = fun (a:Int,b:Int):Int {
        return a + b
    }
    val minus = fun (a:Int,b:Int):Int {
        return a - b
    }
 
    val times = fun(a:Int,b:Int) = a * b
 
    fun test(a:Int,b:Int, ops : List<(Int, Int) -> Int>) {
        ops.forEach() {
            println(it(a,b))
        }
    }
 
    val operations = listOf(sum,minus,times)
    test(1,2, operations) // 3, -1, 2
 
    fun repeatTask(times: Int, task:()->Unit ) {
            for(i in 1..times) {
                task()
            }
    }
    repeatTask(3){ -> println("Task")} // Task Task Task
 
    val sqr2: (Int) -> Int = {it * it}
    println(sqr2(30)) // 900
}

Lambda függvények

    val square: (Int) -> Int = {a: Int -> return a*a}
 
    val nums = listOf(1,2,3,4,5)
    val evens = nums.filter(){it % 2 == 0}
    println(evens)

Függvény visszatérési értékként

    fun createLogger(category: String) = fun (message: String) {
        println("$category - ${Date().toString()} - $message")
    }
 
    val logger = createLogger("system")
    logger("Hello World!")