Scala基础知识之函数

Scala基础知识之函数

使用de定义函数函数名(参数列表): 返回类型 = {ｆｕｎｃｔｉｏｎ　ｂｏｄｙ　｝

注意类型Int 必须要首字母大写

变量可以推断返回类型，所以函数也可以省略返回值类型

再次简化， 变成一行

scala> def max(x:Int, y:Int) = if(x>y) x else y
max: (x: Int, y: Int)Int

scala> max(2,3)
res30: Int = 3

scala>

二、部分应用（Partial application）， 默认值

scala> def sum(x:Int, y:Int) = x+y
sum: (x: Int, y: Int)Int

scala> sum(2,3)
res31: Int = 5
设置第一个参数为默认值
scala> val sum2 = sum(2, _:Int)
sum2: Int => Int = 

scala> sum2(4)
res32: Int = 6

2.1、实现

package com.chb.test
object TestFunc {  
  
  def add(x: Int, y: Int) = x + y
  //部分应用
  def add2 = add(_:Int, 2);

  /**
   * 主函数
   */
  def main(args: Array[String]): Unit = {
    
    println(add(2, 3));
    //add2只用输入一个参数
    println(add2(2));
  }
}




package com.chb.test

object TestFunc {
  /**
   * 默认参数
   */
  def sayMyName(name: String = "jack") {
    println(name);
  }
 
  /**
   * 主函数
   */
  def main(args: Array[String]): Unit = {
    sayMyName("name");
    sayMyName();//输出默认值
  }

outputs:
	name
	jack

}

三、递归函数 如果是递归函数，同样需要指定返回类型。如：

scala> def fun(n:Int):Int = if(n fun(5)
res33: Int = 120
如果不指定返回值类型
scala> def fun(n:Int)= if(n multiply(2)(3)
res36: Int = 6
scala>

这个看起来没有什么用处啊，但是我们说柯里化在递归，和控制抽象方面比较有用
在目前我们不去深究这个使用场景，现在就是让大家知道有这么个形式，大家掌握到这就可以了
柯里化就是把参数可以分开来，把部分函数参数可以用下划线来代替
package com.chb.test
object TestFunc {  
  
  def multiply(m:Int)(n:Int):Int = m*n
 //第一个参数默认， 第二个参数使用"_"代替
  def m2 = multiply(2)_;
  /**
   * 主函数
   */
  def main(args: Array[String]): Unit = {
    println(m2(3));
  }
}

4.1、部分应用第二个参数

#第一个参数使用默认3, 第二个参数使用"_"表示
scala> val timesTwo = multiply(3)_
timesTwo: Int => Int = 

scala> timesTwo(3)
res37: Int = 9


scala>  def adder(m: Int, n: Int) = m + n
adder: (m: Int, n: Int)Int

scala>  (adder _).curried
res39: Int => (Int => Int) = 

五、匿名函数，没有名字， 没有返回值类型

## 匿名函数没有名字
scala> (x:Int, y:Int) => x * y
res40: (Int, Int) => Int = 
#添加上返回值类型， 会报错的。
scala> (x:Int, y:Int):Int => x * y
:1: error: not a legal formal parameter
       (x:Int, y:Int):Int => x * y
                     ^

scala>

什么是函数式编程

函数嵌套

def testinclude(a:Int,b:Int)={ 
	def add(a:Int,b:Int)=a+b; 
	add(a,b);  
}

函数可以赋值给变量

匿名函数
scala> (x:Int) => x+1 
res43: Int => Int = 
函数赋值给变量
scala> var inc = (x:Int)=>x+1
inc: Int => Int = 

scala> inc(10)
res44: Int = 11

scala>

函数的传递

scala> def test02(callback:() => Unit) = {
	      callback();
      }
test02: (callback: () => Unit)Unit

scala> var t01 = () =>print("fffffffffff")
t01: () => Unit = 

scala> test02(t01)
fffffffffff
scala> test02(()=>{})

scala> test02(()=>{})