scala函数，柯里化函数

Posted 2022-01-30 Leo Han

scala中函数没有重载的概念，函数名称唯一，不区分参数，
scala是完全面向对象，也是完全面向函数

根据函数的最后一行推断返回类型：

def test():String=
print(1111)
"Hello world"

这时候可以省略返回类型
如果函数体只有一行代码，大括号可以省略

def test():String = "Hello word "

如果函数的声明没有参数列表，小括号可以省略：

def test = "Hello World"

但是这样访问的时候不能增加小括号，只能用 test访问 （统一访问方式）
如果加上()调用的时候可以用 test() 或者 test
方法不加 = 的时候，表示函数没有返回值（与unit不同）

def test ()
"Hello world"

或者

def test 
"Hello world"

调用的时候必须用 test
编译器不会把最后一行返回，明确没有返回值

可变参数：

def test(name :String*):Unit=

可传人一个

默认参数：

def test(name:String ,age:Int=20):Unit=

scla中函数可以赋值给变量，可以作为函数的参数，可以作为函数的返回值

def f():Unit=
println("Hello world")


def f0=
// f 这样写的话会有问题， 无参的函数这种是默认调用，写成如下格式
f _ //增加特殊符号 _ 下划线

可以写成如下格式： 柯里化函数可以这么写：

def f1(i:Int)								def f(i:Int)(j:Int):Int=
def f0(j:Int):Unit=							i*j
i*j								   
									 	print(f(2)(3))
f _

println(fo(2)(3))

函数闭包

一个函数在实现逻辑时，将外部变量引入到函数内容，改变了这个变量的生命周期，
将函数作为参数传递给另外一个函数，采用特殊的声明， ()=>Unit 参数列表=>返回值类型

val f:(Int)=>Int = f1(10)
def f4(f:()=>Int):Int=
f()+10

def f5():Int=
5

匿名函数：

def f6(f:(Int)=>Unit):Unit
f(10)

f6(
(i:Int )=>println(s"Hello world $i"
)

i可以推导，可以类型类型：

f6(
(i )=>println(s"Hello world $i"）
)
f6(
(i )=>println(s"Hello world $i"）
)

只有一个参数只使用一次的时候，可以省略如下：

f6(
println(_)
)

还可以省略如下：

f6(
println
)

def f7(f:(Int,Int)=>Int):Int
f(10,10)

println(f7((x:Int,y:Int)=>x+y)
println(f7((x,y)=>x+y)
println(f7((x,y)=>x+y)
println(f7(_+_)   //注意这里下划线是表示这两个参数只使用了一次，第一个_表示x,第二个 _ 表示y

def f1="hello world" 是一个函数，相当于：

def f1():String=
"hello world"

参数类型推断

参数推断省去类型信息，参数类型是可以推断出来的，也可以进行相应的简写，相应规则如下

• 参数类型可以推断时，省略参数类型
• 传入的函数只有单个参数时，可以省去括号
• 如果变量只在 => 右边出现一次，可以用 _ 代替

函数如果参数只有一行，且有且只有一个参数并且只是用一遍的时候可以省略
：

list.foreach((i:Int)=>println(i))
list.foreach((i)=>println(i))
list.foreach(println(_))
list.foreach(println(_))
list.foreach(println)

函数柯里话

在函数编程中，接收多个参数的函数都可以转换为接收单个参数的函数，这个转换过程称为柯里化

 def add(x: Int, y: Int) = x + y

def addCurry(x: Int)(y: Int) = x + y