代码是死的，人是活的，关键看你怎么把死的代码玩活- Hunter
使用func定义一个函数, 通过函数名、参数列表, 调用者个函. 使用->与参数独立开，后面接这个函数的返回类型.
func greet(person: String, day: String) -> String {
return "Hello \(person), today is \(day)."
}
greet(person: "Bob", day: "Tuesday")
默认的，函数使用它们的参数名字作为它们的形参标签。在它们的参数名字前面，写一个自定义的参数标签。如果不用参数标签，写_
func greet(_ person: String, on day: String) -> String {
return "Hello \(person), today is \(day)."
}
greet("John", on: "Wednesday")
使用元祖作为复合值，如下例子从这个函数中返回多个值。可以通过名字或数字访问这个元祖的元素。
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 > max {
max = score
} else if score < min {
min = score
}
sum += score
}
return (min, max, sum)
}
let statistics = calculateStatistics(scores: [5, 3, 100, 3, 9])
print(statistics.sum)
print(statistics.2)
函数也能通过形参访问可变的数值，在数组集合中
func sumOf(numbers: Int...) -> Int {
var sum = 0
for number in numbers {
sum += number
}
return sum
}
sumOf()
sumOf(numbers: 42, 597, 12)
函数也能被嵌套，嵌套的函数能访问外部函数定义的变量。你可以在这个函数中使用被嵌套的函数写出更长或复杂的代码。
func returnFifteen() -> Int {
var y = 10
func add() {
y += 5
}
add()
return y
}
returnFifteen()
函数是一等类函数，这意味着函数可以作为另一个函数的返回值
func makeIncrementer() -> ((Int) -> Int) {
func addOne(number: Int) -> Int {
return 1 + number
}
return addOne
}
var increment = makeIncrementer()
increment(7)
一个函数可以作为另一个函数的形参
func hasAnyMatches(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]
hasAnyMatches(list: numbers, condition: lessThanTen)
可以确切的说函数是一个特殊的闭包。包体的代码之后会被调用。闭包体内可以能问变量像，变量、函数。使用in将参数和返回值与闭包体分离。
numbers.map({
(number: Int) -> Int in
let result = 3 * number
return result
})
你可以选择更简洁的写这个闭包。当一个闭包的类型是已知的，作为代理，你可以忽略它的参数类型、返回值类型，甚至都可以忽略。它的语句就是它的返回值
let mappedNumbers = numbers.map({ number in 3 * number })
print(mappedNumbers)
