Kotlin 's Function

7471 단어
Kotlin 's Function

1.Basic Functions


Functions are declared using the fun keyword, followed by a function name and any parameters. You can also specify the return type of a function, which defaults to Unit. The body of the function is enclosed in braces {}. If the return type is other than Unit, the body must issue a return statement for every terminating branch within the body.
fun sayMyName(name: String): String {
    return "Your name is $name" 
} 

A shorthand version of the same:
fun sayMyName(name: String): String = "Your name is $name" 

And the type can be omitted since it can be inferred:
fun sayMyName(name: String) = "Your name is $name" 

2.Function References


We can reference a function without actually calling it by prefixing the function's name with::. This can then be passed to a function which accepts some other function as a parameter.
fun addTwo(x: Int) = x + 2
listOf(1, 2, 3, 4).map(::addTwo) 
# => [3, 4, 5, 6]

Functions without a receiver will be converted to (ParamTypeA, ParamTypeB, ...) -> ReturnType where ParamTypeA, ParamTypeB ... are the type of the function parameters and `ReturnType1 is the type of function return value.
fun foo(p0: Foo0, p1: Foo1, p2: Foo2): Bar {
    //...
}
println(::foo::class.java.genericInterfaces[0]) 
// kotlin.jvm.functions.Function3
// Human readable type: (Foo0, Foo1, Foo2) -> Bar

3. Functions with a receiver


(be it an extension function or a member function) has a different syntax. You have to add the type name of the receiver before the double colon:
class Foo
fun Foo.foo(p0: Foo0, p1: Foo1, p2: Foo2): Bar {
    //...
}
val ref = Foo::foo
println(ref::class.java.genericInterfaces[0]) 
// kotlin.jvm.functions.Function4
// Human readable type: (Foo, Foo0, Foo1, Foo2) -> Bar
// takes 4 parameters, with receiver as first and actual parameters following, in their order

// this function can't be called like an extension function, though
val ref = Foo::foo
Foo().ref(Foo0(), Foo1(), Foo2()) // compile error

class Bar {
    fun bar()
}
print(Bar::bar) // works on member functions, too.

However, when a function's receiver is an object, the receiver is omitted from parameter list, because these is and only is one instance of such type.
object Foo
fun Foo.foo(p0: Foo0, p1: Foo1, p2: Foo2): Bar {
    //...
}
val ref = Foo::foo
println(ref::class.java.genericInterfaces[0]) 
// kotlin.jvm.functions.Function3
// Human readable type: (Foo0, Foo1, Foo2) -> Bar
// takes 3 parameters, receiver not needed

object Bar {
    fun bar()
}
print(Bar::bar) // works on member functions, too.

Since kotlin 1.1, function reference can also be bounded to a variable, which is then called a bounded function reference.
fun makeList(last: String?): List {
    val list = mutableListOf("a", "b", "c")
    last?.let(list::add)
    return list
}

Note: this example is given only to show how bounded function reference works. It's bad practice in all other senses.
There is a special case, though. An extension function declared as a member can't be referenced.
class Foo
class Bar {
    fun Foo.foo() {}
    val ref = Foo::foo // compile error
}

4.Inline Functions


Functions can be declared inline using the inline prefix, and in this case they act like macros in C - rather than being called, they are replaced by the function's body code at compile time. This can lead to performance benefits in some circumstances, mainly where lambdas are used as function parameters.
inline fun sayMyName(name: String) = "Your name is $name"One difference from C macros is that inline functions can't access the scope from which they're called:
inline fun sayMyName() = "Your name is $name"

fun main() {
    val name = "Foo"
    sayMyName() # => Unresolved reference: name
}

5.Lambda Functions


Lambda functions are anonymous functions which are usually created during a function call to act as a function parameter. They are declared by surrounding expressions with {braces} - if arguments are needed, these are put before an arrow ->.
{ name: String ->
    "Your name is $name" //This is returned
}

The last statement inside a lambda function is automatically the return value.
The type's are optional, if you put the lambda on a place where the compiler can infer the types.
Multiple arguments:
{ argumentOne:String, argumentTwo:String ->
    "$argumentOne - $argumentTwo"
}


If the lambda function only needs one argument, then the argument list can be omitted and the single argument be referred to using it instead.
{ "Your name is $it"}
If the only argument to a function is a lambda function, then parentheses can be completely omitted from the function call.
# These are identical
listOf(1, 2, 3, 4).map { it + 2 }
listOf(1, 2, 3, 4).map({ it + 2 })

6.Functions Taking Other Functions


As seen in "Lambda Functions", functions can take other functions as a parameter. The "function type"which you'll need to declare functions which take other functions is as follows:
Takes no parameters and returns anything
() -> Any?

Takes a string and an integer and returns ReturnType
(arg1: String, arg2: Int) -> ReturnType

For example, you could use the vaguest type, () -> Any?, to declare a function which executes a lambda function twice:
fun twice(x: () -> Any?) {
    x(); x();
}

fun main() {
    twice {
        println("Foo")
    } # => Foo
      # => Foo
}

7.Operator functions


Kotlin allows us to provide implementations for a predefined set of operators with fixed symbolic representation (like + or *) and fixed precedence. To implement an operator, we provide a member function or an extension function with a fixed name, for the corresponding type. Functions that overload operators need to be marked with the operator modifier:
data class IntListWrapper (val wrapped: List) {
    operator fun get(position: Int): Int = wrapped[position]
}

val a = IntListWrapper(listOf(1, 2, 3))
a[1] // == 2

More operator functions can be found in here

8.Shorthand Functions


If a function contains just one expression, we can omit the brace brackets and use an equals instead, like a variable assignment. The result of the expression is returned automatically.
fun sayMyName(name: String): String = "Your name is $name"

KotlinChina 프로그래밍 커뮤니티

《Kotlin 미니멀리즘 강좌》가 정식으로 출시되었다.


여기를 클릭 > 경동상점 구매


여기를 클릭>티몰 상점에 가서 읽기 구매


친애하는 독자분들께 대단히 감사드립니다. 여러분 많이 지지해 주세요!!!질문이 있으시면 언제든지 연락 주세요~

좋은 웹페이지 즐겨찾기