Swift学习笔记基础语法-整数类型

1.整数范围

        /**
        *1.Int长度与当前平台的原生字长相同,即32位机同Int32,64同Int64
        *2.一般使用Int,可以提高代码一致性和可复用性
        */
        let min = UInt32.min
        let max = UInt32.max
        let min2 = Int.min
        let max2 = Int.max
        print(min)
        print(max)
        print(min2)
        print(max2)

2.浮点数

        /**
        *Double表示64位浮点数;Float表示32位浮点数。
        */
        let PI:Float = 3.141592689793
        let PI2: Double = 3.141592689793
        print(PI)//输出3.14159
        print(PI2)//输出3.141592689793

        //类型推断
        /**
        *当声明常量或者变量的时候赋给它们一个字面量即可触发类型推断。
        *编译器可以在编译代码的时候自动推断出表达式的类型。
        *因为有类型推断，Swift 很少需要显式指定类型。
        */
        let PI3 = 3 + 0.14159// PI3 会被推测为 Double 类型





        //数值型字面量
        let decimalInteger = 10
        let binaryInteger = 0b10          // 二进制的2
        let octalInteger = 0o10           // 八进制的8
        let hexadecimalInteger = 0x10     // 十六进制的16
        //十进制数 科学记数法
        let 一百万 = 1e6
        let 二百万分之一 = 2e-6
        //十六进制数 科学记数法
        let 十五的16进制2次方 = 0xFp2       //15 × 2^2

        /**
        *数值类字面量可以包括额外的格式来增强可读性。
        *整数和浮点数都可以添加额外的零并且包含下划线。
        */
        let 十亿 = 1_000_000_000
        let 八元 = 0_000_000_008

        //整数和浮点数之间的转换
        /**
        *1.整数和浮点数的转换必须显式指定类型
        *2.加号两边的数类型须相同。如果不进行转换，两者无法相加
        */
        let three = 3
        let point14159 = 0.14159
        let PI4 = Double(three) + point14159
        print(PI4)

        //浮点数转换为整数
        /**
        *用浮点数初始化一个新的整数值时，浮点值会被截断。3.1会变成3，-3.5会变成-3
        */
        let intPI4 = Int(PI4)
        print(intPI4)



         //类型别名type aliases
        /**
        *要给现有类型起一个更有意义的名字时，如处理特定长度的外部资源的数据
        */
        typealias myType = UInt16
        var minValue = myType.min

3.布尔值Bool

        /**
        *与OC，C不同，Swift的布尔值只能用true，false表示
        */
        let trueValue = true
        let falseValue = false

        if trueValue{
            /*
            let i = 1
            if i {
                会报错
            }
            */
        }

4.元组

        /**
        *1.把多个值组合成一个复合值,元组内的值可以是任意类型
        *2.数据结构并不是临时使用时，使用类或者结构体而不是元组。
        */
        let http404Error = (404, "Not Found")// 类型是 (Int, String)
        let shirt = (88,"red",true)
        //分解元组的每个元素（方法一：）
        let (money,color,isNice) = shirt
        print("money is :\(money)")
        print("color is :\(color)")
        print("it is nice :\(isNice)")
        /*
        输出：
        money is :88
        color is :red
        it is nice :true
        */

        //分解元组的每个元素（方法二：）
        print("money is :\(shirt.0)")
        print("color is :\(shirt.1)")
        print("it is nice :\(shirt.2)")

        //分解元组的部分元素
        let (justMoney,_,_) = shirt
        print("The $ is:\(justMoney)")

        //定义元组的时候给单个元素命名，通过名字来获取这些元素的值
        let shirt2 = (length : 80,isNice :false )
        print("length is :\(shirt2.0)")
        print("it is nice :\(shirt2.isNice)")

5.nil

        /**
        *1.声明一个可选常量或者变量但是没有赋值，它们会自动被设置为nil
        *2.Swift 的nil和 Objective-C 中的nil并不一样。
        *   在 Objective-C 中，nil是一个指向不存在对象的指针。
        *   在 Swift 中，nil不是指针——它是一个确定的值，用来表示值缺失。
        *   任何类型的可选状态都可以被设置为nil，不只是对象类型。
        */
        var defaultValue: String?
        print(defaultValue)

6.可选类型与拆包

        /**
        *可选类型（optionals）用来处理值可能缺失的情况
        */
        let 彩票 = "50000"
        let 中奖金额 = Int(彩票)
        if 中奖金额 != nil {
            print("恭喜您中了：\(中奖金额)")
        }                                   //输出 恭喜您中了：Optional(50)

        /**
        *1.使用!拆包，前提是被拆包的可选类型一定有值
        *2.确定可选类型确实包含值，后面加一个感叹号，被称为可选值的强制解析(强制拆包)
        */
        if 中奖金额 != nil {
            print("恭喜您中了：\(中奖金额!)")  //输出 恭喜您中了：50
        }

        /**
        *使用!拆包，如果可选类型值为nil，会有运行时错误
        */
        let 彩票2 = "谢谢惠顾"
        let 中奖金额2 = Int(彩票2)
        //直接使用
        print("恭喜您又中了：\(中奖金额2)") //恭喜您中了：nil
        print("恭喜您又中了：\(中奖金额2!)") //运行时报错：fatal error: unexpectedly found nil while unwrapping an Optional value
        //
        if 中奖金额2 != nil {
            print("恭喜您中了：\(中奖金额2)")
        }else{
            print("再接再厉")
        }






        //可选绑定
        /**
        *判断可选类型是否包含值，如果包含就把值赋给一个临时常量或者变量
        */
        if var temMoney = 中奖金额{
            print("恭喜您中了：\(temMoney),税后\(Double(temMoney) * 0.8))")
        }else{
            print("再接再厉")
        }





        //隐式解析（间接拆包）
        /**
        *如果在变量的生命周期中判断是否nil的话,即变量可能变成nil使用普通可选类型
        *如果变量一直有值，则可用间接拆包
        */
        let 新彩票1: String! = "50"
        print("此次中奖：\(新彩票1)")   //此次中奖：50

        let 新彩票2: String? = "50"
        print("此次中奖：\(新彩票2)")   //此次中奖：Optional("50")

        let 新彩票3: String? = "50"
        print("此次中奖：\(新彩票3!)")  //此次中奖：50

        if let tempMoney = 新彩票1{
            print("此次中奖金额是：\(tempMoney)")
        }

7.错误处理

        /**
        *当一个函数遇到错误条件，它会报错。调用函数的地方能抛出错误消息并合理处理。
        */
        func divideOperations() throws {
            // 这个函数有可能抛出错误
        }
        /**
        *通过在声明中添加throws关键词来抛出错误消息。当你的函数能抛出错误消息时, 你应该在表达式中前置try关键词。
        */
        do {
            try divideOperations()
            // 没有错误消息抛出
        } catch {
            // 有一个错误消息抛出
        }
        /**
        *do语句创建了一个新的包含作用域,能使错误被传播到一个或多个catch中,例如：
        */

        func divideOperations() throws {
            // ...
        }

        do {
            try divideOperations()
            outputResult()
        } catch Error.DivdeByZero {
            reTryDivideOperations()
        } catch Error.WrongNumber(let num) {
           alert(num)
        }

8.断言(Assertion)调试

        /**
        *在某些情况下，如果值缺失或者值并不满足特定的条件，代码可能没办法继续执行。
        *这时可以在代码中触发一个断言（assertion）来结束代码运行并通过调试来找到值缺失的原因。
        */

        //使用断言的情况
        /**
        *1.整数类型的下标索引被传入一个自定义下标脚本实现，但是下标索引值可能太小或者太大。
        *2.需要给函数传入一个值，但是非法的值可能导致函数不能正常执行。
        *3.一个可选值现在是nil，但是后面的代码运行需要一个非nil值。
        */
        var age = 0
        assert(age >= 18,"年龄未满18才可进入")