美文网首页
Swift笔记一:基础部分

Swift笔记一:基础部分

作者: 面试小集 | 来源:发表于2017-08-27 15:34 被阅读7次

    基础部分

    简介

    基本数据类型

    Int : 整型
    Double、Float : 浮点型。
    Bool : 布尔型。
    String :文本型数据。
    Array、Set、Dictionary : 集合类型。
    Tuple : 元组。
    Optional :可选类型。

    常量和变量

    let : 来声明常量。
    var : 来声明变量。

    let maxmunNumberOfLoginAttempts = 10    //常量
    var currentLoginAttempt = 0     //变量
    

    类型标注

    //声明一个类型为String,名字为welcomeMessage的变量
    var welcomeMessage: String
    

    类型安全和类型推断

    类型安全:类型安全的语言可以让你清楚地知道代码要处理的值的类型。编译代码的时候进行类型检查,并把不匹配的标记为错误。
    类型推断:声明变量的时候并不一定要赋值和声明类型,类型推断会帮你确定合适的类型。编译器在编译代码的时候自动推断出表达式的类型。原理:检查赋值即可。
    推断浮点数的时候,swift 总会选择Double, 而不选择Float。

    常量名和变量名

    输出常量和变量

    func print(_ items: Any..., separator: String = default, terminator: String = default)
      // items: 要输出的0个或多个元素。
      //separator: 每个item之间要打印的信息,默认是" "
      //terminator: 所有的item打印完成之后要输出的信息。默认是换行"\n"
    

    demo:

    var name = "river li"
    var age = 25
    print("the current value of name is \(name), age is \(age)")
      //the current value of name is river li, age is 25
    

    注释

    多行注释嵌套

    /*
        /*
        var a = 12
        var b = 25
        */
        c = 45
    */
    

    分号

    不强制使用,但一行内多有个语句必须使用分号隔开。

    数字可读性增强

    let a = 1000000
    let a = 1_000_000
    let b = 123.0012
    let b = 000123.0012
    

    整数转化

    1. Swift 中不允许隐式的类型转换。
    2. 字面量相加,类型推断。
    let c : Int16 = 5
    let d : Int8 = 4
    let e = c + d   //错误,编译保存
    print("c+d=\(e)") 
    
    let f = c + Int16(d)  // 正确
    print("c+d=\(f)")   
    
    let m = 3 + 12.3    //不报错, 类型推断
    let h = d + 12.3    //报错12.3 被推断成Double
    

    类型别名

    typealias AudioSample = UInt16
    

    布尔值

    let right = true    //Bool
    let wrong = false   //Bool
    if right {
        print("right")
    }else{
        print("wrong")
    }
    let i = 1
    if i {
        // 编译报错,i类型推断为Int类型,不是Bool类型。if的判断条件只能使用Bool类型
    }
    
    if i==1 {
        print("right")
    }
    

    元组

    元组:把多个值组合成一个复合值。元组内的值可以是任意类型,并不要求是同类型的。

    let http404Error = (404, "Not Found")
    

    元组内容分解:
    元组适合临时组织值,不适合创建复杂的数据结构。

    let(statusCode, statusMessage) = http404Error
    print("The statusCode is \(statusCode)")
    //The status code is 404
    
    print("The statusMessage is \(statusMessage)")
    //The status message is Not Found
    
    let(statusCode, _) = http404Error  //只取部分元组信息,不需要的使用_忽略
    
    //使用下标访问
    let statusCode = http404Error.0
    let statusMessage = http404Error.1
    
    //定义元组指定元素名
    let http200Status = (statusCode: 200, description: "OK")
    //通过元素名称来获取元素
    let statusCode = http200Status.statusCode
    let description = http200Status.description
    

    可选类型

    使用可选类型(optionals)来处理值可能缺失的情况。
    Swift中的nil
    ​ Swift中的nil和OC中的nil不一样。OC中,nil是一个指向不存在对象的指针。Swift中,nil不是指针,它是一个确定的值,用来表示缺失,任何类型都可以被设置为nil,不只是对象类型。
    ​ nil不能用于不可选的常量和变量。如果代码中有常量或者变量需要处理值缺失的情况,请把它们声明成对应的可选类型。
    ​ 如果声明一个可选常量或者变量但没有赋值,它们会自动被置为nil。

    Int(String) //将一个字符串转换成整数,要么能转化成功"123", 要么转化不成功"Hello"
    let possibleNumber = "123"
    let coverteNumber = Int(possibleNumber)
    //返回值converteNumber被推断为Int?  或者 optional Int
    
    Int?    //? 暗示可能是Int值也可能不包含值。
    
    let m : Int = nil   //报错
    let m : Int?        //m默认为nil
    

    可选值的强制解析

    当你确定可选类型有值之后,你可以在可选的名字后面加一个感叹号(!)来获取值。这个感叹号表示“我知道这个可选有值,请使用它”。这称谓“可选值的强制解析”
    使用!来获取一个不存在的可选值会导致运行时错误。使用!来强制解析值之前,一定要确定可选包含一个非nil的值。

    var a : Int?
    a = 40
    let b = !a
    

    可选绑定

    使用可选绑定来判断可选类型是否包含值,如果包含就把值赋给一个临时常量或者变量。

    var a : Int? = 16
    // 如果a包含可选值,把值赋给b,条件成立。如果a不包含可选值,则条件失败
    if let b = a {
        print("b value is \(b)")
    }else {
        print("不能访问b")
    }
    

    隐式解析可选类型

    可选类型暗示了常量或者变量可以"没有值"。可选可以通过if来判断是否有值,如果有值可以使用可选绑定来解析值。

    var a : Int?
    if a == nil {
      print("a 没有值")
    }
    a = 12
    if let c = a {
        print("c=\(c)")
    }
    
    let possibleString: String? = "An optional String"
    let forcedString: String = possibleString! //需要使用!
    
    // 注意这里,不是问号而是感叹号,这就是隐式解析可选类型,取值的时候不用加!
    let assumedString: String! = "An implicatly unwrapped optinal string"
    let implicitString: String = assumedString
    

    一个隐式解析可选类型其实就是一个普通的可选类型。但可以当做非可选类型来使用。并不需要每次都是用!号来获取值。
    如果隐式解析可选类型没有值的时候尝试读取值会触发运行时错误。

    错误处理

    fun canTrowAnError() throws {
        //这个函数有可能抛出错误。
    }
    

    一个函数可以通过声明中添加throws关键字来抛出错误消息,当你的函数能抛出错误消息时,你应该在表达式中前置try关键字

    do{
      try canTrowAnError()
    }catch {
      // 有一个错误消息抛出
    }
    

    一个do语句创建了一个新的包含作用域,使得错误能被传播到一个或者多个catch语句中。

    func makeASandwich() throws{
        // ...
    }
    func eatASandwich() throws{
        // ...
    }
    
    do {
        try makeASandwich()
        eatASandwich()
    }catch SandWichError.outOfCleanDishes {
            washDishes()
    }catch SandWichError.missingIngredients(let ingredients){
        buyGroceries(ingredients)
    }
    

    断言

    如果在值缺失或者值并不满足特定条件的情况下,你的代码可能无法继续执行,这时,你可以在你的代码中触发一个断言,来结束代码运行,并通过调试来找到问题的原因。

    func assert(_ condition: @autoclosure () -> Bool, _ message: @autoclosure () -> String = default, file: StaticString = #file, line: UInt = #line)
    // condition 断言条件
    // message condition为false的时候触发输出message信息,默认为空字符串
    // file 如果断言失败,则打印文件名,默认是该方法所处的文件。
    // line 如果断言失败,则打印行号,默认是该方法所处的行号。
    

    当代码使用优化编译的时候,断言将会被禁用,Xcode的release模式下,断言就会被禁用
    何时使用断言:
    条件为假,但需要条件为真的时候代码才能继续执行。
    断言可能导致应用终止,所以发布的时候一定要去掉断言。

    相关文章

      网友评论

          本文标题:Swift笔记一:基础部分

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