9： 偏函数，高级函数，匿名函数，参数推断，闭包，柯里化，控制抽象

最新推荐文章于 2024-03-13 18:04:40 发布
最新推荐文章于 2024-03-13 18:04:40 发布
阅读量721 收藏
点赞数 1
分类专栏： Scala 文章标签： scala
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_31821675/article/details/102880490
版权

第十三章 函数式编程-高级

13.1 偏函数(partial function)

13.1.1 提出一个需求，引出思考

给你一个集合 val list = List(1, 2, 3, 4, "abc")，请完成如下要求:
1、将集合 list 中的所有数字 +1，并返回一个新的集合。
2、要求忽略掉 非数字 的元素，即返回的 新的集合 形式为 (2, 3, 4, 5)。

13.1.2 解决方式-filter + map 返回新的集合

13.1.3 解决方式-模式匹配

两种方式的示例代码如下：
示例代码如下：

package com.atguigu.chapter13

/**
  * 给你一个集合 val list = List(1, 2, 3, 4, "abc")，请完成如下要求:
  * 1、将集合 list 中的所有数字 +1，并返回一个新的集合。
  * 2、要求忽略掉 非数字 的元素，即返回的 新的集合 形式为 (2, 3, 4, 5)。
  */
object PartialFunDemo01 {
  def main(args: Array[String]): Unit = {
    // 思路1：filter + map 方式解决
    // 虽然可以解决问题，但是麻烦。
    val list = List(1, 2, 3, 4, "abc")
    // 先过滤，再map
    list.filter(f1)
    println(list.filter(f1).map(f2).map(f3)) // List(2, 3, 4, 5)

    // 思路2：模式匹配
    // 小结：虽然使用模式匹配比较简单，但是不够完美。
    val list2 = list.map(addOne2)
    println(list2) // List(2, 3, 4, 5, ())
  }

  // 模式匹配
  def addOne2(i: Any): Any = {
    i match {
      case x:Int => x + 1
      case _ =>
    }
  }

  // 将 List 转为 Any
  def f1(n: Any): Boolean = {
    n.isInstanceOf[Int]
  }

  // 将 Any 转为 Int [map]
  def f2(n: Any): Int = {
    n.asInstanceOf[Int]
  }

  def f3(n: Int): Int = {
    n + 1
  }
}

输出结果如下：

List(2, 3, 4, 5)
List(2, 3, 4, 5, ())

13.1.4 偏函数的基本介绍

 

13.1.5 偏函数的快速入门

示例代码如下：

package com.atguigu.chapter13

object PartialFunDemo02 {
  def main(args: Array[String]): Unit = {
    // 使用偏函数解决
    val list = List(1, 2, 3, 4, "hello")
    // 定义一个偏函数
    // 1. PartialFunction[Any, Int] 表示偏函数接收的参数类型是 Any，返回的类型是 Int
    // 2. isDefinedAt(x: Any) 如果返回 true，就会去调用 apply 构建对象实例，如果是 false，就过滤
    // 3. apply 构造器，对传入的值 + 1，并返回（新的集合）
    val addOne3 = new PartialFunction[Any, Int] {
      def isDefinedAt(any: Any) = if (any.isInstanceOf[Int]) true else false
      def apply(any: Any) = any.asInstanceOf[Int] + 1 // 将 any 显示转换成 Int
    }

    // 使用偏函数
    // 说明：如果是使用偏函数，则不能使用 map，应该使用 collect
    // 说明偏函数的执行流程
    // 1. 遍历 list 集合的所有元素
    // 2. 然后调用 val element = if(partialFun-isDefinedAt(list单个元素)) {partialFun-apply(list单个元素)}
    // 3. 每得到一个符合要求的元素 element，放入到新的集合，最后返回
    val list3 = list.collect(addOne3)
    println(list3) // List(2, 3, 4, 5)
  }
}

输出结果如下：

List(2, 3, 4, 5)

13.1.6 偏函数的小结

 

13.1.7 偏函数的简写形式

示例代码如下：

package com.atguigu.chapter13

/**
  * 偏函数简化形式
  */
object PartialFunDemo03 {
  def main(args: Array[String]): Unit = {
    // 使用偏函数的简化形式解决
    // 第一种简写形式：
    def f2: PartialFunction[Any, Int] = {
      case i: Int => i + 1 // case 语句可以自动转换为偏函数
      case j: Double => (j * 2).toInt
    }

    val list2 = List(1, 2, 3, 4, 5.6, "hello").collect(f2)
    println(list2) // List(2, 3, 4, 5, 11)

    // 第二种简写形式：
    val list3 = List(1, 2, 3, 4, "ABC").collect { case i: Int => i + 1 }
    println(list3) // List(2, 3, 4, 5)
  }
}

输出结果如下：

List(2, 3, 4, 5, 11)
List(2, 3, 4, 5)

13.2 作为参数的函数

1、基本介绍


2、快速入门案例
示例代码如下：

package com.atguigu.chapter13

object FunParameterDemo01 {
  def main(args: Array[String]): Unit = {
    def plus(x: Int) = 3 + x
    val result1 = Array(1, 2, 3, 4).map(plus(_))
    println(result1.mkString(",")) // (4,5,6,7)

    // 1. 在 scala 中，函数也是有类型，比如 plus 就是 <function1>
    println("puls的函数类型是" + (plus _))

  }
}

输出结果如下：

4,5,6,7
puls的函数类型是<function1>

3、应用案例小结

13.3 匿名函数

1、基本介绍


2、快速入门案例
示例代码如下：

package com.atguigu.chapter13

object AnonymouseFunctionDemo01 {
  def main(args: Array[String]): Unit = {
    // 对匿名函数的说明
    // 1. 不需要写 def 函数名
    // 2. 不需要写返回类型，使用类型推导
    // 3. =  变成  =>
    // 4. 如果有多行，则使用 {} 包括
    val triple = (x: Double) => 3 * x
    println(triple) // <function1>
    println(triple(3)) // 9.0
  }
}

输出结果如下：

<function1>
9.0

3、练习题
请编写一个匿名函数，可以返回2个整数的和，并输出该匿名函数的类型。
示例代码如下：

    val f1 = (n1: Int, n2: Int ) => {
      println("匿名函数被调用")
      n1 + n2
    }
    println("f1类型=" + f1) // f1类型=<function2>
    println(f1(10, 30)) // 40

13.4 高阶函数(higher-order function)

1、基本介绍
  能够接受函数作为参数的函数，叫做高阶函数 (higher-order function)。可使应用程序更加健壮。
2、高阶函数基本使用案例
扩展代码如下：

package com.atguigu.chapter13

object HigherOrderFunctionDemo01 {
  def main(args: Array[String]): Unit = {
    // test 就是一个高阶函数，它可以接收 f: Double => Double 和 f1: Double => Int
    def test(f: Double => Double, f1: Double => Int, n1: Double) = {
      f(f1(n1))
    }

    // sum 是接收一个 Double，返回一个 Double
    def sum(d: Double): Double = {
      d + d
    }

    def mod(d: Double): Int = {
      d.toInt % 2
    }

    val res = test(sum, mod, 5.0)
    println("res=" + res) // 2.0
  }
}

输出结果如下：

res=2.0

3、高阶函数可以返回函数类型
示例代码如下：

package com.atguigu.chapter13

object HigherOrderFunctionDemo02 {
  def main(args: Array[String]): Unit = {
    // 说明
    // 1. minusxy 是高阶函数，因为它返回匿名函数
    // 2. 返回的匿名函数是 (y: Int) => x - y
    // 3. 返回的匿名函数可以使用变量接收
    def minusxy(x: Int) = {
      (y: Int) => x - y // 匿名函数
    }

    // 分步执行
    // f1 就是 (y: Int) => 3 - y
    val f1 = minusxy(3)
    println("f1的类型=" + f1)
    println(f1(1)) // 2
    println(f1(9)) // -6

    // 也可以一步到位的调用（函数柯里化）
    println(minusxy(4)(9)) // -5
  }
}

输出结果如下：

f1的类型=<function1>
2
-6
-5

13.5 参数(类型)推断

1、基本介绍


2、应用案例
示例代码如下：

package com.atguigu.chapter13

object ParameterInferDemo01 {
  def main(args: Array[String]): Unit = {

    val list = List(1, 2, 3, 4)
    println(list.map((x: Int) => x + 1)) // (2,3,4,5)
    println(list.map((x) => x + 1)) // (2,3,4,5) 参数类型是可以推断时，可以省略参数类型。
    println(list.map(x => x + 1)) // (2,3,4,5) 当传入的函数，只有单个参数时，可以省去括号。
    println(list.map(_ + 1)) // (2,3,4,5) 如果变量只在=>右边只出现一次，可以用_来代替。

    println(list.reduce(f1)) // 10
    println(list.reduce((n1: Int, n2: Int) => n1 + n2)) // 10
    println(list.reduce((n1, n2) => n1 + n2)) // 10
    println(list.reduce(_ + _)) // 10
  }

  def f1(n1: Int, n2: Int): Int = {
    n1 + n2
  }
}

输出结果如下：

List(2, 3, 4, 5)
List(2, 3, 4, 5)
List(2, 3, 4, 5)
List(2, 3, 4, 5)
10
10
10
10

3、应用案例小结

13.6 闭包(closure)

1、基本介绍


2、应用案例小结

3、闭包的最佳实践
示例代码如下：

package com.atguigu.chapter13

/**
  * 请编写一个程序，具体要求如下：
  * 编写一个函数 makeSuffix(suffix: String) 可以接收一个文件后缀名(比如.jpg)，并返回一个闭包
  * 调用闭包，可以传入一个文件名，如果该文件名没有指定的后缀(比如.jpg)，则返回 文件名.jpg，如果已经有.jpg后缀，则返回原文件名。
  * 要求使用闭包的方式完成。
  * String.endsWith(xx)
  */
object ClosureDemo01 {
  def main(args: Array[String]): Unit = {
    // 使用并测试
    val f = makeSuffix(".jpg")
    println(f("dog.jpg")) // dog.jpg
    println(f("cat")) // cat.jpg

  }

  // 自定义的函数
  def makeSuffix(suffix: String) = {
    // 返回一个匿名函数，该匿名函数会使用外部函数的suffix，那么该函数和suffix整体形成一个闭包。
    (filename: String) => {
      if (filename.endsWith(suffix)) {
        filename
      } else {
        filename + suffix
      }
    }
  }
}

输出结果如下：

dog.jpg
cat.jpg

4、闭包的好处

13.7 函数柯里化(curry)

1、基本介绍


2、函数柯里化快速入门案例

3、函数柯里化最佳实践

示例代码如下：

package com.atguigu.chapter13

/**
  * 函数柯里化最佳实践
  * 比较两个字符串在忽略大小写的情况下是否相等，注意，这里是两个任务：
  * 全部转大写（或小写）
  * 比较是否相等
  * 针对这两个操作，我们用一个函数去处理的思想，其实也变成了两个函数处理的思想（柯里化）
  */
object CurryDemo02 {
  def main(args: Array[String]): Unit = {
    // 方式1：简单的方式，使用一个函数完成
    def eq(s1: String)(s2: String): Boolean = {
      s1.toLowerCase == s2.toLowerCase
    }
    println(eq("hello")("HELLO"))

    // 方式2：使用稍微高级的用法(隐式类)：形式为 str.方法()
    def eq2(s1: String, s2: String): Boolean = {
      s1.equals(s2)
    }
    // 隐式类：该隐式类扩展了String对象的功能
    implicit class TestEq(s: String) {
      // 体现了将比较字符串的事情，分解成两个任务完成：
      // 任务1：checkEq 完转换大小写
      // 任务2.：f函数完成比较任务
      def checkEq(ss: String)(f: (String, String) => Boolean): Boolean = {
        f(s.toLowerCase, ss.toLowerCase)
      }
    }
    val str1 = "hello"
    println(str1.checkEq("HeLLO")(eq2))

    // 方式2的简化写法
    str1.checkEq("HeLLO")((s1: String, s2: String) => { s1.equals(s2) })
    str1.checkEq("HeLLO")((s1: String, s2: String) => s1.equals(s2)) // 代码块只有一行代码时。可以省略{}
    str1.checkEq("HeLLO")((s1, s2) => s1.equals(s2)) // 参数类型是可以推断时，可以省略参数类型。
    str1.checkEq("HeLLO")(_.equals(_)) // 如果变量只在=>右边只出现一次，可以用_来代替。
  }
}

输出结果如下：

true
true

13.8 控制抽象函数

1、看一个需求


2、控制抽象基本介绍



3、快速入门案例
示例代码如下：

package com.atguigu.chapter13

object AbstractControlDemo01 {
  def main(args: Array[String]): Unit = {
    // myRunInThread 就是一个抽象控制函数，其参数是没有输入，也没有输出的函数 f1: () => Unit
    def myRunInThread(f1: () => Unit) = {
      new Thread {
        override def run(): Unit = {
          f1()
        }
      }.start()
    }

    myRunInThread {
      () =>
        println("干活咯！5秒完成...")
        Thread.sleep(5000)
        println("干完咯！")
    }

    // 简写形式
    def myRunInThread2(f1: => Unit) = {
      new Thread {
        override def run(): Unit = {
          f1
        }
      }.start()
    }

    // 对于没有输入，也没有返回值函数，可以简写成如下形式：
    myRunInThread2 {
      println("干活咯！5秒完成...~~~")
      Thread.sleep(5000)
      println("干完咯！~~~")
    }

  }
}

4、进阶用法：实现类似 while 的 mywhile 函数
示例代码如下：

package com.atguigu.chapter13

object AbstractControlDemo02 {
  def main(args: Array[String]): Unit = {
    var x = 10
    while (x > 0) {
      x -= 1
      println("x=" + x)
    }

    // 说明：实现类似 while 的 mywhile 函数
    // 1 函数名为 mywhile，实现了类似 while 循环的效果
    // 2. condition: => Boolean 是一个没有输入值，返回 Boolean 类型函数
    // 3. block: => Unit 没有输入值，也没有返回值的函数
    def mywhile(condition: => Boolean)(block: => Unit): Unit = {
      // 类似 while 循环，递归
      if (condition) {
        block // x=9 x=8 x=7 ...
        mywhile(condition)(block)
      }
    }

    x = 10
    mywhile(x > 0) {
      x -= 1
      println("x=" + x)
    }

  }
}

输出结果如下：

x=9
x=8
x=7
x=6
x=5
x=4
x=3
x=2
x=1
x=0
-----
x=9
x=8
x=7
x=6
x=5
x=4
x=3
x=2
x=1
x=0
SoWhat1412
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Javascript闭包与函数柯里化浅析
01-19
闭包和柯里化都是JavaScript经常用到而且比较高级的技巧，所有的函数式编程语言都支持这两个概念，因此，我们想要充分发挥出JavaScript中的函数式编程特征，就需要深入的了解这两个概念，闭包事实上更是柯里化所不可...
PHP匿名函数(闭包函数)详解
01-03
在PHP中匿名函数（Anonymous functions），也叫闭包函数（ closures ），允许临时创建一个没有指定名称的函数。经常用作回调函数（callback）的参数。 当然，也有其他应用的情况。 注：php闭包是PHP5.3版本之后才有...
函数柯里化详解
博哥的二进制世界
07-29 1万+
函数柯里化详解
一文了解什么是函数柯里化
最新发布
小铭同学的专栏
03-13 981
函数柯里化是一种将使用多个参数的函数转换为一系列使用一个参数的函数的技术。该技术的名称来自于数学家`Haskell Curry`。
javaScript的函数式编程
酒客的博客
12-15 860
javaScript的函数式编程 理解JavaScript纯函数 ​ 函数式编程中有一个非常重要的概念叫纯函数，JavaScript符合函数式编程的范式，所以也有纯函数的概念； 在react开发中纯函数是被多次提及的；比如react中组件就被要求像是一个纯函数（为什么是像，因为还有class组件），redux中有一个reducer的概念，也是要求必须是一个纯函数；所以掌握纯函数对于理解很多框架的设计是非常有帮助的； 纯函数的维基百科定义： 在程序设计中，若一个函数符合以下条件，那么这个函数被称为纯函数：
js函数柯里化详解
weixin_47450807的博客
02-26 1万+
函数柯里化的实现
柯里化函数
Lu_Xuan_的博客
09-14 719
柯里化介绍、理解柯里化、高级柯里化实现、柯里化？目的是什么？
浅谈PHP匿名函数和闭包
01-02
不过匿名函数仍然是函数，因此可以调用，还可以传入参数，适合作为函数或方法的回调。 闭包是指在创建时封装周围状态的函数，即使闭包所在的环境的不存在了，闭包中封装的状态依然存在。 创建匿名函数 创建匿名函数...
Python 中的闭包、匿名函数、decorator 装饰器与python的偏函数
12-21
像这种内层函数引用了外层函数的变量（参数也算变量），然后返回内层函数的情况，称为闭包（Closure）。在函数内部定义的函数和外部定义的函数是一样的，只是他们无法被外部访问。 闭包的特点是返回的函数还引用了...
JS - 函数柯里化
kelly0721的博客
12-26 2606
柯里化的定义、参数复用、提前返回、延迟计算、柯里化函数的实现
JavaScript 匿名函数（anonymous function）与闭包（closure）
赠人玫瑰,手留余香.
09-13 1347
引入 匿名函数 闭包 变量作用域 函数外部访问函数内部的局部变量 用闭包实现私有成员  引入闭包是用匿名函数来实现。闭包就是一个受到保护的变量空间，由内嵌函数生成。“保护变量”的思想在几乎所有的编程语言中都能看到。  先看下 JavaScript 作用域：  JavaScript 具有函数级的作用域。这意味着，不能在函数外部访问定义在函数内部的变量。  JavaScript 的作用域又是词
函数柯里化
热门推荐
runner_123的博客
04-27 2万+
一、柯里化：把接收多个参数的函数变换成接收一个单一参数的函数（单一参数为多个参数中的第一个） 函数柯里化思想：一个JS预处理的思想，降低通用性，提高适用性。 特点： 参数复用 需要输入多个参数，最终只需输入一个，其余通过arguments来获取 提前返回 避免重复去判断某一条件是否符合，不符合则return 不再继续执行下面的操作 延迟执行 避免重复的去执行程序，等...
前端进阶——函数柯里化
m0_74427119的博客
12-11 1008
指将一个接收多个参数的函数转化为接收一系列单个参数的函数，当传入单个参数的时候，不会立即求值，而是会将参数传入下一个内部函数(形成了闭包)直到真正需要求值时一次性进行求值。
JavaScript中匿名函数的作用和用法
Dontla的博客
03-05 1839
匿名函数可bai以有效的保证在页面上写入Javascript，而不会造成全局变量的污染。 这在给一个不是很熟悉的页面增加Javascript时非常有效，也很优美。 例： <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Title</title> <script> var b=10;
JavaScript：创建匿名函数
kllo__的博客
01-17 431
// 将匿名函数赋值给 myFunc const myFunc = function(param1, param2, ...) { // Statements using param1, param2, ... }; // 调用匿名函数 // param1 value is set to arg1, param2 to arg2, ... myFunc(arg1, arg2, ...);
js 函数柯里化 阮一峰
09-06
函数柯里化是一种编程技巧，指的是将具有多个参数的函数转换为一系列只接受单个参数的函数。这种技巧由数学家兼逻辑学家Haskell Curry命名，因此被称为柯里化。 柯里化的主要目的是提高代码的可读性和复用性。在...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

SoWhat1412

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值