swift 類型.

swift 類型

變量聲明

用let來聲明常量，用var來聲明變量
能夠在一行中聲明多個常量或者多個變量，用逗號隔開

    var x = 0.0, y = 0.0, z = 0.0

類型安全

Swift 是一個類型安全（type safe）的語言。類型安全的語言可讓你清楚地知道代碼要處理的值的類型。
一個變量是什麼類型,經過兩種方式來表達:

類型標註

類型標註表示這個變量能夠存儲某種類型的值,聲明中的冒號表明着「是...類型」:

            var welcomeMessage: String
        

類型推斷

若是你沒有顯式指定類型，Swift 會使用類型推斷（type inference）來選擇合適的類型。有了類型推斷，編譯器能夠在編譯代碼的時候自動推斷出表達式的類型。原理很簡單，只要檢查你賦的值便可。

注意:當推斷浮點數的類型時，Swift 老是會選擇Double而不是Float。通常來講你不多須要寫類型標註。若是你在聲明常量或者變量的時候賦了一個初始值，Swift能夠推斷出這個常量或者變量的類型

變量命名

• 當你將常量或者變量聲明爲肯定的類型，你就不能使用相同的名字再次進行聲明，或者改變其存儲的值的類型
• 若是你須要使用與Swift保留關鍵字相同的名稱做爲常量或者變量名，你可使用反引號（`）將關鍵字包圍的方式將其做爲名字使用。
• 常量的值一旦被肯定就不能更改了。嘗試這樣作會致使編譯時報錯

打印變量和常量

println是一個用來輸出的全局函數，輸出的內容會在最後換行。
xcode的playground使用println,點擊工具條的show the Assistant editor.即能顯示輸出

  var str = "Hello, playground"
  println(str)

類型轉換

SomeType(ofInitialValue)是調用 Swift 構造器並傳入一個初始值的默認方法。
注意，你並不能傳入任意類型的值，只能傳入SomeType內部有對應構造器的值。
不過你能夠擴展示有的類型來讓它能夠接收其餘類型的值（包括自定義類型）
不一樣整數類型的變量和常量能夠存儲不一樣範圍的數字,若是數字超出了常量或者變量可存儲的範圍，編譯的時候會報錯：

  let cannotBeNegative: UInt8 = -1
// UInt8 類型不能存儲負數，因此會報錯
let tooBig: Int8 = Int8.max + 1
// Int8 類型不能存儲超過最大值的數，因此會報錯

let twoThousand: UInt16 = 2_000
let one: UInt8 = 1
//在語言內部，UInt16有一個構造器，能夠接受一個UInt8類型的值，因此這個構造器能夠用現有的UInt8來建立一個新的UInt16
let twoThousandAndOne = twoThousand + UInt16(one)

類型別名

類型別名（type aliases）就是給現有類型定義另外一個名字。你可使用typealias關鍵字來定義類型別名。

  typealias AudioSample = UInt16
  var maxAmplitudeFound = AudioSample.min
// maxAmplitudeFound 如今是 0

斷言

可使用斷言來保證在運行其餘代碼以前，某些重要的條件已經被知足。
若是條件判斷爲true，代碼運行會繼續進行；若是條件判斷爲false，代碼運行中止，你的應用被終止。

let age = -3
assert(age >= 0, "A person's age cannot be less than zero")
// 由於 age < 0，因此斷言會觸發,代碼運行中止,應用被終止

能夠作調試使用

整型 Int

Swift 提供了8，16，32和64位的有符號和無符號整數類型。
Swift 提供了一個特殊的整數類型Int，長度與當前平臺的原生字長相同：

• 在32位平臺上，Int和Int32長度相同。
• 在64位平臺上，Int和Int64長度相同。

Swift 也提供了一個特殊的無符號類型UInt，長度與當前平臺的原生字長相同：

• 在32位平臺上，UInt和UInt32長度相同。
• 在64位平臺上，UInt和UInt64長度相同。

儘可能不要使用UInt，除非你真的須要存儲一個和當前平臺原生字長相同的無符號整數。
除了這種狀況，最好使用Int，即便你要存儲的值已知是非負的。
統一使用Int能夠提升代碼的可複用性，避免不一樣類型數字之間的轉換，而且匹配數字的類型推斷

浮點型 Double和Float

• Double表示64位浮點數。當你須要存儲很大或者很高精度的浮點數時請使用此類型。
• Float表示32位浮點數。精度要求不高的話可使用此類型。

布爾型 Bool

Swift 有兩個布爾常量，true和false：

  let orangesAreOrange = true
let turnipsAreDelicious = false

字符竄 String 和 Character（字符）

Swift 的String類型表示特定序列的Character（字符）類型值的集合,不能用下標取

  for character in "Dog!🐶" {
    println(character)
}
let yenSign: Character = "¥"

字符竄鏈接經過+號將兩個字符竄相連

var emptyString = ""               // 空字符串字面量
var anotherEmptyString = String()  // 初始化 String 實例

emptyString == anotherEmptyString  //true

if emptyString.isEmpty {
    println("什麼都沒有")
}

let string1 = "hello"
let string2 = " there"
let character1: Character = "!"
let character2: Character = "?"

let stringPlusCharacter = string1 + character1        // 等於 "hello!"
let stringPlusString = string1 + string2              // 等於 "hello there"
let characterPlusString = character1 + string1        // 等於 "!hello"
let characterPlusCharacter = character1 + character2  // 等於 "!?"

字符竄插值

字符串插值是一種構建新字符串的方式，能夠在其中包含常量、變量、字面量和表達式。

let multiplier = 3
let message = "\(multiplier) 乘以 2.5 是 \(Double(multiplier) * 2.5)"

插值字符串中寫在括號中的表達式不能包含非轉義雙引號 (") 和反斜槓 (\)，而且不能包含回車或換行符。 插值能夠省去額外的加號進行表達式的鏈接

數組 Array

數組按順序存儲相同類型的數據

聲明數組

  var shoppingList: String[] = ["Eggs", "Milk"]
  var shoppingList = ["Eggs", "Milk"]
  var someInts = Int[]()
  var threeDoubles = Double[](count: 3, repeatedValue:0.0)// [0.0, 0.0, 0.0]
  var anotherThreeDoubles = Array(count: 3, repeatedValue: 2.5)//類型推斷[2.5, 2.5, 2.5]

添加數據,修改數據,讀取數據,刪除數據,

  //添加數據
  shoppingList.append("Flour")
  shoppingList += "Baking Powder"
  shoppingList += ["Chocolate Spread", "Cheese", "Butter"]
  shoppingList.insert("Maple Syrup", atIndex: 0)

  //修改數據
  shoppingList[0] = "aaa"
  shoppingList[4...6] = ["Bananas", "Apples"]//區間操做符,不能越界想數組尾部添加數據

  //讀取數據
  var firstItem = shoppingList[0]
  for item in shoppingList {
      println(item)
  }
  //全局enumerate函數來進行數組遍歷。enumerate返回一個由每個數據項索引值和數據值組成的元組
  for (index, value) in enumerate(shoppingList) {
    println("Item \(index + 1): \(value)")
  }

  //刪除數據
  shoppingList.removeAtIndex(0)
  let apples = shoppingList.removeLast()
  someInts = [] //重置未空數組

字典 Dictionary

無序存儲相同類型數據值可是須要由獨有的標識符引用和尋址（就是鍵值對）

聲明字典

  var airports: Dictionary<String, String> = ["TYO": "Tokyo", "DUB": "Dublin"]
  var airports = ["TYO": "Tokyo", "DUB": "Dublin"]
  var namesOfIntegers = Dictionary<Int, String>()ßß

讀取字典和修改字典數據,刪除字典數據(使用nil)

airports.updateValue("Dublin Internation", forKey: "DUB")
airports["APL"] = "Apple Internation"
airports["APL"] = nil  // APL如今被移除了
airports.removeValueForKey("DUB")
namesOfIntegers = [:]//重置爲空字典

字典遍歷,Swift 的字典類型是無序集合類型。其中字典鍵，值，鍵值對在遍歷的時候會從新排列，並且其中順序是不固定的。

  //注意這裏沒有使用enumerate
for (airportCode, airportName) in airports {
    println("\(airportCode): \(airportName)")
}

for airportCode in airports.keys {
    println("Airport code: \(airportCode)")
}

for airportName in airports.values {
    println("Airport name: \(airportName)")
}
//使用字典建立數組
let airportCodes = Array(airports.keys)
let airportNames = Array(airports.values)

數組和字典的不可變性

• 當爲變量的時候,字典和數組想怎麼玩均可以怎麼玩
• 當數組爲常量時,不能試着改變任何不可變數組的大小，可是咱們能夠從新設定相對現存索引所對應的值
• 當字典爲常量時,意味着咱們不能替換其中任何現有鍵所對應的值。不可變字典的內容在被首次設定以後不能更改。

元組 Tuple

元組取下標使用.操做符..數組和字典取下標使用[];

聲明元組

  var http404Error = (404, "Not Found")  //默認下標0,1
  var http200Status = (statusCode: 200, description: "OK")//默認下標依然存在

訪問元組

  println(http404Error.0);
  println(http200Status.0);
  println(http200Status.statusCode);

分解元組,若是你只須要一部分元組值，分解的時候能夠把要忽略的部分用下劃線（_）標記

  let (statusCode, statusMessage) = http404Error
  let (justTheStatusCode, _) = http404Error

元組很像php中的數組.可是swift是類型安全的.因此若是初始化下標和值後,而後再次賦不一樣的下標或者不一樣類型的值,則會報錯.

  http200Status = ("ddd","dddd"); //錯誤

元組在臨時組織值的時候頗有用，可是並不適合建立複雜的數據結構。若是你的數據結構並非臨時使用，請使用類或者結構體而不是元組。

可選類型 Optional

要麼爲nil,要麼有值等於x.

• nil不能用於非可選的常量和變量。若是你的代碼中有常量或者變量須要處理值缺失的狀況，請把它們聲明成對應的可選類型。
• nil能夠用來給字典移除一個鍵值對

聲明可選類型

  var optional:Int?      //值爲nil
  let possibleNumber = "123"
  let convertedNumber = possibleNumber.toInt()
  // convertedNumber 被推測爲類型 "Int?"， 或者類型 "optional Int"

可選類型的變量不能直接使用,須要先判斷其確實有值,而後使用!解析,注意!號是放在變量名後面,放在前面是表明操做符 否的意思

因爲使用!來獲取一個不存在的可選值會致使運行時錯誤。使用!來強制解析值以前，必定要肯定可選包含一個非nil的值。因此最好使用if進行判斷

if convertedNumber {
    println("\(possibleNumber) has an integer value of \(convertedNumber!)")
} else {
    println("\(possibleNumber) could not be converted to an integer")
}

可選綁定語句,能夠省略解析!.可選綁定能夠用在if和while語句中來對可選類型的值進行判斷並把值賦給一個常量或者變量。

if let actualNumber = possibleNumber.toInt() {     //
    println("\(possibleNumber) has an integer value of \(actualNumber)")
} else {
    println("\(possibleNumber) could not be converted to an integer")
}

隱式解析可選類型

隱式解析可選類型是一個能夠自動解析的可選類型。你要作的只是聲明的時候把感嘆號放到類型的結尾，而不是每次取值的可選名字的結尾。

  let possibleString: String? = "An optional string."
  println(possibleString!) // 須要驚歎號來獲取值

  let assumedString: String! = "An implicitly unwrapped optional string."
  println(assumedString)  // 不須要感嘆號
  // 輸出 "An implicitly unwrapped optional string."

除了不用使用!強制解析外,其餘的和可選類型同樣. 一樣若是你在隱式解析可選類型沒有值的時候嘗試取值，會觸發運行時錯誤。和你在沒有值的普通可選類型後面加一個驚歎號同樣。

  if assumedString {
      println(assumedString)
  }
  // 輸出 "An implicitly unwrapped optional string."
  if let definiteString = assumedString {
    println(definiteString)
  }
// 輸出 "An implicitly unwrapped optional string."