Skip to content

Commit 69a362b

Browse files
authored
add code tabs in node num3 (#2578)
1 parent bace447 commit 69a362b

File tree

1 file changed

+87
-0
lines changed

1 file changed

+87
-0
lines changed

_zh-cn/overviews/scala3-book/why-scala-3.md

Lines changed: 87 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -42,15 +42,21 @@ Scala 比任何其他语言都更支持 FP 和 OOP 范式的融合。
4242
模块化的一些最佳示例可能是标准库中的类。
4343
例如,`List` 被定义为一个类---从技术上讲,它是一个抽象类---并且像这样创建了一个新实例:
4444

45+
{% tabs list %}
46+
{% tab 'Scala 2 and 3' for=list %}
4547
```scala
4648
val x = List(1, 2, 3)
4749
```
50+
{% endtab %}
51+
{% endtabs %}
4852

4953
但是,在程序员看来是一个简单的 `List` 实际上是由几种特殊类型的组合构建的,包括名为`Iterable`, `Seq`, 和 `LinearSeq` 的 traits。
5054
这些类型同样由其他小型的模块化代码单元组成。
5155

5256
除了从一系列模块化 traits 构建/cases像 `List` 这样的类型之外,`List` API还包含数十种其他方法,其中许多是高阶函数:
5357

58+
{% tabs list %}
59+
{% tab 'Scala 2 and 3' for=list-methods %}
5460
```scala
5561
val xs = List(1, 2, 3, 4, 5)
5662

@@ -59,6 +65,8 @@ xs.filter(_ < 3) // List(1, 2)
5965
xs.find(_ > 3) // Some(4)
6066
xs.takeWhile(_ < 3) // List(1, 2)
6167
```
68+
{% endtab %}
69+
{% endtabs %}
6270

6371
在这些示例中,无法修改列表中的值。
6472
`List` 类是不可变的,因此所有这些方法都返回新值,如每个注释中的数据所示。
@@ -68,30 +76,44 @@ xs.takeWhile(_ < 3) // List(1, 2)
6876
Scala的 _类型推断_ 经常使语言感觉是动态类型的,即使它是静态类型的。
6977
对于变量声明,情况确实如此:
7078

79+
{% tabs list %}
80+
{% tab 'Scala 2 and 3' for=dynamic %}
7181
```scala
7282
val a = 1
7383
val b = "Hello, world"
7484
val c = List(1,2,3,4,5)
7585
val stuff = ("fish", 42, 1_234.5)
7686
```
87+
{% endtab %}
88+
{% endtabs %}
7789

7890
当把匿名函数传递给高阶函数时,情况也是如此:
7991

92+
{% tabs list %}
93+
{% tab 'Scala 2 and 3' for=dynamic-hof %}
8094
```scala
8195
list.filter(_ < 4)
8296
list.map(_ * 2)
8397
list.filter(_ < 4)
8498
.map(_ * 2)
8599
```
100+
{% endtab %}
101+
{% endtabs %}
86102

87103
还有定义方法的时候:
88104

105+
{% tabs list %}
106+
{% tab 'Scala 2 and 3' for=list-method %}
89107
```scala
90108
def add(a: Int, b: Int) = a + b
91109
```
110+
{% endtab %}
111+
{% endtabs %}
92112

93113
这在Scala 3中比以往任何时候都更加真实,例如在使用[union types][union-types] 时:
94114

115+
{% tabs union %}
116+
{% tab 'Scala 3 Only' for=union %}
95117
```scala
96118
// union type parameter
97119
def help(id: Username | Password) =
@@ -103,19 +125,27 @@ def help(id: Username | Password) =
103125
// union type value
104126
val b: Password | Username = if (true) name else password
105127
```
128+
{% endtab %}
129+
{% endtabs %}
106130

107131
## 3) 简洁的语法
108132

109133
Scala是一种 low ceremony,“简洁但仍然可读”的语言。例如,变量声明是简洁的:
110134

135+
{% tabs list %}
136+
{% tab 'Scala 2 and 3' for=concise %}
111137
```scala
112138
val a = 1
113139
val b = "Hello, world"
114140
val c = List(1,2,3)
115141
```
142+
{% endtab %}
143+
{% endtabs %}
116144

117145
创建类型如traits, 类和枚举都很简洁:
118146

147+
{% tabs enum %}
148+
{% tab 'Scala 3 Only' for=enum %}
119149
```scala
120150
trait Tail:
121151
def wagTail(): Unit
@@ -132,13 +162,19 @@ case class Person(
132162
age: Int
133163
)
134164
```
165+
{% endtab %}
166+
{% endtabs %}
135167

136168
简洁的高阶函数:
137169

170+
{% tabs list-hof %}
171+
{% tab 'Scala 2 and 3' for=list-hof %}
138172
```scala
139173
list.filter(_ < 4)
140174
list.map(_ * 2)
141175
```
176+
{% endtab %}
177+
{% endtabs %}
142178

143179
所有这些表达方式以及更多表达方式都很简洁,并且仍然非常易读:我们称之为 _富有表现力_
144180

@@ -215,6 +251,8 @@ Scala.js 生态系统 [有几十个库](https://www.scala-js.org/libraries) 让
215251

216252
这里有些例子:
217253

254+
{% tabs list %}
255+
{% tab 'Scala 2 and 3' for=list-more %}
218256
```scala
219257
List.range(1, 3) // List(1, 2)
220258
List.range(start = 1, end = 6, step = 2) // List(1, 3, 5)
@@ -253,34 +291,50 @@ nums.sorted // List(1, 5, 7, 8, 10)
253291
nums.sortWith(_ < _) // List(1, 5, 7, 8, 10)
254292
nums.sortWith(_ > _) // List(10, 8, 7, 5, 1)
255293
```
294+
{% endtab %}
295+
{% endtabs %}
256296

257297
## 8) 内置最佳实践
258298

259299
Scala 习语以多种方式鼓励最佳实践。
260300
对于不可变性,我们鼓励您创建不可变的 `val` 声明:
261301

302+
{% tabs list %}
303+
{% tab 'Scala 2 and 3' for=val %}
262304
```scala
263305
val a = 1 // 不可变变量
264306
```
307+
{% endtab %}
308+
{% endtabs %}
265309

266310
还鼓励您使用不可变集合类,例如 `List``Map`
267311

312+
{% tabs list %}
313+
{% tab 'Scala 2 and 3' for=list-map %}
268314
```scala
269315
val b = List(1,2,3) // List 是不可变的
270316
val c = Map(1 -> "one") // Map 是不可变的
271317
```
318+
{% endtab %}
319+
{% endtabs %}
272320

273321
样例类主要用于 [领域建模]({% link _zh-cn/overviews/scala3-book/domain-modeling-intro.md %}),它们的参数是不可变的:
274322

323+
{% tabs list %}
324+
{% tab 'Scala 2 and 3' for=case-class %}
275325
```scala
276326
case class Person(name: String)
277327
val p = Person("Michael Scott")
278328
p.name // Michael Scott
279329
p.name = "Joe" // 编译器错误(重新分配给 val 名称)
280330
```
331+
{% endtab %}
332+
{% endtabs %}
281333

282334
如上一节所示,Scala 集合类支持高阶函数,您可以将方法(未显示)和匿名函数传递给它们:
283335

336+
{% tabs list %}
337+
{% tab 'Scala 2 and 3' for=higher-order %}
284338
```scala
285339
a.dropWhile(_ < 25)
286340
a.filter(_ < 25)
@@ -289,23 +343,52 @@ a.filter(_ < 30).map(_ * 10)
289343
nums.sortWith(_ < _)
290344
nums.sortWith(_ > _)
291345
```
346+
{% endtab %}
347+
{% endtabs %}
292348

293349
`match` 表达式让您可以使用模式匹配,它们确实是返回值的 _表达式_
294350

351+
{% tabs match class=tabs-scala-version %}
352+
{% tab 'Scala 2' for=match %}
353+
```scala
354+
val numAsString = i match {
355+
case 1 | 3 | 5 | 7 | 9 => "odd"
356+
case 2 | 4 | 6 | 8 | 10 => "even"
357+
case _ => "too big"
358+
}
359+
```
360+
{% endtab %}
361+
362+
{% tab 'Scala 3' for=match %}
295363
```scala
296364
val numAsString = i match
297365
case 1 | 3 | 5 | 7 | 9 => "odd"
298366
case 2 | 4 | 6 | 8 | 10 => "even"
299367
case _ => "too big"
300368
```
369+
{% endtab %}
370+
{% endtabs %}
301371

302372
因为它们可以返回值,所以它们经常被用作方法的主体:
303373

374+
{% tabs match-body class=tabs-scala-version %}
375+
{% tab 'Scala 2' for=match-body %}
376+
```scala
377+
def isTruthy(a: Matchable) = a match {
378+
case 0 | "" => false
379+
case _ => true
380+
}
381+
```
382+
{% endtab %}
383+
384+
{% tab 'Scala 3' for=match-body %}
304385
```scala
305386
def isTruthy(a: Matchable) = a match
306387
case 0 | "" => false
307388
case _ => true
308389
```
390+
{% endtab %}
391+
{% endtabs %}
309392

310393
## 9) 生态系统库
311394

@@ -373,6 +456,8 @@ _安全_ 与几个新的和改变的特性有关:
373456

374457
_人体工程学_ 的好例子是枚举和扩展方法,它们以非常易读的方式添加到 Scala 3 中:
375458

459+
{% tabs extension %}
460+
{% tab 'Scala 3 Only' for=extension %}
376461
```scala
377462
// 枚举
378463
enum Color:
@@ -384,6 +469,8 @@ extension (c: Circle)
384469
def diameter: Double = c.radius * 2
385470
def area: Double = math.Pi * c.radius * c.radius
386471
```
472+
{% endtab %}
473+
{% endtabs %}
387474

388475
_性能_ 涉及几个方面。
389476
其中之一是 [不透明类型][opaque-types]

0 commit comments

Comments
 (0)