在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.函数调用

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

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.函数没有形参，在定义函数时可以省略()，那么在调用函数时也不需要添加()

代码实例如下：

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：求取三个数中最大的一个数

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.函数返回多个值

代码与图片如下：

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表示索引。

格式：

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

实例2：

代码如下：

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)
  }
}

图片与结果如下：