swift知识点

作者: 红红宝宝 | 来源:发表于2021-04-28 09:42 被阅读0次

    元组 tuple:虽然使用起来非常的方便,然而其只适用于简单数据的组合,对于结构复杂的数据,要才用结构体和类来实现。

    Swift 的if 后面的类型只能是bool 类型。

    Swift 的repeat-while ,相当于 OC 里面的 do-while

    Swift 的switch语句不需要加break,使用 fallthrough 可以实现贯穿效果。和OC的switch语句不加break语句一样的效果

    Swift可以使用 _ 忽略某个值.
    用法1:

    let point = (1,1)
    switch point {
    case (0,0):
        print("the origin")
    case (_,0):
        print("on the x-axis")
    case (0,_):
        print("on the y-axis")
    case (-2...2,-2...2):
        print("inside the box")
    default:
        print("many")
    }
    

    用法2:

    func sum(_ v1:Int,_ v2:Int) -> Int{
        return v1 + v2
    }
    sum(10, 20)
    

    Swift的where语句

    高阶函数:返回值是函数的函数

    嵌套函数: 将函数定义在函数的内部

    递归枚举: 使用 indirect 关键字修饰的枚举值表示这个枚举是可以递归的,即此枚举值中的相关值使用其枚举类型本身。

    MemoryLayout: 获取数据类型占用的内存大小

    可选项Optional,一般也叫可选类型,它允许将值设为 nil强制解包:!。本质是 enum 类型

    空合并运算符 : ??

    隐式解包:可以在类型后面加个 感叹号 ❗️,定义一个隐式解包的可选项

    guard 语句

    对引用类型进行比较操作,应使用等同运算符(恒等运算符) ===、!==。

    闭包:一个函数和他捕获的变量/常量环境组合起来。闭包的核心是在其使用的局部变量/常量会被额外的复制或者引用,使这些变量脱离其作用域后依然有效。
    一般指定义在函数内部的函数
    一般它捕获的是外层函数的局部变量/常量
    可以把闭包想象成一个类的实例对象
    存储在堆空间
    捕获的局部变量/常量就是对象的成员(存储属性)
    组成闭包的函数就是类内部定义的方法

    自动闭包的条件:自动闭包参数使用有严格的条件是首先此闭包不能有参数,其次在调用函数传参的时,此闭包的实现只能由一句表达式组成,闭包的返回值即为此表达式的值,自动闭包由 @autoclosure 来声明

    逃逸闭包:是指函数内的闭包在函数执行结束后在函数外依然可以使用

    非逃逸闭包:是指在函数的声明周期结束后,闭包也将会被销毁

    Swift 里面跟实例相关的属性可以分为2大类:
    1、存储属性(Sored Property)
    类似于成员变量这个概念
    存储在实例的内存中
    结构体和类可以定义存储属性
    枚举不可以定义存储属性
    2、计算属性(Computed Property)
    本质就是方法(函数)
    不占用实例的内存
    枚举、结构体、类 都可以定义计算属性
    提示:
    set传入的新值默认叫做 newValue,也可以自定义
    定义计算属性只能用 var ,不能用 let(代表常量,值是一成不变的)

    计算属性的值是可能发生变化的(即使是只读计算属性)
    有set方法的话必须有get方法,有get方法可以没有set方法

    延迟存储属性:使用 lazy 可以定义一个延迟存储属性,在第一次用到属性的时候才会进行初始化
    lazy 属性必须是 var,不能是let
    let 必须在实例的初始化方法完成之前就拥有值
    如果 多条线程 同时第一次访问 lazy 属性,是无法保证属性只被初始化1次,这个是线程不安全的

    属性观察器:willSet, didSet

    类继承
    值类型(枚举、结构体) 不支持继承,只有类支持继承;
    没有父类的类称为基类(Swift 并没有像OC/Java 那样规定 :任何类 最终都要继承于某个基类)
    子类可以重写父类的下标、方法、属性重写必须加上override关键字

    subscript: 下标

    inout 本质是引用传递 (地址传递)

    严格来说属性可以分为:实例属性 和 类型属性
    1、实例属性(Instance Property):只能通过实例去访问
    存储实例属性(Stored Instance Property):存储在实例内存中,每个实例都有一份内存
    计算实例属性(Computed Instance Property)
    2、类型属性(类属性)(Type Property):只能通过类去访问
    存储类属性(Stored Instance Property):整个程序运行中,就只有一份内存(类似于全局变量)
    计算类属性(Computed Instance Property)

    可以通过static定义类型属性,如果是类可以使用关键字class

    结构体和枚举都是值类型,默认情况下,值类型的属性不能被自身的实例方法修改
    解决办法:在 func 前面加上 mutaing 可以允许这种修改行为

    final:被 final 修饰的的下标、方法、属性,禁止被重写;被 final 修饰的类禁止被继承

    初始化器
    类、结构体、枚举都可以定义初始化器
    类有2种初始化器:指定初始化器(designated initializer)、便捷初始化器(convenience initializer)
    子类无法重写父类的便捷初始化器

    用required修饰指定初始化器,表明其所有子类都必须实现该初始化器(通过继承或者重写实现)
    如果子类重写了required初始化器,也必须加上required,不用加override

    可失败的初始化器 init?
    用init! 定义隐式解包的可失败初始化器

    反初始化器 deinit,类似于C++的析构函数、OC中的dealloc方法

    可选链(Optional Chaining)

    Swift提供了2种特殊的类型:Any、AnyObject
    Any:可以代表任意类型(枚举、结构体、类,也包括函数类型)
    AnyObject:可以代表任意类类型(在协议后面写上: AnyObject代表只有类能遵守这个协议)

    is用来判断是否为某种类型
    as用来做强制类型转换。
    as?代表转换可能成功也可能失败,返回可选类型。
    as!,强制类型转换,如果转换失败会报 runtime 运行错误。
    由于 as? 在转换失败的时候也不会出现错误,所以对于如果能确保100%会成功的转换则可使用 as!,否则使用 as?

    do-catch 捕获错误
    try 仅仅代表尝试去调用一个函数
    可以使用try?、try!调用可能会抛出Error的函数,这样就不用去处理Error
    rethrows 表明:函数本身不会抛出错误,但调用闭包参数抛出错误,那么它会将错误向上抛

    defer 语句:用来定义以任何方式(抛错误、return等)离开代码前必须要执行的代码
    defer 语句将延迟至当前作用域结束之前执行

    泛型T 可以将类型参数化,提高代码复用率,减少代码量
    要想得知2个实例是否等价,一般做法是遵守 Equatable 协议,重载 == 运算符;与此同时,等价于重载了 != 运算符
    Swift为以下类型提供默认的Equatable 实现:
    没有关联类型的枚举
    只拥有遵守 Equatable 协议关联类型的枚举(Int,String......都是遵守 Equatable 的)
    只拥有遵守 Equatable 协议存储属性的结构体

    要想比较2个实例的大小,一般做法是:
    遵守 Comparable 协议
    重载相应的运算符


    swift里的extension 相当于OC的category

    匿名函数

    block

    相关文章

      网友评论

        本文标题:swift知识点

        本文链接:https://www.haomeiwen.com/subject/vlamrltx.html