当前位置：网站首页>10 advanced functions of scala

10 advanced functions of scala

2022-08-10 15:21:00 【S_ng】

包括：
1) 函数传名调用
2) Specify the function parameter name to call
3) 可变参数的函数
4) 默认参数值函数
5) 递归函数
6) 高阶函数
7) 内嵌函数
8) 匿名函数
9) 偏应用函数
10) 函数柯里化
1) 函数传名调用
o 概念说明
         传值调用：先计算参数表达式的值,再应用到函数内部,
        把=>去掉即可,That is, in the original way
         传名调用：将未计算的参数表达式直接应用到函数内部,
        用=>to set up call by name
o 应用示例-传值 
object TestCallByValue {
def main(args: Array[String]) {
delayedCalculator(transmitMe());
}
def transmitMe(): String = {
println("我在 transmitMe 方法中!")
return "transmitMe 返回值"; }
def delayedCalculator(t: String): Unit = {
println("在 delayedCalculator 方法--开始")
println("Formally call the passed function： " + t)
println("在 delayedCalculator 方法--结束") } }

o 应用示例-传名 
object TestCallByName {
def main(args: Array[String]) {
delayedCalculator(transmitMe());
}
def transmitMe(): String = {
println("我在 transmitMe 方法中!")
return "transmitMe 返回值";
}
def delayedCalculator(t: => String): Unit = {
println("在 delayedCalculator 方法--开始")
println("Formally call the passed function： " + t)
println("在 delayedCalculator 方法--结束")
}
}
2)Specify the function parameter name to call 
object TestCallByParaName {
def main(args: Array[String]) {
printBabyNames(second = "张二", first = "张一");
}
def printBabyNames(first: String, second: String): Unit 
= {
println("The first child called=" + first);
println("The second child called=" + second);
} }
3)可变(不定长)参数的函数
object TestNonFixParas {
def main(args: Array[String]) {
printAllParasValue("one", "two", "three", "four");
}
def printAllParasValue(paras: String*): Unit = {
for (temp <- paras) {
println(temp);
} }
}
4)默认参数值函数 
object TestDefaultParaFunction {
def main(args: Array[String]) {
println("Use the default return value entirely : " + salaryMoney());
println("Some return values ​​using default values : " + salaryMoney(10));
println("Some return values ​​using default values : " + salaryMoney(10,10000));
}
def salaryMoney(a: Int = 5, unit: Int = 1000): Int = {
return a * unit
} }
5)递归函数
object TestRecusive {
def main(args: Array[String]) {
var n=4
println(n+"的阶乘为="+myFactorial(n))
}
def myFactorial(n: Int): Int = {
if (n <= 1)
return 1
else
return n * myFactorial(n - 1) } }
6)高阶函数
概念说明
第一种：Take one function as an argument to another function,即参数为
函数的函数
第二种：返回值是函数的函数,That is, higher-order functions can produce functions
o 应用示例
参数为函数的函数 
object TestHighFunctionByTransmitFunctionPara {
def main(args: Array[String]) {
delayedCalculator(transmitMe());
}
def transmitMe(): String = {
println("我在 transmitMe 方法中!")
return "transmitMe 返回值"; }
def delayedCalculator(t: => String): Unit = {
println("在 delayedCalculator 方法--开始")
println("Formally call the passed function： " + t)
println("在 delayedCalculator 方法--结束") } }
返回值是函数的函数
object TestHighFunctionByRetFunction {
def main(args: Array[String]) {
var mySalaryFun=multiplyBy(1000);
println(mySalaryFun(10));
}
def multiplyBy(salaryUnit:Int)=(x:Int)=>salaryUnit*x }
7)内嵌函数
o 概念介绍
函数内定义函数,定义在函数内的函数称之为局部函数,
Also called an inline function
o 应用示例 
object TestEmbedFunction {
def main(args: Array[String]) {
var msg="HelloWorld";
printMessage(msg);
}
def printMessage(msg: String): Unit = {
def printMessageInner(msg: String): Unit = {
println(msg);
}
printMessageInner(msg);
} }
8)匿名函数
o 概念介绍
A function without a function name
使代码更简洁,用=>来表示,On the left is the parameter list,letter on the right
数体
o 应用示例
Anonymous usage（Increment the value+1 的函数实现） 
函数定义：
var inc = (x:Int) => x+1
函数使用：
var x = inc(8)+1
9)偏应用函数
o 概念说明
不需要提供函数需要的所有参数,只需要提供部分,或不
提供所需参数
实现方法：A part of the parameters of the bound function,For the unbound part"_"代
替,Thereby forming a partial application function to use
o 应用示例
传统方法实现（Say hello to someone）
import java.util.Date
object TestPartialParasFunction {
def main(args: Array[String]) {
val name="张三"
sayHello(name, "上午好")
Thread.sleep(1000)
sayHello(name, "中午好")
Thread.sleep(1000)
sayHello(name, "晚上好") }
def sayHello(name: String, message: String) 
= {
println(name + "----" + message) } }
Partially applied function implementation（Say hello to someone）
def main(args: Array[String]) {
val name="张三"
val partialSay=sayHello(name,_:String);
partialSay("上午好")
Thread.sleep(1000)
partialSay("中午好")
Thread.sleep(1000)
partialSay("晚上好") }
def sayHello(name: String, message: String) = {
println(name + "----" + message) }
10) 函数柯里化
o 概念说明
Turn the original function that takes two arguments into a new function that takes one argument
的过程.The new function returns a function that takes the original second argument as an argument
数.
Improved flexibility of usage
o 应用举例
传统实现 add 方法定义
def add(x: Int, y: Int) = x + y;
传统实现 add 方法使用 
def main(args: Array[String]) {
println(add(3,4));
}
def add(x: Int, y: Int) = x + y;
柯里化实现 add 方法定义 
def add(x:Int)(y:Int) = x + y
 柯里化实现 add 方法使用
object TestCurryingFunction {
def main(args: Array[String]) {
//Corresponds to the curried form 1 的使用
var curryingAdd1 = add1(3)
//Corresponds to the curried form 2 的使用
var curryingAdd2 = add2(3)(_)
println(curryingAdd1(4));
println(curryingAdd1(4));
}
//Curried form 1
def add1(x: Int) = (y: Int) => x + y;
//Curried form 2
def add2(x: Int)(y: Int) = x + y; }

原网站

版权声明
本文为[S_ng]所创，转载请带上原文链接，感谢
https://yzsam.com/2022/222/202208101443547783.html

边栏推荐

猜你喜欢

随机推荐