Swift 基本数据类型

import UIKit

/*
   编译分为前端编译、后端编译。
   oc是通过clang前端编译，再到LLVM后端编译成为二进制数据
   swift是通过xx前端编译，同样到LLVIM后端编译成为二进制数据
   
   查看汇编代码：
   Xcode - Debug-Debug Workflow - Always Show Disassembly
   设置好后，打好断点，当运行到当前代码的时候就能看到汇编代码
*/

class ValueType: NSObject {
    
    let value1 = 1
    var value2 = 2
    var flowString = ""

    func initWork() {
        
        // Do any additional setup after loading the view.
        
        /* let 修饰常量，var 修饰变量，没有标识类型时，会有类型推断 */
        /*
         常量的说明：
         只能赋值一次
         值不要求在编译时候确定，但是在使用前需要赋值
         值在定义的时候如果不能确定，那么需要声明该值的类型。
         
         变量是可以多次赋值的
       */
        
        //value1 = 2  这样是不行的，会报错
        value2 = 3
        
        //String的用法
        self.useString()
        
        //数组的用法
        let arr1: Array = [1, 3, 5]
        self.useArray(array : arr1)
        
        //控制流的使用
        flowString = self.useControlFlow(array: ["string2", "22", "string_s"])
        print("flowString = \(flowString)")     //flowString = case two
        
        //元组的用法
        self.useTuple()
        
        //字典的用法
        self.useDictionary()
    }
    
    //无参数，无返回值
    func useString(){
        
        //拼接
        var str_one = "Hello "
        str_one.append("world!")
        print(str_one)      // Hello world!
        let a_val = 95
        let str_thr = str_one + String(a_val)   //str_thr =  Hello world!95
        print("str_thr = ", str_thr)
        
        //初始化
        let str_two = String(format: "植物的数量：%d", 15)
        print(str_two)
        
        //字符串的长度
        let length = str_two.count
        print("length = ", length) //length =  8
        
        //判断字符串是否为nil，当为nil时，给一个可选的值 注：这里只能用let
        let optionalString:String? = "defaultString"
        print("when string is nil,the value string lenght = \(String(describing: optionalString))")
        //when string is nil,the value string lenght = Optional("defaultString")
        
        //使用??运算符处理可选值
        let v_nil : String? = nil
        let v_one = "oneStr"
        let oneStr_v = (v_nil ?? v_one)
        print("oneStr_v is \(oneStr_v)")    // oneStr_v is oneStr
    }
    
    //有参数，无返回值
    func useArray(array : Array){
        
        var tempArr = array
        
        //判断数据是否为空
        let boolArr = tempArr.isEmpty
        print("isEmpty = ", boolArr)    //isEmpty =  false
        
        //增加一个元素
        tempArr.append(7)    //[1, 3, 5, 7]
        print(tempArr)
        let array1 = [9, 11, 13]    //元素的类型可以被推断，可以使用这种方式初始化
        let sum_arr = tempArr + array1      //[1, 3, 5, 7, 9, 11, 13]
        print("sum_arr = ", sum_arr)
        
        //元素的插入
        tempArr.insert(4, at: 2)
        print("tempArr new values = \(tempArr)")  //tempArr new values = [1, 3, 4, 5, 7]
        
        //第n个元素
        let num1 : Int = 1
        let num2 : Int = 2
        let val1 = tempArr[num1]
        let val2 = tempArr[num2]
        print("val1 = ", val1, "val2 = ", val2)
        
        //初始化：重复数组，快速创建，两种方式一样
        let array2 = [String](repeating: "A", count: 10)    // 初始化器语法
        let arrayT2 = Array(repeating: "A", count: 10)
        print("array2 = ", array2)
        print("arrayT2 = ", arrayT2)
        
        //元素为多个数据类型的数组
        let array3 : [Any] = ["A", "B", 2.5, 33, [1, 2, 5], "ABC", "CFD", "ST"]
        
        //遍历数组中的元素
        for(value , index) in array3.enumerated(){
            print("value = \(value) index = \(index)") //使用\()的方式把值加入字符串
        }
        
        //所有元素遍历，并且相加
        let sum = tempArr.reduce(0, {x, y in
            x + y})
        print("sum = ", sum)   //sum =  16
        
        //根据条件筛选元素，并返回满足条件的新数组
        let array4 = sum_arr.filter ({value -> Bool in
            return value > 4
        })
        print("array4 = \(array4)")     //[5, 7, 9, 11, 13]
        
        //数组的最值
        let v_max = array4.max()
        let v_min = array4.min()
        print("v_max = \(String(describing: v_max)) v_min = \(String(describing: v_min))")
        // v_max = Optional(13) v_min = Optional(5)
        
        //数组的排序
        var array5 = [88, 3, 5, 99, 126, 36, 27, 32, 22]
        array5.sort()   // 升序
        print("array5 = \(array5)") //[3, 5, 22, 27, 32, 36, 88, 99, 126]
        array5.sort(by: >)  //降序
        print("array5 = \(array5)") //[126, 99, 88, 36, 32, 27, 22, 5, 3]
    }
    
    //有参数有返回值
    func useControlFlow(array : Array) -> String{
        
        let str1 = array[0]
        
        var returnStr = ""
        
        //swift中的switch的case不但可以使用数字，还可以使用string类型
        switch str1 {
        case "string1":
            returnStr = "case one"
        case "string2":
            returnStr = "case two"
        case "string3":
            returnStr = "case three"
        case "string4":
        returnStr = "case four"
            
        default:
            returnStr = "default"
        }
        
        return returnStr
    }
    
    //以上是三种函数的类型：无参数无返回值、有参数无返回值、有参数有返回值
    /*
    1 函数也可以看作是一种类型，它可以作为返回值，还有函数的参数传递
    2 函数可以看作是一个小的闭包，当函数作为另一个函数的参数传递时，可以使用$0来代替(此时函数必须为最后一个参数)
    */
    
    //元组的用法
    func useTuple(){
        
        /*
         元组是数据的一个简单的集合，利用元组可以将多个值捆绑到一个值中
         由于元组是不可变的，元组创建后，其长度已经确定，不可对它有增加或删除的 *** 作，因此元组中的数据是很安全的
         元组内的值可以是任何类型的，而且不必是同一类型的
         元组是没有类型关键字的，如下边这个元组，打印的type如下
       */
        
        let tuples_one = (22, "HTTP Faild", "code is 404")
        print("tuples_one type is \(type(of: tuples_one))")
        // tuples_one type is (Int, String, String)
        
        //访问元组
        let val1 = tuples_one.0
        let str1 = tuples_one.1
        print("val1 = \(val1), str1 = \(str1)")
        // val1 = 22, str1 = HTTP Faild
        
        //初始化时可以给元组的单个元素命名，并可以通过元素名访问对应元素
        let tuples_two = (name : "Bro", age : 20)
        print("The Man's name is \(tuples_two.name), age is \(tuples_two.age)")
        //The Man's name is Bro, age is 20
        //很像oc里的自定义数据模型model，这样解析很方便
        
        //let与var修饰的元组没有太大区别，var修饰的元素可以更改元组内的值，且新值与元组原有类型必须一致
        var tuples_three = (58, "go home", "amy said")
        tuples_three.0 = 55
        print("tuples_three = \(tuples_three)")
        // tuples_three = (55, "go home", "amy said")
    }
    
    //字典的用法
    func useDictionary(){
        
        //空字典，规范元素key、value类型的初始化
        var dict1 : Dictionary = [:]
        
        //增加新的key与value值
        dict1["name"] = "jerray"
        dict1["age"] = 36
        dict1["adress"] = "north"
        print("dict1 = \(dict1)")
        // dict1 = ["age": 36, "adress": "north", "name": "jerray"]
        
        //改某个key对应的值
        dict1.updateValue("sem", forKey: "adress")
        
        //删除某个key对应的值
        dict1.removeValue(forKey: "age")
        
        //所有的key、所有value
        let keys = dict1.keys
        let values = dict1.values
        print("keys = \(keys), values = \(values)")
        //keys = ["adress", "name"], values = ["sem", "jerray"]
    }
}