函数
（1）Swift定义函数使用关键字func，->后定义函数的返回值类型。
fun runoob (site: String, name: String) -> String {
return (site)
}
print(runoff (site: "66666"))
无参数的函数
func funcname () -> String{
return datatype
}
无返回值的函数
func getNet (getwork:String){
print("hhh")
}
（2）元组作为函数返回值
注：元组与数组类似，但是元组中的值可以是任意类型，使用的是方括号。可选元组类型如(Int, Int)?与元组包含可选类型如(Int?, Int?)是不同的.可选的元组类型，整个元组是可选的，而不只是元组中的每个元素值。
func minMax (array: [Int]) -> (min: Int, max: Int)? {
if array.isEmpty {
return nil
}
var currentmin = array[0]
var currentmax = array[0]
for value in array[1..<array.count]{
if value < currentmin {
currentmin = value
}else if value > currentmax {
currentmax = value
}
}
return (currentmin, currentmax)
}
（3）函数的内部参数名和外部参数名，如果声明了外部参数名，则在调用函数的时候必须使用外部参数名
func pow(first a: Int, second b: Int)->Int{
return (a+b)
}
var strr = pow(first:10, second:8)
print(star)
（4）可变参数，可接受0或多个值，在类型后加...来定义
func fun<M>(remeber: M...){
for i in remeber {
print(i)
}
}
（5）常量，变量及I/O参数
在函数的参数前面加inout关键字，就可以改变参数的值，传入参数时需要在参数前面加&符，表示这个值可以被修改。
func swapTwo(a: inout Int, b: inout Int){
let tempA = a
a=b
b=tempA
}
var x = 1
var y = 5
swapTwo(a: &x, b: &y)
（6）使用函数类型，就像定义其他类型的值一样
func sum(a: Int, b: Int) -> Int {
return a+b
}
var addition: (Int, Int) -> Int = sum
// 接下来就可以使用addition调用函数
（7）函数类型作为参数类型，返回类型
func sum(a: Int, b: Int) -> Int {
return a+b
}
var addition: (Int, Int) -> Int = sum
func another (addition: (Int, Int) -> Int,a: Int, b: Int){
print(addition(a, b))
}
another(addition: sum, a: 10, b: 30)
（8）嵌套函数，外部的函数可以调用内部定义的函数
// 以函数作为返回值的嵌套函数
func calcDecrement (forDecrement total: Int) -> Int{
var overallDecrement = 0
func decrementer() -> Int{
overallDecrement -= total
return overallDecrement
}
return decrementer()
}
闭包
（1）闭包的形式有：
全局函数 ： 有名字但不能捕获任何值。
嵌套函数 ： 有名字，也能捕获封闭函数内的值。
闭包表达式 ： 无名闭包，使用轻量级语法，可以根据上下文环境捕获值。
（2）闭包语法实例：
let studname = { print("Swift 闭包实例。") }
studname()
//以下闭包形式接收两个参数并返回布尔值：
let divide = {(val1: Int, val2: Int) -> Int in
return val1 / val2
}
let result = divide(200, 20)
print (result)
（3）闭包表达式
含义：闭包表达式是一种利用简洁语法构建内联闭包的方式。 闭包表达式提供了一些语法优化，使得撰写闭包变得简单明了。
sorted方法：
sorted(by:) 方法,会根据您提供的用于排序的闭包函数将已知类型数组中的值进行排序。返回一个与原数组相同（排序后）的数组，原数组不会被修改。
sorted(by:)方法需要传入两个参数：
已知类型的数组
闭包函数，该闭包函数需要传入与数组元素类型相同的两个值，并返回一个布尔类型值来表明当排序结束后传入的第一个参数排在第二个参数前面还是后面。如果第一个参数值出现在第二个参数值前面，排序闭包函数需要返回 true，反之返回 false。
实例：
let names = ["AT", "AE", "D", "S", "BE"]
// 使用普通函数(或内嵌函数)提供排序功能,闭包函数类型需为(String, String) -> Bool。
func backwards(s1: String, s2: String) -> Bool {
return s1 > s2
}
var reversed = names.sorted(by: backwards)
print(reversed)
（4）参数名称缩写
可以直接通过$0,$1,$2来顺序调用闭包的参数。
实例：
let names = ["AT", "AE", "D", "S", "BE"]
var reversed = names.sorted( by: { $0 > $1 } )
print(reversed)
（5）运算符函数
实例：
let names = ["AT", "AE", "D", "S", "BE"]
var reversed = names.sorted(by: >)
print(reversed)
（6）尾随闭包
格式：
func someFunctionThatTakesAClosure(closure: () -> Void) {
// 函数体部分
}
// 以下是不使用尾随闭包进行函数调用
someFunctionThatTakesAClosure({
// 闭包主体部分
})
// 以下是使用尾随闭包进行函数调用
someFunctionThatTakesAClosure() {
// 闭包主体部分
}
实例：
let names = ["AT", "AE", "D", "S", "BE"]
//尾随闭包
var reversed = names.sorted() { $0 > $1 }
print(reversed)
（7）捕获值
闭包可以在其定义的上下文中捕获常量或变量。
即使定义这些常量和变量的原域已经不存在，闭包仍然可以在闭包函数体内引用和修改这些值。
实例：
func makeIncrementor(forIncrement amount: Int) -> () -> Int {
var runningTotal = 0
func incrementor() -> Int {
runningTotal += amount
return runningTotal
}
return incrementor
}
let incrementByTen = makeIncrementor(forIncrement: 10)
// 返回的值为10
print(incrementByTen())
// 返回的值为20
print(incrementByTen())
// 返回的值为30
print(incrementByTen())
由于没有修改amount变量，incrementor实际上捕获并存储了该变量的一个副本，而该副本随着incrementor一同被存储。
所以我们调用这个函数时会累加
（8）闭包是引用类型
如果您将闭包赋值给了两个不同的常量/变量，两个值都会指向同一个闭包。
实例：
func makeIncrementor(forIncrement amount: Int) -> () -> Int {
var runningTotal = 0
func incrementor() -> Int {
runningTotal += amount
return runningTotal
}
return incrementor
}
let incrementByTen = makeIncrementor(forIncrement: 10)
// 返回的值为10
incrementByTen()
// 返回的值为20
incrementByTen()
// 返回的值为30
incrementByTen()
// 返回的值为40
incrementByTen()
let alsoIncrementByTen = incrementByTen
// 返回的值也为50
print(alsoIncrementByTen())
本文只是我在菜鸟教程上学习的一些自认为关键性的总结，如有需要请前往菜鸟教程学习。
