Skip to content

Commit 985834d

Browse files
benluojulienrf
authored andcommitted
add code tab _zh-cn/overviews/scala3-book/fun-write-method-returns-function.md
1 parent 52bd30d commit 985834d

File tree

1 file changed

+78
-0
lines changed

1 file changed

+78
-0
lines changed

_zh-cn/overviews/scala3-book/fun-write-method-returns-function.md

Lines changed: 78 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -25,48 +25,74 @@ permalink: "/zh-cn/scala3/book/:title.html"
2525
鉴于该声明,您可以开始构建 `greet`
2626
你知道这将是一种方法:
2727

28+
{% tabs fun-write-method-returns-function-1 %}
29+
{% tab 'Scala 2 and 3' %}
2830
```scala
2931
def greet()
3032
```
33+
{% endtab %}
34+
{% endtabs %}
3135

3236
您还知道此方法将返回一个函数,该函数 (a) 采用 `String` 参数,并且 (b) 使用 `println` 打印该字符串。
3337
因此,该函数的类型为 `String => Unit`
3438

39+
{% tabs fun-write-method-returns-function-2 %}
40+
{% tab 'Scala 2 and 3' %}
3541
```scala
3642
def greet(): String => Unit = ???
3743
----------------
3844
```
45+
{% endtab %}
46+
{% endtabs %}
3947

4048
现在你只需要一个方法体。
4149
您知道该方法需要返回一个函数,并且该函数接受一个“字符串”并打印它。
4250
此匿名函数与该描述匹配:
4351

52+
{% tabs fun-write-method-returns-function-3 %}
53+
{% tab 'Scala 2 and 3' %}
4454
```scala
4555
(name: String) => println(s"Hello, $name")
4656
```
57+
{% endtab %}
58+
{% endtabs %}
4759

4860
现在您只需从方法中返回该函数:
4961

62+
{% tabs fun-write-method-returns-function-4 %}
63+
{% tab 'Scala 2 and 3' %}
5064
```scala
5165
// a method that returns a function
5266
def greet(): String => Unit =
5367
(name: String) => println(s"Hello, $name")
5468
```
69+
{% endtab %}
70+
{% endtabs %}
5571

5672
因为这个方法返回一个函数,所以你可以通过调用`greet()`来得到这个函数。
5773
这是在 REPL 中做的一个很好的步骤,因为它验证了新函数的类型:
5874

75+
{% tabs fun-write-method-returns-function-5 %}
76+
{% tab 'Scala 2 and 3' %}
5977
````
78+
{% endtab %}
79+
{% endtabs %}
6080
scala> val greetFunction = greet()
6181
val greetFunction: String => Unit = Lambda....
6282
-----------------------------------------
6383
````
84+
{% endtab %}
85+
{% endtabs %}
6486

6587
现在你可以调用`greetFunction`了:
6688

89+
{% tabs fun-write-method-returns-function-6 %}
90+
{% tab 'Scala 2 and 3' %}
6791
```scala
6892
greetFunction("Joe") // prints "Hello, Joe"
6993
```
94+
{% endtab %}
95+
{% endtabs %}
7096

7197
恭喜,您刚刚创建了一个返回函数的方法,然后执行了该函数。
7298

@@ -75,36 +101,52 @@ greetFunction("Joe") // prints "Hello, Joe"
75101
如果您可以传递问候语,我们的方法会更有用,所以让我们这样做。
76102
您所要做的就是将问候语作为参数传递给 `greet` 方法,并在 `println` 中的字符串中使用它:
77103

104+
{% tabs fun-write-method-returns-function-7 %}
105+
{% tab 'Scala 2 and 3' %}
78106
```scala
79107
def greet(theGreeting: String): String => Unit =
80108
(name: String) => println(s"$theGreeting, $name")
81109
```
110+
{% endtab %}
111+
{% endtabs %}
82112

83113
现在,当您调用您的方法时,该过程更加灵活,因为您可以更改问候语。
84114
当您从此方法创建函数时,它是这样的:
85115

116+
{% tabs fun-write-method-returns-function-8 %}
117+
{% tab 'Scala 2 and 3' %}
86118
````
87119
scala> val sayHello = greet("Hello")
88120
val sayHello: String => Unit = Lambda.....
89121
----------------------
90122
````
123+
{% endtab %}
124+
{% endtabs %}
91125

92126
REPL 类型签名输出显示 `sayHello` 是一个接受 `String` 输入参数并返回 `Unit`(无)的函数。
93127
所以现在当你给 `sayHello` 一个 `String` 时,它会打印问候语:
94128

129+
{% tabs fun-write-method-returns-function-9 %}
130+
{% tab 'Scala 2 and 3' %}
95131
```scala
96132
sayHello("Joe") // prints "Hello, Joe"
97133
```
134+
{% endtab %}
135+
{% endtabs %}
98136

99137
您还可以根据需要更改问候语以创建新函数:
100138

139+
{% tabs fun-write-method-returns-function-10 %}
140+
{% tab 'Scala 2 and 3' %}
101141
```scala
102142
val sayCiao = greet("Ciao")
103143
val sayHola = greet("Hola")
104144

105145
sayCiao("Isabella") // prints "Ciao, Isabella"
106146
sayHola("Carlos") // prints "Hola, Carlos"
107147
```
148+
{% endtab %}
149+
{% endtabs %}
108150

109151
## 一个更真实的例子
110152

@@ -117,27 +159,53 @@ sayHola("Carlos") // prints "Hola, Carlos"
117159
此外,由于该函数会打印给定的字符串,因此您知道它的类型为 `String => Unit`
118160
使用该信息编写方法签名:
119161

162+
{% tabs fun-write-method-returns-function-11 %}
163+
{% tab 'Scala 2 and 3' %}
120164
```scala
121165
def createGreetingFunction(desiredLanguage: String): String => Unit = ???
122166
```
167+
{% endtab %}
168+
{% endtabs %}
123169

124170
接下来,因为您知道可能返回的函数接受一个字符串并打印它,所以您可以为英语和法语编写两个匿名函数:
125171

172+
{% tabs fun-write-method-returns-function-12 %}
173+
{% tab 'Scala 2 and 3' %}
126174
```scala
127175
(name: String) => println(s"你好,$name")
128176
(name: String) => println(s"Bonjour, $name")
129177
```
178+
{% endtab %}
179+
{% endtabs %}
130180

131181
在方法内部,如果你给这些匿名函数起一些名字,它可能会更易读,所以让我们将它们分配给两个变量:
132182

183+
{% tabs fun-write-method-returns-function-13 %}
184+
{% tab 'Scala 2 and 3' %}
133185
```scala
134186
val englishGreeting = (name: String) => println(s"Hello, $name")
135187
val frenchGreeting = (name: String) => println(s"Bonjour, $name")
136188
```
189+
{% endtab %}
190+
{% endtabs %}
137191

138192
现在您需要做的就是 (a) 如果 `desiredLanguage` 是英语,则返回 `englishGreeting`,并且 (b) 如果 `desiredLanguage` 是法语,则返回 `frenchGreeting`
139193
一种方法是使用 `match` 表达式:
140194

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' %}
141209
```scala
142210
def createGreetingFunction(desiredLanguage: String): String => Unit =
143211
val englishGreeting = (name: String) => println(s"Hello, $name")
@@ -146,23 +214,33 @@ def createGreetingFunction(desiredLanguage: String): String => Unit =
146214
case "english" => englishGreeting
147215
case "french" => frenchGreeting
148216
```
217+
{% endtab %}
218+
{% endtabs %}
149219

150220
这是最后的方法。
151221
请注意,从方法返回函数值与返回字符串或整数没有什么不同呃值。
152222

153223
这就是 `createGreetingFunction` 构建法语问候函数的方式:
154224

225+
{% tabs fun-write-method-returns-function-15 %}
226+
{% tab 'Scala 2 and 3' %}
155227
```scala
156228
val greetInFrench = createGreetingFunction("french")
157229
greetInFrench("Jonathan") // prints "Bonjour, Jonathan"
158230
```
231+
{% endtab %}
232+
{% endtabs %}
159233

160234
这就是它构建英语问候功能的方式:
161235

236+
{% tabs fun-write-method-returns-function-16 %}
237+
{% tab 'Scala 2 and 3' %}
162238
```scala
163239
val greetInEnglish = createGreetingFunction("english")
164240
greetInEnglish("Joe") // prints "Hello, Joe"
165241
```
242+
{% endtab %}
243+
{% endtabs %}
166244

167245
如果你对这段代码感到满意——恭喜——你现在知道如何编写返回函数的方法了。
168246

0 commit comments

Comments
 (0)