scala高级函数
-
- 一.函数至简原则
- 二.匿名的简化原则
- 三.高阶函数
- 四.柯里化和闭包
- 五.递归
- 六.抽象控制
- 七.惰性加载
????函数对于scala(函数式编程语言)来说非常重要,大家一定要学明白,加油!!!!????
一.函数至简原则
1.return可以省略,Scala会把函数体最后一行代码作为返回值
def f0(name:String):String ={ name } println(f0("scala"
2.如果函数体内只有一行代码,可以省略花括号
def f2(name:String):String=name
3.如果返回值类型如果能推断出来,:和返回值类型可以一起省略
def f3(name:String)=name
这不就相当于数学上的函数嘛! f(x)=x。 这也是至简原则的目的,让函数最终尽可能符合我们数学上的使用习惯。
4.如果return没有省略,则返回值类型不能省略
def f4(name:String)={ return name } //会报错
5.如果函数声明Unit(空类型),那么即使函数体中使用return也不起作用
def f5(name:String):Unit={ return name }
6.scala如果期望是无返回值类型,可以省略等号,这种函数也叫做过程,不存在映射关系
def f6(name:String){ println(name) }
7.如果函数无参数,但是声明了参数列表,那么调用时,小括号,可加可不加
def f7():Unit={ println(name) } f7() f7
8.如果函数没有参数列表,那么小括号可以省略,调用时小括号必须省略
def f8:Unit={ println(name) } f8
9.如果不关心名称,只关心逻辑处理,那么函数名(def)可以省略,也不需要返回值。也就是匿名函数!lambda表达式
(name:String) =>{println(name)}
lambda表达式没有函数名如何调用呢?
用法1:直接定义个变量,这样就相当于有了名字
val fun =(name:String) =>{println(name)} //lambda表达式的返回值(函数类型)赋给fun 相当于有了名字 fun("scala")
用法2:定义一个函数,以函数作为参数传入
//相当于函数的参数是固定的,这个函数的操作却决于传入的函数 val fun =(name:String) =>{println(name)} def f(func:String =>Unit):Unit={ //String =>Unit 是函数的类型,代表函数的参数是String类型,返回类型是Unit func("scala") } f(fun) f((name:String) =>{println(name)})
匿名函数就是一个表达式,它的返回值也就是这个表达式的值。
二.匿名的简化原则
1.参数类型可以省略,会根据形参进行自动推导
f((name) =>{println(name)}) //看用法2中定义的函数,传入的参数已经定义死了,必须是String =>Unit(String类型)
2.类型省略之后,如果只有一个参数,圆括号可以省略.
f(name=>{println(name)})
3.匿名函数如果只有一行,大括号也可以省略
f(name=>println(name))
4.如果参数只出现一次,则参数省略且后面可以用_代替,注意对应顺序
f(println(_)
5.如果可以推断出,当前传入的println是一个函数体,而不是调用语句,可以直接省略下划线
f(println) //传入的是一个操作
案例:定义一个“二元运算”函数,只对1和2两个数操作,但是具体的运算通过传入的参数决定
def dualFunction(fun:(Int,Int)=>Int):Int={ fun(1,2) //具体的参数已经是定死的 } val add = (a:Int,b:Int)=>a+b val minus = (a:Int,b:Int)=>a-b println(dualFunction(add)) println(dualFunction(minus)) println(dualFunction((a,b)=>a-b)) println(dualFunction(_-_))
三.高阶函数
函数在scala编程里面是一等公民,不想Java只能在类里面定义方法,非常灵活,在一个代码块中就可以定义函数,调用函数。
1.函数可以作为值进行传递,类似给函数起别名
def f(n:Int):Int={ println("f调用") n+1 } val f1 = f _ //f _ 代表f这整个函数体 val f2:Int=>Int =f //这样f1(函数对象)就是函数类型(f2:Int=>Int),编译器知道要传函数,所以可以只写个f
2.函数作为参数进行传递
这里就是匿名函数案例演示的那种,参数是定义死的,具体操作看传入的函数(参数)
但是数据一定要定义死嘛?我们可以函数参数和数据参数一起传入
def dualEval(op:(Int,Int)=>Int,a:Int,b:Int):Int={ op(a,b) } def add(a:Int,b:Int):Int={ a+b } println(dualEval(add,12,35)) //把普通函数作为参数
3.函数作为函数的返回值返回
看到这里我们可以发现,只要是值用到的地方,我们都可以用函数进行代替。
这里就设计到函数嵌套了
def f5():Int => Unit{ //Int => Unit这里说明返回值是函数类型 def f6(a:Int)={ println("f6调用"+6) } f6 //return 可以省略 } println(f5()) //这里得到的是一个引用(函数),也就是得到的f6() println(f5()(25))
**应用案例:**对数组进行处理,将操作抽象出来,处理完毕之后的结果返回一个新的数组。(也就是大数据map操作)
yield:就是在for循环中,每次循环都会产生一个值,然后将每次产生的值保存,最后组成一个集合。
val arr:Array[Int]=Array(12,45,75,98) //每次只对数组中的一个元素进行操作,这个操作是单独抽象的,只需要单独的定义操作 def arrayOperations(array: Array[Int],op:Int=>Int):Array[Int]={ for (elem <- array) yield op(elem) } //定义一个加1操作 def addOne(elem:Int):Int={ elem+1 } //调用函数 var newArray:Array[Int]=arrayOperations(arr,addOne) println(newArray.mkString(",")) //这里传入匿名函数也是可以的 var newArray2 = arrayOperations(arr,_+1 )
这里的应用是以后处理大数据,来了一堆集合,数据就是那些,但是需要进行很多步操作, 我们通过这样可以单独定义他 们的操作。
案例:通过函数嵌套的方式接受三个参数,当这三种类型参数都为假时,返回fales。
def f1(i:Int):String=>(Char=>Boolean)={ def f2(s:String):Char=>Boolean={ def f3(c:Char):Boolean={ if (i==0&&s==""&&c=='0') false else true } f3 } f2 } println(f1(0)("")('0')) //结果为false //可以用匿名函数进行简化书写,但是这种书写也会被函数的柯里化给代替 def func1(i:Int):String=>(Char=>Boolean)={ s=>c=> if (i==0&&s==""&&c=='0') false else true }
四.柯里化和闭包
闭包:如果一个函数,访问到了它的外部(局部)变量的值,那么这个函数和他所处的环境成为闭包
函数柯里化:把一个参数列表的多个参数,变成多个参数列表,每个参数都是一个小括号
函数性编程语言(scala)定是支持闭包的。它可以延长他所使用的参数的做作用域(如上面那个案例,内层函数用到了外层函数的一个局部变量或者是一个参数,为了我们在调用的时候还能分层调用,在调用的时候第二步还能使用外层函数的参数,那么闭包会把外层函数的参数或者局部变量和内层函数打包起来,保存到一个函数对象里面,存放在堆内存里面)。
柯里化:
def addCurrying(a:Int)(b:Int):Int={ a+b } //一旦使用了柯里化,底层一定使用了闭包 println(addCurrying(23)(32)) }
五.递归
递归:一个函数/方法在函数/方法体内又调用了本身
方法调用自身
方法必须要有跳出的逻辑
方法调用自身时,传递的参数应该有规律
Scala中递归必须声明返回值类型
//递归计算阶乘 def fact(n:Int):Int={ if (n==0) return 1 //这个return不能省,因为scala只能自动返回最后一行,这里不是最后一行 fact(n-1)*n } //尾递归:递归最后一行返回的只有对于自身的调用,没有其他额外的计算,这样当前这层函数不用保存任何东西,这样就用压栈了,节省空间。 def tailFact(n:Int):Int={ @tailrec //如果写的不是尾递归,idea会报错 def loop(n:Int,currRes:Int):Int={ if(n==0)return currRes loop(n-1,currRes*n) //每次调用我不需要保存上一层的任何信息,不用压栈,做一个栈帧的覆盖就节省空间了。 } loop(n,1) } //尾递归只有函数式编程语言才支持,比如Java就不支持
六.抽象控制
1.值调用:把计算后的值传递过去
2.名调用:把代码传递过去
//传值参数 def f0(a:Int):Unit={ println("a"+a) } def f1():Int={ println("f1调用") 12 } f0(f1) //传名参数,传递的不再是具体的值,而是代码块 def f2(a:=>Int):Unit={ //注意这里参数的类型 println("a:"+a) println("a:"+a) } f2(f1()) //每一次用到a的时候,都会把f2中完整的代码块执行一遍。
传名调用的案例:自己实现一个while循环函数
//1.用闭包实现一个函数,将代码块作为参数传入,递归调用 def myWhile(condition:=>Boolean):(=>Unit)=>Unit={ //内层函数需要递归调用,参数就是循环体(代码块) def doLoop(op:=>Unit):Unit={ if(condition){ op myWhile(condition)(op) //尾递归 } } doLoop _ } n=10 myWhile(n>=1){ println(n) n-=1 }//参数是一个代码块时,小括号可以省略 //2.用匿名函数实现 def myWhile2(condition:=>Boolean):(=>Unit)=>Unit={ //内层函数需要递归调用,参数就是循环体(代码块) op=>{ if(condition){ op myWhile2(condition)(op) //尾递归 } } } //3.用函数柯里化实现 def myWhile(condition:=>Boolean)(op:=>Unit):Unit={ if(condition){ op myWhile3(condition)(op) } }
七.惰性加载
说明:函数的返回值被声明lazy时,函数的执行将被推迟,直到我们首次对此取值,该函数才会被执行,这种函数我们称之为惰性函数。
(不用到,不执行加载)
lazy val result:Int = sum(13,47) println("1.函数调用") println("2.result="+result) def sum(a:Int,b:Int):Int={ printlb("3.sum调用") } //最后输出顺序时1 3 2