Swift 2-Day

闭包

定义

// 一般形式：
{
 (parameters) -> returnType in
 statements
 }

// 完整写法
let say:(String) -> Void = {
    (name: String) -> Void in
    print("hello \(name)")
}
say("HaRi")
//Swift可以根据闭包上下文推断参数和返回值的类型，所以上面的例子可以简化如下
let calAdd2:(Int,Int)->(Int) = {
    a,b in  //也可以写成(a,b) in
    return a + b
}
print(calAdd2(150,100))
//上面省略了返回箭头和参数及返回值类型，以及参数周围的括号。当然你也可以加括号，为了好看点，看的清楚点。(a,b)
//单行表达式闭包可以隐式返回，如下，省略return
let calAdd3:(Int,Int)->(Int) = {(a,b) in a + b}
print(calAdd3(50,200))

//如果闭包没有参数，可以直接省略“in”
let calAdd4:()->Int = {return 100 + 150}
print("....\(calAdd4())")

//这个写法，我随便写的。打印出“我是250”
//这个是既没有参数也没返回值，所以把return和in都省略了
let calAdd5:()->Void = {print("我是250")}
calAdd5()

特殊

// 如果闭包是最后一个参数, 可以直接将闭包写到参数列表后面, 这样可以提高阅读性, 称之为尾随闭包
bubbleSort(array: &arr){
    (a: Int, b: Int) -> Int in
    if a > b{
        return 1;
    }else if a < b
    {
        return -1;
    }else
    {
        return 0;
    }
}

// 闭包表达式优化,
// 1.类型优化, 由于函数中已经声明了闭包参数的类型, 所以传入的实参可以不用写类型
// 2.返回值优化, 同理由于函数中已经声明了闭包的返回值类型,所以传入的实参可以不用写类型
// 3.参数优化, swift可以使用$索引的方式来访问闭包的参数, 默认从0开始
bubbleSort(array: &arr){
    if $0 > $1{
        return 1
    }else if $0 < $1
    {
        return -1
    }else
    {
        return 0
    }
}

// 如果只有一条语句可以省略 return
let hello = {
    "I'm XiaoHange"
}
print(hello())

print("__________________________")


/*
 自动闭包:
 顾名思义，自动闭包是一种自动创建的闭包，封装一堆表达式在自动闭包中，然后将自动闭包作为参数传给函数。而自动闭包是不接受任何参数的，但可以返回自动闭包中表达式产生的值。
 
 自动闭包让你能够延迟求值，直到调用这个闭包，闭包代码块才会被执行。说白了，就是语法简洁了，有点懒加载的意思。
 */

var array = ["1","100","hi","hello"]
print(array.count) // 4
let removeBlock = {array.remove(at: 3)}
print(array.count) // 4
print("执行代码块移除\(removeBlock())")
print(array.count) // 3
print("__________________________")



/*
 逃逸闭包:
 当一个闭包作为参数传到一个函数中，需要这个闭包在函数返回之后才被执行，我们就称该闭包从函数种逃逸。一般如果闭包在函数体内涉及到异步操作，但函数却是很快就会执行完毕并返回的，闭包必须要逃逸掉，以便异步操作的回调。
 
 逃逸闭包一般用于异步函数的回调，比如网络请求成功的回调和失败的回调。语法：在函数的闭包行参前加关键字“@escaping”。
 */

//例1:
func doSomething(some: @escaping() -> Void) {
    //延时操作, 注意这里的单位是秒
    DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + 1) {
       // 1s后操作
       some()
    }
    print("函数体")
}
doSomething {
    print("逃逸闭包")
}

//例2:
var comletionHandle:() -> String = {"约吗?"}

func doSomthing2(some: @escaping() -> String) {
    comletionHandle = some
}
doSomthing2 { () -> String in
    return "还是不约吧!"
}
print(comletionHandle())

//将一个闭包标记为@escaping意味着你必须在闭包中显式的引用self。
//其实@escaping和self都是在提醒你，这是一个逃逸闭包，
//别误操作导致了循环引用！而非逃逸包可以隐式引用self。
//例子如下:
var completionHandlers: [() -> Void] = []
//逃逸
func someFuncionWithEscapingClosure(completionHandler: @escaping () -> Void)
{
    completionHandlers.append(completionHandler)
}
//非逃逸
func someFunctionWithNonescapingCloure(cloure: () -> Void)
{
    cloure()
}

class SomeClass{
    var x = 10
    func doSomething()
    {
        someFuncionWithEscapingClosure {
            self.x = 100
        }
        someFunctionWithNonescapingCloure {
            x = 200
        }
    }
}

枚举

定义

enum 变量名 : 数据类型(可选){
	//case 单个变量
	case 变量名
	//case 多个变量
	case 变量名1,变量名2,......
	//关联词
	case 变量名3(元组)
}

遍历

令枚举遵循 CaseIterable 协议。Swift 会生成一个 allCases 属性，用于表示一个包含枚举所有成员的集合

enum Beverage: CaseIterable {
    case coffee, tea, juice
}
for beverage in Beverage.allCases {
    print(beverage)
}
// coffee
// tea
// juice

设置默认值

enum 变量名:数据类型{
	case a=默认值
}
//原始值的隐式赋值
enum Planet: Int {
    case mercury = 1, venus, earth, mars, jupiter, saturn, uranus, neptune
}
print(Planet.earth.rawValue)  //3
print(Planet(rawValue: 7))  //Optional(main.Planet.uranus)

类和结构体

对比

同

定义属性用于存储值
定义方法用于提供功能
定义下标操作用于通过下标语法访问它们的值
定义构造器用于设置初始值
通过扩展以增加默认实现之外的功能
遵循协议以提供某种标准功能

异

继承允许一个类继承另一个类的特征
类型转换允许在运行时检查和解释一个类实例的类型
析构器允许一个类实例释放任何其所被分配的资源
引用计数允许对一个类的多次引用
类是引用 结构体和枚举是值传递

定义

struct SomeStructure {
    // 在这里定义结构体
}
class SomeClass {
    // 在这里定义类
}
var Mystruct=SomeStructure()
var Myclass=SomeClass()

构造器

init() {
    // 在此处执行构造过程
}


var Myclass=SomeClass(width:123,height:213)

析构函数

deinit {
    // 执行析构过程
}

可选类型

作用：基本数据类型没有nil必须初始化，但可选类型可以为nil

 格式: Optional<类型> 或者在类型后面加上?号
 var opa: Optional<Int>
var opb: Int?

数据转换

as进行数据转换。 as：向上转型  as！as？： 向下转换