函数基础 #

一、函数定义 #

1.1 基本语法 #

scala 
def functionName(parameters): ReturnType = body

1.2 简单函数 #

scala 
def greet(): Unit =
  println("Hello, Scala!")

def add(a: Int, b: Int): Int =
  a + b

def square(x: Int): Int = x * x

1.3 函数调用 #

scala 
greet()

val sum = add(10, 20)
println(sum)

val result = square(5)
println(result)

二、参数 #

2.1 多个参数 #

scala 
def printInfo(name: String, age: Int, city: String): Unit =
  println(s"$name, $age years old, lives in $city")

printInfo("Alice", 25, "Beijing")

2.2 无参数函数 #

scala 
def currentTime(): Long = System.currentTimeMillis()

def pi = 3.14159

println(currentTime())
println(pi)

2.3 默认参数 #

scala 
def greet(name: String, greeting: String = "Hello"): String =
  s"$greeting, $name!"

println(greet("Alice"))
println(greet("Bob", "Hi"))

2.4 命名参数 #

scala 
def createPerson(name: String, age: Int, city: String = "Unknown"): Person =
  Person(name, age, city)

createPerson("Alice", 25)
createPerson(name = "Bob", age = 30)
createPerson(age = 35, name = "Charlie")
createPerson("David", city = "Shanghai", age = 28)

三、返回值 #

3.1 显式返回类型 #

scala 
def add(a: Int, b: Int): Int = a + b

def greet(name: String): String = s"Hello, $name!"

def isEven(n: Int): Boolean = n % 2 == 0

3.2 类型推断 #

scala 
def add(a: Int, b: Int) = a + b

def greet(name: String) = s"Hello, $name!"

3.3 Unit 返回类型 #

scala 
def printMessage(msg: String): Unit =
  println(msg)

def log(msg: String): Unit =
  println(s"[${java.time.LocalDateTime.now()}] $msg")

3.4 块表达式返回值 #

scala 
def calculate(x: Int): Int =
  val doubled = x * 2
  val squared = doubled * doubled
  squared

def process(input: String): String =
  val trimmed = input.trim
  val upper = trimmed.toUpperCase
  upper

四、多参数列表 #

4.1 柯里化函数 #

scala 
def add(a: Int)(b: Int): Int = a + b

val result = add(10)(20)

val addTen = add(10) _
val result2 = addTen(5)

4.2 多参数列表示例 #

scala 
def foldLeft[A, B](list: List[A])(initial: B)(f: (B, A) => B): B =
  list.foldLeft(initial)(f)

val sum = foldLeft(List(1, 2, 3, 4, 5))(0)(_ + _)

4.3 配置与数据分离 #

scala 
def process(config: Config)(data: Data): Result =
  ???

val processor = process(defaultConfig) _
val result = processor(someData)

五、可变参数 #

5.1 定义可变参数 #

scala 
def sum(numbers: Int*): Int =
  numbers.sum

sum(1, 2, 3, 4, 5)
sum()

5.2 可变参数与普通参数 #

scala 
def format(prefix: String, values: String*): String =
  s"$prefix: ${values.mkString(", ")}"

format("Names", "Alice", "Bob", "Charlie")

5.3 传递序列给可变参数 #

scala 
val numbers = Seq(1, 2, 3, 4, 5)
val result = sum(numbers*)

5.4 可变参数内部实现 #

scala 
def printAll(args: String*): Unit =
  args.foreach(println)
  println(s"Total: ${args.length} arguments")

六、递归函数 #

6.1 普通递归 #

scala 
def factorial(n: Int): Int =
  if n <= 1 then 1
  else n * factorial(n - 1)

factorial(5)

6.2 尾递归 #

scala 
@annotation.tailrec
def factorial(n: Int, acc: Int = 1): Int =
  if n <= 1 then acc
  else factorial(n - 1, n * acc)

factorial(5)

6.3 尾递归优化 #

尾递归函数会被编译器优化为循环，不会栈溢出：

scala 
@annotation.tailrec
def countdown(n: Int): Unit =
  if n > 0 then
    println(n)
    countdown(n - 1)

countdown(100000)

6.4 相互递归 #

scala 
@annotation.tailrec
def isEven(n: Int): Boolean =
  if n == 0 then true
  else isOdd(n - 1)

@annotation.tailrec
def isOdd(n: Int): Boolean =
  if n == 0 then false
  else isEven(n - 1)

七、嵌套函数 #

7.1 定义嵌套函数 #

scala 
def outer(x: Int): Int =
  def inner(y: Int): Int = x + y
  inner(10)

outer(5)

7.2 嵌套函数访问外部变量 #

scala 
def process(data: List[Int]): List[Int] =
  val threshold = 10
  
  def filterData(item: Int): Boolean = item > threshold
  
  def transform(item: Int): Int = item * 2
  
  data.filter(filterData).map(transform)

7.3 嵌套函数隐藏实现 #

scala 
def factorial(n: Int): Int =
  @annotation.tailrec
  def loop(current: Int, acc: Int): Int =
    if current <= 1 then acc
    else loop(current - 1, current * acc)
  
  loop(n, 1)

八、函数作为值 #

8.1 函数类型 #

scala 
val add: (Int, Int) => Int = (a, b) => a + b
val greet: String => String = name => s"Hello, $name!"

add(10, 20)
greet("Scala")

8.2 函数赋值 #

scala 
def double(x: Int): Int = x * 2

val doubler: Int => Int = double
val result = doubler(5)

8.3 函数作为参数 #

scala 
def applyTwice(f: Int => Int, x: Int): Int = f(f(x))

def double(x: Int): Int = x * 2

applyTwice(double, 3)

九、方法与函数 #

9.1 方法（Method） #

使用 def 定义的是方法：

scala 
def add(a: Int, b: Int): Int = a + b

9.2 函数（Function） #

函数是对象，可以赋值给变量：

scala 
val add = (a: Int, b: Int) => a + b

9.3 方法转函数 #

使用 _ 将方法转换为函数：

scala 
def add(a: Int, b: Int): Int = a + b

val addFunc = add _
val addFunc2: (Int, Int) => Int = add

9.4 Eta 扩展 #

Scala 会自动进行 Eta 扩展：

scala 
def double(x: Int): Int = x * 2

val numbers = List(1, 2, 3, 4, 5)
numbers.map(double)
numbers.map(double _)

十、函数最佳实践 #

10.1 使用有意义的函数名 #

scala 
def calculateTotalPrice(items: List[Item]): Double = ???
def isEligibleForDiscount(customer: Customer): Boolean = ???
def sendEmail(to: String, subject: String, body: String): Unit = ???

10.2 保持函数简短 #

scala 
def processOrder(order: Order): Result =
  val validated = validate(order)
  val priced = calculatePrice(validated)
  val saved = save(priced)
  sendConfirmation(saved)

def validate(order: Order): Order = ???
def calculatePrice(order: Order): Order = ???
def save(order: Order): Order = ???
def sendConfirmation(order: Order): Result = ???

10.3 使用默认参数减少重载 #

scala 
def connect(host: String, port: Int = 8080, timeout: Int = 5000): Connection = ???

connect("localhost")
connect("localhost", 9090)
connect("localhost", 9090, 10000)

10.4 使用命名参数提高可读性 #

scala 
createUser(
  name = "Alice",
  age = 25,
  email = "alice@example.com",
  isActive = true
)

十一、总结 #

函数定义要素 #

要素 说明 示例
def 定义关键字 def add…
参数列表 输入参数 (a: Int, b: Int)
返回类型 输出类型 : Int
函数体 实现逻辑 = a + b

参数特性 #

特性 语法 示例
默认参数 param: Type = value greeting: String = “Hello”
命名参数 name = value greet(name = “Alice”)
可变参数 param: Type* numbers: Int*
多参数列表 (params1)(params2) def add(a: Int)(b: Int)

下一步，让我们学习 高阶函数！

最后更新：2026-03-27