Swift Learning 14: Closures (Closures)

2. * Closures (Closures)
4. * Closures are self-contained functional code blocks that can be used in code or used as parameters to pass values.
6. * Closures in Swift are similar to the lambdas in C, OC, and other programming languages such as Python (blocks).
8. * Closures can capture and store references to any constants and variables defined in the context. This is called the self-containment of variables and variables,
10. * Hence the name "closure" ("Closures)"). Swift also handles memory management for all captured references.
12. *
14. * Global functions and nested functions are really special closures.
16. * Closures in the form of:
18. * (1) Global functions are closures, have names but cannot capture any values.
20. * (2) Nested functions are closures and have names that can also capture values within the enclosing function.
22. * (3) The closure expressions are anonymous closures, which use lightweight syntax to capture values based on the context environment.
24. *
26. * Closures in Swift have a lot of optimizations in place:
28. * (1) Infer parameters and return value types based on context
30. * (2) Implicit return from a single-line expression closure (that is, the closure body has only one line of code, you can omit return)
32. * (3) You can use simplified parameter names, such as $ A, $ (starting from 0, representing the I parameter ...)
34. * (4) provides trailing closure syntax (Trailing closure syntax)
36. */
40. //Use the Sort method in the swift standard library to simplify closures in a step-by-step manner
42. //Sort function requires two parameters
44. //Parameter one: array
46. //Parameter two: A closure: With two parameters, these two parameter types are the same as the element types in the array, the return value is bool
48. var names = ["Swift", "Arial", "Soga", "Donary"]
52. //First way: Using Functions
54. Func Backwards (firststring:string, secondstring:string), Bool {
56. return firststring > Secondstring //ascending sort
58. }
60. //The second argument here, a function is passed
62. //reversed is equal to ["Swift", "Soga", "Donary", "Arial"]
64. var reversed = sort (nams, backwards)
68. //Second way: Use closure mode
70. //Complete closure The notation is a parameter list and a return value within the curly braces, indicating the beginning of the closure with the keyword in
72. //(firststring:string, secondstring:string) closure parameter list
74. //-bool indicates that the closure return value type is bool
76. the//in keyword indicates the beginning of the closure body
78. Reversed = sort (names, {(firststring:string, secondstring:string), Bool in
80. return firststring > Secondstring
82. })
86. //This can be further simplified because the closure code is shorter and can be written on one line
88. Reversed = sort (names, {(firststring:string, secondstring:string), Bool in return firststring > SecondS Tring})
92. Here's a further simplification: automatically infer types based on environment context
94. The argument list does not indicate a type, nor does it indicate a return value type, because Swift can be extrapolated from context
96. The type of firststring and secondstring will be the type of the names array element, and the return value type will be based on the return statement result
98. Reversed = sort (names, {firststring, secondstring in return firststring > secondstring})
102. Further simplification: implicit return (single-line statement closure)
104. Because the closure body has only one line of code, you can omit return
106. Reversed = sort (names, {firststring, secondstring in Firststring > secondstring})
110. Further simplification: Using simplified parameter names ($i, i=0,1,2 ... starting from 0)
112. Swift infers that a closure requires two parameters, the same type as the names array element
114. Reversed = sort (names, {$0 > $1})
118. The simplest way to do this: using Operators
120. Reversed = sort (names, >)
126. /*
128. * Trailing closures (Trailing Closures)
130. * If the function requires a closure parameter as a parameter, and this parameter is the last parameter, and the closure expression is very long,
132. * It is useful to use trailing closures. Trailing closures can be placed outside the function argument list, which is outside the brackets. If the function has only one argument,
134. * Then you can omit the brackets () and follow the closures directly.
136. */
138. The array method map () requires a closure as a parameter
140. Let strings = numbers. map { //Map function after () can be omitted
142. (var number), String in
144. var output = ""
146. While number > 0 {
148. Output = String (number% 10) + output
150. Number/= 10
152. }
154. return Output
156. }
160. /* Capture Value
162. * Closures can be captured to defined constants and variables according to the environment context. Closures can reference and modify these captured constants and variables,
164. * Even if defined as a constant in the original scope or the variable no longer exists (very good).
166. * The simplest form of closure in Swift is a nested function.
168. */
170. Func increment (#amount: int), ((), int) {
172. var total = 0
174. Func Incrementamount (), Int {
176. Total + = Amount //Total is a variable in the body of an external function, which can be captured
178. return Total
180. }
182. return incrementamount //Returns a nested function (closure)
184. }
188. Closures are reference types, so incrementbyten declarations as constants can also modify total
190. Let Incrementbyten = Increment (amount: 10)
192. Incrementbyten () //Return 10,incrementbyten is a closed package
194. Here is no change to the increment reference, so the previous value will be saved
196. Incrementbyten () //Return
198. Incrementbyten () //Return
202. Let Incrementbyone = Increment (amount: 1)
204. Incrementbyone () //return 1
206. Incrementbyone () //return 2
208. Incrementbyten () //Return
210. Incrementbyone () //Return 3

Swift Learning 14: Closures (Closures)