@@ -16,76 +16,118 @@ permalink: "/zh-cn/scala3/book/:title.html"
16
16
17
17
从上一节回到这个例子:
18
18
19
+ {% tabs fun-function-variables-1 %}
20
+ {% tab 'Scala 2 and 3' %}
19
21
``` scala
20
22
val doubledInts = ints.map((i : Int ) => i * 2 )
21
23
```
24
+ {% endtab %}
25
+ {% endtabs %}
22
26
23
27
我们注意到这部分表达式是一个匿名函数:
24
28
29
+ {% tabs fun-function-variables-2 %}
30
+ {% tab 'Scala 2 and 3' %}
25
31
``` scala
26
32
(i : Int ) => i * 2
27
33
```
34
+ {% endtab %}
35
+ {% endtabs %}
28
36
29
37
它被称为 * 匿名* 的原因是它没有分配给变量,因此没有名称。
30
38
31
39
但是,可以将匿名函数(也称为* 函数字面量* )分配给变量以创建* 函数变量* :
32
40
41
+ {% tabs fun-function-variables-3 %}
42
+ {% tab 'Scala 2 and 3' %}
33
43
``` scala
34
44
val double = (i : Int ) => i * 2
35
45
```
46
+ {% endtab %}
47
+ {% endtabs %}
36
48
37
49
这将创建一个名为 ` double ` 的函数变量。
38
50
在这个表达式中,原始函数字面量在 ` = ` 符号的右侧:
39
51
52
+ {% tabs fun-function-variables-4 %}
53
+ {% tab 'Scala 2 and 3' %}
40
54
``` scala
41
55
val double = (i : Int ) => i * 2
42
56
-----------------
43
57
```
58
+ {% endtab %}
59
+ {% endtabs %}
44
60
45
61
新变量名在左侧:
46
62
63
+ {% tabs fun-function-variables-5 %}
64
+ {% tab 'Scala 2 and 3' %}
47
65
``` scala
48
66
val double = (i : Int ) => i * 2
49
67
------
50
68
```
69
+ {% endtab %}
70
+ {% endtabs %}
51
71
52
72
并且函数的参数列表在此处加下划线:
53
73
74
+ {% tabs fun-function-variables-6 %}
75
+ {% tab 'Scala 2 and 3' %}
54
76
``` scala
55
77
val double = (i : Int ) => i * 2
56
78
--------
57
79
```
80
+ {% endtab %}
81
+ {% endtabs %}
58
82
59
83
就像方法的参数列表一样,这意味着 ` double ` 函数有一个参数,一个名为 ` i ` 的 ` Int ` 。
60
84
你可以在 REPL 中看到 ` double ` 的类型为 ` Int => Int ` ,这意味着它接受一个 ` Int ` 参数并返回一个 ` Int ` :
61
85
86
+ {% tabs fun-function-variables-7 %}
87
+ {% tab 'Scala 2 and 3' %}
62
88
``` scala
63
89
scala> val double = (i : Int ) => i * 2
64
90
val double : Int => Int = ...
65
91
```
92
+ {% endtab %}
93
+ {% endtabs %}
66
94
67
95
### 调用函数
68
96
69
97
现在你可以像这样调用` double ` 函数:
70
98
99
+ {% tabs fun-function-variables-8 %}
100
+ {% tab 'Scala 2 and 3' %}
71
101
``` scala
72
102
val x = double(2 ) // 4
73
103
```
104
+ {% endtab %}
105
+ {% endtabs %}
74
106
75
107
您还可以将 ` double ` 传递给 ` map ` 调用:
76
108
109
+ {% tabs fun-function-variables-9 %}
110
+ {% tab 'Scala 2 and 3' %}
77
111
``` scala
78
112
List (1 , 2 , 3 ).map(double) // List(2, 4, 6)
79
113
```
114
+ {% endtab %}
115
+ {% endtabs %}
80
116
81
117
此外,当您有 ` Int => Int ` 类型的其他函数时:
82
118
119
+ {% tabs fun-function-variables-10 %}
120
+ {% tab 'Scala 2 and 3' %}
83
121
``` scala
84
122
val triple = (i : Int ) => i * 3
85
123
```
124
+ {% endtab %}
125
+ {% endtabs %}
86
126
87
127
您可以将它们存储在 ` List ` 或 ` Map ` 中:
88
128
129
+ {% tabs fun-function-variables-11 %}
130
+ {% tab 'Scala 2 and 3' %}
89
131
``` scala
90
132
val functionList = List (double, triple)
91
133
@@ -94,9 +136,13 @@ val functionMap = Map(
94
136
" 3x" -> triple
95
137
)
96
138
```
139
+ {% endtab %}
140
+ {% endtabs %}
97
141
98
142
如果将这些表达式粘贴到 REPL 中,您会看到它们具有以下类型:
99
143
144
+ {% tabs fun-function-variables-12 %}
145
+ {% tab 'Scala 2 and 3' %}
100
146
````
101
147
// a List that contains functions of the type `Int => Int`
102
148
functionList: List[Int => Int]
@@ -105,6 +151,8 @@ functionList: List[Int => Int]
105
151
// values have the type `Int => Int`
106
152
functionMap: Map[String, Int => Int]
107
153
````
154
+ {% endtab %}
155
+ {% endtabs %}
108
156
109
157
## 关键点
110
158
0 commit comments