常量和變量

聲明常量和變量

常量和變量必須在使用之前聲明
使用let關(guān)鍵字聲明常量
使用var關(guān)鍵字聲明變量

let a = 10  //聲明一個名字是 a 的新常量，并賦值為10 
var b = 20 //聲明一個名字是 b 的變量，并賦值為20 

可以在一行中聲明多個常量或者多個變量，用逗號隔開

var x = 10, y = 20
let  a = 30, b = 40

類型標(biāo)注

var name: String //聲明一個類型為String,名字為name的變量
name = "jay"

可以在一行中定義多個同樣類型的變量，用逗號分割，并在最后一個變量名之后添加類型標(biāo)注

var x, y, z: Double

注意：一般來說，很少寫類型標(biāo)注，如果你在聲明常量或者變量的時賦了初始值，swift可以推斷出這個常量或者變量的類型，上述的例子中，沒有給name賦初始值，它使用的是指定變量類型

命名常量和變量

常量和變量名稱幾乎可以包含任何字符，包括Unicode字符

let π = 3.14159
let 你好 = "你好世界"
let ???????? = "dog"

打印常量和變量

 var name:String
 name = "jay"
 print(name) // jay
 print("name is \(name)")// name is jay

注釋

// 這是一個注釋
/*這是一個注釋*/

與C中的多行注釋不同，Swift中的多行注釋可以嵌套在其他多行注釋中。您可以通過啟動多行注釋塊然后在第一個塊中開始第二個多行注釋來編寫嵌套注釋。然后關(guān)閉第二個塊，然后是第一個塊

/* 這是第一個多行注釋的開頭
 /* 這是第二個被嵌套的多行注釋 */
這是第一個多行注釋的結(jié)尾 */

分號

• Swift并不強(qiáng)制要求你在每條語句的結(jié)尾處使用分號（;）

let cat = "??"

• Swift也可以按習(xí)慣添加分號

let cat = "??"; 

• 有一種情況下必須要用分號，即你打算在同一行內(nèi)寫多條獨立的語句

let cat = "??"; print(cat)

整型

• 整數(shù)是整數(shù)，沒有小數(shù)部分，如42、-23
• 整數(shù)有符號（正，零或負(fù)）如Int32
• 無符號（正或零）如UInt8

整數(shù)范圍

let minValue = UInt8.min  // minValue 為 0，是 UInt8 類型
let maxValue = UInt8.max  // maxValue 為 255，是 UInt8 類型

Int與UInt

一般來說，你不需要專門指定整數(shù)的長度。Swift 提供了一個特殊的整數(shù)類型Int 和 UInt，長度與當(dāng)前平臺的原生字長相同

在32位平臺上，Int 和 Int32 長度相同
在64位平臺上，Int 和 Int64 長度相同
在32位平臺上，UInt 和 UInt32 長度相同
在64位平臺上，UInt 和 UInt64 長度相同

浮點數(shù)

• 浮點數(shù)是有小數(shù)部分的數(shù)字，如3.14159、0.1 、 -273.15
• Double表示64位浮點數(shù)（當(dāng)你需要存儲很大或者很高精度的浮點數(shù)時請使用此類型）
• Float表示32位浮點數(shù)（精度要求不高的話可以使用此類型）

類型安全和類型推斷

Swift是一個類型安全（type safe）的語言，所以它會在編譯你的代碼時進(jìn)行類型檢查（type checks），并把不匹配的類型標(biāo)記為錯誤。這可以讓你在開發(fā)的時候盡早發(fā)現(xiàn)并修復(fù)錯誤

let meaningOfLife = 42 //推測為 Int 類型
let pi = 3.14159 // 當(dāng)推斷浮點數(shù)的類型時，Swift 總是會選擇 Double 而不是Float

表達(dá)式中同時出現(xiàn)了整數(shù)和浮點數(shù)，會被推斷為 Double 類型

let anotherPi = 3 + 0.14159 //anotherPi 會被推測為 Double 類型

數(shù)值型字面量

• 一個十進(jìn)制數(shù)，沒有前綴， 如let decimalInteger = 17
• 一個二進(jìn)制數(shù)，前綴是0b，如let binaryInteger = 0b10001
• 一個八進(jìn)制數(shù)，前綴是0o，如let octalInteger = 0o21
• 一個十六進(jìn)制數(shù)，前綴是0x，如let hexadecimalInteger = 0x11

數(shù)值型類型轉(zhuǎn)換

常量a是UInt8類型，常量b是UInt16類型,它們不能直接相加，因為它們類型不同。所以要調(diào)用UInt16(a)來創(chuàng)建一個新的UInt16數(shù)字并用a的值來初始化，現(xiàn)在兩個數(shù)字的類型都是 UInt16，可以進(jìn)行相加。目標(biāo)常量 c 的類型被推斷為 UInt16，因為它是兩個 UInt16 值的和

let a :UInt8 = 10
let b :UInt16 = 20
let c = UInt16(a) + b

• 整數(shù)和浮點轉(zhuǎn)換
  • 整數(shù)和浮點數(shù)的轉(zhuǎn)換必須顯式指定類型

      let a = 3
      let b = 0.14159
      //let c = a + b //報錯
      let c = Double(a) + b //正確
    

  • 浮點數(shù)到整數(shù)

     //當(dāng)用這種方式來初始化一個新的整數(shù)值時，浮點值會被截斷。也就是說 4.75 會變成 4，-3.9 會變成 -3
      let d = Int(c)   //3
    

類型別名

給現(xiàn)有類型再起另一個名字，使用typealias關(guān)鍵字

typealias weight = UInt16   //weight被定義為UInt16的一個別名
var value = weight.min  //實際上是UInt16.min

布爾值

• true
• false

元組

元組（tuples）把多個值組合成一個復(fù)合值。元組內(nèi)的值可以是任意類型，并不要求是相同類型, (Int,String),(Int,Int,Bool)

• 元組的定義

//定義元組時，可以在元組中命名各個元素
let http200Status = (statusCode: 200, description: "OK")
//也可以直接定義
let http404Error = (404,"Not Found")

• 元組的訪問
  • 可以將元組的內(nèi)容分解為單獨的常量或變量

  let http404Error = (404,"Not Found")
  let (statusCode,statusMessage) = http404Error;
  print(statusCode)//404
  print(statusMessage)//Not Found
  

  • 如果你只需要一部分元組值，分解的時候可以把要忽略的部分用下劃線（_）標(biāo)記

  let http404Error = (404,"Not Found")
  let (statusCode, _) = http404Error
  print("The status code is \(statusCode)")//The status code is 404
  

  • 通過下標(biāo)來訪問元組中的單個元素，下標(biāo)從零開始

  let http404Error = (404,"Not Found")
  print("The status code is \(http404Error.0)")//The status code is 404
  print("The status message is \(http404Error.1)")//The status code is 404
  

  • 如果在元組中命名元素，則可以使用元素名稱來訪問這些元素的值

    let http200Status = (statusCode: 200, description: "OK")
    print("The status code is \(http200Status.statusCode)")// Prints "The status code is 200"
    print("The status message is \(http200Status.description)")// Prints "The status message is OK"
    

• 元組作為返回值
  元組在臨時組合值的時候很有用，但是并不適合創(chuàng)建復(fù)雜的數(shù)據(jù)結(jié)構(gòu)。如果你的數(shù)據(jù)結(jié)構(gòu)并不是臨時使用，請使用類或者結(jié)構(gòu)體而不是元組

可選類型（Optionals）

optionals

• 使用可選類型（optionals）來處理值可能缺失的情況
• 可選的代表兩種可能性：
  • 有值
  • 沒有值
• 一個可選的 XXX 被寫作 XXX? ，問號暗示包含的值是可選類型，也就是說可能包含 XXX 值也可能不包含值。

let possibleNumber = "123"
let convertedNumber = Int(possibleNumber)
print(convertedNumber)  //Optional(123)

因為該構(gòu)造器可能會失敗，所以它返回一個可選類型（optional）Int，而不是一個 Int。也就是說可能包含 Int 值也可能不包含值。

nil

給可選變量賦值為nil來表示它沒有值：

var value: Int? = 10  // value 包含一個可選的 Int 值 10
value = nil  // value 現(xiàn)在不包含值

聲明一個可選常量或者變量但是沒有賦值，它們會自動被設(shè)置為 nil

var message: String?  // message 被自動設(shè)置為 nil

注意：
nil不能用于非可選的常量和變量。如果你的代碼中有常量或者變量需要處理值缺失的情況，請把它們聲明成對應(yīng)的可選類型。

if 語句以及強(qiáng)制解析

可以使用 if 語句和 nil 比較來判斷一個可選值是否包含值,使用(==)或(!=)來執(zhí)行比較

• 如果可選類型有值，它將不等于 nil

var code: Int? = 10
if code != nil {
   print("code contains some integer value")
}

• 當(dāng)你確定可選類型確實包含值之后，你可以在可選的名字后面加一個感嘆號（!）來獲取值。這個驚嘆號表示“我知道這個可選有值，請使用它。這被稱為可選值的強(qiáng)制解析（forced unwrapping）

var code: Int? = 10
if code != nil {
    print("code has an integer value of \(code!).")//code has an integer value of 10.
}

注意：
使用 ! 來獲取一個不存在的可選值會導(dǎo)致運行時錯誤。使用 ! 來強(qiáng)制解析值之前，一定要確定可選包含一個非 nil 的值。

可選綁定（optional binding）

使用可選綁定來判斷可選類型是否包含值，如果包含就把值賦給一個臨時常量或者變量

var code: Int? = 10
if let constantName = code {
     print("code has an integer value of \(constantName!).")
}
//(1)判斷constantName是否有值，如果沒有值就不執(zhí)行大括號中的內(nèi)容；
//(2)如果constantName有值的話，就把constantName進(jìn)行解包

隱式解析可選類型（implicitly unwrapped optionals）

有時候在程序架構(gòu)中，第一次被賦值之后，可以確定一個可選類型總會有值。這種類型的可選狀態(tài)被定義為隱式解析可選類型

把想要用作可選的類型的后面的問號（String?）改成感嘆號（String!）來聲明一個隱式解析可選類型。

一個隱式解析可選類型其實就是一個普通的可選類型，但是可以被當(dāng)做非可選類型來使用，并不需要每次都使用解析來獲取可選值。下面的例子展示了可選類型 String 和隱式解析可選類型 String 之間的區(qū)別：

let name: String? = "xiaoming."
let studentName: String = name!  // 需要感嘆號來獲取值

let city: String! = "Shanghai."
let studentCity: String = city // 不需要感嘆號

注意：
如果一個變量之后可能變成nil的話請不要使用隱式解析可選類型。如果你需要在變量的生命周期中判斷是否是nil的話，請使用普通可選類型。

he