函式，閉包，列舉，結構體

函式多值返回

// 利用 元組 返回多個值
// 利用 陣列 輸入多個值
func calcMaxmain( values :[Int])-> (max :Int , min :Int) {
    var max = values[0]  // 元組
    var min = values[1]

    for v in values {
        if v > max {
            max = v
        }
        if v < min {
             min = v
        }
    }
    return
 
 (max , min )
}


let valuews = [1,2,2,10,9,5]
let maxmin = calcMaxmain(values: valuews)

函式可巢狀的定義

swift中 函式內 任然可以 定義函式

//函式巢狀定義
//功能：出處某數以內的非負偶數
func oushu(threshold :Int) {

    var number = 0
    func add2(){  
        number += 2
    }//巢狀定義

    while number < threshold {
        print(number)
        add2()
    }
}
oushu(threshold: 20
 
)
*/

函式型別

比如一個加法的函式，引數有兩個整形，返回一個整形 那麼 這個 函式定義可以是：

func addFun（num1：Int ， num2: Int） -> Int { code }

我們可以將這個 函式按 引數和返回值的型別 抽象為 （Int，Int）->Int swift中 函式可以看作一個類 而形如（Int，Int）->Int 叫一個函式型別

//函式型別

// 函式作為 引數傳遞
// 編寫一個函式 ，第一個引數是一個數學計算的函式 ， 
//第二第三引數是整數 ，返回2，3引數經過第一個引數計算的結果

func getSmaller(num1:Int,num2:Int)
 
->Int{
    return (num1 > num2) ? num1:num2
}
//第一個 數學計算函式 比較輸出小的數

func addFuction (num1:Int,num2:Int)->Int{
    return num2+num1
}
//第二個 數學計算函式 加法

func mathResult(mathFunction : (Int , Int)->Int ,num1: Int ,num2:Int)->Int {
    return mathFunction(num1,num2)
}
// 函式的引數 有3個 第一個是 函式型別 作了引數 
//並且 函式的功能是將第2第3的兩個整形作為 第一個形引數

print(mathResult(mathFunction: getSmaller, num1: 5, num2: 6))
print(mathResult(mathFunction: addFuction, num1: 5, num2: 6))


// 函式型別 作為函式返回
func makeIncrementer() ->((Int)->Int){
    func add1(num:Int)->Int{
        return num+1
    }
    return add1
}
var incrementer = makeIncrementer()
//incrementer 是 一個 (Int)->Int 的函式型別

var rst = incrementer(9)
print(rst)

閉包 Closure

自包含的功能程式碼塊（block），可以在程式碼中使用或者用來作為引數傳值。 把一段函式塊（block）作為一個整體 ，

函式也是一種特殊的閉包 閉包可以理解為匿名的函式

//閉包的定義
{(parameters) -> return type in
   statements
}

閉包有許多的變形 和 簡寫 ， 可以有引數 ，也可以無引數

//閉包 Closure

// 1. 定義閉包
var b1 = {
    print("我是閉包1")
}
b1()

// 2.1 帶引數的閉包
var b2 = {
    (param :String) in
    print("閉包引數：\(param)")
}
b2("你好")

// 2.2 帶返回值的閉包
var b3 = {
    (param :String) -> String in
    return "閉包返回\(param)"
}
print(b3("你好"))

// 2.3 自帶實參的閉包
var b4 = {
    (p1: String , p2: String) -> String in
    return "\(p1) \(p2)"
}("hello","world")
print(b4)

// 3 閉包簡化
// 3.1 簡化 自動推導引數 和 返回值
var s1 = {
    (p1, p2) in//引數型別 與 返回值 型別省略
    return "\(p1) \(p2)"
}("hello","world")
print("簡化1:\(s1)")

//3.2 簡化 如果閉包只包含一個return語句 ，可以省略return
var s2 = {
    (p1, p2) in
    "\(p1) \(p2)"//return 關鍵字省略
}("hello","world")
print("簡化2:\(s2)")

//3.3 簡化 引數名 可以省略，使用 $0，$1，$2 (dollar符)
var s3 = {
    //(p1, p2) in

    $0+" "+$1
    //"\(p1)+ \(p2)"
}("hello","world")
print("簡化3:\(s3)")

閉包和函式的一些組合

尾隨閉包，內斂方式

//4.1 帶閉包引數的函式 ，尾隨閉包
func myOperation(num1 : Int,num2 : Int,operation:(Int,Int)->Int) ->Int {
    let rst = operation (num1,num2)
    return rst
}

//實現閉包
let mulipleColsure = {
    (a: Int ,b :Int) -> Int in
    return a*b
}

var rst = myOperation(num1: 5, num2: 2, operation: mulipleColsure)
print(rst)

//4.2使用inline的方式傳遞閉包， 內斂方式
rst = myOperation(num1: 3, num2: 3, operation: { (a, b) -> Int in
    a*b
})
print(rst)

//簡化
rst = myOperation(num1: 5, num2: 3, operation: {
    $0*$1
})
print(rst)


//4.3 尾隨閉包
//如果閉包是函式的最後一個引數，可以將閉包後置到函式體外
rst = myOperation(num1: 9, num2: 2){$0*$1}
print (rst)

//5 閉包在集合中的應用
let names = ["Zhangxueyou","Liubei","Danna","Mark"]
var rst = names.sorted()
print(rst)
//["Danna", "Liubei", "Mark", "Zhangxueyou"]
//更改 排序規則

//--------------錯誤需要修改致歉-----------------------------------------------------

列舉

在其他語言如c++中也有列舉 但swift中有一點不同的地方 列舉中 可以定義函式（本質也是一種類）

//列舉

//練習 建立列舉 儲存週五工作日 ，編寫description函式 ，描述工作日

enum Weekday {
    case Mon
    case Tue
    case Wen
    case Thu
    case Fri

    func description() {
        switch self {
        case .Mon:
            print("本週第一天")
        case .Fri:
            print("馬上要週末了")
        default:
            print("還是認真工作吧")
        }
    }
    func xfunc()
    {
        print("I am x_function yeah!")
    }
}

var day = Weekday.Mon
print(day)
day.description()

day = .Fri //賦予新值
day.description()

day.xfunc()

結構體

以一個小的案例展示 同樣的，swift中結構體內 可以定義方法 要求：定義結構體，儲存學生資訊，包括姓名、年齡、性別、學號、班級。其中性別是列舉型別，列舉值為Male和Female。結構體中包括方法description，該方法列印輸出上述學生資訊

//Structure 結構體

//create a Structure


enum Sex {
    case Male
    case Female
}
struct Student {

    var name: String
    var sex :Sex
    var age:Int
    var ID :String
    var classNum :Int

    func description() {
       print("My name is \(name),and from Class \(classNum)，今年\(age)歲了，我的ID是\(ID),我是個\(sex)")
    }
}

var stu1 = Student(name: "John", sex: Sex.Male, age: 20, ID: "2016110246", classNum: 2)

stu1.description()

要求：建立5個學生物件，儲存在字典中，字典以學生學號為主鍵key，遍歷字典並輸出所有學生資訊。

var stu2 = Student(name: "Johnny", sex: Sex.Male, age: 20, ID: "2016110246", classNum: 2)
var stu3 = Student(name: "Mary"  , sex: Sex.Female, age: 21, ID: "2016110245", classNum: 2)
var stu4 = Student(name: "Jack"  , sex: Sex.Male, age: 20, ID: "2016110244", classNum: 2)
var stu5 = Student(name: "John"  , sex: Sex.Female, age: 18, ID: "2016110143", classNum: 1)


var studentDict = [String:Student]( )


studentDict[stu1.ID] = stu1
studentDict[stu2.ID] = stu2
studentDict[stu3.ID] = stu3
studentDict[stu4.ID] = stu4
studentDict[stu5.ID] = stu5


for value in studentDict {
    value.value.description()
}

僅為筆記 ， 旨在記錄，定有缺漏，有錯必改