Scala（第五章 函数式编程）

已于 2023-08-11 23:45:12 修改
阅读量223 收藏
点赞数
分类专栏： scala 文章标签： scala 开发语言 后端
于 2023-08-10 09:09:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nlcexiyue/article/details/132201786
版权

文章目录


1）面向对象编程

1、 解决问题，分解对象，行为，属性，然后通过对象的关系以及行为的调用来解决问题。
对象：用户
行为：登录、连接JDBC、读取数据库
属性：用户名、密码
2、Scala语言是一个完全面向对象编程语言，万物皆对象。
3、对象的本质：对数据和行为的一个封装

2）函数式编程

1、解决问题时，将问题分解成一个一个的步骤，将每个步骤进行封装（函数），通过调用这些封装好的步骤，解决问题。
例如：请求 -> 用户名、密码 -> 连接JDBC -> 读取数据库
2、Scala语言是一个完全函数式编程语言。万物皆函数。
3、函数的本质：函数可以当作一个值进行转递

3）在Scala中函数式编程和面向对象编程完美融合在一起了。

5.1 函数基础

5.1.1 函数基本语法

1）基本语法
在这里插入图片描述
2）案例实操

需求：定义一个函数，实现将传入的名称打印出来。

object TestFunction {
 def main(args: Array[String]): Unit = {
	 // （1）函数定义
	 def f(arg: String): Unit = {
	  println(arg)
	 }
	 // （2）函数调用
	 // 函数名（参数）
	 f("hello world")
 }
}

   
   

   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

5.1.2 函数和方法的区别

1）核心概念

1、为完成某一功能的程序语句的集合，称为函数。
2、类中的函数称之为方法。

2）案例实操

1、Scala语言可以在任何的语法结构中声明任何的语法
2、函数没有重载和重写的概念；方法可以进行重载和重写
3、Scala中函数可以嵌套定义

object TestFunction {
 // (2)方法可以进行重载和重写，程序可以执行
 def main(): Unit = {
 }
 def main(args: Array[String]): Unit = {
	 // （1）Scala 语言可以在任何的语法结构中声明任何的语法import java.util.Date
	 new Date()
	 // (2)函数没有重载和重写的概念，程序报错
	 def test(): Unit ={
	   println("无参，无返回值")
	 }
	 test()
	 def test(name:String):Unit={
	   println()
	 }
	 //（3）Scala 中函数可以嵌套定义
	 def test2(): Unit ={
	   def test3(name:String):Unit={
	      println("函数可以嵌套定义")
       }
      }
   }
}

   
   

   
   

    
    
   
   

   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23

5.1.3 函数定义

1）函数定义

（1）函数 1：无参，无返回值
（2）函数 2：无参，有返回值
（3）函数 3：有参，无返回值
（4）函数 4：有参，有返回值
（5）函数 5：多参，无返回值
（6）函数 6：多参，有返回值

2）案例实操

package com.atguigu.chapter05
 object TestFunctionDeclare {
	 def main(args: Array[String]): Unit = {
	 // 函数 1：无参，无返回值
	 def test1(): Unit ={
	  println("无参，无返回值")
	 }
	 test1()
	 // 函数 2：无参，有返回值
	 def test2():String={
	  return "无参，有返回值"
	 }
	 println(test2())
	 // 函数 3：有参，无返回值
	 def test3(s:String):Unit={
	  println(s)
	 }
	 test3("jinlian")
	 // 函数 4：有参，有返回值
	 def test4(s:String):String={
	   return s+"有参，有返回值"
	 }
	 println(test4("hello "))
	 // 函数 5：多参，无返回值
	 def test5(name:String, age:Int):Unit={
	   println(s"$name, $age")
	 }
	 test5("dalang",40)
  }
}

   
   

   
   

    
    
   
   

   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30

5.1.4 函数参数

1）案例实操

（1）可变参数
（2）如果参数列表中存在多个参数，那么可变参数一般放置在最后
（3）参数默认值，一般将有默认值的参数放置在参数列表的后面
（4）带名参数

object TestFunction {
 def main(args: Array[String]): Unit = {
	 // （1）可变参数
	 def test( s : String* ): Unit = {
	   println(s)
	 }
	 // 有输入参数：输出 Array
	 test("Hello", "Scala")
	 // 无输入参数：输出 List()
	 test()
	 // (2)如果参数列表中存在多个参数，那么可变参数一般放置在最后
	 def test2( name : String, s: String* ): Unit = {
	   println(name + "," + s)
	 }
	 test2("jinlian", "dalang")
	 // (3)参数默认值
	 def test3( name : String, age : Int = 30 ): Unit = {
	   println(s"$name, $age")
	 }
	 // 如果参数传递了值，那么会覆盖默认值
	 test3("jinlian", 20)
	 // 如果参数有默认值，在调用的时候，可以省略这个参数
	 test3("dalang")
	 // 一般情况下，将有默认值的参数放置在参数列表的后面
	 def test4( sex : String = "男", name : String ): Unit = {
	   println(s"$name, $sex")
	 }
	// Scala 函数中参数传递是，从左到右
	 //test4("wusong")
	 //（4）带名参数
	 test4(name="ximenqing")
 }
}

   
   

   
   

    
    
   
   

   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33

5.1.5 函数至简原则（重点）

函数至简原则：能省则省

1）至简原则细节

（1）return 可以省略，Scala 会使用函数体的最后一行代码作为返回值
（2）如果函数体只有一行代码，可以省略花括号
（3）返回值类型如果能够推断出来，那么可以省略（:和返回值类型一起省略）
（4）如果有 return，则不能省略返回值类型，必须指定
（5）如果函数明确声明 unit，那么即使函数体中使用 return 关键字也不起作用
（6）Scala 如果期望是无返回值类型，可以省略等号
（7）如果函数无参，但是声明了参数列表，那么调用时，小括号，可加可不加
（8）如果函数没有参数列表，那么小括号可以省略，调用时小括号必须省略
（9）如果不关心名称，只关心逻辑处理，那么函数名（def）可以省略

2）案例实操

object TestFunction {
 def main(args: Array[String]): Unit = {
 // （0）函数标准写法
 def f( s : String ): String = {
   return s + " jinlian"
 }
 println(f("Hello"))
 // 至简原则:能省则省
 //（1） return 可以省略,Scala 会使用函数体的最后一行代码作为返回值
 def f1( s : String ): String = {
 s + " jinlian"
 }
 println(f1("Hello"))
 //（2）如果函数体只有一行代码，可以省略花括号
 def f2(s:String):String = s + " jinlian"
 //（3）返回值类型如果能够推断出来，那么可以省略（:和返回值类型一起省略）
 def f3( s : String ) = s + " jinlian"
   println(f3("Hello3"))
 //（4）如果有 return，则不能省略返回值类型，必须指定。
 def f4() :String = {
     return "ximenqing4"
 }
 println(f4())
 //（5）如果函数明确声明 unit，那么即使函数体中使用 return 关键字也不起作用
 def f5(): Unit = {
   return "dalang5"
 }
 println(f5())
 //（6）Scala 如果期望是无返回值类型,可以省略等号
 // 将无返回值的函数称之为过程
 def f6() {
 "dalang6"
 }
 println(f6())
 //（7）如果函数无参，但是声明了参数列表，那么调用时，小括号，可加可不加
 def f7() = "dalang7"
 println(f7())
 println(f7)
 //（8）如果函数没有参数列表，那么小括号可以省略,调用时小括号必须省略
 def f8 = "dalang"
 //println(f8())
 println(f8)
 //（9）如果不关心名称，只关心逻辑处理，那么函数名（def）可以省略
 def f9 = (x:String)=>{println("wusong")}
 def f10(f:String=>Unit) = {
 f("")
 }
 f10(f9)
 println(f10((x:String)=>{println("wusong")}))
 }
}

   
   

   
   

    
    
   
   

   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51

5.2 函数高级

5.2.1 高阶函数

1、在Scala中，函数是一等公民。怎么体现的呢?
2、对于一个函数我们可以：定义函数、调用函数

object TestFunction {
 def main(args: Array[String]): Unit = {
 // 调用函数
foo()
 }
 // 定义函数
 def foo():Unit = {
   println("foo...")
 }
}

   
   

   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

3、但是其实函数还有更高阶的用法

1）函数可以作为值进行传递

object TestFunction {
 def main(args: Array[String]): Unit = {
 //（1）调用 foo 函数，把返回值给变量 f
 //val f = foo()
 val f = foo
   println(f)
//（2）在被调用函数 foo 后面加上 _，相当于把函数 foo 当成一个整体，传递给变量 f1
 val f1 = foo _
 foo()
 f1()
//（3）如果明确变量类型，那么不使用下划线也可以将函数作为整体传递给变量
var f2:()=>Int = foo 
 }
 def foo():Int = {
   println("foo...")
 1
 }
}

   
   

   
   

    
    
   
   

   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

2）函数可以作为参数进行传递

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

// （1）定义一个函数，函数参数还是一个函数签名；f 表示函数名称;(Int,Int)表示输入两个 Int 参数；Int 表示函数返回值
def f1(f: (Int, Int) => Int): Int = {
f(2, 4)
}

// （2）定义一个函数，参数和返回值类型和 f1 的输入参数一致
def add(a: Int, b: Int): Int = a + b

// （3）将 add 函数作为参数传递给 f1 函数，如果能够推断出来不是调用，_可以省略
println(f1(add))
println(f1(add _))
//可以传递匿名函数
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

3）函数可以作为函数返回值返回

def main(args: Array[String]): Unit = {
 def f1() = {
 def f2() = {
 }
  f2 _
 }
 val f = f1()
 // 因为 f1 函数的返回值依然为函数，所以可以变量 f 可以作为函数继续调用
 f()
 // 上面的代码可以简化为
 f1()()
}

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

5.2.2 匿名函数

1）说明

没有名字的函数就是匿名函数。
(x: Int) => {函数体}
x: 表示输入参数类型;Int: 表示输入参数类型；函数体：表示具体代码逻辑

 
 

 
 
  • 1
  • 2
  • 3

2）案例实操

需求1：传递的函数有一个参数
传递匿名函数至简原则：
（1）参数的类型可以省略，会根据形参进行自动的推导
（2）类型省略之后，发现只有一个参数，则圆括号可以省略；其他情况：没有参数和参
数超过 1 的永远不能省略圆括号。
（3）匿名函数如果只有一行，则大括号也可以省略
（4）如果参数只出现一次，则参数省略且后面参数可以用_代替

def main(args: Array[String]): Unit = {
 // （1）定义一个函数：参数包含数据和逻辑函数
 def operation(arr: Array[Int], op: Int => Int) = {
  for (elem <- arr) yield op(elem)
 }
 // （2）定义逻辑函数
 def op(ele: Int): Int = {
  ele + 1
 }
 // （3）标准函数调用
 val arr = operation(Array(1, 2, 3, 4), op)
 println(arr.mkString(","))
 // （4）采用匿名函数
 val arr1 = operation(Array(1, 2, 3, 4), (ele: Int) => {
  ele + 1
 })
  println(arr1.mkString(","))
 // （4.1）参数的类型可以省略，会根据形参进行自动的推导;
 val arr2 = operation(Array(1, 2, 3, 4), (ele) => {
  ele + 1
 })
 println(arr2.mkString(","))
 // （4.2）类型省略之后，发现只有一个参数，则圆括号可以省略；其他情况：没有参数和参数超过 1 的永远不能省略圆括号。
 val arr3 = operation(Array(1, 2, 3, 4), ele => {
  ele + 1
 })
 println(arr3.mkString(","))
 // (4.3) 匿名函数如果只有一行，则大括号也可以省略
 val arr4 = operation(Array(1, 2, 3, 4), ele => ele + 1)
   println(arr4.mkString(","))
 //（4.4）如果参数只出现一次，则参数省略且后面参数可以用_代替
 val arr5 = operation(Array(1, 2, 3, 4), _ + 1)
   println(arr5.mkString(","))
 }
}

 
 

 
 

  
  
 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35

需求2：传递的函数有两个参数

object TestFunction {
 def main(args: Array[String]): Unit = {
 def calculator(a: Int, b: Int, op: (Int, Int) => Int): Int 
= {
  op(a, b)
 }
 // （1）标准版
 println(calculator(2, 3, (x: Int, y: Int) => {x + y}))
 // （2）如果只有一行，则大括号也可以省略
 println(calculator(2, 3, (x: Int, y: Int) => x + y))
 // （3）参数的类型可以省略，会根据形参进行自动的推导;
 println(calculator(2, 3, (x , y) => x + y))
 // （4）如果参数只出现一次，则参数省略且后面参数可以用_代替
 println(calculator(2, 3, _ + _))
 }
}

 
 

 
 

  
  
 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16

5.2.3 高阶函数案例（集合再将）

需求：模拟Map映射、Filter过滤、Reduce聚合

object TestFunction {
 def main(args: Array[String]): Unit = {
 // （1）map 映射
 def map(arr: Array[Int], op: Int => Int) = {
   for (elem <- arr) yield op(elem)
 }
 val arr = map(Array(1, 2, 3, 4), (x: Int) => {
  x * x
 })
 println(arr.mkString(","))
 // （2）filter 过滤。有参数，且参数再后面只使用一次，则参数省略且后面参数用_表示
 def filter(arr:Array[Int],op:Int =>Boolean) ={
 var arr1:ArrayBuffer[Int] = ArrayBuffer[Int]()
 for(elem <- arr if op(elem)){
   arr1.append(elem)
 }
 arr1.toArray
 }
 var arr1 = filter(Array(1, 2, 3, 4), _ % 2 == 1)
 println(arr1.mkString(","))
 // （3）reduce 聚合。有多个参数，且每个参数再后面只使用一次，则参数省略且后面参数用_表示，第 n 个_代表第 n 个参数
 def reduce(arr: Array[Int], op: (Int, Int) => Int) = {
 var init: Int = arr(0)
 for (elem <- 1 until arr.length) {
   init = op(init, elem)
 }
 init
 }
 //val arr2 = reduce(Array(1, 2, 3, 4), (x, y) => x * y)
 val arr2 = reduce(Array(1, 2, 3, 4), _ * _)
   println(arr2)
 }
}

 
 

 
 

  
  
 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33

5.2.4 函数柯里化&闭包

闭包：函数式编程的标配

1）说明

1、闭包：如果一个函数，访问到了它的外部（局部）变量的值，那么这个函数和他所处的环境，称为闭包
2、函数柯里化：把一个参数列表的多个参数，变成多个参数列表

2）案例实操

object TestFunction {
 def main(args: Array[String]): Unit = {
 def f1()={
 var a:Int = 10
 def f2(b:Int)={
   a + b
 }
 f2 _
 }
 // 在调用时，f1 函数执行完毕后，局部变量 a 应该随着栈空间释放掉
 val f = f1()
 // 但是在此处，变量 a 其实并没有释放，而是包含在了 f2 函数的内部，形成了闭合的效果
 println(f(3))

println(f1()(3))
// 函数柯里化，其实就是将复杂的参数逻辑变得简单化,函数柯里化一定存在闭包
def f3()(b:Int)={
a + b
}
println(f3()(3))
}
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22

5.2.5 递归

1）说明

一个函数/方法在函数/方法体内又调用了本身，我们称之为递归调用

2）案例实操

object TestFunction {
 def main(args: Array[String]): Unit = {
 // 阶乘
 // 递归算法
 // 1) 方法调用自身
 // 2) 方法必须要有跳出的逻辑
 // 3) 方法调用自身时，传递的参数应该有规律
 // 4) scala 中的递归必须声明函数返回值类型
 println(test(5))
 }
 def test(i : Int) : Int = {
 if (i == 1) {
  1
 } else {
  i * test(I - 1)
 }
 }
}

 
 

 
 

  
  
 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

5.2.6 控制抽象

1）值调用：把计算后的值传递过去

object TestControl {
 def main(args: Array[String]): Unit = {
 def f = ()=>{
 println("f...")
 10
 }
 foo(f())
 }
 def foo(a: Int):Unit = {
 println(a)
 println(a)
 }
}

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

2）名调用：把代码传递过去

object TestControl {
 def main(args: Array[String]): Unit = {
 def f = ()=>{
   println("f...")
   10
 }
 foo(f())
 }
//def foo(a: Int):Unit = {
 def foo(a: =>Int):Unit = {//注意这里变量 a 没有小括号了
   println(a)
   println(a)
 }
}
输出结果：
f...
10
f...
10 

 
 

 
 

  
  
 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

注意：Java只有值调用；Scala既有值调用，又有名调用。

3）案例实操

object TestFunction {
 def main(args: Array[String]): Unit = {
 // （1）传递代码块
 foo({
    println("aaa")
 })
 // （2）小括号可以省略
 foo{
   println("aaa")
 }
 }
 def foo(a: =>Unit):Unit = {
   println(a)
   println(a)
 }
}

 
 

 
 

  
  
 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16

自定义一个while循环

object TestFunction {
 def main(args: Array[String]): Unit = {
 var i:Int = 1
 myWhile(i <= 10){
   println(i)
   i +=1
 }
 }
 def myWhile(condition: =>Boolean)(op: =>Unit):Unit={
 if (condition){
  op
  myWhile(condition)(op)
 }
 }
}

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

5.2.7 惰性函数

1）说明

当函数返回值被声明为 lazy 时，函数的执行将被推迟，直到我们首次对此取值，该函
数才会执行。这种函数我们称之为惰性函数。

2）案例实操

def main(args: Array[String]): Unit = {
 lazy val res = sum(10, 30)
 println("----------------")
 println("res=" + res)
}
def sum(n1: Int, n2: Int): Int = {
 println("sum 被执行。。。")
 return n1 + n2
}

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

输出结果：

sum被执行。。。。
res = 40

注意：lazy不能修饰var类型的变量

下一章（第六章） 面向对象

某科学的南条
关注
专栏目录
Scala核心编程 第五章—Scala函数式编程基础
星星的博客
09-19 1万+
函数式编程 1.介绍 在学习Scala中将方法、函数、函数式编程和面向对象编程明确一下： 在scala中，方法和函数几乎可以等同(比如他们的定义、使用、运行机制都一样的)，只是函数的使用方式更加的灵活多样。 函数式编程是从编程方式(范式)的角度来谈的，可以这样理解：函数式编程把函数当做一等公民，充分利用函数、 支持的函数的多种使用方式。 比如： 在Scala当中，函数是一等公民，像变量...
Scala函数式编程
weixin_57342469的博客
07-31 1152
函数定义的方式函数1：无参，无返回值函数2：无参，有返回值函数3：有参，无返回值函数4：有参，有返回值函数5：多参，无返回值函数6：多参，有返回值// 函数的定义x+y// 使用方法，类中的函数print(function.add("张三"))// 函数的定义方式// 无参，无返回值def add1(): Unit = print("这是无参，无返回值的函数")// 无参，有返回值def add():String= "这是无参，有返回值的函数"// 有参，无返回值。
scala函数式编程
weixin_53898747的博客
04-03 1449
目录不同范式对比：1.面向对象编程2.函数式编程2.1函数基本语法2.2函数和方法的区别核心概念： 2.3函数定义 2.4函数参数2.5 函数至简原则2.6.高阶函数 三.偏函数四.柯里化函数五.递归函数递归函数注意点： 六.控制抽象1.值调用，把计算后的值传递过去， 2.名调用，把代码传递过去，七.惰性加载面向对象和面向过程都是命令式编程，但是函数式编程不关心具体运行过程，而是关心数据之间的映射。纯粹的函数式编程语言中没有变量，所有量都是常量，计算过程就是不停的表达式求值的过程，每一段程序都有返回值。不关
Scala函数式编程详解
weixin_40994552的博客
08-14 786
Scala 函数式编程 functional programming FP1 纯函数 PURE FUNCTIONS1.1 纯函数例子1.2 非纯函数1.3 写纯函数2 函数作为变量传递 PASSING FUNCTIONS AROUND3 函数式编程中不会用 null 值 NO NULL VALUES3.1 使用 Option/Some/None3.2 使用返回 Option 类型的函数3.3 理解 Option3.4 使用 foreach3.5 替代 null 值3.6 替代方案4 伴随对象 COMPAN
Scala 函数式编程
mengxianglong123的博客
11-02 729
scala编程语言将函数式编程和面向对象编程完美地融合在一起了。 面向对象编程 分解对象，行为，属性，然后通过对象的关系以及行为的调用来解决问题 函数式编程 将问题分解成一个一个的步骤，将每个步骤进行封装（函数），通过调用这些封装好的功能按照指定的步骤，解决问题。 一、基础函数编程 1.1 基本语法 [修饰符] def 函数名 ( 参数列表 ) [:返回值类型] = { 函数体 } private def test( s : String ) : Unit = { printl.
【scala】第五章—— 函数式编程
无邪的博客
11-23 123
1）面向对象编程解决问题，分解对象，行为，属性，然后通过对象的关系以及行为的调用来解决问题。对象：用户行为：登录、连接 JDBC、读取数据库属性：用户名、密码Scala 语言是一个完全面向对象编程语言。万物皆对象对象的本质：对数据和行为的一个封装2）函数式编程解决问题时，将问题分解成一个一个的步骤，将每个步骤进行封装（函数），通过调用这些封装好的步骤，解决问题。例如：请求->用户名、密码->连接 JDBC->读取数据库Scala 语言是一个完全函数式编程语言。万物皆函数。
Scala函数式编程课后习题答案（第六章）
dlke03的博客
05-23 1380
Scala函数式编程课后习题答案（第六章）
从Scala循环里看函数式编程
cxlmap的博客
01-31 326
我们用几分钟来想象一下自己是一名伐木工人，手里有林场里最好的斧子，因此你是工作效率最高的。突然有一天场里来了个推销的，他把一种新的砍树工具——链锯——给夸到了天上去。这人很有说服力，所以你也买了一把，不过你不懂得怎么用。你估摸着按照自己原来擅长的砍树方法，把链锯大力地挥向树干——不知道要先发动它。“链锯不过是时髦的样子货罢了”，没砍几下你就得出了这样的结论，于是把它丢到一边重新捡起用惯了的斧子。就...
第14讲-Scala编程详解：函数式编程
buzhidaoyaa的博客
10-21 191
引言 Scala中的函数是Java中完全没有的概念。因为Java是完全面向对象的编程语言，没有任何面向过程编程语言的特性，因此Java中的一等公民是类和对象，而且只有方法的概念，即寄存和依赖于类和对象中的方法。Java中的方法是绝对不可能脱离类和对象独立存在的。 而Scala是一门既面向对象，又面向过程的语言。因此在Scala中有非常好的面向对象的特性，可以使用Scala来基于面向对象的思想开发大...
Scala基础(10) 函数式编程
01-20
在本篇 Scala 基础教程的第 10 部分，我们将探讨函数式编程的概念及其在 Scala 中的应用。函数式编程是一种编程范式，它强调将计算视为数学函数的评估，避免可变状态和副作用。在 Scala 中，由于其与 Java 类似的...
2. Flink快速上手
howard2005的专栏
10-29 284
通过今天的实战，您应该已经了解了如何快速上手Apache Flink，并进行简单的批处理和流处理操作。希望这些内容能够帮助您在实际项目中更好地使用Flink。
记本地第一次运行seatunnel示例项目
大尾猴的博客
10-30 477
静态源码编译通过：https://blog.csdn.net/u011924665/article/details/143372464。
2024年，Rust开发语言，现在怎么样了?
LiangGang365的专栏
10-27 1174
Rust到底好不好用，最终还是要看具体的业务场景应用。比如，目前用Rust来编写纯UI的前端，可能还不是很成熟。但在内存管理、安全性和性能优化等领域，Rust无疑是一种非常优秀的语言选择。国内华为、字节、百度、阿里、美团等在通用组件、基础平台系统都在使用rust，其他国内数据库厂商、交易所、理想汽车、小鹏汽车等，以及大量在区块链、游戏行业提供的远程职位
Vue项目中动态路由与权限控制：router.beforeEach的使用及无token重定向登录页
Jiaberrr的博客
10-31 587
本文将详细介绍在Vue项目中如何使用router.beforeEach钩子函数动态添加权限路由，并在没有token时重定向到登录页，从而实现路由权限控制。
Nginx安装配置详解
最新发布
qq_40851623的博客
11-01 643
轻量级的Web服务器，主要有反向代理、负载均衡的功能。能够支撑5万的并发量，运行时内存和CPU占用低，配置简单，运行稳定。
预览 PDF 文档
a123456234的博客
10-29 696
在现代Web应用中，文件预览功能是非常常见的需求之一。特别是在企业级应用中，用户经常需要查看各种类型的文件，如 PDF、Word、Excel 等。本文将详细介绍如何在Vue项目中实现 PDF 文档的预览功能。 前端通过调用后端 API 获取文件的二进制数据，并将其转换为 Blob 对象。然后使用window.URL.createObjectURL 方法生成一个临时的 URL，最后通过 window.open 方法在新窗口中打开这个 URL，从而实现文件预览。
快速创建一个微信小程序，详细步骤以及示范程序代码
elirlove1的博客
10-25 3378
创建一个微信小程序涉及前端和后端的搭建与联调。以下是一个快速创建微信小程序的详细步骤以及示范程序代码。
scala 函数式编程 第三章
04-06
第三章介绍了Scala的函数和方法，以及它们的区别。具体内容如下： 1. 函数和方法的区别：函数是一段可以独立调用的代码，它可以像变量一样被传递、返回和赋值；而方法是属于某个对象或类的一段代码，它必须通过对象或类来调用。 2. 函数的定义方式：可以使用def关键字定义函数，也可以使用匿名函数（lambda表达式）。 3. 函数的参数：Scala的函数可以没有参数，也可以有多个参数。参数可以有默认值，也可以是可变参数。 4. 函数的返回值：Scala的函数可以没有返回值，也可以有返回值。返回值类型可以显式声明，也可以自动推断。 5. 方法的定义方式：方法必须定义在对象或类中，使用def关键字表示。方法可以有访问修饰符和参数列表，也可以有返回值类型和方法体。 6. 方法的参数：和函数一样，方法可以有多个参数，也可以有默认值和可变参数。 7. 方法的返回值：方法必须有返回值类型，如果没有显式声明，则默认返回Unit类型。 8. 函数和方法的调用：函数可以直接调用，也可以通过变量、高阶函数等方式调用；方法必须通过对象或类来调用。 9. 函数式编程的特点：函数式编程强调函数的纯粹性、不可变性和高阶函数的使用，它能够简化代码、提高可读性和可维护性。 总之，Scala的函数和方法都是非常重要的编程工具，它们可以让我们更加灵活地组织代码，提高开发效率和代码质量。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值