Skip to content

Commit 60c2d30

Browse files
benluojulienrf
authored andcommitted
add code tab _zh-cn/overviews/scala3-book/fun-write-map-function.md
1 parent 6f61983 commit 60c2d30

File tree

1 file changed

+50
-2
lines changed

1 file changed

+50
-2
lines changed

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

Lines changed: 50 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -20,73 +20,121 @@ permalink: "/zh-cn/scala3/book/:title.html"
2020
创建函数的第一步是准确地陈述问题。
2121
只关注 `List[Int]`,你说:
2222

23-
> 我想编写一个 `map` 方法,该方法可用于将函数应用于给定的 `List[Int]` 中的每个元素,
24-
> 并将转换后的元素作为新列表返回。
23+
> 我想编写一个 `map` 方法,该方法可用于将函数应用于给定的 `List[Int]` 中的每个元素,并将转换后的元素作为新列表返回。
2524
2625
鉴于该声明,您开始编写方法签名。
2726
首先,您知道您想接受一个函数作为参数,并且该函数应该将 `Int` 转换为某种通用类型 `A`,因此您编写:
2827

28+
{% tabs map-accept-func-definition %}
29+
{% tab 'Scala 2 and 3' %}
2930
```scala
3031
def map(f: (Int) => A)
3132
```
33+
{% endtab %}
34+
{% endtabs %}
3235

3336
使用泛型类型的语法要求在参数列表之前声明该类型符号,因此您添加:
3437

38+
{% tabs map-type-symbol-definition %}
39+
{% tab 'Scala 2 and 3' %}
3540
```scala
3641
def map[A](f: (Int) => A)
3742
```
43+
{% endtab %}
44+
{% endtabs %}
3845

3946
接下来,您知道 `map` 也应该接受 `List[Int]`
4047

48+
{% tabs map-list-int-param-definition %}
49+
{% tab 'Scala 2 and 3' %}
4150
```scala
4251
def map[A](f: (Int) => A, xs: List[Int])
4352
```
53+
{% endtab %}
54+
{% endtabs %}
4455

4556
最后,您还知道 `map` 返回一个转换后的 `List`,其中包含泛型类型 `A` 的元素:
4657

58+
{% tabs map-with-return-type-definition %}
59+
{% tab 'Scala 2 and 3' %}
4760
```scala
4861
def map[A](f: (Int) => A, xs: List[Int]): List[A] = ???
4962
```
63+
{% endtab %}
64+
{% endtabs %}
5065

5166
这负责方法签名。
5267
现在您所要做的就是编写方法体。
5368
`map` 方法将它赋予的函数应用于它赋予的列表中的每个元素,以生成一个新的、转换的列表。
5469
一种方法是使用 `for` 表达式:
5570

71+
{% tabs for-definition class=tabs-scala-version %}
72+
{% tab 'Scala 2' %}
73+
```scala
74+
for (x <- xs) yield f(x)
75+
```
76+
{% endtab %}
77+
{% tab 'Scala 3' %}
5678
```scala
5779
for x <- xs yield f(x)
5880
```
81+
{% endtab %}
82+
{% endtabs %}
5983

6084
`for` 表达式通常使代码出奇地简单,对于我们的目的,它最终成为整个方法体。
6185

6286
把它和方法签名放在一起,你现在有了一个独立的 `map` 方法,它与 `List[Int]` 一起工作:
6387

88+
{% tabs map-function class=tabs-scala-version %}
89+
{% tab 'Scala 2' %}
90+
```scala
91+
def map[A](f: (Int) => A, xs: List[Int]): List[A] =
92+
for (x <- xs) yield f(x)
93+
```
94+
{% endtab %}
95+
{% tab 'Scala 3' %}
6496
```scala
6597
def map[A](f: (Int) => A, xs: List[Int]): List[A] =
6698
for x <- xs yield f(x)
6799
```
100+
{% endtab %}
101+
{% endtabs %}
68102

69103
### 使其泛型化
70104

71105
作为奖励,请注意 `for` 表达式不做任何取决于 `List` 中的类型为 `Int` 的事情。
72106
因此,您可以将类型签名中的 `Int` 替换为泛型类型参数 `B`
73107

108+
{% tabs map-function-full-generic class=tabs-scala-version %}
109+
{% tab 'Scala 2' %}
110+
```scala
111+
def map[A, B](f: (B) => A, xs: List[B]): List[A] =
112+
for (x <- xs) yield f(x)
113+
```
114+
{% endtab %}
115+
{% tab 'Scala 3' %}
74116
```scala
75117
def map[A, B](f: (B) => A, xs: List[B]): List[A] =
76118
for x <- xs yield f(x)
77119
```
120+
{% endtab %}
121+
{% endtabs %}
78122

79123
现在你有了一个适用于任何 `List``map` 方法。
80124

81125
这些示例表明 `map` 可以按需要工作:
82126

127+
{% tabs map-use-example %}
128+
{% tab 'Scala 2 and 3' %}
83129
```scala
84130
def double(i : Int) = i * 2
85131
map(double, List(1, 2, 3)) // List(2, 4, 6)
86132

87133
def strlen(s: String) = s.length
88134
map(strlen, List("a", "bb", "ccc")) // List(1, 2, 3)
89135
```
136+
{% endtab %}
137+
{% endtabs %}
90138

91139
现在您已经了解了如何编写接受函数作为输入参数的方法,让我们看看返回函数的方法。
92140

0 commit comments

Comments
 (0)