前言：
1.此文中的語法會根據(jù)Swift的升級變動而更新鸣哀。
2.如果需要請移步 -> swift2.2 語法（中）灵奖、swift 2.2語法（下）

Swift與OC中常見的區(qū)別

• 導(dǎo)入框架

  • OC:
    
    

     #import <UIKit>
     #import "AFNetWorking.h"
    
    

  • Swift:
    
    

     import UIKit
    
    

• 定義標(biāo)識符

  • OC:
    
    

     int i = 0;
    
    

  • Swift:
    
    

     // 不可變標(biāo)識符
     let i = 0  或 let i : Int = 0
    
     // 可變標(biāo)識符
     var i = 0  或 var i : Int = 0
    
    

• ";"號的使用

  • OC：每個語句后都必須加上;以示結(jié)尾
  • Swift：
    
    1.如果在一行中只有一條語句,那么語句結(jié)束時 ";" 號可以省略
    
    2.如果一行中有多條,那么需要以 ";" 進行分割

常量和變量

• 在定義一個標(biāo)識符時,必須明確告訴編譯器這個標(biāo)識符是變量還是常量
• 常量,需要在定義最前面加上 'let',定義后不可修改
• 變量,需要在定義最前面加上 'var',定義后可以修改
  • 格式:let/var 標(biāo)識符名稱 : 類型 = 10;
    
    
    

 import UIKit
 
 // 定義一個常量
 let a : Int = 0    //  或 let a = 0
 // 因為常量不可修改飘蚯，所以 a = 1 的是錯誤的寫法
 
 // 定義一個變量
 var b : Int = 0    //  或 var b = 0
 // 因為變量可以修改矢门，所以來修改下變量
 b = 1
 

• 常量使用注意

  • 在開發(fā)中優(yōu)先使用常量,只有發(fā)現(xiàn)該標(biāo)識符需要修改時,再改成變量(保證數(shù)據(jù)更加安全)
  • 常量本質(zhì):指向的內(nèi)存地址不可修改,但通過內(nèi)存地址找到對應(yīng)的對象,就可以修改對象內(nèi)部屬性
    
    
    

  //  創(chuàng)建一個常量指向UIView并修改內(nèi)部屬性
  let view : UIView = UIView()
  //  設(shè)置尺寸
  view.frame = CGRectMake(0, 0, 150, 150)
  //  設(shè)置背景顏色
   = UIColor.greenColor()
  
  //  定義一個常量保存尺寸信息
  let rect = CGRectMake(0, 0, 150, 150)
  //  定義一個變量指向UIView并切換到UIButton
  var tempView : UIView = UIView(frame: rect)
  //  設(shè)置背景顏色
  tempView.backgroundColor = UIColor.redColor()
  //  切換變量指向的View
  tempView = UIButton(type: .Custom)
      
  

swift中數(shù)據(jù)類型

• 介紹
  • Swift中的數(shù)據(jù)類型也有：整型/浮點型/對象類型/結(jié)構(gòu)體類型等
    • 整型
      • 有符號
        • Int8 : 有符號8位整型
        • Int16 : 有符號16位整型
        • Int32 : 有符號32位整型
        • Int64 : 有符號64位整型
        • Int : 和平臺相關(guān)(默認(rèn),相當(dāng)于OC的NSInteger)
      • 無符號
        • UInt8 : 無符號8位整型
        • UInt16 : 無符號16位整型
        • UInt32 : 無符號32位整型
        • UInt64 : 無符號64位整型
        • UInt : 和平臺相關(guān)(常用,相當(dāng)于OC的NSUInteger)(默認(rèn))
      • 浮點型
        • Float : 32位浮點型
        • Double : 64浮點型(默認(rèn))

類型推導(dǎo)

• Swift是強類型語言
• Swift中任何一個標(biāo)識符都有明確的類型
• 注意：
  • Swift中在定義一個標(biāo)識符時,有直接給該標(biāo)識符進行賦值,那么標(biāo)識符后面的類型可以省略（因為類型推導(dǎo)會自動根據(jù)后面賦值的類型推導(dǎo)出前面標(biāo)識符的類型）
  • 在Swift中可以通過option + 鼠標(biāo)左鍵,可以查看某個標(biāo)識符的類型
    
    
    

//  定義一個Int類型的常量
let a : Int = 15
//  因為有類型推導(dǎo)的特性懂拾，所以上面的語句可以簡寫為
let a = 15  //  編譯器會自動根據(jù)右邊值得類型判定數(shù)據(jù)類型

//  定義一個浮點類型的常量
let b : Double = 3.14
//  因為有類型推導(dǎo)的特性脂倦，所以上面的語句可以簡寫為
let b = 3.14    //  因為右邊是浮點型數(shù)據(jù)，所以編譯器會判定常量類型為浮點型

基本運算

• 在Swift中,不同類型的數(shù)據(jù)類型之間不能進行運算(因為Swift中沒有隱式轉(zhuǎn)換)
• 如果數(shù)據(jù)類型不一致,就需要轉(zhuǎn)化數(shù)據(jù)類型,使類型一致
  
  
  

//  相同類型運算
let a = 15
let b = 20
//  求和
let sum = a + b


//  不同類型運算
let a = 30.0
let b = 15
//  轉(zhuǎn)換類型
let tempA = Int(a)
//  求和
let sum = tempA + b

判斷分支

• 介紹
  • 判斷分支指if/switch/三目運算符等判斷語句
  • 通過判斷分支可以控制程序的執(zhí)行順序

• if判斷

  • if后面的()可以省略掉

  • 在Swift中冯痢，判斷語句必須有明確的真假

    • if后面的判斷句沒有非0(nil)即真概念
    • if后面的判斷句必須明確真假(Bool) --> true/false
      
      
      

    let a = 15
    
    if a > 11{
        print(a)
    }
    
    //  因為Swift中氮昧，只有聲明成可選類型，才能判斷是否為空
    let view : UIView? = UIView()
    
    if view != nil {
    
    view!.backgroundColor = UIColor.blueColor()
    
    }
    
    

• 三目運算符(和OC一樣浦楣，沒有別的區(qū)別)
  
  
  

let a = 15
let b = 20

var result = a > b ? a : b

print(result)

• guard(守衛(wèi))使用
  • guard是Swift2.0新增的語法
  • 它與if語句非常類似,設(shè)計的目的是提高程序的可讀性
  • guard語句必須跟上else,{}內(nèi)必須跟上break/continue/return
    
    
    

/* 假設(shè)成績?yōu)?00分,60以下為不及格 */

//  定義一個常量
let a = 99

//  定義一個test函數(shù)袖肥，參數(shù)Int類型
func test(a : Int) {
    
    guard a >= 60 else {
        
        print("不及格")
        return
    }
    
    print("優(yōu)秀")
}

//  調(diào)用函數(shù)
test(a)

• switch判斷

  • 介紹
    • 蘋果對Switch進行了大大的增強，使其擁有其他語言沒有的特性
  • 使用
    • 基本用法和OC一樣
    • switch后面的（）可以省略
    • case后的break可以省略（默認(rèn)會自動填補break）
      
      
      

  
  let a = 0
  
  switch a {
  case 0 :
      print("真")
  case 1 :
      print("假")
  default :
      print("其它")
  }
  
  

  • 一個case判斷中振劳，可以判斷多個值（值之間用 “,” 分隔）
    
    
    

  
  let a = 0
  
  switch a {
  case 0, 1 :
      print("真假")
  default :
      print("其它")
  }
  
  

  • 如果希望出現(xiàn)case穿透椎组，可以使用關(guān)鍵字fallthrough
    
    
    

  let a = 0
  
  switch a {
  case 0 :
      fallthrough
  case 1 :
      print("假")
  default :
      print("其它")
  }
  
  

  • switch支持多種數(shù)據(jù)類型（包含浮點型、字符串類型）

  • switch支持區(qū)間判斷

    • 常見的區(qū)間
      
      1.半開半閉區(qū)間：0..<10(表示0~9)
      
      2.閉區(qū)間：0...10（表示0~10）
      
      
      

    
    /* 假設(shè)成績?yōu)?00分 */
    
    let a = 88
    
    switch a {
    
    case 0..<60:
     print("不及格")
    case 60..<80:
     print("幾個")
    case 80..<90:
     print("良好")
    case 90..<100:
     print("優(yōu)秀")
    default:
     print("滿分")
    
    }
    
    

循環(huán)

• 循環(huán)是開發(fā)中必不可少的历恐，常見循環(huán)有：for/while/do...while

  • for循環(huán)
    • for后面的()可以省略
      
      
      

  //  傳統(tǒng)寫法
  for var i = 0; i < 15; i++ {
      print(i)
  }
  
  //  區(qū)間循環(huán)
  for i in 0..<15 {
      print(i)
  }
  
  for i in 0...15 {
      print(i)
  }
  
  //  特殊寫法
  //  有時候我們只需要循環(huán)語句內(nèi)的操作寸癌，不需要i，那么i可以用_代替
  for _ in 0..<15 {
      print("hello world")
  }
  
  

  • while循環(huán)
    • while的判斷句必須有真假（沒有非0即真概念）
    • while后面的()可以省略
      
      
      

  
  var a = 0
  
  while a < 10 {
      a++
  }
  
  

  • do...while循環(huán)
    • 使用repeat關(guān)鍵字代替了do
      
      
      

  let a = 0
  repeat {
      print(a)
      a++
  } while a < 20
  
  

字符串

• OC和swift中字符串的區(qū)別

  • OC中字符串類型為NSString弱贼，在swift中字符串類型為String
  • OC中字符串用@“”包裝蒸苇，swift中字符串用“”包裝

• 使用String原因

  • String是一個結(jié)構(gòu)體，性能較高吮旅；NSString是一個OC對象溪烤，性能較差
  • String支持直接遍歷
  • swift提供了String和NSString間無縫轉(zhuǎn)換

• 定義

  • 不可變字符串
    
    
    

  let str = "hello world"
  
  

  • 可變字符串
    
    
    

  var str = "hello world"
  
  

• 使用

  • 獲取字符串長度
    
    
    

  let count = str.characters.count
  
  

  • 遍歷字符串
    
    
    

  var str = "hello world"
  
  for tmp in str.characters {
      
  }
  
  

  • 字符串拼接
    
    
    

  let str1 = "hello"
  let str2 = "world"
  let str = str1 + str2
  
  

  • 字符串和其它數(shù)據(jù)類型拼接
    
    
    

  let str1 = "xiao ming"
  let str2 = 23
  
  let str = "\(str1)今年\(str2)歲"
  
  

  • 字符串的格式化

    • 如：時間
      
      
      

    let min = 3
    
    let time = String(format:"%02d", arguments:[min])
    
    

  • 字符串截取方式

    • 常用方式：String轉(zhuǎn)換成NSString后再截取（簡便）
      
      
      

    let myStr = "hello world"
    var subStr = (myStr as NSString).substringFromIndex(4)
    subStr = (myStr as NSString).substringToIndex(3)
    subStr = (myStr as NSString).substringWithRange(NSRange(location: 4, length: 5))
    
    

    • 方式二：使用swift原生截取方式
      
      
      

    //  定義一個String類型的常量str
    let str : String = "http://blog.csdn.net/yeshaojian"
    
    //  截取開始位置
    let startIndex = str.startIndex.advancedBy(7)
    let head = str.substringFromIndex(startIndex)
    
    //  截取結(jié)束位置
    let endIndex = str.endIndex.advancedBy(-11)
    let foot = str.substringToIndex(endIndex)
    
    //  截取中間網(wǎng)址
    let range = Range(start: startIndex, end: endIndex)
    let middle = str.substringWithRange(range)
    
    

數(shù)組

• 介紹

  • 數(shù)組（Array）是一串有序的由相同類型元素構(gòu)成的集合
  • 數(shù)組中的集合元素是有序的庇勃，可以重復(fù)出現(xiàn)
  • swift中的數(shù)組
    • swift數(shù)組是一個泛型集合,類型是Array檬嘀，

• 初始化數(shù)組

  • 數(shù)組分為可變數(shù)組和不可變數(shù)組

    • 使用let修飾的數(shù)組是不可變數(shù)組
    • 使用var修飾的數(shù)組是可變數(shù)組
      
      
      

    //  在swift中任意類型一般不用NSObject而會使用AnyObject
    //  定義一個不可變數(shù)組(存儲內(nèi)容為AnyObject)
    let array : [AnyObject] = ["123", 15, ["se"]]
    
    //  定義一個可變數(shù)組,并初始化值
    var arrayM : [String] = [String]()
    
    

    注意：在swift中任意類型一般不用NSObject而會使用AnyObject

  • 聲明數(shù)組的簡便寫法
    
    
    

  //  聲明可變數(shù)組
  var arrayM2 : Array<String>
  //  或
  var arrayM3 : [String]
  
  //  聲明不可變數(shù)組
  let array1 : Array<AnyObject>
  let array2 : [AnyObject]
  
  

  注意：聲明的數(shù)組需要初始化才能使用，數(shù)組類型一般都是在聲明的同時進行初始化

  • 對聲明的數(shù)組進行初始化
    
    
    

  //  初始化值
  arrayM2 = ["1", "2", "3"]
  //  初識化后可追加值
  arrayM2.append("隔壁老王")
  
  //  因為上面我們聲明的array1是let(常量)责嚷，所以初始化后不能追加元素（不能使用append追加元素）
  array1 = ["se", 234]
  
  

  • 數(shù)組的增鸳兽、刪、改罕拂、查
    
    

  //  定義一個可變數(shù)組
  var arrayM : [AnyObject] = ["123", 15, 25, 35]
  
  //  添加數(shù)據(jù)
  arrayM.append("隔壁老王")
  
  //  取值
  arrayM[4]
  
  //  修改元素
  arrayM[0] = "12"
  
  //  刪除數(shù)組最前面的元素（這邊填 2 就表示刪除2次揍异，所以執(zhí)行完畢后 隔壁老李 和 "123" 會被刪除)
  arrayM.removeFirst(2）
  
  //  刪除數(shù)組最后面的元素
  arrayM.removeLast()
  
  //  刪除指定下標(biāo)的元素(0 表示刪除第一個元素)
  arrayM.removeAtIndex(0)
  
  //  刪除所有元素
  arrayM.removeAll()
  
  

  • 數(shù)組的遍歷

  //  定義一個可變數(shù)組
  var arrayM : [AnyObject] = ["123", 15, 25, 35, "隔壁老王"]
  
  //  方式一：遍歷數(shù)組下標(biāo)
  for i in 0..<arrayM.count {
      print(i)
  }
  
  //  方式二：遍歷數(shù)組內(nèi)容
  for name in arrayM {
      print(name)
  }
  
  //  方式三：設(shè)置數(shù)組遍歷區(qū)間
  for name in arrayM[0..<3] {
      print(name)
  }
  
  //  方式四（常用）遍歷數(shù)組同時獲取下標(biāo)
  for (i, name) in arrayM.enumerate() {
      print("\(i)--\(name)")
  }
  
  

  • 數(shù)組合并

  // 相同類型的數(shù)組才能合并
  let array1 = ["123", "157", "12345", "234567", "15689123"]
  let array2 = ["1568648", "26879435", "1578715645"]
  
  let array3 = array1 + array2
  
  //  一個數(shù)組最好不要存放多種類型數(shù)據(jù)
  var arrayM1 = ["mms", 56, "隔壁老王", 37, "15689123"]
  var arrayM2 = [12, "哈哈哈哈", "1578715645"]
  
  var arrayM3 = arrayM1 + arrayM2
  
  

  注意:只有相同類型的數(shù)組才能合并

字典

• 介紹

  • 字典由鍵(key)集合和值(value)集合兩部分構(gòu)成
  • 鍵集合不能有重復(fù)元素，而值集合可以重復(fù)聂受，每一個鍵對應(yīng)一個值
  • 字典可以按照某個鍵來訪問對應(yīng)的元素
  • swift字典類型為Dictionary蒿秦，和數(shù)組一樣死個`泛型集合``

• 初始化字典

  • swift的字典分為可變和不可變字典2種

    • 使用let修飾的字典是不可變字典
    • 使用var修飾的字典是可變字典
      
      
      

    //  定義一個不可變字典
    let dict = ["name" : "laoWang", "city" : "隔壁", "age" : 35]
    
    //  定義一個
    var dictM : [String : AnyObject] = [String : AnyObject]()
    
    

    注意：在swift中任意類型一般不用NSObject而會使用AnyObject

  • 聲明字典
    
    
    

  //  聲明不可變字典
  let dict1 : [Int : AnyObject]
  let dict2 : Dictionary<Int, AnyObject>
  
  //  聲明可變字典
  var dictM1 : [Int : AnyObject]
  var dictM2 : Dictionary<Int, AnyObject>
  
  

  注意：和數(shù)組一樣，聲明的字典也需要初始化值后才可使用

  • 聲明的字典需要初始化才能使用蛋济，字典類型一般是在聲明的同時進行初始化
    
    
    

  //  初始化不可變字典值
  dict1 = [0 : "aa", 1 : "bb", 2 : "cc"]
  dict2 = ["name" : "laoWang", "age" : 35]
  
  //  初始化可變字典值
  dictM1 = ["name" : "laoWang", "age" : 35]
  dictM2 = [0 : "aa", 1 : "bb", 2 : "cc"]
  
  

  • 字典的增刪改查

  //  添加Key為city value為gebi
  dictM1["city"] = "gebi"
  
  //  修改
  dictM1["name"] = "laoLi"
  
  //  查詢
  dictM1["name"]
  
  //  刪除
  dictM1.removeValueForKey("city")
  
  //  刪除所有元素
  dictM1.removeAll()
  
  

  • 字典遍歷
    
    
    

  //  方式一：遍歷字典內(nèi)所有值
  for value in dictM1.values {
      print(value)
  }
  
  //  方式二：遍歷字典中所有的鍵
  for key in dictM1.keys {
      print(key)
  }
  
  //  方式三：遍歷字典中鍵和值
  for (key, value) in dictM1 {
      print("\(key) : \(value)")
  }
  
  

  • 字典合并
    
    
    

  //  字典合并
  //  只有字典內(nèi)容類型相同的字典才可合并
  //  定義一個不可變字典（key:String類型 value:AnyObject類型）
  let dict1 : [String : AnyObject] = ["name" : "laoWang", "age" : 35]
  //  定義一個可變字典（key:String類型 value:AnyObject類型）
  var dictM2 : Dictionary<String, AnyObject> = ["city" : "gebi"]
  
  //  遍歷dict1的key和value并合并（添加）到dictM2字典中
  for (key, value) in dict1 {
      dictM2[key] = value 
  }
  
  print(dictM2)
  
  

  注意：只有字典內(nèi)容類型相同的字典才可合并

元組

• 元組是Swift中特有的,OC中并沒有相關(guān)類型

  • 元組是一種數(shù)據(jù)結(jié)構(gòu)棍鳖，類似于數(shù)組或者字典
  • 可以用于定義一組數(shù)據(jù)
  • 多個值組合而成的復(fù)合值。元組中的值可以是任意類型，而且每一個元素的類型可以不同
  • 組成元組類型的數(shù)據(jù)稱為“元素”

• 定義元組
  
  
  

  //  方法一：基本寫法（格式：(元素,元素)  數(shù)據(jù)類型不限）
  let personInfo1 = ("老王", 35, 1.80, "laoWang")
  
  //  方法二：在上面方法的基礎(chǔ)給元素定義名稱
  let personInfo2 = (name:"老王", age:35, height:1.80, EnglishName:"laoWang")
  
  //  方法三：先定義元素名渡处，在設(shè)置值
  let (name, age, height, EnglishName) = ("老王", 35, 1.80, "laoWang")
  
  //  方法四：明確有幾個元素并且確定類型
  var personInfo3 : (Int, String) = (0, "老王")
  
  

• 元組操作
  
  
  

  //  通過下標(biāo)或者別名讀取值
  personInfo1.0
  
  personInfo2.name
  
  name
  
  

可選類型

• 可選類型作用：

  • 在OC中镜悉，如果一個變量暫停不適用，可以賦值為0（基本屬性類型）或賦值為空（對象類型）
  • 在swift中医瘫，nil被定義為一個特殊的類型侣肄，因為和真是的類型不匹配是不能賦值的（強類型語言特性）
  • 為了在開發(fā)中賦值為nil，畢竟很經(jīng)常用到醇份，所以推出了可選類型
  • 可選類型的取值為：
    • 空值
    • 有值

• 可選類型定義

  • 基本寫法(不常用)
    
    
    

  //  基本寫法
  let user : Optional<String> = nil
  
  

  • 糖語法（推薦）
    
    
    

  //  糖語法
  let user : String? = nil
  
  

• 可選類型簡單使用

//  可選類型使用
var user : String? = nil

//  給可選類型賦值(我們上面定義的可選類型為String類型稼锅，所以只能給他賦值String類型)
user = "laoWang"

//  可選類型取值(在可選類型內(nèi)，只能通過強制解包來取出可選類型的真實類型)
//  強制解包方式一：
user!

//  需要注意的是僚纷，如果可選類型為nil(為空)矩距，強制取出其中的值(強制解包)，會出錯
//  強制解包方式二：
if user != nil {
    print (user!)
}

//  為了在if語句里面方便使用user怖竭，我們可以定義一個可選綁定類型锥债，這樣也能達(dá)到嚴(yán)謹(jǐn)取值的效果（底層也是幫我們進行判斷，有值就會解包）
if let userStr = user {
    print (userStr)
}

注意：

1.如果可選類型為nil(為空)痊臭，強制取出其中的值(強制解包)哮肚，會出錯，所以解包前需要進行判斷
2.為了使用方便广匙，解包會以可選綁定的形式實現(xiàn)

• 可選類型重要性（讓代碼邏輯更加嚴(yán)謹(jǐn)）

//  OC中允趟，我們在定義一個包含中文的NSURL的時候是這樣的
NSString *urlStr = @"http://www.xxxxx.com/中文/sie";

//  因為字符串中包含中文，所以需要對字符串進行UTF8編碼轉(zhuǎn)換鸦致，防止出現(xiàn)訪問錯誤
NSString *str = [urlStr stringByReplacingPercentEscapesUsingEncoding:NSUTF8StringEncoding];

//  再將其包裝成NSURL
NSURL *url = [NSURL URLWithString:str];


//  在swift中拼窥，如果字符串中包含中文，且我們沒有對其進行處理蹋凝，那么就會直接返回nil
//  也就是說，url可能有值也可能沒值总棵，這時候就需要用可選類型來接收
//  方法一：標(biāo)準(zhǔn)寫法
let url : NSURL? = NSURL(string: "http://www.xxxxx.com/中文/sie")
//  方法二：利用類型推導(dǎo)
let url2 = NSURL(string: "http://www.xxxxx.com/中文/sie")
//  方法三：可選綁定
if let temp = url {
    let request = NSURLRequest(URL: temp)
    print (request)
}

類型轉(zhuǎn)化

• 類型轉(zhuǎn)化符號

  • as:將示例轉(zhuǎn)成某一類型
    • as?:判斷是否有值鳍寂，有則轉(zhuǎn)換，沒有則不轉(zhuǎn)換（推薦）
    • as!:不判斷是否有值情龄，直接轉(zhuǎn)換（不安全）
  • is:用來判斷一個示例是否是某一種類型
    
    
    

  //  定義一個數(shù)組
  let array : [AnyObject] = ["laoWang", 15, 18.9]
  
  //  取出數(shù)組中的第二個元素
  let temp = array[1]
  
  //  判斷第一個元素類型是否為字符串
  if temp is String {
      print("true")
  } else {
      print("flase")
  }
  
  //  將objc轉(zhuǎn)成真實類型
  //  方式一：使用as?將AnyObject轉(zhuǎn)成可選類型迄汛，通過判斷可選類型是否有值，來決定是否轉(zhuǎn)換成功
  let age = temp as? Int
  print(age)
  
  //  方式二：使用as!將AnyObject轉(zhuǎn)成真實類型骤视，因為objc的真實類型為Int不是String鞍爱，通過as！進行轉(zhuǎn)換后专酗，會直接報錯
  let age1 = temp as! String
  print(age1)