Swift(二 控制语句 集合类型)

第七章 控制语句

1、分支语句（条件语句）

if

• if
  大括号不能省略。判断句必须有明确的真假（Bool值），不再有非0 nil即真

   var score = 95
   if score > 85 {
       print("Good")
   }
  

• if-else
  条件满足为true，那么else就跳过。如果为false，忽略if语句，直接执行else语句组。

• else-if
  多个分支中只执行一个语句组。

guard （只能在函数里面使用）

在Swift2之后新添加的关键字。目的是替换复杂if-else语句的嵌套，提高可读性。guard-else,在条件不满足的情况下执行else语句return\throw,满足的话就跳过else，好处是条件直接是自己想要的，而不是再想出用它的补集做判断guard解析 函数里面跟return 循环里面跟break continue 根据语境选择关键字。

  func guardFun(score: Int){
       guard  score > 85 else{
              print(" not Good")
              return // 方法内使用
       }
     print("Good") // 这是需要执行的代码 
 }

switch

• switch可以比较整数、浮点数、字符、字符串、元组等类型，既可以是离散的 又可以是连续的。
• switch后面必须有个default语句，case与default后面不需要显式添加break语句，分支执行完其中一个case或者default语句就会跳出swich语句，不再是遇到break才跳出switch。但是， 在enum枚举中，枚举值如果全部列举出来，default可有可无，最好不加。
• 当case后面跟着多个离散值的时候，用“ , ”分离开即可，是 ”或“ 的关系。
• fallthrough case穿透

2、循环语句

while、repeat-while(相当于do-while)、for-in

while条件语句只能写一个Bool类型的表达式。不存在非0即真

while 循环条件{
    满足条件要执行的语句组  // 最少执行0次
}

repeat {
    满足条件要执行的语句组  // 最少执行1次
}while 循环条件

Swift3：for语句只能与in关键字结合使用。对范围和集合进行遍历。不再有 for-i

for v in 1...3 {  // v不用加let var关键字. 如果循环里面用不到v  就换成下划线_  循环更高效。
      print(v*v)
}

let numbers = [1, 2, 3, 4, 5]
for item in numbers {
    print("count is \(item)")
}
// 非要利用索引index 调用enumerated()->(index, element)返回元组实例函数
for (index, element) in numbers.enumerated() {
     print("index:\(index), element:\(element)")
}
 // 这个方法也可以用到索引k
 for k in 0..

3、跳转语句

break 标签写在循环前面

  label1: for i1 in 1...3 {
       label2: for i2 in (1...2).reversed() {  // reversed()反向遍历区间
            if i2 == i1 {
                 break label1  // 跳出标签为label1的循环
           }
       print("(i1, i2) = (\(i1), \(i2))")
     }
}
#结果：(i1, i2) = (1, 2)

continue

可带标签 也可不带标签。

 label1: for i1 in 1...3 {
       label2: for i2 in (1...2).reversed() {  // reversed()反向遍历区间
            if i2 == i1 {
                 continue label1  // 跳出标签为label1的循环体中尚未执行的语句，接着进行label1的条件判断，决定是否继续循环。
           }
       print("(i1, i2) = (\(i1), \(i2))")
     }
}
#结果：
   (i1, i2) = (1, 2)
   (i1, i2) = (3, 2)
   (i1, i2) = (3, 1)

fallthrough - 贯通之意，用在switch中

如果符合的case最后加了fallthrough，那么这个case之后的case\default代码会继续执行。不再有fallthrough或者碰到default是最后要执行的， 执行完就结束switch分支语句。

4、区间运算符 （两种）

• 闭区间：1...3 代表： 1 <= 范围 <= 3 （1是下临界值 3是上临界值）
• 半开区间： 1..<3 代表： 1 <= 范围 < 3 （1是下临界值 3是上临界值）

5、where语句

类似SQL中的where语句。能用在swith\for语句中，进行条件过滤。

• case （xx1, let age, xx3）where age>20:
  // 要执行的代码... let age是值的绑定

• // numbers是个数组
  for item in numbers where item > 5 {
  print("Count is: (item)");
  }

第八章 Swift原生集合类型

1、数组

• Array是结构体类型，是一个一维泛型集合。元素是有序的，可以重复出现。
  声明：

  var studentList: Array
  var studentList1: [String]
  

  初始化：声明的时候，可以初始化 也可以不初始化。但是 let定义的数组为不可变数组 必须声明的时候初始化，以后也不可以修改。

   var student: [String] = ["张三", "李四", "王五"]  // : [String] 去掉更常用
  

  特殊初始化：

    // 进行了初始化 var studentList1: [String]只声明 没有进行初始化，即没有开辟内存空间
    var studentList2 = [String]()   // 常用
    var studentList3 = Array()   // 不常用
  

• 可变数组的插入元素：

    student.insert("刘备", at: student.count)
    #warning  student.count 是指数组的长度
    student.append("lpn")  // 追加元素
  

• 删除元素

       student.remove(at: 1)
  

• 修改元素

       str[0] = "qwe"
  

• 取出元素

        str[0]
  

• 遍历数组

  1、for (index, value) in student.enumerated() {
     print("\(index)---\(value)") // index是索引，value是元素
  }
  
  2、for i in 0..

• 数组的合并： 相同类型的数组才能允许合并

   str + str1
  

2、Set

• 是由一串无序的，不能重复 的相同类型元素构成的集合。结构体类型，也是一个一维泛型集合。

• Set声明 let不可变 var可变

  var studentList: Set
  

• Set初始化

   // 初始化
  var studentList1: Set = ["张三", "李四", "王五", "赵六"]
  var studentList2 = Set()
  // var studentList3 = ["张三", "李四"] 这个默认的是数组
  // var studentList3: [String] = ["张三", "李四"] 这个默认的是数组
  

• Set操作 无序！！始终操作对象在最左边

  insert(_:) // 插入一个元素  在开始的位置
  removeFirst() // 删除最后一个元素（即是左边第一个元素）
  remove(_:)  // 删除指定的元素
  contains(_:) // 是否包含某个元素  返回Bool
  

• 遍历与数组遍历一样 for - in ，enumerated()->(index, value)元组

• Set运算

  let A: Set = ["a", "b", "e", "d"]
  let B: Set = ["d", "c", "e", "f"]
  
  A.intersection(B) // 交集 {"e", "d"}
  A.union(B)  // 并集 {"b", "e", "a", "f", "d", "c"}
  A.symmetricDifference(B) // 异或  属于A但不属于B 属于B但不属于A {"b", "f", "a", "c"}
  A.subtracting(B) // A与B的差集 {"b", "a"}
  A.isSubset(of: B) // A是B的子集吗 返回Bool值 false
  

3、字典---即使类型一直也不能相加+合并，数组可以

• 同名映射\散列表 结构体类型 也是一个泛型集合

• 字典的声明：

  var dict1: Dictionary
  var dict2: [Int: String]  // 属于简写
  

• 初始化：let定义的(不可变)字典的同时 必须进行初始化

  var dict1 =  Dictionary()  // 可变字典先创建 后赋值
  var dict2 = [Int: String]()  // 可变字典常用[Int: AnyObject]() AnyObject指类型，而NSObject指创建对象
  var dict3 = [102 : "123"]  // 类型也可以带上  不可变的字典常用简单
  var dict3: Dictionary = [102 : "123"]
  var dict3: [Int: String] = [102 : "123"]
  

• 添加

   var dict1 = [String: AnyObject]() // 不同类型
   
   dict1["height"] = 1.88 as AnyObject
   dict1["name"] = "xxx" as AnyObject
   dict1["age"] = 18 as AnyObject
  

• 删除

    dict1.removeValue(forKey: "name")
  

• 修改

  dict1["name"] = "123" as AnyObject // 如果name  key不存在那么久add添加，如果存在就update修改  同updateValue
  
  var dict3:[Int: String] = [102 : "123"]
  var replaceStr = dict3.updateValue("456", forKey: 102)
  print(replaceStr!)   // 返回被替换的值打印 ”123“
  

• 遍历

  var dict3:[Int: String] = [102 : "张三", 103: "李四", 104: "王五"]
  
  for key in dict3.keys {
      print(key)
  }
  for value in dict3.values {
     print(value)
  }
  for (key , value) in dict3 {  // 逗号分隔键值对，返回元组类型
     print("\(key)-\(value)")
  }