Swift 2-Day

╰+攻爆jí腚メ 2022-08-31 06:57 149阅读 0赞

# 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？： 向下转换