新書推薦：
《
甲骨文丛书·剑桥世界暴力史（第一卷）：史前和古代世界（套装全2册）
》
售價：NT$
959.0
《
甲骨文丛书·中华早期帝国：秦汉史的重估
》
售價：NT$
1367.0
《
欲望与家庭小说
》
售價：NT$
449.0
《
惜华年（全两册）
》
售價：NT$
320.0
《
甲骨文丛书·古代中国的军事文化
》
售價：NT$
454.0
《
中国王朝内争实录（套装全4册）：从未见过的王朝内争编著史
》
售價：NT$
1112.0
《
半导体纳米器件：物理、技术和应用
》
售價：NT$
806.0
《
创客精选项目设计与制作 第2版 刘笑笑 颜志勇 严国陶
》
售價：NT$
281.0
|
| 編輯推薦： |
|
《函数式与并发编程》主要围绕两个主题:函数式编程和并发编程。本书主要使用Scala 编写代码示例，逐一讲解各编程特性的用法和注意事项，是一本不可多得的工具书，强烈推荐给程序员们。笔者周围的程序员提到这两个主题时都存在一定的畏难情绪，这是正常的，也是可以理解的。程序员不仅需要丰富的编程经验，还要具备深厚的编程设计思维，而这并非一朝一夕就能形成的，需要经年累月的实战和经验积累。我并不推荐读者将本书从头读到尾，这样不利于理解和消化书中的知识点。建议具备一定的函数式编程和并发编程基础的读者建立场景和问题，通过解决问题的方式来学习本书，并在遇到问题时查阅本书。本书也可作为理解这两个主题的途径。
|
| 內容簡介： |
现代语言支持的函数式和并发编程语言特性可能富有挑战性，即使是经验丰富的开发人员，当面对函数式与并发编程时，也可能心生畏惧。面向对象编程的程序员之所以畏惧这些特性，很可能是因为他们对这些特性的工作方式有所误解。为了消除误解，程序员应首先熟悉这些强大的特性背后的抽象概念。
《函数式与并发编程》介绍了一系列核心的编程语言结构，可让你的编程工作变得高效起来，无论你使用的是哪种编程语言，你都能从中获益——在当下的工作中，以及在未来的职业发展中。Charpentier用大量重点突出的小型Scala代码示例阐释了函数式与并发编程的关键概念，并通过完整的案例研究对前述技术和技巧进行深入的探究和阐释。这些技术和技巧将从一种语言传递到另一种语言——包括Java的最新版本。利用函数式和并发编程语言特性，开发人员和程序员将能编写出易于理解、调试、优化和改进的优质代码。
另外，本书还讨论了现代编程语言中常用的类型策略，包括类型推断、子类型、多态性、类型类、类型边界和变型。
核心主题
● 递归和尾递归
● 模式匹配和代数数据类型
● 可持久化结构和不可变性
● 高阶函数和lambda表达式
● 延迟求值和流
● 线程和线程池
● 原子性和锁
● 同步和线程安全对象
● 无锁、非阻塞模式
● Future、Promise和函数并发编程
《函数式与并发编程》中的大部分代码示例都是使用Scala编写的，其中包含函数式与并发编程的许多标准特性；然而，读者不必事先了解Scala，而只需要熟悉一些基本概念，如类、方法、对象、类型、变量、循环和条件语句等。此外，读者在编程方面应有足够的经验，以免因为简单的语法问题而分心。
|
| 關於作者： |
|
Michel Charpentier 是美国新罕布什尔大学(UNH)计算机科学系的副教授。多年来，他一直致力于分布式系统、正式验证以及移动传感器网络等领域的研究。自 1999 年以来，他一直在UNH工作，目前正在讲授编程语言、并发性、形式验证和模型检查等课程。
|
| 目錄：
|
第I部分 函数式编程
第1章 函数式编程的概念 3
1.1 什么是函数式编程 3
1.2 函数 4
1.3 从函数到函数式编程概念 5
1.4 小结 6
第2章 编程语言中的函数 7
2.1 定义函数 7
2.2 合成函数 8
2.3 定义为方法的函数 9
2.4 定义为方法的运算符 10
2.5 扩展方法 10
2.6 局部函数 11
2.7 重复参数 12
2.8 可选参数 13
2.9 命名参数 13
2.10 类型参数 14
2.11 小结 16
第3章 不可变性 17
3.1 纯函数和非纯函数 17
3.2 动作 18
3.3 表达式与语句 20
3.4 函数变量 22
3.5 不可变对象 23
3.6 可变状态的实现 24
3.7 函数式列表 25
3.8 混合编程 27
3.9 更新可变/不可变对象的集合 28
3.10 小结 30
第4章 案例研究：active-passive集合 31
4.1 面向对象设计 31
4.2 函数值 33
4.3 函数对象 35
4.4 小结 36
第5章 模式匹配与代数数据类型 38
5.1 函数开关 38
5.2 元组 39
5.3 选项 40
5.4 回顾函数式列表 41
5.5 树 43
5.6 示例：列表拉链 46
5.7 提取器 48
5.8 小结 49
第6章 递归程序设计 51
6.1 递归的必要性 51
6.2 递归算法 53
6.3 递归算法的关键原理 55
6.4 递归结构 56
6.5 尾递归 58
6.6 尾递归函数示例 60
6.7 小结 63
第7章 列表递归 64
7.1 等价的递归算法 64
7.2 遍历列表 65
7.3 返回列表 66
7.4 从执行堆栈中构建列表 68
7.5 多个/嵌套列表上的递归 69
7.6 除尾部以外的子列表递归 71
7.7 逆序创建列表 73
7.8 示例：排序 74
7.9 高效地构建列表 77
7.10 小结 78
第8章 案例研究：二叉搜索树 79
8.1 二叉搜索树 79
8.2 二叉搜索树的整数集 80
8.3 未重新平衡情况下的实现 81
8.4 自平衡树 86
8.5 小结 90
第9章 高阶函数 92
9.1 函数作为值 92
9.2 柯里化 95
9.3 函数字面量 96
9.4 函数与方法 99
9.5 单一抽象方法接口 100
9.6 部分应用 100
9.7 闭包 104
9.8 控制反转 107
9.9 小结 108
第10章 标准高阶函数 109
10.1 带有谓词参数的函数 109
10.2 映射和遍历 111
10.3 flatMap 112
10.4 fold和reduce 116
10.5 iterate、tabulate和unfold 118
10.6 sortWith、sortBy、maxBy和minBy 119
10.7 groupBy和groupMap 120
10.8 标准高阶函数的实现 121
10.9 foreach、map、flatMap和for推导式 122
10.10 小结 124
第11章 案例研究：文件树 125
11.1 设计概述 125
11.2 节点搜索辅助函数 126
11.3 字符串表示 126
11.4 构建树 128
11.5 查询 131
11.6 导航 135
11.7 树形拉链 135
11.8 小结 138
第12章 延迟计算 139
12.1 延迟求值的参数 139
12.2 按名称参数 140
12.3 控制抽象 142
12.4 内部领域特定语言 144
12.5 作为延迟求值列表的流 145
12.6 管道流 147
12.7 无限数据结构流 148
12.8 迭代 149
12.9 列表、流、迭代程序和视图 151
12.10 字段和局部变量的延迟求值 154
12.11 示例：子集和 155
12.12 小结 157
第13章 故障处理 158
13.1 例外情况和特殊值 158
13.2 使用Option 160
13.3 使用Try 160
13.4 使用Either 162
13.5 高阶函数和管道 163
13.6 小结 166
第14章 案例研究：蹦床 167
14.1 尾调用优化 167
14.2 用于尾调用的蹦床函数 168
14.3 Java中的尾调用优化 169
14.4 处理非尾调用 170
14.5 小结 174
第15章 类型(及相关概念) 175
15.1 类型策略 175
15.2 类型集合 179
15.3 类型服务 180
15.4 抽象数据类型 181
15.5 类型推断 182
15.6 子类型 185
15.7 多态性 188
15.8 类型变换 190
15.9 类型边界 195
15.10 类型类 199
15.11 小结 203
第Ⅱ部分 并发编程
第16章 并发编程的概念 208
16.1 非顺序程序 208
16.2 并发编程相关概念 211
16.3 小结 211
第17章 线程与不确定性 213
17.1 执行线程 213
17.2 使用lambda表达式创建线程 214
17.3 多线程程序的不确定性 215
17.4 线程终止 216
17.5 测试和调试多线程程序 218
17.6 小结 219
第18章 原子性和锁 220
18.1 原子性 220
18.2 非原子操作 222
18.3 原子操作和非原子复合操作 223
18.4 锁 226
18.5 内部锁 227
18.6 选择锁目标 229
18.7 小结 231
第19章 线程安全对象 232
19.1 不可变对象 232
19.2 封装同步策略 233
19.3 避免引用转义 234
19.4 公用锁和私有锁 235
19.5 利用不可变类型 236
19.6 线程安全 239
19.7 小结 240
第20章 案例研究：线程安全队列 242
20.1 作为列表对组的队列 242
20.2 单个公用锁的实现 242
20.3 单个私有锁的实现 245
20.4 应用锁拆分 247
20.5 小结 249
第21章 线程池 250
21.1 即发即弃异步执行 250
21.2 示例：并行服务器 252
21.3 不同类型的线程池 254
21.4 并行集合 256
21.5 小结 260
第22章 同步 261
22.1 同步的必要性 261
22.2 同步器 264
22.3 死锁 265
22.4 使用线程转储调试死锁 267
22.5 Java内存模型 268
22.6 小结 272
第23章 常用同步器 274
23.1 锁 274
23.2 锁存器和栅栏 276
23.3 信号量 278
23.4 条件 279
23.5 阻塞队列 284
23.6 小结 287
第24章 案例研究：并行执行 289
24.1 顺序引用实现 289
24.2 每个任务一个新线程 290
24.3 有界线程数 291
24.4 专用线程池 292
24.5 共享线程池 293
24.6 有界线程池 294
24.7 并行集合 295
24.8 使用条件提交异步任务 295
24.9 双信号量实现 299
24.10 小结 300
第25章 Future与Promise 302
25.1 函数任务 302
25.2 Future作为同步器 303
25.3 超时、故障和取消 306
25.4 Future变体 307
25.5 Promise 308
25.6 示例：线程安全缓存 309
25.7 小结 311
第26章 函数并发编程 312
26.1 阻塞的正确性和性能问题 312
26.2 回调 314
26.3 Future的高阶函数 316
26.4 Future的flatMap函数 318
26.5 示例：重新访问并行服务器 319
26.6 函数并发编程模式 322
26.7 小结 325
第27章 最小化线程阻塞 327
27.1 原子操作 327
27.2 无锁数据结构 330
27.3 fork/join池 332
27.4 异步编程 333
27.5 actor 334
27.6 反应流 337
27.7 非阻塞同步 338
27.8 小结 340
第28章 案例研究：并行策略 341
28.1 问题定义 341
28.2 带超时的顺序实现 342
28.3 使用invokeAny的并行实现 344
28.4 使用CompletionService的并行实现 345
28.5 Scala Future的异步实现 346
28.6 带有CompletableFuture的异步实现 348
28.7 缓存策略的结果 350
28.8 小结 353
—附录和词汇表通过扫描封底二维码获取—
附录 Java和Kotlin的特性 354
词汇表 381
|
| 內容試閱：
|
在开始阅读本书之前，最好先思考一下编程语言和编程语言特性之间的区别。我相信，若能依仗一套通用的编程语言特性，开发人员肯定能从中获益，而且，无论是现在还是将来，对这些特性的深入了解都将有助于他们在各种编程语言中高效发挥。
编程语言的世界丰富多样，并且一直在发展。作为一名开发人员，你需要适应变化并反复将编程技能从一种语言迁移至另一种语言。通过掌握一组核心特性，可以更加轻松地学习全新的编程语言。这些核心特性往往是当今编程语言所共享的，并且在许多未来的语言中也可能会用到。
本书运用了大量代码示例来说明编程语言的特性——这些示例主要运用Scala语言编写(原因将在稍后详述)。然而，这些概念在不同程度上与其他编程语言相关联，如Java、C 、Kotlin、Python、C#、Swift、Rust、Go、JavaScript之类的流行语言，以及任何未来可能出现的支持强类型以及函数式和/或并发编程的语言。
若要领悟语言和特性之间的区别，不妨考虑以下编程任务：
对给定列表中的每个数字执行随机移位(移位值在-10到10之间选取)。返回移位数字列表，并忽略所有非正值。
Java程序员可能会按如下方式实现所需的功能：
ListrandShift(Listnums，Randomrand){
varshiftedNums=newjava.util.ArrayList(nums.size());
for(intnum:nums){
intshifted=num rand.nextInt(-10，11);
if(shifted>0)shiftedNums.add(shifted);
}
returnshiftedNums;
}
Python程序员可能会按如下方式编写：
defrand_shift(nums，rand):
shifted_nums=[]
fornuminnums:
shifted=num rand.randrange(-10，11)
ifshifted>0:
shifted_nums.append(shifted)
returnshifted_nums
尽管它们是用两种不同的语言编写的，但这两段代码都遵循类似的原理：创建一个新的空列表以保存移位的数字，将每个原始数字随机移位，并仅在它们为正值时将新值添加到结果列表中。就思路和目的而言，这两个程序是相同的。
其他程序员可能会选择直接解决这个问题。下面是一个可能的Java变体：
ListrandShift(Listnums，Randomrand){
returnnums.stream()
.map(num->num rand.nextInt(-10，11))
.filter(shifted->shifted>0)
.toList();
}
这个实现的细节现在并不重要——它依赖于函数式编程概念，这将在本书第I部分中讨论。重要的是代码与先前的Java实现明显不同。
可以使用Python编写类似的函数变体：
defrand_shift(nums，rand):
returnlist(filter(lambdashifted:shifted>0，
map(lambdanum:num rand.randrange(-10，11)，nums)))
与第一个Python程序相比，这个实现显然更接近第二个Java变体。
这4个程序演示了解决最初那个问题的两种不同的方式。它们在Java或Python中将命令式实现与函数式实现进行对比。从根本上区分这些程序的不是语言(Java与Python)，而是它们使用的编程特性(命令式与函数式)。命令式变体(赋值语句、循环)和函数式变体(高阶函数、lambda表达式)中使用的编程语言特性独立于Java和Python而存在；事实上，它们在许多编程语言中都可用。
我并不是说编程语言无关紧要。我们都知道，对于一个给定的任务，某些语言要比其他语言更适用。但我想强调的是跨语言扩展的核心特性和概念，尽管它们出现在不同的语法下。例如，经验丰富的Python程序员更可能以如下方式编写示例函数程序：
defrand_shift(nums，rand):
return[shiftedforshiftedin(num rand.randrange(-10，11)fornuminnums)
ifshifted>0]
这段代码看起来与前面的Python代码不同——细节并不重要。注意，函数map和filter在任何地方都不可见。不过，从概念上讲，这是同一个程序，只不过使用了一种称为列表推导的特殊Python语法，而非map和filter。
这里需要理解的重要概念是map和filter(乃至更普遍的高阶函数，map和filter都是高阶函数的例子)而非列表推导。这种理解有两个方面的好处。首先，更多的语言支持高阶函数，而不是推导语法。例如，如果使用Java编程，则必须显式地(至少目前如此)编写map和filter。其次，如果所示语言使用了一种不太常见的语法，就像Python中的列表推导那样，那么一旦你意识到这只是你理解的某个概念的变体，就能更容易辨别出正在运行的是什么。
前面的代码示例说明了以简单命令式编程特性编写的程序与利用多种语言中可用的函数式编程特性编写的程序之间的区别。我可以对并发编程提出类似的论点。语言(和库)已经更新换代，不必像20年前那样编写今天的并发程序了。但是为了帮助你更深刻地认识这一点，不妨回到2004年，也就是Java1.4的时代，并思考以下问题：
给定两个任务，每个任务产生一个字符串，并行调用两个任务并返回产生的第一个字符串。
假设类型StringComputation具有字符串生成方法compute。在Java1.4中，此问题可以通过以下方式解决(不要试图理解代码；代码很长，细节不重要)：
StringfirstOf(finalStringComputationcomp1，finalStringComputationcomp2)
throwsInterruptedException{
classResult{
privateStringvalue=null;
publicsynchronizedvoidsetValue(Stringstr){
if(value==null){
value=str;
notifyAll();
}
}
publicsynchronizedStringgetValue()throwsInterruptedException{
while(value==null)
wait();
returnvalue;
}
}
finalResultresult=newResult();
Runnabletask1=newRunnable(){
publicvoidrun(){
result.setValue(comp1.compute());
}
};
Runnabletask2=newRunnable(){
publicvoidrun(){
result.setValue(comp2.compute());
}
};
newThread(task1).start();
newThread(task2).start();
returnresult.getValue();
}
此实现使用了你可能不熟悉的特性(详见本书第Ⅱ部分)。以下是需要注意的要点。
●代码长约30行。
●它依赖于同步方法，这是Java虚拟机(JVM)中可用的一种锁形式。
●它使用wait和notifyAll方法，这些方法在JVM上实现了基本的同步机制。
●它启动自己的两个线程来并行运行这两个任务。
下面快进到今天的Java，并重新实现该程序：
StringfirstOf(StringComputationcomp1，StringComputationcomp2，Executorthreads)
throwsInterruptedException，ExecutionException{
varresult=newCompletableFuture();
result.completeAsync(comp1::compute，threads);
result.completeAsync(comp2::compute，threads);
returnresult.get();
}
同样，忽略细节，并看以下这几点。
●代码更短。
●省略了类Result。它实现了一个自己的Future形式，但现在有很多语言可以使用Future，包括Java。
●没有同步方法。代码在任何地方都不依赖锁。
●没有wait和notifyAll方法。相反，CompletableFuture正确而高效地实现了自己的同步。
●没有显式创建线程。相反，线程以Executor的形式作为参数传递，并且可以与应用程序的其他部分共享。
我想强调的是，这两种变体之间还有一个不同之处。在新代码中，两个Runnable类已消失，且已被一种奇怪的语法所取代，这种语法在Java1.4:comp1::compute中并不存在。你可能会觉得这种语法令人费解，因为compute方法似乎缺少括号。实际上，此代码不调用compute，而是将方法本身用作completeAsync的参数。它可以改为lambda表达式：comp1::compute与()->comp1.compute()相同。将函数作为参数传递给函数，是函数式编程的一个基本理念(这将在本书第Ⅰ部分进行详细的探讨)，编写并发代码时也经常使用。
这个示例的重点是：即使仍然可以用今天的Java编写第一个版本的程序，也不应该这么做。因为很难保持多线程代码的正确性，而若要让它正确并高效，则是难上加难。相反，应该借助语言中可用的内容并有效地利用它。你是否充分利用了当前使用的编程语言？
一种趋势是，编程语言正变得越来越抽象，而其特性却越来越丰富，这一转变使得许多编程任务的要求降低了。与Java1相比，Java19包含更多需要理解的概念，但使用Java19编写正确而高效的程序比使用Java1更容易。特性丰富的编程语言可能更难学习，但一旦掌握，你就会认识到它们的强大。
当然，一种方案的难度很大程度上取决于各人的编程背景，而且重要的是清晰地区分“简单”和“熟悉”的概念。前面介绍的Java和Python程序的函数式变体并不比命令式变体更复杂，但对于某些程序员来说肯定不那么熟悉。事实上，程序员在Java或Python中从命令式变体转换到函数式变体(反之亦然)比在相同的命令式或函数式风格中从Java转换到Python(反之亦然)要更难。后一种转换主要是语法问题，而第一种转换需要范式转变。
当前特性丰富的编程语言的大多数优点都聚焦于函数式编程、并发和类型——它们正是本书的三个主题。一个普遍的趋势是为开发人员提供抽象，使他们可以不必编写非必要的实现细节，而不必编写的代码就是无漏洞代码。
例如，jump和goto很早就被高级编程语言所抛弃，取而代之的是结构化循环。但是，许多循环本身就可以使用一组标准的高阶函数来替换。类似地，直接用线程和锁来编写并发程序可能非常具有挑战性。相反，依赖线程池、特性和其他机制，可以生成更简单的模式。在许多情况下，除非必须编写自己的哈希映射或排序方法，否则没有必要使用循环和锁：这是不必要的工作，容易出错，而且不太可能达到现有实现的性能。至于类型，其安全性(能够捕捉错误)和灵活性(不必在设计选择中受过度的约束)之间一直存在对立，这种对立通常可以由安全、灵活但复杂的类型系统来解决。
本书并不是一本全面的综合指南，并未涵盖函数式和并发编程或者类型的方方面面。但是，若想在日常编程中利用现代语言构造，则需要熟悉这些特性背后的抽象概念。例如，应用函数模式比了解lambda表达式的语法更重要。本书只介绍有效使用语言特性所需的基本概念。本书所涵盖的内容非常有限，仅仅揭示了函数式和并发编程以及类型相关知识的冰山一角(Scala也是如此)。更深入的主题还有待你通过其他途径探索。
选择Scala的理由
如前所述，本书中的大部分代码示例都是用Scala编写的。这可能不是你最熟悉的语言，也可能不是你开发下一个应用程序时计划使用的语言。因此，你可能会很自然地问我为什么选择它而非更主流的语言。
Scala是一种旨在结合面向对象编程和函数式编程的语言，同时对并发性有很好的支持。它是一种混合式语言，也称为多范式语言。事实上，之前使用Java和Python编写的随机移位程序的3个版本都可以用Scala编写：
defrandShift(nums:List[Int]，rand:Random):List[Int]={
valshiftedNums=List.newBuilder[Int]
for(num<-nums){
valshifted=num rand.between(-10，11)
if(shifted>0){
shiftedNums =shifted
}
}
shiftedNums.result()
}
defrandShift(nums:List[Int]，rand:Random):List[Int]=
nums.view
.map(num=>num rand.between(-10，11))
.filter(shifted=>shifted>0)
.toList
defrandShift(nums:List[Int]，rand:Random):List[Int]=
for{
num<-nums
shifted=num rand.between(-10，11)
ifshifted>0
}yieldshifted
第一个函数是命令式的，基于迭代和可变列表。第二个变体是函数式的，它显式地使用了map和filter。最后一个变体依赖于Scala中的for推导式，这是一种类似于Python的列表推导式(但比它更强大)的机制。
还可以使用Scala编写并发问题的简洁解决方案。它用到了Future和线程池，就像前面的Java程序：
deffirstOf(comp1:StringComputation，comp2:StringComputation)
(usingExecutionContext):String={
valfuture1=Future(comp1.compute())
valfuture2=Future(comp2.compute())
Await.result(Future.firstCompletedOf(Set(future1，future2))，timeout)
}
考虑到本书的主旨，将Scala用作代码示例的好处有以下几点。首先，这种语言特性丰富，可以在不切换语言的情况下阐释许多概念。Scala不但拥有函数式和并发编程的许多标准特性，还具有强大的类型系统。其次，Scala是最近才推出的，它设计得很精致(通常也很巧妙)。与早期的语言相比，Scala被用于讨论基础概念时没有那么多历史包袱。最后，Scala语法非常传统，大多数程序员都可以直接上手。
然而，重要的是谨记本书的重点是编程语言特性，而非Scala。虽然我个人喜欢将其用作一种教学语言，但我并非在推销Scala。这也不是一本Scala的教科书。这一切皆因我恰好需要一种在我涉猎的所有领域都有简洁表现的编程语言，而我相信Scala满足以上所有要求。
目标读者
本书的目标读者是有足够经验的程序员，他们不会因为简单的语法问题而分心。我假设读者具有一定的Java经验，或者有足够的整体编程经验来阅读和理解简单的Java代码。本书读者应熟悉类、方法、对象、类型、变量、循环和条件等概念。读者还应基本理解程序执行(执行堆栈、垃圾回收、异常)，以及数据结构和算法。有关书中深入介绍的其他关键术语的基本定义与涉及的章节，可以参阅术语表(通过扫描封底二维码获取)。
不必事先了解函数式编程或并发编程，也不必事先了解Scala。许多读者可能对函数式或并发概念(如递归或锁)有一定的了解，但这并不是必需的。例如，不要求能理解前面讨论的函数式Python和Java程序，或者两个Java并发程序，或者最后两个Scala函数。事实上，如果你认为这些程序有点奇怪和难以理解，那么本书是为你量身打造的！相比之下，数字移位程序的命令式变体应该很容易理解，我希望你能够理解所有与之对应的代码，无论它是用Java、Python，还是用Scala编写的。如果Scala的语法与其他语言的语法相似，你应该能理解简单的Scala语法，并能掌握新引入的元素。
Scala的语法受到了Java语法的启发，而Java的语法又受到了C语法的启发——大多数程序员都能快速适应此承接及过渡。Scala与Java的不同之处将在介绍代码示例时一一说明。现在，我只强调三点不同。
●分号推理。在Scala中，终止分号是由编译器推断出来的并且很少显式使用。它们可能会偶尔出现，例如，用于将两个语句放在同一行。
●不需要“return”。尽管Scala中存在return关键字，但它很少被使用。相反，函数会隐式返回其主体中计算的最后一个表达式的值。
●符号缩进。用于定义代码块的大括号通常可以从缩进中推断出来，并且它们是可选的。第一个ScalarandShift变体可以写成如下形式：
defrandShift(nums:List[Int]，rand:Random):List[Int]=
valshiftedNums=List.newBuilder[Int]
fornum<-numsdo
valshifted=num rand.between(-10，11)
ifshifted>0thenshiftedNums =shifted
endfor
shiftedNums.result()
endrandShift
当使用缩进来创建块时，可以添加标记来强调块结尾，但它们是任意的。randShift函数的更短版本采用以下形式：
defrandShift(nums:List[Int]，rand:Random):List[Int]=
valshiftedNums=List.newBuilder[Int]
fornum<-numsdo
valshifted=num rand.between(-10，11)
ifshifted>0thenshiftedNums =shifted
shiftedNums.result()
在本书中，代码示例一般情况下依赖于缩进而不是大括号，并且为了紧凑起见省略了大多数结束标记。希望读者能够阅读这种形式的命令式Scala代码，就像前面的函数一样。
如何阅读本书
本书的主要价值在于它的代码示例(扫描封底二维码即可下载完整代码示例)。在很大程度上，文本仅是用来描述代码的。代码示例往往很短，并侧重于要阐释的概念。特别是，很少有示例被设计用于执行日常编程中需要解决的特定任务。这并非一本食谱。
而且，本书将从头开始引入概念，从基本原理开始，并向应用程序级别进行扩展和抽象。而最具应用性的代码往往集中在各个部分的最后章节。这种安排最有助于深入理解那些可以在之后被转换成Scala之外的其他语言的特性。如果你感觉前面讲述的主题过于简单，节奏太慢，请一定要耐住性子。
建议按从头至尾的顺序阅读本书。大多数章节及代码示例都是以开头几章介绍的想法和程序为基础展开的。例如，同一问题的多种解决方案通常散布在不同的章节，以阐释不同的编程语言特性集。同样，关于并发编程的第Ⅱ部分也使用了第Ⅰ部分关于函数式编程的概念。
虽然不建议随机浏览本书内容，但你仍旧可以快速浏览关于熟知的特性的部分。对于那些将本书用作教材的本科生和研究生而言，只要能理解代码，便可直接进入下一部分。若觉得代码费解，就应该放慢速度，留意文本中的解释。
可以通过以下方式安全地跳过某些内容。
●关于类型的第15章可以被完全跳过。在本书的其他章节，几个代码示例简化了假设，以避免类型边界和类型变换之类的复杂概念。基本了解Java类型，包括泛型(但不一定要使用通配符)和多态性，就足够了。
●任何补充知识(如“关于作用域”)都可以被安全地忽略。你可能会发现这些补充知识都是作为参考内容而设计的，鉴于这本书的主题(我不想让你失望)，而且它们可能很长，在正文中也很少被提及，这些参考性的知识都可以被忽略。
●任何“案例研究”章节都可以被跳过。不过，不建议你这样做，因为案例研究的代码采用了最有趣的方式来组合特性。而且所有的案例研究涉及的概念或语法全都来自前述章节而非后述章节。正文通常不会提及案例研究中的代码，只有一个小例外：10.8节提到的一个二叉搜索树的高级实现位于第8章。
|
|
購物車/收銀台(0) | 在線留言板
| 付款方式
| 聯絡我們
| 運費計算
| 幫助中心 |
加入書簽
HOME
新書上架
