Swift学习笔记一

1.可选类型Optional

? 可以为 nil ，！不能为nil
强制解析 myString！（访问myString）
自动解析 var myString:String!
可选绑定 var myString:String?

循环

while
repeat { }while
continue语句：停止本次循环开始下次循环
break ：会立刻结束整个控制流的执行
fallthrough：如果在case执行完后，继续执行下面的case，需要使用fallthrough(贯穿)关键字。

字符串

字符串字面量
```
 var stringA = "Hello"
```
String 实例化
```
 var stringB = String("Swift!");
```
stringA.isEmpty (判断是否为空)

Siwft4.0 修改：String成Collection类型

 let greeting = "Hello Mars"
 print(greeting.count)
 greeting.forEach{print($0)}

字符 Character

不能创建空的 Character

字符串连接字符

 let charB: Character = "B"
 var str:String = "Hello"
 str.append(charB)

数组

创建：

 var arry1: Array = Array()

 var someInts = [Int](repeating: 0, count: 3)

 var somebInts:[Int] = [10, 20, 30]

访问数组：

     //1
     var someVar = somebInts[0]
     //2
     Array(somebInts[0..<2])

修改
```
 arrInts[2] = 50
```

删除

 //1
 arrInts.remove(at: 2)
 //2
 arrInts.removeLast()

遍历数组

 //1
 for (index, item) in arrInts.enumerated() {
     print("\(index),\(item)")
 }
 //2.
 arrInts.forEach {print($0)}
 //3. for-in

合并数组
```
  var ints = somebInts + arrInts
```
count 、 isEmpty

字典

创建

 //1
 var dict = [Int: String]() //key为int value为String
 //2
 var dic:[Int: String] = [1:"One", 2:"Two", 3:"Three"]

访问 dic[key]

修改字典

 //1.updateValue
 var oldVal = dic.updateValue("One 的新值", forKey:1)
 var dd = dic[1]
  //2.通过key来修改
 dic[1] = "最新 One值"
 print(String(describing:dic[1]))

移除key-value对

 //1.removeValue
 var removedValue = dic.removeValue(forKey: 2)
 //2.
 dic[2] = nil

遍历字典
```
//1. for-in
//2. enumerate
```

字典转数组

 let dictkeys = [Int](someDict.keys)
 let dictValues = [String](someDict.values)

count , isEmpty

函数

常量，变量及I/O参数

如果想要声明一个变量参数，可以在参数定义前加 inout 关键字，这样就可以改变这个参数的值了。

当传入的参数作为输入输出参数时，需要在参数名前加 & 符，表示这个值可以被函数修改。

  func swapTwoInts(_ a: inout Int, _ b: inout Int)    {
  let temporaryA = a
  a = b
  b = temporaryA
  }
  var x = 1
  var y = 5
  swap(&x, &y)

2.嵌套函数

    func qiantaohanshu(fordec total: String) -> (String) -> String {
        func neihanshu (haha: String) -> String{
            return total + haha
        }
        return neihanshu
    }
    let diaoyong = qiantaohanshu(fordec: "天啊")
    diaoyong("好的")
    qiantaohanshu(fordec: "我是")("徐征")
    //打印结果为 我是徐征

闭包 Closures

表达式

 let divide = {(val1: Int, val2: Int) -> Bool in
      return val1 > val2
 }
 let result = divide(20,30)
 print(result)

尾随闭包：尾随闭包是一个书写在函数括号之后的闭包表达式，函数支持将其作为最后一个参数调用
闭包是引用类型：这也意味着如果您将闭包赋值给了两个不同的常量/变量，两个值都会指向同一个闭包：

集合 Set

    var vowel: Set = ["a", "e", "i", "o", "u"]
    vowel.count
    vowel.isEmpty

    vowel.contains("a")
    type(of: vowel.remove("a"))
    vowel.insert("a")
    //vowel.removeAll()

    for character in vowel.sorted() {
        print(character)
    }
    //
    vowel.forEach{print($0)}

结构体 struct 枚举 enum

都是值类型

类 Class

引用类型
恒等运算符 ===：如果两个常量或者变量引用同一个类实例则返回 true
不恒等运算符 !== 如果两个常量或者变量引用不同一个类实例则返回 true

属性

延迟存储属性 lazy :

('var' 关键字是必须的)

 class samples {
     lazy var no = number() //'var' 关键字是必须的
 }

 class number {
     var name =  "是小鸟"
 }
 var firstSample = samples()
 print(firstSample.no.name)

计算属性 getter setter
只读计算属性 getter

属性观察值： 可以为除了延迟存储属性之外的其他存储属性添加属性观察器，也可以通过重载属性的方式为继承的属性（包括存储属性和计算属性）添加属性观察器。

注意： 不需要为无法重载的计算属性添加属性观察器，因为可以通过 setter 直接监控和响应值的变化。

 //willSet 在设置新的值之前调用
 //didSet 在新的值被设置之后立即调用
 //willSet和didSet观察器在属性初始化过程中不会被调用
 
 class Samplepgm {
     var counter: Int = 0 {
         willSet(newTotal) {
             print("计数器：\(newTotal)")
         }
         didSet {
             if counter > oldValue {
                 print("新增数\(counter - oldValue)")
             }
         }
     }
     
 }

 let NewCounter = Samplepgm()
 NewCounter.counter = 100
 NewCounter.counter = 800

类型属性：类型属性是作为类型定义的一部分写在类型最外层的花括号（{}）内。

使用关键字 static 来定义值类型的类型属性，关键字 class 来为类定义类型属性。

 //static
 struct StructName {
     static var storedTypeProperty = " "
     static var computedTypeProperty: Int {
         //这里返回 一个 Int 值
         return 30
     }
 }
 //class
 class ClassNames {
     class var computedTypeProperty: Int {
         //这里返回一个 Int 值
         return 27
     }
 }

类似于实例的属性，类型属性的访问也是通过点运算符(.)来进行。但是，类型属性是通过类型本身来获取和设置，而不是通过实例