[Swift4] Swift笔记 2.0（函数，闭包，枚举，结构体）

Swift笔记 2.0

函数，闭包，枚举，结构体

---

---

函数多值返回

需要多值返回

// 利用 元组 返回多个值
// 利用 数组 输入多个值
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()
}

---

仅为笔记 ， 旨在记录，定有缺漏，有错必改

---