用 func 来定义一个函数。func后面写上函数名，紧跟着是参数列表，写在括号里。在返回类型与参数名之间用 -> 来分隔开。
func greet(name: String,day: String) -> String {
return "Hello \(name),today is \(day)."
}
greet("Bob","Tuesday")
试一试
去掉 day 参数。在问候语里加上一个今天特价菜的参数
使用元组来创建一个组合值——例如，要从函数里返回多个值。元组里的这些元素既可以用名称进行引用，也可以用数字来引用。
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([5,3,100,9])
println(statistics.sum)
println(statistics.2)
函数还可以接受一批参数，将它们收集到一个数组里。
func sumOf(numbers: Int...) -> Int {
var sum = 0
for number in numbers {
sum += number
}
return sum
}
sumOf()
sumOf(42,597,12)
试一试
写一个函数计算参数的平均值。
函数是可以嵌套的。嵌套的函数可以访问到定义在函数外的变量。你可以用嵌套函数来把又长又臭的代码组织一下。
func returnFifteen() -> Int {
var y = 10
func add() {
y += 5
}
add()
return y
}
returnFifteen()
函数是头等（first－class，博主注：不知道该怎么翻译了）类型。意思是函数可以返回另一个函数作为它的值。
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(numbers,lessThanTen)
函数其实是闭包（可以过后调用的代码段）的一个特例。闭包内的代码可以访问到变量和函数必须是与闭包创建的范围是一致的，即便闭包是在另一个范围内执行——在讲嵌套函数时就说过这个例子了。闭包可以不用写名称，只需把代码写在花括弧内 ({})。在代码体里用 in 来分隔开参数和返回类型。
numbers.map({
(number: Int) -> Int in
let result = 3 * number
return result
})
试一试
重写这个闭包，对所有奇数都返回0
有几种方法可以更简明地写闭包。当闭包的类型是已知的，比如委托的回调，可以忽略掉参数的类型，返回类型，或者两个都忽略。单行语句的闭包隐式返回语句中的值。
let mappedNumbers = numbers.map({ number in 3 * number })
println(mappedNumbers)
你可以用数字而不是名称来引用参数——这种方法在非常短的闭包中尤其实用。作为最后一个参数传到函数里的闭包可以在括号后面马上出现。
let sortedNumbers = sorted(numbers) { $0 > $1 }
println(sortedNumbers)
