Scala中函数的基本使用

Scala中的基础函数是程序的基本构建块，用于封装可复用的逻辑。其定义格式为def 函数名(参数名: 参数类型): 返回值类型 = { 函数体 }，参数需显式声明类型，返回值类型可省略（编译器自动推断），但递归函数必须指定。函数体中最后一个表达式的值即为返回值，无需显式return。

基础函数支持多种特性：

‌参数默认值 ‌：def add(a: Int, b: Int = 10): Int = a + b，调用时可省略默认参数。
‌可变参数 ‌：def sum(nums: Int*): Int = nums.sum，通过*接收不定数量参数，调用时用sum(1,2,3)或sum(1 to 5:_*)。
‌匿名函数 ‌：(x: Int, y: Int) => x + y，可赋值给变量或作为高阶函数参数。
‌高阶函数 ‌：接收或返回其他函数，如def map(arr: Array[Int], f: Int => Int): Array[Int] = arr.map(f)。

函数还可嵌套定义（内部函数），支持尾递归优化（避免栈溢出），并能通过元组（(a, b)）或样例类返回多个值。Scala鼓励函数式编程风格，函数为一等公民，可像值一样传递和操作，提升代码简洁性与模块化。

1.定义函数

要点：

特别注意要写=
返回值类型要指定

格式：

2.函数调用

上述代码实现了比较两个数之间的大小。以下为代码实例：

scala 复制代码

object base32 {
 //定义一个函数
  //功能：求两个数的较大者
  def max(x:Int, y:Int):Int ={
    if(x > y)
      x
    else
      y
  }
  
  def main(args: Array[String]): Unit = {
val rst = max(1,100)
    println(s"${rst}")
  }

}

3.函数规则

1.只有一行可以省略{}。当Scala的函数体中只有一行表达式时可以省略{}，输出结果依然不变。

2.最后一条语句为函数的返回值。当函数体中有多个语句存在时，返回最后一条语句的值。

3.函数的返回类型可以省略。它会自动推断。

4.函数没有形参，在定义函数时可以省略()，那么在调用函数时也不需要添加()

代码实例如下：

scala 复制代码

object base32 {
 //定义一个函数
  //功能：求两个数的较大者
  def max(x:Int, y:Int):Int ={
    if(x > y)
      x
    else
      y
  }

  def say():Unit = {
    printf("hahahaha~~~")
  }

  def main(args: Array[String]): Unit = {
val rst = max(1,100)
    println(s"${rst}")

    //调用一个没有（）的函数，不用加（）
    say
  }

}

实例1： 求取三个数中最大的一个数。

scala 复制代码

object base33 {
 /* 1. 三选一 /
  if(x>y && x >z){
  x
  } else if(y>x&&y>z){
  y
  } else{
  z
  }
  */
  //2. 两次二选一
  def max(x:Int, y:Int, z:Int) = {
  var t = if(x>y) x else y
  if(t>z) t else z
}
def main(args: Array[String]): Unit = {
  val rst = max(1000,200,100)
  println(s"${rst}")
  }
}

上述代码和图片为例子的解答。

4.函数返回多个值

代码与图片如下：

scala 复制代码

bject base34 {
  // 定义一个函数
  // 功能：求三个数的最大值和最小值。
  // 注意：函数需要返回多个值。把要放回的数据使用()包在一起，成为一个整体
  def max(x:Int, y:Int, z:Int):(Int, Int) = {
    var maxValue = if(x>y) x else y
    maxValue = if(maxValue>z) maxValue else z
    var minValue = if(x>y) y else x
    minValue = if(minValue>z) z else minValue
    // println(minValue, maxValue)
    (minValue, maxValue) // 是一个整体
  }
  def main(args: Array[String]): Unit = {
    val rst = max(1000,200,100)
    // 访问这个整体中的某个值： ._数字
    println(s"最大值是:${rst._1},最大值是:${rst._2}")
  }
}

5.元组

定义元组:

第一种表示方式为：（元素1，元素2，...元素N）

第二种表示方式为：new TupleN（元素1，元素2，...元素N）。N最大为22

访问元组****

元组通过Tuple_INDEX的方式访问元组中的元素，Tuple表示元组，INDEX表示索引。

格式：

scala 复制代码

t = new Tuple2(1,2); println(t._1, t._2)

实例2：

代码如下：

scala 复制代码

object base35 {
  def main(args: Array[String]): Unit = {
    // 元组：容器，可以装入不同的数据类型的数据
    // 1. 定义一个元组。使用（）把数据包起来，就可以了。
    val t = (1, "1", 1.2, false, 0)

    // 2. 取出元素，通过 ._数字序号 访问
    // 取出 1.2
    println(t._3)
    // 取出false
    println(t._4)
  }
}

图片与结果如下：