@@ -25,48 +25,74 @@ permalink: "/zh-cn/scala3/book/:title.html"
25
25
鉴于该声明,您可以开始构建 ` greet ` 。
26
26
你知道这将是一种方法:
27
27
28
+ {% tabs fun-write-method-returns-function-1 %}
29
+ {% tab 'Scala 2 and 3' %}
28
30
``` scala
29
31
def greet ()
30
32
```
33
+ {% endtab %}
34
+ {% endtabs %}
31
35
32
36
您还知道此方法将返回一个函数,该函数 (a) 采用 ` String ` 参数,并且 (b) 使用 ` println ` 打印该字符串。
33
37
因此,该函数的类型为 ` String => Unit ` :
34
38
39
+ {% tabs fun-write-method-returns-function-2 %}
40
+ {% tab 'Scala 2 and 3' %}
35
41
``` scala
36
42
def greet (): String => Unit = ???
37
43
----------------
38
44
```
45
+ {% endtab %}
46
+ {% endtabs %}
39
47
40
48
现在你只需要一个方法体。
41
49
您知道该方法需要返回一个函数,并且该函数接受一个“字符串”并打印它。
42
50
此匿名函数与该描述匹配:
43
51
52
+ {% tabs fun-write-method-returns-function-3 %}
53
+ {% tab 'Scala 2 and 3' %}
44
54
``` scala
45
55
(name : String ) => println(s " Hello, $name" )
46
56
```
57
+ {% endtab %}
58
+ {% endtabs %}
47
59
48
60
现在您只需从方法中返回该函数:
49
61
62
+ {% tabs fun-write-method-returns-function-4 %}
63
+ {% tab 'Scala 2 and 3' %}
50
64
``` scala
51
65
// a method that returns a function
52
66
def greet (): String => Unit =
53
67
(name : String ) => println(s " Hello, $name" )
54
68
```
69
+ {% endtab %}
70
+ {% endtabs %}
55
71
56
72
因为这个方法返回一个函数,所以你可以通过调用` greet() ` 来得到这个函数。
57
73
这是在 REPL 中做的一个很好的步骤,因为它验证了新函数的类型:
58
74
75
+ {% tabs fun-write-method-returns-function-5 %}
76
+ {% tab 'Scala 2 and 3' %}
59
77
````
78
+ {% endtab %}
79
+ {% endtabs %}
60
80
scala> val greetFunction = greet()
61
81
val greetFunction: String => Unit = Lambda....
62
82
-----------------------------------------
63
83
````
84
+ {% endtab %}
85
+ {% endtabs %}
64
86
65
87
现在你可以调用` greetFunction ` 了:
66
88
89
+ {% tabs fun-write-method-returns-function-6 %}
90
+ {% tab 'Scala 2 and 3' %}
67
91
``` scala
68
92
greetFunction(" Joe" ) // prints "Hello, Joe"
69
93
```
94
+ {% endtab %}
95
+ {% endtabs %}
70
96
71
97
恭喜,您刚刚创建了一个返回函数的方法,然后执行了该函数。
72
98
@@ -75,36 +101,52 @@ greetFunction("Joe") // prints "Hello, Joe"
75
101
如果您可以传递问候语,我们的方法会更有用,所以让我们这样做。
76
102
您所要做的就是将问候语作为参数传递给 ` greet ` 方法,并在 ` println ` 中的字符串中使用它:
77
103
104
+ {% tabs fun-write-method-returns-function-7 %}
105
+ {% tab 'Scala 2 and 3' %}
78
106
``` scala
79
107
def greet (theGreeting : String ): String => Unit =
80
108
(name : String ) => println(s " $theGreeting, $name" )
81
109
```
110
+ {% endtab %}
111
+ {% endtabs %}
82
112
83
113
现在,当您调用您的方法时,该过程更加灵活,因为您可以更改问候语。
84
114
当您从此方法创建函数时,它是这样的:
85
115
116
+ {% tabs fun-write-method-returns-function-8 %}
117
+ {% tab 'Scala 2 and 3' %}
86
118
````
87
119
scala> val sayHello = greet("Hello")
88
120
val sayHello: String => Unit = Lambda.....
89
121
----------------------
90
122
````
123
+ {% endtab %}
124
+ {% endtabs %}
91
125
92
126
REPL 类型签名输出显示 ` sayHello ` 是一个接受 ` String ` 输入参数并返回 ` Unit ` (无)的函数。
93
127
所以现在当你给 ` sayHello ` 一个 ` String ` 时,它会打印问候语:
94
128
129
+ {% tabs fun-write-method-returns-function-9 %}
130
+ {% tab 'Scala 2 and 3' %}
95
131
``` scala
96
132
sayHello(" Joe" ) // prints "Hello, Joe"
97
133
```
134
+ {% endtab %}
135
+ {% endtabs %}
98
136
99
137
您还可以根据需要更改问候语以创建新函数:
100
138
139
+ {% tabs fun-write-method-returns-function-10 %}
140
+ {% tab 'Scala 2 and 3' %}
101
141
``` scala
102
142
val sayCiao = greet(" Ciao" )
103
143
val sayHola = greet(" Hola" )
104
144
105
145
sayCiao(" Isabella" ) // prints "Ciao, Isabella"
106
146
sayHola(" Carlos" ) // prints "Hola, Carlos"
107
147
```
148
+ {% endtab %}
149
+ {% endtabs %}
108
150
109
151
## 一个更真实的例子
110
152
@@ -117,27 +159,53 @@ sayHola("Carlos") // prints "Hola, Carlos"
117
159
此外,由于该函数会打印给定的字符串,因此您知道它的类型为 ` String => Unit ` 。
118
160
使用该信息编写方法签名:
119
161
162
+ {% tabs fun-write-method-returns-function-11 %}
163
+ {% tab 'Scala 2 and 3' %}
120
164
``` scala
121
165
def createGreetingFunction (desiredLanguage : String ): String => Unit = ???
122
166
```
167
+ {% endtab %}
168
+ {% endtabs %}
123
169
124
170
接下来,因为您知道可能返回的函数接受一个字符串并打印它,所以您可以为英语和法语编写两个匿名函数:
125
171
172
+ {% tabs fun-write-method-returns-function-12 %}
173
+ {% tab 'Scala 2 and 3' %}
126
174
``` scala
127
175
(name : String ) => println(s " 你好, $name" )
128
176
(name : String ) => println(s " Bonjour, $name" )
129
177
```
178
+ {% endtab %}
179
+ {% endtabs %}
130
180
131
181
在方法内部,如果你给这些匿名函数起一些名字,它可能会更易读,所以让我们将它们分配给两个变量:
132
182
183
+ {% tabs fun-write-method-returns-function-13 %}
184
+ {% tab 'Scala 2 and 3' %}
133
185
``` scala
134
186
val englishGreeting = (name : String ) => println(s " Hello, $name" )
135
187
val frenchGreeting = (name : String ) => println(s " Bonjour, $name" )
136
188
```
189
+ {% endtab %}
190
+ {% endtabs %}
137
191
138
192
现在您需要做的就是 (a) 如果 ` desiredLanguage ` 是英语,则返回 ` englishGreeting ` ,并且 (b) 如果 ` desiredLanguage ` 是法语,则返回 ` frenchGreeting ` 。
139
193
一种方法是使用 ` match ` 表达式:
140
194
195
+ {% tabs fun-write-method-returns-function-14 class=tabs-scala-version %}
196
+ {% tab 'Scala 2' %}
197
+ ``` scala
198
+ def createGreetingFunction (desiredLanguage : String ): String => Unit = {
199
+ val englishGreeting = (name : String ) => println(s " Hello, $name" )
200
+ val frenchGreeting = (name : String ) => println(s " Bonjour, $name" )
201
+ desiredLanguage match {
202
+ case " english" => englishGreeting
203
+ case " french" => frenchGreeting
204
+ }
205
+ }
206
+ ```
207
+ {% endtab %}
208
+ {% tab 'Scala 3' %}
141
209
``` scala
142
210
def createGreetingFunction (desiredLanguage : String ): String => Unit =
143
211
val englishGreeting = (name : String ) => println(s " Hello, $name" )
@@ -146,23 +214,33 @@ def createGreetingFunction(desiredLanguage: String): String => Unit =
146
214
case " english" => englishGreeting
147
215
case " french" => frenchGreeting
148
216
```
217
+ {% endtab %}
218
+ {% endtabs %}
149
219
150
220
这是最后的方法。
151
221
请注意,从方法返回函数值与返回字符串或整数没有什么不同呃值。
152
222
153
223
这就是 ` createGreetingFunction ` 构建法语问候函数的方式:
154
224
225
+ {% tabs fun-write-method-returns-function-15 %}
226
+ {% tab 'Scala 2 and 3' %}
155
227
``` scala
156
228
val greetInFrench = createGreetingFunction(" french" )
157
229
greetInFrench(" Jonathan" ) // prints "Bonjour, Jonathan"
158
230
```
231
+ {% endtab %}
232
+ {% endtabs %}
159
233
160
234
这就是它构建英语问候功能的方式:
161
235
236
+ {% tabs fun-write-method-returns-function-16 %}
237
+ {% tab 'Scala 2 and 3' %}
162
238
``` scala
163
239
val greetInEnglish = createGreetingFunction(" english" )
164
240
greetInEnglish(" Joe" ) // prints "Hello, Joe"
165
241
```
242
+ {% endtab %}
243
+ {% endtabs %}
166
244
167
245
如果你对这段代码感到满意——恭喜——你现在知道如何编写返回函数的方法了。
168
246
0 commit comments