Higher-Order Functions and Lambd

Higher-Order Functions and Lambdas(高阶函数和Lambdas)

目录：
1、Higher-Order Functions（高阶函数）
2、Function types（函数类型）
3、Lambda Expressions and Anonymous Functions（lambda表达式和匿名函数）

1、Higher-Order Functions（高阶函数）
高阶函数是：“将函数作为参数或返回函数”的函数

将函数作为参数的函数

fun fooFunction(bar: Int = 1, baz: Int = 1, lamb: () -> Int): Int {
    println("foo: lambda result=${lamb()}")
    return lamb()
}

返回函数的函数

fun fooFunction(a: Int): () -> Int {

    a + 1

    return fun(): Int = a
}

2、Function types（函数类型）
如同Int，String，Boolean类型一样，当函数作为参数时，也需要定义类型

kotlin使用一系列函数类型，例如(Int) -> String处理函数的声明：

    //此时，(String) -> Unit 定义的onClick是一个函数，等同于：fun onClick(x:String):Unit{}
    val onClick: (String) -> Unit = {
        
    }
    onClick("string")

编译器可推断变量的函数类型，如下：

    val simplyFunctiontype = { x: Int, y: Int ->
        x + y
    }

等同于：

    val simplyFunctiontype: (Int, Int) -> Int = { x, y ->
        x + y
    }

3、Lambda Expressions and Anonymous Functions（lambda表达式和匿名函数）

1、Lambda表达式和匿名函数是“函数文字”，即未声明但立即作为表达式传递的函数，

fun compare(a: String, b: String): Boolean = a.length < b.length;

2、Lambda expression syntax(Lambda表达式语法)

/*
Lambda表达式的全部语法
 */
val sum = { x: Int, y: Int -> x + y }

lambda表达式总是被花括号括起来，完整语法形式的参数声明进入花括号内部并具有可选的类型注释，主体在->符号后面，如果lambda的推断返回类型不是Unit，则lambda主体内的最后一个（或可能是单个）表达式将被视为返回值

如果我们将所有可选的注释都留下，那么剩下的就是下面这样：

    //Full version：Lambda expression syntax
    val lambdaSumWithExplicitly: (Int, Int) -> Int = { oneParam, twoParam ->
        //lambda将最后一行表达式作为返回的值
        oneParam * twoParam
    }

3、Passing a lambda to the last parameter（将lambda表达式作为函数的最后一个参数）

将Lambda表达式作为函数参数

fun fooFunction(bar: Int = 1, baz: Int = 1, lamb: () -> Int): Int {
    println("foo: lambda result=${lamb()}")
    return lamb()
}

调用带有lambda表达式参数的函数

      //括号之外传递
    val lambdaParamOutResult = fooFunction {
        ""
        1
    }
    //括号之内传递
    val lambdaParamInResult = fooFunction(lamb = {
        ""
        1
    })
    //括号之内传递，并且全参数赋值
    val lambdaParamFullResult = fooFunction(1, 2, lamb = {
        ""
        1
    })

4、it:implicit name of a single parameter（it：一个参数的隐式名称）

    //it:implicit name of a single parameter
    val lambdaImplicitIt: (Int) -> Int = {
        it * it
    }

    println("lambdaImplicitIt:${lambdaImplicitIt(5)}")//result=5*5

5、Returning a value from a lambda expression（lambda表达式返回值）

隐式返回最后一个表达式的值

    //it:implicit name of a single parameter
    val lambdaImplicitIt: (Int) -> Int = {
        val result = it * it
        result//implicit return result
    }

6、Underscope for unused variables（使用'_'作为未使用参数）

如果lambda参数未使用，则可以放置下划线代替其名称

    //使用:"_"代替未使用的参数的名称
    val lambdaProduct: (Int, Int) -> Int = { _, y ->
        y * y
    }

7、Anonymous functions（匿名函数）
匿名函数与常规函数的区别：匿名函数省略了常规函数的函数名

    val anonymousFunction = fun(x: Int): Int {
        return x * x
    }
    println("Anonymous function:${anonymousFunction(5)}")

    val anonymousFunction = fun(x: Int) = x * x
    println("Anonymous function:${anonymousFunction(5)}")

8、Expansion Anonymous Function（‘拓展+匿名’的函数）

fun expansionAnonymous() {
    println();
    /*
    常规匿名函数的定义
     */
    val commonFunction = fun(num: Int): Int {
        return num * num
    }

    /*
    拓展匿名函数的定义
     */
    val expansionAnonymousFunction = fun Int.(param: Int): Int {
        return param * param
    }

    val a = 1;
    println("expansionAnonymousFunction:${a.expansionAnonymousFunction(5)}")
}

---

想要查看更多、更详细有料干货点击我https://pdliuw.github.io/

未完待续。。。