Swift-002-4.0基础语法补充

Swift 基础语法补充：

一.可选类型：

可选类型是swift的一大特色，在定义变量时，如果指定这个变量是可选的话，就是说这个变量可以有一个指定类型的值或者为nil。

? 和 ! 的区别

“?”表示可选类型（Optionals），“!”表示隐式可选类型，其实还是可选类型。

可选类型：将已存在的某种类型（结构体、枚举、类）定义为可选类型，表示该“新”类型的值可以为空nil   

var nickName : String?

使用self.label!是明确声明此时self.label里一定有值，无论什么情况都调用后面的.text赋值方法。

而使用self.view?是声明此时并不确定self.view里是否有值，所以只在view有值时调用后面.addSubview方法。

这样做的目的一是让代码更明确， 二是给编译器提供更多线索，在编译时发现更多潜在错误。

1.定义一个optional 的常量：

let x:Optional = 10
print(x)

点击进去查看，可以发现Option其实是一个枚举类型。这个枚举有两个值，一个是none，表示没有值，而另一个是some，表示某一类值。

在输出的时候，可以看见控制台上的内容Optional(10)，它的作用就是提示这是一个可选值。

而在实际开发中，一般不用上述方式创建可选值，而是指定一个类型，再在其后添一个问号。

let x:Optional = 10  //第一种写法
let x:Int? = 20     //第二种写法
print(x)

上述代码问号的意思就是定义一个可选的Int类型，可能没有值，也可能有一个整数。

2.解包：

试试将上面案例x和y相加，这个时候还能输出结果么？

此时可以看到编译器已经报错。在前面的教程中提到过，不同类型的值是不能直接运算的。而可选项若它的值为nil则不能参加计算。

因此引入解包的概念，“!”代表强制解包。它的意思是从可选值中强行获取对应的非空值。

输出结果：

3.解包常见错误：

 

//错误示范1
let y : Int?
print(y)

使用let定义的是常量，在初始化时必须要给出值。

//错误示范2：
let y : Int? = nil
print(y)

强制解包是危险操作，如果可选值为nil，强制解包系统会奔溃。

4.let 和 var的可选默认值：

//默认值测试
let x: Int?
print(x)
var y :Int?
print(y)

用let做测试时会直接报错，说明let的可选值是没有默认值的，而用var做测试时，报错信息就变成了警告，运行的结果为nil。可以由此推测出var的可选项默认值为nil。

swift中有规定，对象中的任何属性在创建对象时，都必须有明确的初始化值。

5.可选绑定：

用if let/var表示。它将变量赋值给一个临时变量，在这个操作中会做两步操作：首先判断变量是否有值，如果没有值，则直接不执行大括号里面的内容；如果有值，系统会自动将变量进行解包，并且将解包后的结果，赋值给临时变量。

//例如

通过一个字符串创建NSURL对象

 

let url: URL? = URL(string: "https://www.baidu.com")

接着创建NSURLRequest对象.

强制解包非常危险，当url有中文的时候可能会变成nil。所以要判断url是否为空再对其进行解包。

if let url = url {
    let request = URLRequest(url: url)
}

二.If语句和三目运算符：

1>.if语句

在swift中，if语句是不用带小括号的，但是后面跟的语句必须有花括号，哪怕只有一行代码。

  let a = 10
  //if 条件句是没有小括号的
  if a > 5 {
      print("小仙女")
   }else {
      print("小鲜肉")
   }

2>.三目运算:

三目运算符的写法是表达式后跟一个问号，用冒号来隔开条件是否成立的值。

let x = 10
x > 5 ? print("小仙女") : print("妖精")  //注意swift语法比较严谨，空格也要注意

如果开发者只想处理条件成立的部分，此时可以在冒号后面用一个小括号来代替条件不成立的部分。

x > 5 ? print("你写了两次啦"):()

三目运算的简单模式：处理可选项

 "??"的意思是说，如果表达式有值，就使用那个值，如果没有，就是呀“??”后面的值来代替

let x:Int? = nil
let y:Int? = 9
print((x ?? 0) + (y ?? 0))

运行之后结果为9

再说说运算符的优先级

let name:String? = "安琪拉"
print((name ?? "") + "火烧屁屁咯")
print(name ?? "" + "火烧屁屁咯")
/*
输出结果：
安琪拉火烧屁屁咯
安琪拉
*/

从运行的结果可以看到，“??”的优先级是最低的。如果没有小括号的约束，它会将后面的语句都当成是一个表达式。

if  let 和 var 连用 (提高安全性，括号里面一定是有值的)

        let oName:String? = "小小"
        let oAge:Int? = 18
        //方法1
        if oName != nil && oAge != nil {
            print(oName! + String(oAge!))
        }
        //方法2 let和var连用
        if var name = oName , let age = oAge {
            name = "哈哈"
            print(name + String(age))
        }else {
            print("x 或 y的值为NIl")
        }

 三、Guard使用：

Guard里面是一定有值的

   let oName:String? = "小小"
   let oAge:Int? = 18
   guard let name = oName , let age = oAge else {
        print("姓名或者年龄是nil")
        return
    }
     print(name + String(age))

 四、Switch使用：

Swift中的Switch可以使用任意类型，而不限制是Int类型

    //Swift中的Switch可以使用任意类型，而不限制是Int类型
    //Swift中的Switch不需要break
    //如果要使多个值等于相同的结果,直接用","逗号隔开
    func demo(num:String) {
        switch num {
        case "10","9":
            print("优秀~")
        case "8":
            break
        default:
            print("及格")
        }
    }

 五、For循环：

数字和...之间不能加空格

    //For循环
    func demo() {
        //大于0 小于5
        for i in 0..<5 {
            print(i)
        }
        //输出结果：0 1 2 3 4
        print("----------------------")
        //大于0 小于等于5
        //数字和...之间不能加空格
        for i in 0...5 {
            print(i)
        }
        //输出结果：0 1 2 3 4 5
    }

//逆序

        //逆序
        for i in (0..<10).reversed() {
            print(i)
        }
        //输出结果：9 8 7 6 5 4 3 2 1 0

 六、字符串：

 由双引号包裹起来的文本字符集

   func demo() {
        //不可变字符串
        let someString = "someString"
        //可变字符串
        var variableString = "Horse"
        variableString += "and carriage"
        print(someString + variableString)
        //字符串初始化
        var anotherEmptyString = String()
        let emptyString = ""
        //字符串判断是否为空
        if emptyString.isEmpty {
            print("Nothing !")
        }
    }

 遍历字符串和计算文字长度：

        //遍历字符串：
        for character in "Dog!?".characters {
            //print(character)
        }
        //计算文字的长度，每个汉字代表3个字节
        let str = "Hello world 你好"
        print(str.lengthOfBytes(using: String.Encoding.utf8))//计算字节的数量
        print(str.characters.count)//字符的个数

七、数组：

//Set 无序不重复

//用于存储多个元素的集合，元素的类型必须一致,同时，Swift支持泛型集合

//集合的可变性取决于是常量和变量

 ①创建数组

        //Array
        //A：初始化方法
        //Array<Element> : Element 是数组中唯一存在的指定类型 或者 [element]
        var someInt = [Int]()//创建一个空数组 数组的值类型被推断为Int类型
        someInt = [1,2,3]
        print(someInt)//结果：[1, 2, 3]
        var threeDoubles = Array(repeating: 1.2, count: 3)//repeating 后为数组默认值,count 为数组长度
        print(threeDoubles[1]) //结果：1.2    
              
        //B：通过两个数组相加创建数组
        let threeDoubles = Array(repeating: 0.0, count: 3)
        let anotherDoubles = Array(repeating: 2.9, count: 2)
        let result = threeDoubles + anotherDoubles
        print(result)
        
        //C: 字面量创建数组
        var shoppingList :[String] = ["EGGS","MILK"]
        var shoppingList2 = ["Eggs","Milk"]  

②操作数组

 

        //字面量创建数组
        var shoppingList = ["Eggs","Milk"]
        //转义斜杠 + () 格式化打印字符串 //isEmpty判断是否为0
        print("一共有(shoppingList.count)项")
        //给数组添加新元素
        shoppingList.append("Flour")
        //第二种添加方法
        shoppingList += ["cheese", "Butter"]//追加
        //在具体索引值添加元素 insert
        shoppingList.insert("Map", at: 3)
        //替换指定元素
        shoppingList[2...4] = ["替换2","替换3"]
        //删除
        shoppingList.remove(at: 0)
        //删除最后一个
        shoppingList.removeLast()
        print(shoppingList)
        //遍历
        for i in shoppingList {
            print(i)
        }
        //for
        //enumerated
        for (index,value) in shoppingList.enumerated() {
            print(String(index+1)+(value))
        }
        print("--------------------------------------")

 

八、集合

①创建集合

         //Set 无序不重复     
        //集合Set 形式：Set<Element>
        //创建空的集合
        var letters = Set<Character>()
        print("Letters的集合长度为(letters.count)")
        //用数组字面量构造集合
        //var favorite:Set<String> = ["Rock","Hip pop"]
        var favorite:Set = ["Rock","Hip pop"]
        //添加元素
        favorite.insert("Jazz")
        if let removeBack = favorite.remove("Rock") {
            print(removeBack)
        }else {
            print("没有值")
        }
        //删除整个集合 removeAll
        //遍历并排序
        for item in favorite.sorted() {
            //按照首字母输出
            print("item-(item)")
        }

②操作集合 真子集，即子集不等于父集

      func demo2() {
        let oddD: Set = [1,3,5,7,9]
        let evenD: Set = [0,2,4,6,8]
        let singleDPrime: Set = [2,3,5,7]
        print(oddD.union(evenD).sorted()) // 合并
        //结果：[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
        print(oddD.intersection(evenD).sorted()) //相交
        //结果：[]
        print(oddD.subtracting(singleDPrime).sorted()) //取差值
        //结果：[1, 9]
        print(oddD.symmetricDifference(singleDPrime).sorted())//取两个集合不同
        //结果：[1,2,9]
       }

               let houseAnimals:Set = ["?","?","?"]
        let farmAnimals:Set = ["?","?","?","?","?","?"]
        let cityAnimals:Set = ["?","?"]
        print(houseAnimals.isSubset(of: farmAnimals))//判断前一个值是否包含在后面的集合 结果：true
        print(farmAnimals.isSuperset(of: houseAnimals))//判断所有的值是否包含  结果：true
        print(farmAnimals.isDisjoint(with: cityAnimals))//是否没有交集       结果：false (有交集)

 九、字典

创建字典和操作字典：

        //创建字典
        var nameOfIntegers = [Int:String]() //创建一个空的字典
        var someDict:[Int:String] = [1:"one",2:"two",3:"three"]//字面量方式创建
        //获取值
        let someVar = someDict[2]
        print("key=1的值(someVar!)")//输出结果为：two
        //修改值
        var oldVar = someDict.updateValue("one的新值", forKey: 1)
        print("key=1的值(oldVar!)")//oldVar 是旧值
        someDict[2] = "two的新值"
        print(someDict[1]!)
        
        //操作字典
        //移除
        var removeValue = someDict.removeValue(forKey: 2)
        print("key=2的值为(removeValue!)")//输出结果为：key=2的值为two的新值
        
        //someDict[3] = nil
        //print(someDict) //输出结果：[1: "one的新值"]
        
        //遍历字典
        for (key,value) in someDict {
            print("遍历字典key:(key) value:(value)")
        }
        for (key,value) in someDict.enumerated() {
            print("遍历字典key:(key) value:(value)")//带索引
        }
        //字典转数组
        let dictKeys = [Int](someDict.keys)
        let dictValues = [String](someDict.values)

十.函数与闭包

//函数与闭包

//函数相当于Objective-C中的方法，是一段完成特定任务的独立代码片段。可以通过给函数命名来标志某个函数的功能。而这个名字可以用来在需要的时候“调用”该函数完成其任务。格式如下

       

        func 函数名（参数列表）-> 返回值类型 {
               代码块
               return 返回值
         }
         func表示关键字，多个参数列表之间用逗号隔开，也可以没有参数。使用->指向返回值类型。如果没有返回值，可以用Void代替，也可以省略

    //1、定义无参无返回的函数
    func phone() ->  Void {
        print("小米")
    }
    //phone()
    
    //2.定义无参，有返回值
    func phoneNum() -> String {
        return "123456"
    }
    //print(phoneNum())
    //3.定义有参无返回值
    func callPhone(phoneNum:String) -> Void {
        print("打电话给(phoneNum)")
    }
    //4.定义有参有返回的函数
    func sum(num1 : Int , num2 : Int) -> Int {
        return num1 + num2
    }
    //5.函数无返回值类型:
    func demo() {
    }
    func demo1() -> () {
    }
    func demo2() -> Void {
    }
    //6._ 下划线的使用
    func firstFunc(_ age1 : Int , _ age2 : Int) -> Int {
        return age1 + age2
    }
    //在swift4之后，调用函数的时候，能直观的看到参数。而在之前调用之时，只能看见第二个参数之后的名称，表达起来并不直观。如何解决这个问题呢？
    //可以采用给参数起别名的方式，在参数前面添加一个别名。
    func getSum(number1 num1: Int,number2 num2 : Int) -> Int{
        return num1 + num2
    }

函数的默认值

    //函数的默认值
    func defaultFunc( name:String = "小Boss", age:String = "18") -> String {
        return name + age
    }
    //print(defaultFunc())  //输出结果  小Boss18
    //print(defaultFunc(name: "小明", age: "18")) //输出结果  小明18
    //print(defaultFunc(name: "小仙女")) //输出结果  小仙女18

闭包：自包含的函数代码块

      let f = sum  //f 是把函数的指针记录下来
      print(f(20,40))//结果：60
      func sum(x:Int , y:Int) -> Int {
         return x + y
      }
    
        //1.无参无返回值的闭包
        let b1 = {
            print("干掉他们")
        }
        b1()
        //闭包格式 {形参列表 -> 返回值类型 in 实现代码}
        //2.有参无返回值的闭包
        let b2 = {
            (x:String) -> () in print(x)
        }
        b2("String")
        //3.带参数，带返回值的闭包
        let b3 = {
            (x:Int) -> Int in return x + 3
        }
        print(b3(4))//输出结果：7

尾随闭包和逃逸闭包：

      override func viewDidLoad() {
        super.viewDidLoad()
        //普通调用
        myFunc(strP: "Hello", closureP: {
            (string) in print(string)
        })
        //尾随闭包调用
        myFunc(strP: "Hello") {
            (string) in print(string)
        }
        testEscaping {
            [unowned self] () -> Void in
            self.x = 100
        }
        print("x=(x)")//输出结果为：x=10 没有被修改为100
        callBackArray.first?()//修改了x
        print("x=(x)")//输出结果为：x=100 修改成功
    }
    
    //1.尾随闭包
    func myFunc(strP:String,closureP:(String) -> Void) -> Void {
        closureP(strP)
    }
    
    //2.逃逸闭包  在函数之后才能被调用 (闭包逃出了函数的作用域)
    var x = 10
    var callBackArray:[()->Void] = [] //定义数组，数组的元素都是闭包类型的
    //@escaping 允许逃逸出函数
    //逃逸闭包的方法
    func testEscaping(callBack:@escaping () -> Void) {
        callBackArray.append(callBack)
    }