Swift学习笔记二-函数和闭包

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
//
// main.swift
// FunctionsAndClosures
//
// Created by Adrift on 16/4/18.
// Copyright © 2016年 Adrift. All rights reserved.
//

import Foundation

//## ###### 函数和闭包## ###### ##
//## ###### #函数## ##
//使用func声明一个函数,使用名字和参数调用一个函数,用->指定函数返回值类型
func greet(name:String,day:String,eat:String) ->String {
return "Hello \(name),Today is \(day),eat \(eat) in the morning."
}
var result = greet("小红", day: "Monday",eat:"something")
print(result)
//使用元组让一个函数返回多个值,元组的元素可以用名称或数组来表示
func calculateStatistics(scores:[Int]) ->(min:Int,max:Int,sum:Int) {
var min = scores[0]
var max = scores[0]
var sum = 0
for score in scores {
if score < min {
min = score;
}else if score > max {
max = score
}
sum += score
}
return (min, max, sum)
}
let statistics = calculateStatistics([5, 3, 100, 3, 9])
print(statistics.sum)
print(statistics.0)
//函数可以带有可变个数的参数,这些参数在函数内表现为数组形式.
func sumOf(numbers:Int...)->Int {
var sum = 0;
for number in numbers {
sum += number
}
return sum
}
print(sumOf())
print(sumOf(1,2,3,4,5,6))
//函数可以嵌套,被嵌套的函数可以访问外侧函数的变量,可以使用嵌套函数来宠后一个太长的或者复杂的函数.
func returnFifteen() -> Int {
var y = 10
func add() {
y += 5
}
add()
return y
}
print(returnFifteen())
//函数是第一等类型,这意味着函数可以作为另一个函数的返回值
func makeIncrementer() -> (Int -> Int) {
func addOne(number:Int) -> Int {
return 1 + number
}
return addOne
}
var increment = makeIncrementer()
print(increment(7))
//函数当做参数
func hasAnyMathches(list:[Int], condition: Int -> Bool) -> Bool {
for item in list {
if condition(item) {
return true
}
}
return false
}
func lessThanTen(number:Int) -> Bool {
return number < 10
}
var numbers = [20, 19, 7, 12]
hasAnyMathches(numbers, condition: lessThanTen)
//函数实际上是一种特殊的闭包:它是一段能之后被调取的代码。闭包中的代码能访问闭包所建作用域中能得到的变量和函数,即使闭包是在一个不同的作用域被执行的 - 你已经在嵌套函数例子中所看到。你可以使用{}来创建一个匿名闭包。使用in将参数和返回值类型声明与闭包函数体进行分离。
var result1 = numbers.map({
(number:Int) -> Int in
let result = 3 * number
return result
})
print("\(result1) hehe")

var result2 = numbers.map({
(number:Int) -> Int in
if number % 2 != 0 {
return 0
}
return 0
})
print("\(result1) hehe")
//有很多种创建更简洁的闭包的方法。如果一个闭包的类型已知,比如作为一个回调函数,你可以忽略参数的类型和返回值。单个语句闭包会把它语句的值当做结果返回。
let mappedNumbers = numbers.map({ number in 3 * number })
print(mappedNumbers)

//可以通过参数位置而不是参数名字来引用参数——这个方法在非常短的闭包中非常有用。当一个闭包作为最后一个参数传给一个函数的时候,它可以直接跟在括号后面。当一个闭包是传给函数的唯一参数,你可以完全忽略括号。
let sortedNumbers = numbers.sort { $0 > $1 }
print(sortedNumbers)

–EOF–