ScalaNote04-函数式编程

函数

函数定义

  为完成某一功能的程序指令(语句)的集合,称为函数。在scala中函数的基本语法如下:

def 函数名 ([参数名: 参数类型], ...)[[: 返回值类型] =] {
	语句...
	return 返回值
}

函数声明关键字为def (definition)
[参数名: 参数类型], …:表示函数的输入(就是参数列表), 可以没有。 如果有,多个参数使用逗号间隔
函数中的语句:表示为了实现某一功能代码块
函数可以有返回值,也可以没有
返回值形式1: : 返回值类型 =
返回值形式2: = 表示返回值类型不确定,使用类型推导完成
返回值形式3: 表示没有返回值,return 不生效
如果没有return ,默认以执行到最后一行的结果作为返回值
如果有return,返回值形式必须为: 返回值类型 =
如果有return,返回值形式为空,则没有返回值
如果返回值形式为:Unit=,即使有return也无返回值
递归函数未执行之前是无法推断出来结果类型,在使用时必须有明确的返回值类型

**如果返回值类型不一致,可以用"="类型推导。**如下所示:

def demof1(x1:Int,x2:Int)={
    if (x1==1){
        234
    }else{
        "hahah"
    }
}
demof1: (x1: Int, x2: Int)Any
println(demof1(10,10))
hahah

  **如果函数存在多个参数,每一个参数都可以设定默认值,那么这个时候,传递的参数到底是覆盖默认值,还是赋值给没有默认值的参数,就不确定了(默认按照声明顺序[从左到右])。在这种情况下,可以采用带名参数。**举个例子,我们只想修改user参数,别的不变

def mysqlCon(add:String = "localhost",port : Int = 3306,
               user: String = "root", pwd : String = "root"): Unit = {
    println("add=" + add)
    println("port=" + port)
    println("user=" + user)
    println("pwd=" + pwd)
  }
mysqlCon: (add: String, port: Int, user: String, pwd: String)Unit
mysqlCon(user="test")
add=localhost
port=3306
user=test
pwd=root

如果不带参数名,默认从左往右

mysqlCon("x1",8888)
add=x1
port=8888
user=root
pwd=root

递归调用

  一个函数在函数体内又调用本身,称之为递归调用。

  • 程序执行一个函数时,就创建一个新的受保护的独立空间(新函数栈)
  • 函数的局部变量是独立的,不会相互影响
  • 递归必须向退出递归的条件逼近,否则就是无限递归,死循环了
  • 当一个函数执行完毕,或者遇到return,就会返回,遵守谁调用,就将结果返回给谁

通过两个例子来看下递归的逻辑~先看一个简单递归函数:

def test (n: Int){
    if (n > 2) {
      test (n - 1)
    }
    println("n=" + n) 
  }
test: (n: Int)Unit
test(4)
n=2
n=3
n=4

函数的执行顺序如下:

  • ->Step1:test(4),执行判断,执行test(3),此时pprintln(“n”+4)还没有执行
  • ->Step2:test(3),执行判断,执行test(2),此时println(“n”+3)还没有执行
  • ->Step3:test(2),不满足if条件,直接print(“n=”,2)
  • ->回到Step2,println(“n”+2),此时Step2完成
  • ->回到Step1,println(“n”+1),此时Step1完成

  第二个例子求出斐波那契数列1,1,2,3,5,8,13…给定整数n,求出它的斐波那契数,如f(n=1)=1,f(n=7)=14

// 注意:这里必须指定返回值类型  
def Fibonacci(n:Int): Int = {
    if(n==1){
        1
    }else if(n==2){
        1
    }else{
       Fibonacci(n-1)+Fibonacci(n-2) 
    }
}
Fibonacci: (n: Int)Int
println("Fibonacci(7)="+Fibonacci(7)+"\n"+"Fibonacci(8)="+Fibonacci(8))
Fibonacci(7)=13
Fibonacci(8)=21

过程

  将函数的返回类型为Unit的函数称之为过程(procedure),如果明确函数没有返回值,那么等号可以省略。比如下面的code:

  def f(id: Int): Unit = {
    println("hahah")
  }

惰性函数

  惰性计算(尽可能延迟表达式求值)是许多函数式编程语言的特性。惰性集合在需要时提供其元素,无需预先计算它们,这带来了一些好处。首先,可以将耗时的计算推迟到绝对需要的时候。其次,可以创造无限个集合,只要它们继续收到请求,就会继续提供元素。函数的惰性使用让您能够得到更高效的代码。

  当函数返回值被声明为lazy时,函数的执行将被推迟,直到我们首次对此取值,该函数才会执行。这种函数称为惰性函数! 看个demo:

object demo{
   def main(): Unit = {
    lazy val res = sum(10, 20)
    println("-----------------")
    println("res=" + res) 
   }
def sum(n1 : Int, n2 : Int): Int = {
    println("sum() Execute..")
    return  n1 + n2
   } 
}
defined object demo
demo.main()
-----------------
sum() Execute..
res=30

可以看到main函数中调用sum函数时,没有打印"sum() Execute…",而是先println("-----------------");然后取res值时真正执行了sum函数

异常处理

  和Python、R一样,Scala中也是使用try catch处理异常,看一个简单的例子:

try {
      val r = 10 / 0
    } catch {
      case ex: ArithmeticException=> println("The divisor is 0")
      case ex: Exception => println("Error")
    } finally {
      println("scala finally...")
    }

The divisor is 0
scala finally...

  可疑的代码放在try{}中,catch{}进行异常捕获,如果有异常发生,catch字句是按次序捕捉的。因此,在catch字句中,越具体的异常越要靠前,越普遍的异常越靠后。无论异常是否发生finally{}语句都会执行。
  异常处理自己用的比较少,还是之前用r方便debug,把异常写到log中,其他的细节以后遇到再补充。

                                2020-02-20 于南京市 栖霞区

  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值