@@ -20,73 +20,121 @@ permalink: "/zh-cn/scala3/book/:title.html"
20
20
创建函数的第一步是准确地陈述问题。
21
21
只关注 ` List[Int] ` ,你说:
22
22
23
- > 我想编写一个 ` map ` 方法,该方法可用于将函数应用于给定的 ` List[Int] ` 中的每个元素,
24
- > 并将转换后的元素作为新列表返回。
23
+ > 我想编写一个 ` map ` 方法,该方法可用于将函数应用于给定的 ` List[Int] ` 中的每个元素,并将转换后的元素作为新列表返回。
25
24
26
25
鉴于该声明,您开始编写方法签名。
27
26
首先,您知道您想接受一个函数作为参数,并且该函数应该将 ` Int ` 转换为某种通用类型 ` A ` ,因此您编写:
28
27
28
+ {% tabs map-accept-func-definition %}
29
+ {% tab 'Scala 2 and 3' %}
29
30
``` scala
30
31
def map (f : (Int ) => A )
31
32
```
33
+ {% endtab %}
34
+ {% endtabs %}
32
35
33
36
使用泛型类型的语法要求在参数列表之前声明该类型符号,因此您添加:
34
37
38
+ {% tabs map-type-symbol-definition %}
39
+ {% tab 'Scala 2 and 3' %}
35
40
``` scala
36
41
def map [A ](f : (Int ) => A )
37
42
```
43
+ {% endtab %}
44
+ {% endtabs %}
38
45
39
46
接下来,您知道 ` map ` 也应该接受 ` List[Int] ` :
40
47
48
+ {% tabs map-list-int-param-definition %}
49
+ {% tab 'Scala 2 and 3' %}
41
50
``` scala
42
51
def map [A ](f : (Int ) => A , xs : List [Int ])
43
52
```
53
+ {% endtab %}
54
+ {% endtabs %}
44
55
45
56
最后,您还知道 ` map ` 返回一个转换后的 ` List ` ,其中包含泛型类型 ` A ` 的元素:
46
57
58
+ {% tabs map-with-return-type-definition %}
59
+ {% tab 'Scala 2 and 3' %}
47
60
``` scala
48
61
def map [A ](f : (Int ) => A , xs : List [Int ]): List [A ] = ???
49
62
```
63
+ {% endtab %}
64
+ {% endtabs %}
50
65
51
66
这负责方法签名。
52
67
现在您所要做的就是编写方法体。
53
68
` map ` 方法将它赋予的函数应用于它赋予的列表中的每个元素,以生成一个新的、转换的列表。
54
69
一种方法是使用 ` for ` 表达式:
55
70
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' %}
56
78
``` scala
57
79
for x <- xs yield f(x)
58
80
```
81
+ {% endtab %}
82
+ {% endtabs %}
59
83
60
84
` for ` 表达式通常使代码出奇地简单,对于我们的目的,它最终成为整个方法体。
61
85
62
86
把它和方法签名放在一起,你现在有了一个独立的 ` map ` 方法,它与 ` List[Int] ` 一起工作:
63
87
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' %}
64
96
``` scala
65
97
def map [A ](f : (Int ) => A , xs : List [Int ]): List [A ] =
66
98
for x <- xs yield f(x)
67
99
```
100
+ {% endtab %}
101
+ {% endtabs %}
68
102
69
103
### 使其泛型化
70
104
71
105
作为奖励,请注意 ` for ` 表达式不做任何取决于 ` List ` 中的类型为 ` Int ` 的事情。
72
106
因此,您可以将类型签名中的 ` Int ` 替换为泛型类型参数 ` B ` :
73
107
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' %}
74
116
``` scala
75
117
def map [A , B ](f : (B ) => A , xs : List [B ]): List [A ] =
76
118
for x <- xs yield f(x)
77
119
```
120
+ {% endtab %}
121
+ {% endtabs %}
78
122
79
123
现在你有了一个适用于任何 ` List ` 的 ` map ` 方法。
80
124
81
125
这些示例表明 ` map ` 可以按需要工作:
82
126
127
+ {% tabs map-use-example %}
128
+ {% tab 'Scala 2 and 3' %}
83
129
``` scala
84
130
def double (i : Int ) = i * 2
85
131
map(double, List (1 , 2 , 3 )) // List(2, 4, 6)
86
132
87
133
def strlen (s : String ) = s.length
88
134
map(strlen, List (" a" , " bb" , " ccc" )) // List(1, 2, 3)
89
135
```
136
+ {% endtab %}
137
+ {% endtabs %}
90
138
91
139
现在您已经了解了如何编写接受函数作为输入参数的方法,让我们看看返回函数的方法。
92
140
0 commit comments