函數
（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())
本文只是我在菜鳥教程上學習的一些自認為關鍵性的總結，如有需要請前往菜鳥教程學習。
