4、Scala函数式基础

一、内置控制结构

创新互联建站服务项目包括吉州网站建设、吉州网站制作、吉州网页制作以及吉州网络营销策划等。多年来，我们专注于互联网行业，利用自身积累的技术优势、行业经验、深度合作伙伴关系等，向广大中小型企业、政府机构等提供互联网行业的解决方案，吉州网站推广取得了明显的社会效益与经济效益。目前，我们服务的客户以成都为中心已经辐射到吉州省份的部分城市，未来相信会继续扩大服务区域并继续获得客户的支持与信任！

1、if表达式

val filenameNice = if (!args.isEmpty) args(0) else "default.txt"

2、while循环

不管是while还是do...while，我们都不能叫做表达式，而应该叫做循环，因为它们不会计算出一个新值。它们的值类型是Unit，在scala中Unit和()是相等的

def gcdLoop(x: Long, y: Long): Long = {

var a = x

var b = y

while (a != 0) {

val temp = a

a = b % a

b = temp

}

do...while...表达式

var line = ""

do {

line = scala.io.StdIn.readLine()

println("Read: " + line)

} while (line != "")

在scala中给var重新赋值，永远都是返回()(即Unit)

() != ""将永远返回true

var tempLine = ""

while ((tempLine = scala.io.StdIn.readLine()) != "") // This doesn't work!

println("Read: " + tempLine)

因为while循环不计算出值，所以while的代码不那么的函数式，一般都会含有var变量，

scala选择保留while是因为有些场景使用while的代码的可读性还是很强的

采用递归来消除掉var

def gcd(x: Long, y: Long): Long =

if (y == 0) x else gcd(y, x % y)

3、for表达式

用for表达式迭代一个任意集合

val filesHere = (new java.io.File(".")).listFiles

for (file <- filesHere)

println(file)

for表达式中的过滤

for (

file <- filesHere

if file.isFile

if file.getName.endsWith(".scala")

) println(file)

嵌套迭代(nested iteration)

def grep(pattern: String) =

for (

file <- filesHere

if file.getName.endsWith(".scala");

line <- fileLines(file)

if line.trim.matches(pattern)

) println(file + ": " + line.trim)

可以在迭代的过程中，绑定中间值到一个变量

上面的()可以换成{}，这样每一个语句后面的分号就可以省略

def grepBindValue(pattern: String) =

for {

file <- filesHere

if file.getName.endsWith(".scala")

line <- fileLines(file)

trimmed = line.trim

if trimmed.matches(pattern)

} println(file + ": " + trimmed)

for ... yield ... 可以生成一个新的集合

//返回的是Array，是因为filesHere的类型是Array

def scalaFiles: Array[File] =

for {

file <- filesHere

if file.getName.endsWith(".scala")

} yield file

val forLineLengths: List[Int] =

for {

file <- filesHere.toList

if file.getName.endsWith(".scala")

line <- fileLines(file)

trimmed = line.trim

if trimmed.matches(".*object.*")

} yield trimmed.length

4、异常处理

scala中抛异常使用throw关键字，异常的捕获用catch关键字。捕获到异常后，可以计算并返回一个值

val n = 5

val half: Int =

if (n % 2 == 0)

n / 2

else

throw new RuntimeException("n must be even")

println(half)

try {

//val f = new FileReader("input.txt") //这个会抛FileNotFoundException

// Use and close file

throw new IOException("test")

} catch {

case e @(_: FileNotFoundException | _: IOException) => {

// Handle missing file

println("All Exception = " + e.getMessage)

}

case ex: Exception => {

// Handle other I/O error

println("IOException = " + ex.getMessage)

}

val file = new FileReader("input.txt")

try {

// Use the file

} finally {

file.close() // Be sure to close the file

}

5、break和continue

非得使用break的话，我们可以使用scala.util.control中的break

import scala.util.control.Breaks._

import java.io._

val in = new BufferedReader(new InputStreamReader(System.in))

breakable {

while (true) {

println("? ")

if (in.readLine() == "") break

}

二、函数

1、本地函数。定义在函数内部的函数为本地函数，智能被此函数内部调用。

def processFile(filename: String, width: Int) = {

//本地函数

def processLine(line: String) = {

if (line.length > width)

println(filename + ": " + line.trim)

}

val source = Source.fromFile(filename)

for (line <- source.getLines())

processLine(line)

}

2、first class function 函数可以作为函数的参数进行传递

3、函数的参数

不定长参数

def echo(args: String*) =

for (arg <- args) println(arg)

使用参数名字来给参数设置值

def speed(distance: Float, time: Float): Float =

distance / time

speed(distance = 100, time = 10)

默认参数值

def printTime(out: java.io.PrintStream = Console.out) =

out.println("time = " + System.currentTimeMillis())

printTime()

printTime(Console.err)

4、函数闭包

函数捕获一个自由变量而变成一个闭包。每次调用函数的时候都产生一个新的闭包。

var more = 1

val addMore = (x: Int) => x + more //函数捕获一个自由变量而变成一个闭包

addMore(10)

当自由变量的值改变的时候，闭包对自由变量的改变也是可以捕获的到

more = 9999

addMore(10)

val someNumbers = List(-11, -10, -5, 0, 5, 10)

var sum = 0

someNumbers.foreach(sum += _)

println(sum)

5、尾递归

什么是尾递归呢？如果调用自身方法的动作是函数体的最后一个动作的话，那么这个递归就是一个尾递归

递归：更函数式、简洁以及没有var，但是函数的调用可能会消耗点时间。while循环是命令式编程，可能会更高效的，因为没有方法的调用。但是如果是尾递归的话，编译器是会优化的，其效率和while循环是一样的

可以使用注解tailrec来标志是否为尾递归

@tailrec

def boom(x: Int): Int =

if (x == 0) throw new Exception("boom!")

else boom(x - 1)

尾递归的限制，以下递归，不会进行尾递归优化，因为jvm的指令集使得尾递归的优化受限

递归调用的函数不是函数体所在的函数

def isEven(x: Int): Boolean =

if (x == 0) true else isOdd(x - 1)

def isOdd(x: Int): Boolean =

if (x == 0) false else isEven(x - 1)

三、高阶函数及函数柯里化

高阶函数(high-order functions)就是用函数作为参数的函数。高阶函数可以减少冗余代码，高阶函数可以使得客户端代码简洁。

def filesEnding(query: String) =

for (file <- filesHere; if file.getName.endsWith(query))

yield file

def filesContaining(query: String) =

for (file <- filesHere; if file.getName.contains(query))

yield file

改造后：

private def filesMatching(matcher: String => Boolean) =

for (file <- filesHere; if matcher(file.getName))

yield file

柯里化

//柯里化函数(curring function)

def curriedSum(x: Int)(y: Int) = x + y

curriedSum(1)(2)

//说明柯里化的过程

def first(x: Int) = (y: Int) => x + y

val second = first(1)

second(2)

示例：自定义循环控制语句

var i = 10

while (i == 0) {

i -= 1

println(i)

}

until(i == 0) {

i -= 1

println(i)

}

def until(condition: => Boolean)(block: => Unit) {

if (!condition) {

block

until(condition)(block)

}

by name by value

by name 执行的时候才执行，by value调用就执行

//by-name parameter

def byNameAssert(predicate: => Boolean) =

if (assertionsEnabled && !predicate)

throw new AssertionError

byNameAssert(5 > 3)

//by-value parameter

def boolAssert(predicate: Boolean) =

if (assertionsEnabled && !predicate)

throw new AssertionError

boolAssert(5 > 3)

分享标题：4、Scala函数式基础
网址分享：http://cdiso.cn/article/pdpgdh.html

4、Scala函数式基础

其他资讯