函数基础语法-CSDN博客

本文链接：https://blog.csdn.net/2402_89806763/article/details/146900699

函数基本语法

基本语法

案例实操

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

object TestFunction {

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

// （1）函数定义

def f(arg: String): Unit = {

println(arg)

}

// （2）函数调用

// 函数名（参数）

f("hello world")

}

1. 1. 函数和方法的区别
核心概念
1. 为完成某一功能的程序语句的集合，称为函数。
2. 类中的函数称之方法。
案例实操

Scala 语言可以在任何的语法结构中声明任何的语法
函数没有重载和重写的概念；方法可以进行重载和重写
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 ={

println("函数可以嵌套定义")

}

函数定义函1：无参，无返回值函数 2：无参，有返回值函数 3：有参，无返回值函数 4：有参，有返回值函数 5：多参，无返回值函数 6：多参，有返回值2）案例实操函数参数案例实操可变参数如果参数列表中存在多个参数，那么可变参数一般放置在最后参数默认值，一般将有默认值的参数放置在参数列表的后面带名参数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 = {

函数至简原则（重点）函数至简原则：能省则省至简原则细节return 可以省略，Scala 会使用函数体的最后一行代码作为返回值如果函数体只有一行代码，可以省略花括号返回值类型略def f8 = "dalang"//println(f8()) println(f8)//（9）如果不关心名称，只关心逻辑处理，那么函数名（def）可以省略def f9 = (x:String)=>{println("wu如果能够推断出来，那么可以省略（:和返回值类型一起省略）如果有 return，则不能省略返回值类型，必须指定如果函数明确声明unit，那么即使函数体中使用 return 关键字也不起作用Scala 如果期望是无返回值类型，可以省略等号如果函数无参，但是声明了参数列表，那么调用时，小括号，可加可不加如果函数没有参数列表，那么小括号可以省略，调用时小括号必须省略如果不关心名称，只关心逻辑处理，那么函数名（def）可以省略案例实操

wu略def f8 = "dalang"//println(f8()) println(f8)//（9）如果不关心名称，只关心逻辑处理，那么函数名（def）可以省略def f9 = (x:String)=>{println("wu

匿名函数说明没有名字的函数就是匿名函数。(x:Int)=>{函数体}x：表示输入参数类型；Int：表示输入参数类型；函数体：表示具体代码逻辑2）案例实操需求 1：传递的函数有一个参数传递匿名函数至简原则：参数的类型可以省略，会根据形参进行自动的推导类型省略之后，发现只有一个参数，则圆括号可以省略；其他情况：没有参数和参数超过 1 的永远不能省略圆括号。匿名函数如果只有一行，则大括号也可以省略如果参数只出现一次，则参数省略且后面参数可以用_代替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})

扩展练习练习 1：定义一个匿名函数，并将它作为值赋给变量 fun。函数有三个参数，类型分别为 Int，String，Char，返回值类型为Boolean。要求调用函数 fun(0, “”, ‘0’)得到返回值为 false，其它情况均返回 true。练习 2：定义一个函数 func，它接收一个 Int 类型的参数，返回一个函数（记作 f1）。它返回的函数 f1，接收一个 String 类型的参数，同样返回一个函数（记作 f2）。函数 f2 接收一个 Char 类型的参数，返回一个Boolean 的值。要求调用函数 func(0) (“”) (‘0’)得到返回值为 false，其它情况均返回 true。

高阶函数案例需求：模拟 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）闭包

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

控制抽象值调用：把计算后的值传递过去object TestControl {def main(args: Array[String]): Unit = { def f = ()=>{println("f...")

名调用：把代码传递过去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 = {println(a)}}输出结果：f... 10 f...10注意：Java 只有值调用；Scala 既有值调用，又有名调用。案例实操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)}}自定义一个 While 循环object TestFunction {def main(args: Array[String]): Unit = { var i:Int = 1myWhile(i <= 10){ println(i)i +=1}}def myWhile(condition: =>Boolean)(op: =>Unit):Unit={ if (condition){op myWhile(condition)(op)}}}惰性加载说明

当函数返回值被声明为 lazy 时，函数的执行将被推迟，直到我们首次对此取值，该函数才会执行。这种函数我们称之为惰性函数。案例实操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}输出结果：----------------sum 被执行。。。res=40注意：lazy 不能修饰 var 类型的变量