Scala 系列(十)—— 函数 & 闭包 & 柯里化

一、函数

1.1 函数与方法

Scala 中函数与方法的区别非常小,如果函数作为某个对象的成员,这样的函数被称为方法,否则就是一个正常的函数。

// 定义方法
def multi1(x:Int) = {x * x}
// 定义函数
val multi2 = (x: Int) => {x * x}

println(multi1(3)) //输出 9
println(multi2(3)) //输出 9

也可以使用 def 定义函数:

def multi3 = (x: Int) => {x * x}
println(multi3(3))  //输出 9 

multi2multi3 本质上没有区别,这是因为函数是一等公民,val multi2 = (x: Int) => {x * x} 这个语句相当于是使用 def 预先定义了函数,之后赋值给变量 multi2

1.2 函数类型

上面我们说过 multi2multi3 本质上是一样的,那么作为函数它们是什么类型的?两者的类型实际上都是 Int => Int,前面一个 Int 代表输入参数类型,后面一个 Int 代表返回值类型。

scala> val multi2 = (x: Int) => {x * x}
multi2: Int => Int = $$Lambda$1092/[email protected]

scala> def multi3 = (x: Int) => {x * x}
multi3: Int => Int

// 如果有多个参数,则类型为:(参数类型,参数类型 ...)=>返回值类型
scala> val multi4 = (x: Int,name: String) => {name + x * x }
multi4: (Int, String) => String = $$Lambda$1093/[email protected]

1.3 一等公民&匿名函数

在 Scala 中函数是一等公民,这意味着不仅可以定义函数并调用它们,还可以将它们作为值进行传递:

import scala.math.ceil
object ScalaApp extends App {
  // 将函数 ceil 赋值给变量 fun,使用下划线 (_) 指明是 ceil 函数但不传递参数
  val fun = ceil _
  println(fun(2.3456))  //输出 3.0

}

在 Scala 中你不必给每一个函数都命名,如 (x: Int) => 3 * x 就是一个匿名函数:

object ScalaApp extends App {
  // 1.匿名函数
  (x: Int) => 3 * x
  // 2.具名函数
  val fun = (x: Int) => 3 * x
  // 3.直接使用匿名函数
  val array01 = Array(1, 2, 3).map((x: Int) => 3 * x)
  // 4.使用占位符简写匿名函数
  val array02 = Array(1, 2, 3).map(_ * 3)
  // 5.使用具名函数
  val array03 = Array(1, 2, 3).map(fun)

}

1.4 特殊的函数表达式

1. 可变长度参数列表

在 Java 中如果你想要传递可变长度的参数,需要使用 String ...args 这种形式,Scala 中等效的表达为 args: String*

object ScalaApp extends App {
  def echo(args: String*): Unit = {
    for (arg <- args) println(arg)
  }
  echo("spark","hadoop","flink")
}
// 输出
spark
hadoop
flink

2. 传递具名参数

向函数传递参数时候可以指定具体的参数名。

object ScalaApp extends App {

  def detail(name: String, age: Int): Unit = println(name + ":" + age)

  // 1.按照参数定义的顺序传入
  detail("heibaiying", 12)
  // 2.传递参数的时候指定具体的名称,则不必遵循定义的顺序
  detail(age = 12, name = "heibaiying")

}

3. 默认值参数

在定义函数时,可以为参数指定默认值。

object ScalaApp extends App {

  def detail(name: String, age: Int = 88): Unit = println(name + ":" + age)

  // 如果没有传递 age 值,则使用默认值
  detail("heibaiying")
  detail("heibaiying", 12)

}

二、闭包

2.1 闭包的定义

var more = 10
// addMore 一个闭包函数:因为其捕获了自由变量 more 从而闭合了该函数字面量
val addMore = (x: Int) => x + more

如上函数 addMore 中有两个变量 x 和 more:

  • x : 是一个绑定变量 (bound variable),因为其是该函数的入参,在函数的上下文中有明确的定义;
  • more : 是一个自由变量 (free variable),因为函数字面量本生并没有给 more 赋予任何含义。

按照定义:在创建函数时,如果需要捕获自由变量,那么包含指向被捕获变量的引用的函数就被称为闭包函数。

2.2 修改自由变量

这里需要注意的是,闭包捕获的是变量本身,即是对变量本身的引用,这意味着:

  • 闭包外部对自由变量的修改,在闭包内部是可见的;
  • 闭包内部对自由变量的修改,在闭包外部也是可见的。
// 声明 more 变量
scala> var more = 10
more: Int = 10

// more 变量必须已经被声明,否则下面的语句会报错
scala> val addMore = (x: Int) => {x + more}
addMore: Int => Int = $$Lambda$1076/[email protected]

scala> addMore(10)
res7: Int = 20

// 注意这里是给 more 变量赋值,而不是重新声明 more 变量
scala> more=1000
more: Int = 1000

scala> addMore(10)
res8: Int = 1010

2.3 自由变量多副本

自由变量可能随着程序的改变而改变,从而产生多个副本,但是闭包永远指向创建时候有效的那个变量副本。

// 第一次声明 more 变量
scala> var more = 10
more: Int = 10

// 创建闭包函数
scala> val addMore10 = (x: Int) => {x + more}
addMore10: Int => Int = $$Lambda$1077/[email protected]

// 调用闭包函数
scala> addMore10(9)
res9: Int = 19

// 重新声明 more 变量
scala> var more = 100
more: Int = 100

// 创建新的闭包函数
scala> val addMore100 = (x: Int) => {x + more}
addMore100: Int => Int = $$Lambda$1078/[email protected]

// 引用的是重新声明 more 变量
scala> addMore100(9)
res10: Int = 109

// 引用的还是第一次声明的 more 变量
scala> addMore10(9)
res11: Int = 19

// 对于全局而言 more 还是 100
scala> more
res12: Int = 100

从上面的示例可以看出重新声明 more 后,全局的 more 的值是 100,但是对于闭包函数 addMore10 还是引用的是值为 10 的 more,这是由虚拟机来实现的,虚拟机会保证 more 变量在重新声明后,原来的被捕获的变量副本继续在堆上保持存活。

三、高阶函数

3.1 使用函数作为参数

定义函数时候支持传入函数作为参数,此时新定义的函数被称为高阶函数。

object ScalaApp extends App {

  // 1.定义函数
  def square = (x: Int) => {
    x * x
  }

  // 2.定义高阶函数: 第一个参数是类型为 Int => Int 的函数
  def multi(fun: Int => Int, x: Int) = {
    fun(x) * 100
  }

  // 3.传入具名函数
  println(multi(square, 5)) // 输出 2500

  // 4.传入匿名函数
  println(multi(_ * 100, 5)) // 输出 50000

}

3.2 函数柯里化

我们上面定义的函数都只支持一个参数列表,而柯里化函数则支持多个参数列表。柯里化指的是将原来接受两个参数的函数变成接受一个参数的函数的过程。新的函数以原有第二个参数作为参数。

object ScalaApp extends App {
  // 定义柯里化函数
  def curriedSum(x: Int)(y: Int) = x + y
  println(curriedSum(2)(3)) //输出 5
}

这里当你调用 curriedSum 时候,实际上是连着做了两次传统的函数调用,实际执行的柯里化过程如下:

  • 第一次调用接收一个名为 x 的 Int 型参数,返回一个用于第二次调用的函数,假设 x 为 2,则返回函数 2+y
  • 返回的函数接收参数 y,并计算并返回值 2+3 的值。

想要获得柯里化的中间返回的函数其实也比较简单:

object ScalaApp extends App {
  // 定义柯里化函数
  def curriedSum(x: Int)(y: Int) = x + y
  println(curriedSum(2)(3)) //输出 5

  // 获取传入值为 10 返回的中间函数 10 + y
  val plus: Int => Int = curriedSum(10)_
  println(plus(3)) //输出值 13
}

柯里化支持多个参数列表,多个参数按照从左到右的顺序依次执行柯里化操作:

object ScalaApp extends App {
  // 定义柯里化函数
  def curriedSum(x: Int)(y: Int)(z: String) = x + y + z
  println(curriedSum(2)(3)("name")) // 输出 5name

}

参考资料

  1. Martin Odersky . Scala 编程 (第 3 版)[M] . 电子工业出版社 . 2018-1-1
  2. 凯.S.霍斯特曼 . 快学 Scala(第 2 版)[M] . 电子工业出版社 . 2017-7

更多大数据系列文章可以参见 GitHub 开源项目大数据入门指南

原文地址:https://www.cnblogs.com/heibaiying/p/11432927.html

时间: 2024-10-01 11:04:56

Scala 系列(十)—— 函数 & 闭包 & 柯里化的相关文章

【Scala】高阶函数和柯里化

高阶函数 在数学和计算机科学中,高阶函数是至少满足下列一个条件的函数: - 接受一个或多个函数作为输入 - 输出一个函数 在数学中它们也叫做算子(运算符)或泛函.微积分中的导数就是常见的例子,因为它映射一个函数到另一个函数. 高阶函数的例子 假设有一个函数对给定两个数区间中的所有整数求和: def sumInts(a: Int, b: Int): Int = if(a > b) 0 else a + sumInts(a + 1, b) 如果现在要求连续整数的平方和: def square(x:

浅析 JavaScript 中的 函数 currying 柯里化

原文:浅析 JavaScript 中的 函数 currying 柯里化 何为Curry化/柯里化? curry化来源与数学家 Haskell Curry的名字 (编程语言 Haskell也是以他的名字命名). 柯里化通常也称部分求值,其含义是给函数分步传递参数,每次传递参数后部分应用参数,并返回一个更具体的函数接受剩下的参数,这中间可嵌套多层这样的接受部分参数函数,直至返回最后结果.因此柯里化的过程是逐步传参,逐步缩小函数的适用范围,逐步求解的过程. 柯里化一个求和函数 按照分步求值,我们看一个

js高阶函数--判断数据类型、函数胡柯里化;

一.判断数据类型: 常见的判断有typeof.instanceof. constructor. prototype,先来看typeof: var a = "hello world"; var b = 10; var c = [1, 3, 5]; var d = new Date(); var e = function() {}; console.log(typeof a); // string console.log(typeof b); // number console.log(t

Effective JavaScript Item 26 使用bind来进行函数的柯里化(Curry)

本系列作为Effective JavaScript的读书笔记. 在上一个Item中介绍了bind的一种用法:用来绑定this对象.但是实际上,bind含有另一种用法,就是帮助函数进行柯里化.关于柯里化,这里有一份百科可以参考: http://zh.wikipedia.org/wiki/%E6%9F%AF%E9%87%8C%E5%8C%96 但是实际上,关于柯里化只需要记住一点就够了:柯里化是把接受多个参数的函数变换成接受一个单一参数(通常是最初函数的第一个参数,但是并无限制)的函数,并且返回这个

深入详解函数的柯里化

深入详解函数的柯里化 一.补充知识点之函数的隐式转换 JavaScript作为一种弱类型语言,它的隐式转换是非常灵活有趣的.当我们没有深入了解隐式转换的时候可能会对一些运算的结果会感动困惑,比如4 + true = 5.当然,如果对隐式转换了解足够深刻,肯定是能够很大程度上提高对js的使用能力.只是我没有打算将所有的隐式转换规则分享给大家,这里暂时只分享一下,函数在隐式转换中的一些规则. 来一个简单的思考题. 1 2 3 4 5 function fn() { return 20; } cons

关于arguments对象以及函数的柯里化;

1.arguments对象 Arguments是个类似数组但不是数组的对象,说他类似数组是因为其具备数组相同的访问性质及方式,能够由arguments[n]来访问对应的单个参数的值,并拥有数组长度属性length.还有就是arguments对象存储的是实际 传递给函数的参数,而不局限于函数声明所定义的参数列表,而且不能显式创建 arguments 对象.在JavaScript中函数不介意传递进来多少参数,也不会因为参数不统一而错误.实际上,函数体内可以通过 arguments 对象来接收传递进来

理解运用JS的闭包、高阶函数、柯里化

一.闭包 1. 闭包的概念 闭包与执行上下文.环境.作用域息息相关 执行上下文 执行上下文是用于跟踪运行时代码求值的一个规范设备,从逻辑上讲,执行上下文是用执行上下文栈(栈.调用栈)来维护的. 代码有几种类型:全局代码.函数代码.eval代码和模块代码:每种代码都是在其执行上下文中求值. 当函数被调用时,就创建了一个新的执行上下文,并被压到栈中 - 此时,它变成一个活动的执行上下文.当函数返回时,此上下文被从栈中弹出 function recursive(flag) { // Exit cond

[Effective JavaScript 笔记]第26条:使用bind方法实现函数的柯里化

bind方法的作用,除了有绑定函数到对象外,我们来看看bind方法的一些其它应用. 简单示例 例子:假设有一个装配URL字符串的简单函数.代码如下 function simpleURL(protocol,domain,path){ return protocol+'://'+domain+'/'+path; } 要将特定站点的路径字符串构建为绝对路径URL.可以使用ES5中数组的map方法来实现.如下 var paths=['wengxuesong/','wengxuesong/p/556048

javascript中的函数currying(柯里化) 的理解

首先简要说一下什么是curry化 :它是一种通过把多个参数填充到函数体中,实现将函数转换成一个新的经过简化的(使之接受的参数更少)函数技术.(摘自:精通JavaScrtpt图灵计算机科学丛书-21页) //写一个简单点的 function curry(fn/*function*/ , scope/*object?*/){ //取到除必须参数的其他参数,也就是第二个以后的所有参数,做一个缓存 var args = [].slice.call(arguments , 2); console.log(