Kotlin 学习记录（Lambda & 空类型）

  val fun1 = {9} //定义了一个返回了Int的函数
  
  //该定义参照了情况3
  //传入一个Lambda来表示的形式参数，该形参为一个无参返回Int的函数
  var fun11 : (()->(Int)) ->Int = {initfunc -> initfunc()} 
  
  var value00 = fun11(fun1)
  println("value00 => $value00")

  var value1 = 9
  val fun2:(Int,Int)->Double = {a,b-> (a-b).toDouble()}
  var value2 = fun2(value1,3)
  println("value2 => $value2")//输出：value2 => 6.0
  
  //等价形式如下
  var fun3 = {a:Int,b:Int -> a+b}
  var value3 = fun3(3,6)
  
  println("value3 => $value3")//输出：value3 => 9
  //3. lambda表达式作为函数中的参数的时候，这里举一个例子：
  //  fun test(a : Int, 参数名 : (参数1 ： 类型，参数2 : 类型, ... ) -> 表达式返	 //回类型){
  //     ...
  //  }
  //
  
  //下面两个新形式都可以作为value计算的表达式，fun与var功能似乎一样了？NO
  //三种形式定义该test函数，fun声明，var声明，匿名函数。
  //fun test(a:Int,b:Int,add:(Int,Int)->Int):Int{ return add(a,b)}//是一个函数
  //var test: (Int,Int,(Int,Int)->Int) -> Int = {a,b,add -> add(a,b)}//该变量是lambda变量
  
  var test = fun(a:Int,b:Int,add:(Int,Int)->Int):Int{ return add(a,b)} //是一个函数
  
  println("value4 = $value4")

   fun test(num1 : Int, bool : (Int) -> Boolean) : Int{
     return if (bool(num1)){ num1 } else 0
  }
  
  println(test(10,{it > 5})) // {} 代表这是一个Lambda表达式，无{}会使得编译器不认识it
  println(test(4,{it > 5}))

  val map = mapOf<String,String>("key1" to "value1","key2" to  "value2","key3" to  "value3")
  
  map.forEach{
      key,value -> println("$key '-' $value")
  }
  map.forEach{
          _,value -> println(" '-' $value")
  }

  val test1 = fun (x:Int,y:Int) = x+y; //单表达式函数可以 = 替换 {}
  val test2 = fun (x:Int,y:Int) : Int= x+y;
  val test3 = fun (x:Int,y:Int) : Int{
      return x+y
  }
  println(test1(1,3))
  println(test2(2,3))
  println(test3(3,3))
  
  /**
  //这是错的，fun的需要返回值为Unit，但你给了个Int
      val test4= fun(x:Int,y:Int) {
          return x+y
      } 
  */

val iop = fun  Int.(other:Int):Int = this + other
println(20.iop(2)) //上面的this指的是左边的20 或者是 上面fun后的第一个Int

class HTML{
	fun body(){
		println("This is HTML body")
	}
}

fun  html(init: HTML.() -> Unit): HTML{
	val html = HTML()
	html.init()
	return html
}

html {
	body()
}

让函数返回一个函数，并携带状态值

fun test5(a:Int):()->Int{
    println("")
    var b = 3
    return fun():Int{
        println("b=> $b")
        b++
        return b + a
    }
}

var t = test5(3)
println(t()) // 每次执行t函数的时候，b变量的值都是保留了上次执行结束的值，
			 // 因此，叫做携带状态值
println(t())
println(t())

var sum = 0
val arr = arrayOf(1,2,3,4,5,6,7,8,9,10,11)
arr.filter { it<7 }.forEach{sum += it}
//arr.filter { it<7 }.forEach ({sum += it})

println(sum)