Scala学习笔记12: 高阶函数

第十二章 高阶函数

在Scala中, 高阶函数 (Higher-Order Functions) 是指可以接受函数作为参数或返回函数作为结果的函数 ;

高阶函数是函数式编程的重要概念之一, 它允许在函数间传递行为, 从而实现更灵活和抽象的编程方式 .

1- 作为值的函数

在Scala中, 函数可以作为值进行传递和操作, 这是函数式编程的一个重要特性 ;

通过将函数赋值给变量或作为参数传递给其他函数, 可以方便地处理函数并实现更灵活的编程方式 ;

示例:

    // 定义一个接受函数作为参数的高阶函数
    def operateOnFunction(x: Int, func: Int => Int): Int = {
      func(x)
    }

    // 定义一个函数
    val double = (x: Int) => x * 2

    // 将函数赋值给变量
    val myFunction = double

    // 调用高阶函数，并将函数作为参数传递
    val result = operateOnFunction(5, myFunction)

    println(result) // 输出: 10

• 在上面的示例中, 函数 double 被赋值给变量 myFunction , 然后 myFunction 作为值传递给 operateOnFunction 高阶函数进行操作 ;
• 这展示了在Scala中如何处理函数作为值的灵活性 ;

通过将函数视为一等公民(First-Class Citizens) , Scala支持函数作为值的概念, 使得函数可以像其他数据类型一样被操作和传递, 从而实现更具变现力和可组合性的编程风格 .

2- 匿名函数

在Scala中, 匿名函数是一种没有明确名称的函数, 通常用于简单的功能或作为高阶函数的参数 ;

匿名函数可以通过 => 符号定义, 无需显示的命名函数

示例: 使用匿名函数作为高阶函数的参数

    // 定义一个接受函数作为参数的高阶函数
    def operateOnNumber(x: Int, func: (Int) => Int): Int = {
      func(x)
    }

    // 使用匿名函数作为参数
    val result1 = operateOnNumber(5, (x: Int) => x + 1) // 匿名函数实现加1操作
    val result2 = operateOnNumber(5, (x: Int) => x * x) // 匿名函数实现平方操作

    println(result1) // 输出: 6
    println(result2) // 输出: 25

• 在上面的示例中, (x: Int) => x + 1) 和 (x: Int) => x * x) 就是匿名函数, 他们分别实现了加1和平方的操作, 并为参数传递给 operateOnNumber 高阶函数 ;

通过使用匿名函数, 可以在不需要显示定义函数的情况下, 直接在需要的地方编写简单的功能逻辑, 从而简化代码并提高可读性 .

3- 带函数参数的函数

在Scala中, 可以创建接受函数作为参数的函数, 这种函数称为高阶函数 ;

通过高阶函数, 可以实现更灵活和抽象的编程方式 ;

示例:

    // 定义一个接受函数作为参数的高阶函数
    def operateOnList(list: List[Int], f: Int => Int): List[Int] = {
      list.map(f) // 使用map方法对列表中的每个元素应用函数f
    }

    // 定义一个函数，将每个元素乘以2
    def multiplyBy2(x: Int): Int = x * 2

    // 创建一个列表
    val numbers = List(1, 2, 3, 4, 5)

    // 使用高阶函数operateOnList，将每个元素乘以2
    val result = operateOnList(numbers, multiplyBy2)
    println(result) // 输出: List(2, 4, 6, 8, 10)

• 在上面的示例中, operateOnList 是一个接受函数作为参数的高阶函数, 他接受一个整数列表和一个函数作为参数, 并使用传入的函数对列表中每个元素进行操作 ;
• 通过将函数作为参数传递给高阶函数, 可以轻松地对列表中的元素进行不同的操作 .

4- 参数类型推断

在Scala中, 参数类型推断是指编译器根据上下文推断函数或表达式中参数的类型;

这种功能使得代码更简洁, 减少了显示类型声明的需要, 提高了代码的可读性和灵活性 ;

示例:

    // 定义一个函数, 编译器可以推断参数类型
    def add(x: Int, y: Int): Int = {
      x + y
    }
    
    // 调用函数, 无需显示声明参数类型
    val result = add(1, 2)
    println(result) // 输出: 3

• 在这个示例中, 函数 add 的参数 x 和 y 没有显示声明类型, 但编译器可以根据上下文推断出他们的类型为整数类型 ;
• 这种参数类型推断功能使得Scala代码更具表现力和简洁性 ;

需要注意的是, 尽管Scala编译器通常能够进行类型推断, 但在某些情况下可能出现推断失败的情况, 此时可能需要显示声明参数类型以帮助编译器正确推断 .

5- 闭包

在Scala中, 闭包(Closure) 是指一个函数捕获并绑定了其自由变量的函数值 ;

换句话说, 闭包是一个函数, 它可以访问其定义范围之外的变量, 并且在函数被调用时仍然保持对这些变量的引用 ;

示例:

    // 定义一个接受整数参数的函数, 返回一个函数
    def multiplier(factor: Int): Int => Int = {
      (x: Int) => x * factor // 返回一个闭包函数, 该函数接受一个整数参数, 并返回一个整数
    }

    // 创建一个乘以3的闭包函数
    val multiplyBy3 = multiplier(3)

    // 使用闭包进行计算
    println(multiplyBy3(5)) // 输出: 15

    // 创建一个乘以4的闭包函数
    val multiplyBy4 = multiplier(4)

    // 使用闭包进行计算
    println(multiplyBy4(5)) // 输出: 20

• 在上面的示例中, multiplier 函数返回一个闭包, 这个闭包捕获了 factor 变量的值 ;
• 通过调用 multiplier 函数并传入不同的参数, 我们可以创建不同的闭包, 每个闭包都保持对其捕获的 factor 变量的引用 ;
• 这使得闭包可以在函数定义范围之外访问和操作自由变量 ;

闭包在Scala中是一种强大的概念, 它可以帮助实现函数的状态保持和延迟计算等功能 .

6- SAM转换

在Scala中, SAM (Single Abstract Method) 转换是指将具有单个抽象方法的 trait 或抽象类转换为函数 ;

这种转换使得可以直接将符合抽象方法签名的函数传递给期望接收该 trait 或抽象类实例的地方, 从而简化代码并提高灵活性 ;

示例:

假设有一个定义了单个抽象方法的 trait MyTrait :

    trait MyTrait {
      def doSomething(x: Int): Int
    }

现在, 可以通过SAM转换将符合 doSomething 方法签名的函数转换为 MyTrait 的实例 ;

    // 定义一个函数, 符合MyTrait的抽象方法签名
    def myFunction: Int => Int = (x: Int) => x * 2


    // 使用SAM转换将函数转换为 MyTrait 实例
    val myTraitInstance = new MyTrait {
      override def doSomething(x: Int): Int = myFunction(x)
    }

    // 调用trait实例的抽象方法
    val result = myTraitInstance.doSomething(5)

    println(result) // 输出: 10

• 在这个示例中, 我们定义了一个函数 myFunction , 它符合 MyTrait 中 doSomthing 方法的签名 ;
• 然后通过 SAM 转换, 我们将这个函数转换为实现了 MyTrait 的匿名类实例 myTraitInstance , 并可以调用 doSomething 方法 ;

通过SAM转换, Scala提供了一种简洁的方式类将函数转换为 trait 或抽象类的实例, 从而更方便地在代码中使用函数式编程的特性 .

7- 柯里化

柯里化 (Currying) 是指将接受多个参数的函数转换为一系列接受单个参数的函数的过程 ;

在Scala中, 柯里化是一种常见的函数式编程技术, 它可以带来更高的灵活性和可组合性 ;

示例:

    // 定义一个接受两个参数的普通函数
    def add(a: Int, b: Int): Int = a + b

    // 使用柯里化将上述函数转换为接受单个参数的函数序列
    def curriedAdd(a: Int)(b: Int): Int = a + b // 使用柯里化语法定义的函数

    val addCurried = (a: Int) => (b: Int) => a + b // 使用的是匿名函数和函数字面量的方式实现柯里化

    // 调用柯里化后的函数序列
    val result1 = curriedAdd(2)(3)
    val result2 = addCurried(3)(5)

    println(result1) // 输出: 5
    println(result2) // 输出: 8

• 在上面的示例中, add 函数接受两个参数, 而 curriedAdd 和 addCurried 函数经过柯里化后, 将其转换为接受单个参数的函数序列 ;
• 通过柯里化, 我们可以逐步传递参数, 每次传递一个参数, 最终得到函数的结果 ;

柯里化在Scala中常用于创建更具表现力和灵活性的函数, 特别是在函数式编程和组合函数时 ;

通过柯里化, 可以更方便地进行部分应用和函数组合, 使得代码更加简洁和易于理解 .

8- 控制抽象

在Scala中, 控制抽象 (Control Abstraction) 是一种编制技术, 通过它可以创建具有灵活控制结构的函数或方法 ;

控制抽象允许开发人员定义接受函数作为参数的高阶函数, 从而实现对代码执行流程的控制 ;

一个常见的控制抽象示例是使用高阶函数实现条件控制:

    // 定义一个高阶函数, 接受一个条件和两个函数作为参数
    def conditional(condition: Int => Boolean, f1: Int => Int, f2: Int => Int): Int => Int = {
      // 定义一个内部函数, 接受一个整数作为参数
      def inner(x: Int): Int = {
        // 如果条件成立, 则调用第一个函数, 否则调用第二个函数
        if (condition(x)) f1(x) else f2(x)
      }
      // 返回内部函数
      inner
    }

    val f1 = (x: Int) => x * 2
    val f2 = (x: Int) => x / 2
    val f3 = conditional((x: Int) => x % 2 == 0, f1, f2)
    println(f3(4)) // 输出: 8
    println(f3(5)) // 输出: 2

• 在上面的示例中, conditional 函数是一个控制抽象, 它接受一个条件和两个函数作为参数 ;
• 根据条件的结果, 它执行其中一个函数 ;
• 通过这种方式, 我们可以灵活地控制代码的执行流程 ;

控制抽象在Scala中是一种强大的编程技术, 它使得代码更具表现力和灵活性 ;

通过使用控制抽象, 开发人员可以实现各种自定义控制结构, 从而更好地适应不同的编程需求 .

9- return表达式

在Scala中, return 表达式用于从函数或方法中提前返回结果 ;

然而, 在函数式编程中, 通常推荐避免使用 return , 而是通过函数的返回值来控制程序流程 ;

在Scala中, 可以使用 return 表达式, 但它的使用方式和在传统的命令式编程语言中略有不同 ;

示例:

    def findPositiveNumbers(numbers: List[Int]): Int = {
      for (num <- numbers) {
        if (num > 0) {
          return num // 找到第一个正数并返回, 使用return表达式提前返回结果
        }
      }
      return 0 // 如果没有找到正数, 返回0
    }

    val numbers = List(-1, 2, -3, 4, -5)
    val positiveNumber = findPositiveNumbers(numbers)

    println(positiveNumber) // 输出: 2

• 在上面的示例中, findPositiveNumbers 函数用于在列表中找第一个正数 ;
• 当找到第一个正数时, 使用 return 表达式提前返回结果 ;
• 如果没有找到正数, 则返回默认值 0 ;

需要注意的是, 在函数式编程中, 通常更推荐使用不可变函数和纯函数, 避免副作用和可变状态 ;

因此, 尽量避免在Scala中过渡使用 return 表达式, 而是通过函数的返回值来控制程序流程, 以保持代码的函数式和易于理解性 .

end