Swift3 基础语法

学习swift3的笔记，可粘贴运行

     override func viewDidLoad() {
        super.viewDidLoad()
        //1.可选类型
        let myString1:String? = nil
        if myString1 != nil {
            print(myString1)
        }else{
            print("字符串为 nil")
        }

        var myString2:String?
        
        myString2 = "Hello, Swift!"
        
        if myString2 != nil {
            // 强制解析
            print( myString2! )
        }else{
            print("myString 值为 \(myString2)")
        }
        
        var myString3:String!
        
        myString3 = "Hello, Swift!"
        
        if myString3 != nil {
            print(myString3)
        }else{
            print("myString 值为 \(myString3)")
        }
        
        /* 2.Bool
         布尔型字面量的默认类型是 Bool。
         布尔值字面量有三个值，它们是 Swift 的保留关键字：
         true 表示真。
         false 表示假。
         nil 表示没有值。
         */
        
        //3.for循环
        print("闭区间运算符:")
        for index in 1...5 {
            print("\(index) * 5 = \(index * 5)")
        }
        
        print("半开区间运算符:")
        for index in 1..<5 {
            print("\(index) * 5 = \(index * 5)")
        }
          
         /* 4.循环控制语句
         continue 语句
         告诉一个循环体立刻停止本次循环迭代，重新开始下次循环迭代。
         break 语句
         中断当前循环。
         fallthrough 语句
         如果在一个case执行完后，继续执行下面的case，需要使用fallthrough(贯穿)关键字。
          */
        
         //5.字符串
        // 使用字符串字面量创建空字符串
        let stringA = ""
        if stringA.isEmpty {
            print( "stringA 是空的" )
        } else {
            print( "stringA 不是空的" )
        }
        // 实例化 String 类来创建空字符串
        let stringB = String()
        
        if stringB.isEmpty {
            print( "stringB 是空的" )
        } else {
            print( "stringB 不是空的" )
        }
        // stringAa 可被修改
        var stringAa = "欢迎光临"
        stringAa += "http://www.baidu.com"
        print( stringAa )
        // stringBb 不能修改
        let stringBb = String("欢迎光临")
        //stringBb += "http://www.runoob.com" 报错
        print( stringBb )
        //字符串连接
        let constA = "欢迎光临："
        let constB = "http://www.baidu.com"
        let stringAB = constA + constB
        print("\(stringAB) 的长度为\(stringAB.characters.count)")
        // 字符串的比较
        var varA   = "Hello, Swift!"
        let varB   = "Hello, Swift!"
        if varA == varB {
            print( "\(varA) 与 \(varB) 是相等的" )  //相等
        } else {
            print( "\(varA) 与 \(varB) 是不相等的" )
        }
        //连接字符串
        varA.append(varB)
        //Unicode 字符串
        var unicodeString   = "欢迎光临"
        print("UTF-8 编码: ")
        for code in unicodeString.utf8 {
            print("\(code) ")
        }
        print("\n")
        print("UTF-16 编码: ")
        for code in unicodeString.utf16 {
            print("\(code) ")
        }
        /*
         1.isEmpty
         判断字符串是否为空，返回布尔值
         2.hasPrefix(prefix: String)
         检查字符串是否拥有特定前缀
         3.hasSuffix(suffix: String)
         检查字符串是否拥有特定后缀。
         4.Int(String)
         转换字符串数字为整型。 实例:
         let myString: String = "256"
         let myInt: Int? = Int(myString)
         5.String.characters.count
         计算字符串的长度
         6.utf8
         您可以通过遍历 String 的 utf8 属性来访问它的 UTF-8 编码
         7.utf16
         您可以通过遍历 String 的 utf8 属性来访问它的 UTF-16 编码
         8.unicodeScalars
         您可以通过遍历String值的unicodeScalars属性来访问它的 Unicode 标量编码.
         9.  +
         连接两个字符串，并返回一个新的字符串
         10. +=
         连接操作符两边的字符串并将新字符串赋值给左边的操作符变量
         11. ==
         判断两个字符串是否相等
         12. <
         比较两个字符串，对两个字符串的字母逐一比较。
         13. !=
         比较两个字符串是否不相等。
         */
        
        //6. 字符,不能创建空的Character（字符） 类型变量或常量
        var char1: Character = "A"
        char1 = "j"
        print("char1 的值为 \(char1)")
        //遍历字符串中的字符
        for ch in "Hello".characters {
            print(ch)
        }
        
        //7.数组
        //以下实例创建了一个类型为 Int ，大小为 3，初始值为 0 的空数组：
        var array = Array.init(repeating: 0, count: 3)
        array = [12,24,23];
        var someInts:[Int] = [10,20,30]
        someInts.remove(at: 1) //移除某个值
        someInts.append(50)  //添加某个值
        someInts[0] = 60  //修改某个值
        print(array,someInts,array[0])
        //遍历数组
        for item in someInts {   //不带入索引
            print(item)
        }
        for (index, item) in someInts.enumerated() {  // 带入索引
            print("在 index = \(index) 位置上的值为 \(item)")
        }
        //合并数组 +
        let intsC = array + someInts
        print(intsC,"的个数为：\(intsC.count),  判断是否为空：\(intsC.isEmpty)")
        
        //8.字典
        var someDict1 = [Int: String]()
        someDict1 = [1:"one",2:"two",3:"three"];
        var someDict2: [String: String] = ["1":"one","2":"two","3":"three"];
        var someDict3:[AnyHashable : Any] = ["1":"one",2:"two","3":40,4:"four"];//可变类型
        print(someDict1,"访问字典元素：\(someDict1[1]),\(someDict2["1"]),\(someDict3[2]),\(someDict3["3"])")
        someDict1.updateValue("新值one", forKey: 1)  //修改字典方法一
        someDict1[2] = "新值two"  //修改字典方法二
        someDict1[4] = "新增four" //新增字典元素
        someDict1.removeValue(forKey: 3)  //删除字典元素方法一
        someDict1[3] = nil   // 删除字典元素方法二
        print(someDict1,"someDict1含有字典元素个数为： \(someDict1.count)")
        //遍历字典
        for (key, value) in someDict1 {  // 遍历元素值
            print("key:\(key)","value:\(value)")
        }
        for (key, value) in someDict1.enumerated() { //遍历整个元素，value包涵键值对
            print("key:\(key)","value:\(value)")
        }
        let dictkeys = [Int](someDict1.keys)  //获取所有字典的key
        let dictvalues = [String](someDict1.values) //获取所有字典的值
        print(dictkeys,dictvalues,"判断字典是否为空：\(someDict1.isEmpty)")
           
        //9.函数
        print(mult(no1: 10, no2: 3)) //带参数及返回值
        print(minMax(array: [34,-3,56,25,7,45,847])) //元组作为函数返回值
        print(pow(firstArg: 3, secondArg: 5)) //函数可添加局部参数名和外部参数名
        
        vari(members: 12,23,4,5)       //参数可变，参数类型可变函数
        vari(members: "haha","hello")
        vari(members: [3,8])
        vari(members: ["1":"one",2:"two","3":"three"])
        
        var a = 20
        var b = 80
        swap(&a, &b)     //变量参数：传入函数内修改有效并传出
        print(a,b)
        
        let decrem = calcDecrement(forDecrement: 88)  // 返回内嵌函数
        print(decrem()) //调用内嵌函数
        
        //10.闭包
        let studname = { print("Swift 闭包实例。") }
        studname()
        let divide = {(val1: Int, val2: Int) -> Int in
            return val1 / val2
        }
        let result = divide(200, 20)
        print (result)
        
        /*
         Swift 标准库提供了名为sorted的函数，会根据您提供的用于排序的闭包函数将已知类型数组中的值进行排序。
         */
        let names = ["AT", "AE", "D", "S", "BE"]
        let reversed = names.sorted( by: < )
        // let reversed = names.sorted(by: backwards)  //backwards可为闭包
        print(reversed)
        
        // 以下是不使用尾随闭包进行函数调用
        someFunctionThatTakesAClosure(closure: {
            // 闭包主体部分
            print("以下是不使用尾随闭包进行函数调用")
        })
        // 以下是使用尾随闭包进行函数调用，()可省略
        someFunctionThatTakesAClosure() {
            // 闭包主体部分
            print("以下是使用尾随闭包进行函数调用")
        }
        
    }
        
    func mult(no1: Int, no2: Int) -> Int {
        return no1*no2
    }
    /*
     注意
     可选元组类型如(Int, Int)?与元组包含可选类型如(Int?, Int?)是不同的.可选的元组类型，整个元组是可选的，而不只是元组中的每个元素值。
     */
    func minMax(array: [Int]) -> (min: Int, max: Int) {
        var currentMin = array[0]
        var currentMax = array[0]
        for value in array[1.. currentMax {
                currentMax = value
            }
        }
        return (currentMin, currentMax)
    }
    func pow(firstArg a: Int, secondArg b: Int) -> Int {  //firstArg 为外部参数名，a 为局部参数
        var res = a
        for _ in 1..(members: N...){  //可变参数函数
        for i in members {
            print(i)
        }
    }
    func swapTwoInts( a:inout Int, b:inout Int){ //变量参数：传入函数内修改有效并传出，关键字：inout
        
        let t = a
        a = b
        b = t
    }
    func calcDecrement(forDecrement total: Int) -> () -> Int {
        var overallDecrement = 10
        func decrementer() -> Int {     //内嵌函数
            overallDecrement -= total
            return overallDecrement
        }
        return decrementer
    }
    func backwards(s1: String, s2: String) -> Bool {  // 使用普通函数(或内嵌函数)提供排序功能,闭包函数类型需为(String, String) -> Bool。
        return s1  < s2
    }
    func someFunctionThatTakesAClosure(closure: () -> Void) {
        // 函数体部分
        closure() // 回调
        
        print("输出函数体")
    }