Skip to content

Commit 1eb3108

Browse files
benluojulienrf
authored andcommitted
add code tab in _zh-cn/overviews/scala3-book/fun-anonymous-functions.md
1 parent 5fc921b commit 1eb3108

File tree

1 file changed

+64
-1
lines changed

1 file changed

+64
-1
lines changed

_zh-cn/overviews/scala3-book/fun-anonymous-functions.md

+64-1
Original file line numberDiff line numberDiff line change
@@ -13,28 +13,39 @@ layout: multipage-overview
1313
permalink: "/zh-cn/scala3/book/:title.html"
1414
---
1515

16-
1716
匿名函数(也称为 *lambda*)是作为参数传递给高阶函数的代码块。
1817
维基百科将 [匿名函数](https://en.wikipedia.org/wiki/Anonymous_function) 定义为“未绑定到标识符的函数定义”。
1918

2019
例如,给定这样的列表:
2120

21+
{% tabs fun-anonymous-1 %}
22+
{% tab 'Scala 2 and 3' %}
2223
```scala
2324
val ints = List(1, 2, 3)
2425
```
26+
{% endtab %}
27+
{% endtabs %}
2528

2629
您可以通过使用 `List``map` 方法和自定义匿名函数将 `ints` 中的每个元素加倍来创建一个新列表:
2730

31+
{% tabs fun-anonymous-2 %}
32+
{% tab 'Scala 2 and 3' %}
2833
```scala
2934
val doubledInts = ints.map(_ * 2) // List(2, 4, 6)
3035
```
36+
{% endtab %}
37+
{% endtabs %}
3138

3239
如注释所示,`doubledInts` 包含列表`List(2, 4, 6)`
3340
在该示例中,这部分代码是一个匿名函数:
3441

42+
{% tabs fun-anonymous-3 %}
43+
{% tab 'Scala 2 and 3' %}
3544
```scala
3645
_ * 2
3746
```
47+
{% endtab %}
48+
{% endtabs %}
3849

3950
这是“将给定元素乘以 2”的简写方式。
4051

@@ -43,43 +54,63 @@ _ * 2
4354
一旦你熟悉了 Scala,你就会一直使用这种形式来编写匿名函数,这些函数在函数的一个位置使用一个变量。
4455
但如果你愿意,你也可以用更长的形式来写它们,所以除了写这段代码:
4556

57+
{% tabs fun-anonymous-4 %}
58+
{% tab 'Scala 2 and 3' %}
4659
```scala
4760
val doubledInts = ints.map(_ * 2)
4861
```
62+
{% endtab %}
63+
{% endtabs %}
4964

5065
您也可以使用以下形式编写它:
5166

67+
{% tabs fun-anonymous-5 %}
68+
{% tab 'Scala 2 and 3' %}
5269
```scala
5370
val doubledInts = ints.map((i: Int) => i * 2)
5471
val doubledInts = ints.map((i) => i * 2)
5572
val doubledInts = ints.map(i => i * 2)
5673
```
74+
{% endtab %}
75+
{% endtabs %}
5776

5877
所有这些行的含义完全相同:将 `ints` 中的每个元素加倍以创建一个新列表 `doubledInts`
5978
(稍后会解释每种形式的语法。)
6079

6180
如果您熟悉 Java,了解这些 `map` 示例与以下 Java 代码等价可能会有所帮助:
6281

82+
{% tabs fun-anonymous-5-b %}
83+
{% tab 'Java' %}
6384
```java
6485
List<Integer> ints = List.of(1, 2, 3);
6586
List<Integer> doubledInts = ints.stream()
6687
.map(i -> i * 2)
6788
.collect(Collectors.toList());
6889
```
90+
{% endtab %}
91+
{% endtabs %}
6992

7093
## 缩短匿名函数
7194

7295
当你想要明确时,你可以使用这个长格式编写一个匿名函数:
7396

97+
{% tabs fun-anonymous-6 %}
98+
{% tab 'Scala 2 and 3' %}
7499
```scala
75100
val doubledInts = ints.map((i: Int) => i * 2)
76101
```
102+
{% endtab %}
103+
{% endtabs %}
77104

78105
该表达式中的匿名函数是这样的:
79106

107+
{% tabs fun-anonymous-7 %}
108+
{% tab 'Scala 2 and 3' %}
80109
```scala
81110
(i: Int) => i * 2
82111
```
112+
{% endtab %}
113+
{% endtabs %}
83114

84115
如果您不熟悉这种语法,将 `=>` 符号视为转换器会有所帮助,因为表达式使用 `=>` 符号右侧的算法(在这种情况下,一个将 `Int` 加倍的表达式)把符号左侧的参数列表(名为 `i``Int` 变量) *转换*为新结果。
85116

@@ -88,52 +119,84 @@ val doubledInts = ints.map((i: Int) => i * 2)
88119
这种长形式可以缩短,如以下步骤所示。
89120
首先,这是最长和最明确的形式:
90121

122+
{% tabs fun-anonymous-8 %}
123+
{% tab 'Scala 2 and 3' %}
91124
```scala
92125
val doubledInts = ints.map((i: Int) => i * 2)
93126
```
127+
{% endtab %}
128+
{% endtabs %}
94129

95130
因为 Scala 编译器可以从 `ints` 中的数据推断 `i` 是一个 `Int`,所以可以删除 `Int` 声明:
96131

132+
{% tabs fun-anonymous-9 %}
133+
{% tab 'Scala 2 and 3' %}
97134
```scala
98135
val doubledInts = ints.map((i) => i * 2)
99136
```
137+
{% endtab %}
138+
{% endtabs %}
100139

101140
因为只有一个参数,所以不需要在参数 `i` 周围的括号:
102141

142+
{% tabs fun-anonymous-10 %}
143+
{% tab 'Scala 2 and 3' %}
103144
```scala
104145
val doubledInts = ints.map(i => i * 2)
105146
```
147+
{% endtab %}
148+
{% endtabs %}
106149

107150
因为当参数在函数中只出现一次时,Scala 允许您使用 `_` 符号而不是变量名,所以代码可以进一步简化:
108151

152+
{% tabs fun-anonymous-11 %}
153+
{% tab 'Scala 2 and 3' %}
109154
```scala
110155
val doubledInts = ints.map(_ * 2)
111156
```
157+
{% endtab %}
158+
{% endtabs %}
112159

113160
### 变得更短
114161

115162
在其他示例中,您可以进一步简化匿名函数。
116163
例如,从最显式的形式开始,您可以使用带有 `List``foreach` 方法的匿名函数打印 `ints` 中的每个元素:
117164

165+
{% tabs fun-anonymous-12 %}
166+
{% tab 'Scala 2 and 3' %}
118167
```scala
119168
ints.foreach((i: Int) => println(i))
120169
```
170+
{% endtab %}
171+
{% endtabs %}
121172

122173
和以前一样,不需要 `Int` 声明,因为只有一个参数,所以不需要 `i` 周围的括号:
123174

175+
{% tabs fun-anonymous-13 %}
176+
{% tab 'Scala 2 and 3' %}
124177
```scala
125178
ints.foreach(i => println(i))
126179
```
180+
{% endtab %}
181+
{% endtabs %}
127182

128183
因为 `i` 在函数体中只使用一次,表达式可以进一步简化为 `_` 符号:
129184

185+
{% tabs fun-anonymous-14 %}
186+
{% tab 'Scala 2 and 3' %}
130187
```scala
131188
ints.foreach(println(_))
132189
```
190+
{% endtab %}
191+
{% endtabs %}
133192

134193
最后,如果一个匿名函数由一个接受单个参数的方法调用组成,您不需要显式命名和指定参数,因此您最终可以只写方法的名称(此处为 `println`):
135194

195+
{% tabs fun-anonymous-15 %}
196+
{% tab 'Scala 2 and 3' %}
136197
```scala
137198
ints.foreach(println)
138199
```
200+
{% endtab %}
201+
{% endtabs %}
139202

0 commit comments

Comments
 (0)