swift_基础

不同类型数据不能直接处理，需要转型

let i = 1; let j = 2.0;  let m = Double(i)+j;
也可直接定义 let i = 1 + 1.0 时，可以获取Double数据

运算符

1. 位运算
   ~ 取反 &位与 |位或 ^位异 <<左移 >>右移
2. 区间运算符

   1..<9  1到8    
   1...9   1到9 
   list[...3]  list 从0到3
   list[3....] list从到结束
   let range = ...3  0到3的PartialRangeThrough
   ``` 
   3，??
   两个？号后接默认值

   let list = [“1”,”2”]
   let s = list[3] ?? “3”

   ```
   let img : UIImageView? = nil        
   let icon :UIImage? = img?.image ?? UIImage(named: "xxx.png")

字符串

1. “双引号”，与普通NSString一样

2. “”” 三引号 “”” 可定义多行，可加双引号，注意：中间的空格号最后封闭有关

3. 如果想转成熟悉的NSString用的话可以：let str = “”; (str as NSString).substring(to: 10)

4. 字符串拼接

   let string1 = "hello"let string2 = " there"var welcome = string1 + string2//  "hello there"
   var instruction = "look over"instruction += string2// “look over there"
   let exclamationMark: Character = "!""hello there”.append(exclamationMark)// "hello there!"

5. 字符串插值

   let multiplier = 3
   let message = "\(multiplier) times 2.5 is \(Double(multiplier) * 2.5)" 
   // "3 times 2.5 is 7.5"

定义和调用函数

1. 定义：

   • 多个形参 func goodJoker(param:String,param2:String) -> [String:String] {return [param:param2]}

   • 复合返回 func goodJoker(param:String,param2:String) -> (v1:String , v2:String) {return (param , param2)}

   • 可空 如果返回的值可能为nil 则需要在返回值定义时后面加？ 如 ： (v1:String , v2:String)?

     类似 (String, String)?的可选元组类型和包含可选类型的元组 (String?, String?)是不同的。对于可选元组类型，整个元组是可选的，而不仅仅是元组里边的单个值

   • 参数标签 上面方法调用 self.goodJoker(param:”joker”, param2:”is good”) 每次调用都需要tag与OC一样
     

     也可以自定义`tag func joker(tag param:String)` 调用  self.joker(tag: "joker is good")<br>
     神奇的_    如果用下划线定义tag 则可以直接调用 self.joker("joker is good")

   • 参数默认值 OC中定义不同的参数传值需要定义多个方法，现在一个搞定
     func whoGood(_ who:String = "joker", is isGood:Bool = true) {}
     
     调用方式

     self.whoGood("me") 
     self.whoGood(is:false)      
     self.whoGood()

   • 可变形参

     func test(numbers: Double...) ->Double {
        var total:Double = 0;  
        for number in numbers{ 
           total += number
          }; 
        retrun total;
     }

   • 输入输出 inout： 函数能够修改一个形式参数的值，而且你想这些改变在函数结束之后依然生效，那么就需要将形式参数定义为输入输出形式参数 （记得加&）

     func swapTwoInts(_ a: inout Int, _ b: inout Int) {//两个参数值替换    
             let temporaryA = a    
             a = b    
             b = temporaryA
         }
     var someInt = 3
     var anotherInt = 107
     swapTwoInts(&someInt, &anotherInt)
     print("someInt is now \(someInt), and anotherInt is now \(anotherInt)") // prints "someInt is now 107, and anotherInt is now 3"

   • 函数类型: 函数也可以做为参数，返回值

     func addTwoInts(_ a: Int, _ b: Int) -> Int {    
          return a + b
      }
      var mathFunction: (Int, Int) -> Int = addTwoInts// 作为参数
      
      ——————————————————————————————————————————————————
      
      func printMathResult(_ mathFunction: (Int, Int) -> Int, _ a: Int, _ b: Int) {// 作为形式参数    
         print("Result: \(mathFunction(a, b))")
      }
      printMathResult(addTwoInts, 3, 5)
      // Prints "Result: 8"
      
      ——————————————————————————————————————————————————
      
      func chooseMath(_ p:Int) -> String {        
         return "this parameter = \(p)";    
       }
       func chooseStepFunction(_ method:(Int) -> String,_ p:Int) -> (Int,Int) -> Int {          
             print(method(p))          
             return addTwoInts    
       }
       print("new result = \((chooseStepFunction(chooseMath,1))(3,5))")
       // this parameter = 1
       // new result = 8
       解读：上面分别将chooseMath作为参数将addTwoInts作为返回值，

     • 内嵌函数 在默认情况下在外部是被隐藏起来的，但却仍然可以通过包裹它们的函数来调用它们。
       
       包裹的函数也可以返回它内部的一个内嵌函数来在另外的范围里使用

       func chooseStepFunction(backward: Bool) -> (Int) -> Int {    
            func stepForward(input: Int) -> Int { 
                return input + 1 
            }    
            func stepBackward(input: Int) -> Int { 
                return input - 1 
             }    
             return backward ? stepBackward : stepForward
        }
        var currentValue = -4
        let moveNearerToZero = chooseStepFunction(backward: currentValue > 0)
        // moveNearerToZero now refers to the nested stepForward() function
        while currentValue != 0 {    
            print("\(currentValue)... ")    
            currentValue = moveNearerToZero(currentValue)
        }
        print("zero!")
        // -4...// -3...// -2...// -1...// zero!

闭包 （与oc的blocks相似）

1. 闭包语法

       { (parameters) -> (return type) in    
       statements  
   }
   例：
   var list = [1, 2]
   list.sort { (s1:Int, s2:Int) -> Bool in            
                       return s1>s2        
              }

2. 闭包捕获值
   
   一个闭包能够从上下文捕获已被定义的常量和变量。即使定义这些常量和变量的原作用域已经不存在，闭包仍能够在其函数体内引用和修改这些值

   func makeIncrementer(forIncrement amount: Int) -> () -> Int {    
           var runningTotal = 0    
           func incrementer() -> Int {        
                   runningTotal += amount        
                   return runningTotal    
            }    
           return incrementer
    }
    let incrementByTen = makeIncrementer(forIncrement: 10)  
    incrementByTen()  //return a value of 10  
    incrementByTen()  //return a value of 20  
    incrementByTen()  //return a value of 30

3. 闭包的循环强引用

   class ClosureCode {    
    var delegate :SubVideoMode?    
    var nameStr = ""    
    lazy var someClosure: (Int, String) -> String = {
            [unowned self, weak delegate = self.delegate] (index: Int, stringToProcess: String) -> String in
             return "print \(self.nameStr)  \(index)  \(stringToProcess)"    
     }
   }

4. 引用 weak 弱引用 与 unowned 无主引用 （不安全，无主引用假定是永远有值的，程序会尝试访问曾今存在过的内存地址）
   
   当两个对象分别强引用对方时，无法释放，需要关键字标记 （应用区别，加？可空的用weak,没有？不可空的用unowned）

权举

1. 定义

   //普通
   enum UserName{      
       case joker      
       case god   // 也可以直接用，分隔  case joker,god
   }
   //定义不同类型值 
   enum Species{
        case person(String,Int)        
        case pig(Int)
    }
   //指定值 
   enum Numbers{
        case zero = 0 , one ,two
   }
   //zero明确为0，后面的依次加1
   // Numbers.zero.rawValue 为0  如果定义时未给值刚为zero
   //可以通过原始值初始化  let num = Numbers(rawValue: 1) 获取的是Numbers.one

2. 使用:
   
   可以直接以点开头，如：.joker 则是获取的是UserName.joker btn的属性 btn.setTitleColor(UIColor.white, for: .normal)
   
   不同类型值的使用

   switch species {
   case .persion(let name, let age):    print("person: \(name), \(age)")
   case .pig(let weight):    print("pig: \(weight).")
   }

六，类和结构休

1. 定义

   class SomeClass {
       // class definition goes here
   }
   struct SomeStructure {
       // structure definition goes here
   }

2. 类实例判断是否引用自同一个类实例 相同于（===） 不相同于（!==）
3. convenience: convenience用来进行方便的初始化，就相当于构造函数重载。不能调用super.init 可以用self.init
4. required：required 子类需要添加异于父类的初始化方法时，必须先要实现父类中使用required修饰符修饰过的初始化方法，并且也要使用required修饰符而不是override
5. final 可以防止方法重写
6. 可失败初始化器 init?{} 可以返回nil

错误处理

do {
    try expression
    statements
} catch pattern 1 {
    statements
} catch pattern 2 where condition {
    statements
}