函数式编程

Scala 也是一种函数式编程语言，其函数也能当成值来应用。Scala 提供了轻量级的语法用以定义匿名函数，反对高阶函数，容许嵌套多层函数，并反对柯里化。Scala 的 case class 及其内置的模式匹配相当于函数式编程语言中罕用的代数类型。

在 Scala 中，存在办法和函数两个概念，办法和函数在语义上区别很细小。
Scala 中的办法跟 Java 的相似，办法是组成类的一部分。scala 中的函数则是一个残缺的对象。
Scala 中办法和函数在语法上区别不大，只是类中申明的函数咱们叫办法，办法有重载和重写，而函数则没有。

1. 一般函数编程

1.1 根本语法

[修饰符] def 函数名 (参数列表) [: 返回值类型] = {函数体}

示例

object Scala_Fun {def main(args: Array[String]): Unit = {test("hello")
  }

  /**
   * 一般函数示例
   * @param str
   */
  private def test(str:String):Unit = {println(str)
  }
}

1.2 函数定义

object Scala_Fun {def main(args: Array[String]): Unit = {
    // 无参，无返回值
    def fun1(): Unit ={println("无参且无返回值")
    }
    
    // 无参，有返回值
    def fun2(): String ={
      // 能够省略 return
      "张三" 
    }
    
    // 有参，无返回值
    def fun3(str:String): Unit ={println(str)
    }
    
    // 有参，有返回值
    def fun4(str:String): String ={"hello:"+ str}
    
    // 关键字参数
  }

}

1.3 函数参数

object Scala_Fun {def main(args: Array[String]): Unit = {
    // 可变参数
    def fun1(names:String*): Unit ={println(names)
    }
    fun1("张三","李四")

    // 可变参数不能搁置在参数列表的后面，个别放在参数列表的最初
    // 如果学过 python，会发现传参这里跟 python 传参很类似
    /*    谬误示范
    def fun2(names:String*, count:Int): Unit ={ }*/
    def fun2(count:Int,names:String*): Int ={println(names)
      count
    }

    // 参数默认值
    def fun3(name:String, age:Int = 18): Unit ={println(name+ ":" + age)
    }
    
    // 命名传参
    fun3(name="张三")

  }
  
}

1.4 函数精简准则

object Scala_Fun {def main(args: Array[String]): Unit = {
    // Scala 中函数能够进行精简，所谓是能省则省，当然前提是编译器能够主动推断
    def fun1(name:String): String ={return "姓名:"+name}

    // 1. 当函数有返回值时，能够将函数体中最初一行执行的代码作为返回后果，所以能够省略 return 关键字
    def fun2(name:String): String ={"fun2:"+name}
    println(fun2("张三"))

    // 2. 如果编译器能够推断出函数的返回值类型，返回值类型则能够省略
    def fun3(name:String)={"fun3:"+name}
    println(fun3("张三"))

    // 3. 如果函数体逻辑只有一行代码，则函数体的大括号能够省略
    def fun4(name:String) = "fun4:"+name
    println(fun4("张三"))

    // 4. 如果函数没有参数，调用时候，小括号能够省略
    def fun5(): String ={"fun5"}
    println(fun5)

    // 5. 如果函数没有提供参数，那申明时，小括号能够省略，调用时，也不能应用小括号
    def fun6 = "fun6"
    println(fun6)

    // 6. 如果函数应用 Unit 申明没有返回值，那函数体中的 return 关键字不会起作用。/*
    def fun7():Unit={return "张三"}*/
    // 7. 函数体中如果应用 return 关键字，则返回值不能省略
    def fun8():String = {"fun8"}
    // 8. 如果函数没有返回值，Unit 又不想用，那能够同时省略等号，但保留花括号
    def fun9(){println("张三")
    }

    // 9. 匿名函数：当只关怀代码逻辑，不关怀函数名时，则函数名和 def 关键字能够省略
    // 匿名函数规定：(参数列表) => {函数逻辑}
    val fun10 = (name:String)=>println(name)
    fun10("张三")

   }

}

2. 高阶函数编程

2.1 什么是高阶函数和柯里化 Currying

1）数学概念

回顾下数学知识：
y=f(x) 这是最开始接触的一般函数
y=g(f(x)) 这个就是咱们接触到的高阶函数

在数学和计算机科学中，高阶函数至多该当是满足上面一个条件的函数：
1）承受一个或者多个函数作为参数
2）输入一个函数

程序中咱们的高阶函数也相似

2）柯里化 Currying
柯里化：指的是将原来承受两个参数的函数变成新的接管一个参数的函数, 新的函数返回一个以原有第二个参数为参数的函数
z = f(x, y) 转换成 z =f(x)(y)

2.2 函数作为值

object Scala_Fun {def main(args: Array[String]): Unit = {def fun1():String = {"张三"}
    val v1 = fun1() // 调用函数，把函数的返回后果赋值给变量 v1
    val v2 = fun1 _ // 把函数作为值赋值给变量 v2
    println(v1)
    println(v2)

   }

}

2.3 函数作为参数

object Scala_Fun {def main(args: Array[String]): Unit = {def fun1():String = {"张三"}

    def fun2(fun:()=>String): Unit ={println(fun())
    }
    fun2(fun1)

   }

}

2.4 把函数作为返回值

object Scala_Fun {def main(args: Array[String]): Unit = {def fun1():String = {"张三"}

    def fun2() = {fun1 _}
    println(fun2()())

   }

}

2.5 闭包

函数在应用内部变量时，如果内部变量生效时，会将这个变量蕴含到以后的函数外部，造成闭合的成果，这个就是闭包。
匿名函数自身就是一种闭包。
代码示例

object Scala_Fun {def main(args: Array[String]): Unit = {def outFun(i:Int) ={def inFun(j:Int) = {i + j}
      inFun _
    }
    val res = outFun(10)(10)
    println(res)
  }

}

2.6 惰性函数

惰性函数，也就是提早加载，直到咱们首次对此取值，该函数才会执行，应用 lazy 关键字申明其返回值时，就会造成惰性函数。
示例：

object Scala_Fun {def main(args: Array[String]): Unit = {def fun():String = {println("张三")
      "张三"
    }
    lazy val res = fun()
    println(res)
  }

}

2.7 函数柯里化

object Scala_Fun {def main(args: Array[String]): Unit = {
    // 应用柯里化形式申明函数
    def fun1(a:Int,b:Int,f:(Int,Int)=>Int):Unit = { }
    def fun2(a:Int)(b:Int)(f:(Int,Int)=>Int) = {f(a,b)
    }
    // 调用函数
    println(fun2(10)(20)(_ + _))
  }

}

学过 Python 的话，会发现这里的高阶函数和 Python 的高阶函数大同小异。