一、定義
1.let 用于定義常量，定義完后不能修改。
var 用于定義變量，可以修改。
swift可以自動識別屬性類別。
2.類型別名
類型別名對當前的類型定義了另一個名字，類型別名通過使用 typealias 關(guān)鍵字來定義，語法格式如下：

typealias newname = type

如：

typealias Feed = Int
var distance : Feed = 100
print(distance)
輸出結(jié)果為100

3.類型推斷
當你要處理不同類型的值時，類型檢查可以幫你避免錯誤。然而，這并不是說你每次聲明常量和變量的時候都需要顯式指定類型。
如果你沒有顯式指定類型，Swift 會使用類型推斷（type inference）來選擇合適的類型。
例如，如果你給一個新常量賦值42并且沒有標明類型，Swift 可以推斷出常量類型是Int，因為你給它賦的初始值看起來像一個整數(shù)：

let meaningOfLife = 42
// meaningOfLife 會被推測為 Int 類型
let pi = 3.14159
// pi 會被推測為 Double 類型
let anotherPi = 3 + 0.14159
// anotherPi 會被推測為 Double 類型

注：當推斷浮點數(shù)的類型時，Swift 總是會選擇Double而不是Float。
如果表達式中同時出現(xiàn)了整數(shù)和浮點數(shù)，會被推斷為Double類型。

4.變量聲明
var variableName = <initial value>
var variableName : <initial type>

var varA = 2
print(varA)

var varB:Float
varB = 2
print(varB)

結(jié)果為

2
2.0

5.變量輸出
在字符串中可以使用括號與反斜線來插入變量()，如下實例：

var name =  "welcome"
var content = "myhome"
print("\(name)你\(content)")

結(jié)果為

welcome你myhome

6.可選(Optionals)類型
Swift 的可選（Optional）類型，用于處理值缺失的情況。可選表示"那兒有一個值，并且它等于 x "或者"那兒沒有值"。Swfit語言定義后綴？作為命名類型Optional的簡寫，換句話說，以下兩種聲明是相等的：

var optionalInteger: Int?
var optionalInteger: Optional<Int>

var myString:String? = nil

if myString != nil {
    print(myString)
}else{
    print("字符串為 nil")
}

結(jié)果為nil

可選類型類似于Objective-C中指針的nil值，但是nil只對類(class)有用，而可選類型對所有的類型都可用，并且更安全。在Swift中定義了Optinal類型來表示各種類型的無值狀態(tài),并規(guī)定了nil不能用于非可選的常量和變量,只能用于Optinal類型。

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

var myString:String?

myString = "Hello, Swift!"

if myString != nil {
   print(myString)
}else{
   print("myString 值為 nil")
}

var myString:String?
myString = "hello,Swift"

if myString != nil {
    print(myString!)
}else{
    print("myString is nil")
}

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

8.自動解析
你可以在聲明可選變量時使用感嘆號（!）替換問號（?）。這樣可選變量在使用時就不需要再加一個感嘆號（!）來獲取值，它會自動解析。

var myString:String!

myString = "Hello, Swift!"

if myString != nil {
   print(myString)
}else{
   print("myString 值為 nil")
}

9.可選綁定
使用可選綁定（optional binding）來判斷可選類型是否包含值，如果包含就把值賦給一個臨時常量或者變量?？蛇x綁定可以用在if和while語句中來對可選類型的值進行判斷并把值賦給一個常量或者變量。

if let constantName = someOptional {
    statements
}

var myString:String?
myString = "HELLo,swift"
if let yourString = myString {
    print("dff\(yourString)")
}else{
    print("nil")
}

10.常量
let constantName = <initial value>

11.類型標注
當你聲明常量或者變量的時候可以加上類型標注（type annotation），說明常量或者變量中要存儲的值的類型。如果要添加類型標注，需要在常量或者變量名后面加上一個冒號和空格，然后加上類型名稱。

var constantName:<data type> = <optional initial value>

let constA = 42
print(constA)

let constB:Float = 3.14159

print(constB)

12.函數(shù)

函數(shù)聲明: 告訴編譯器函數(shù)的名字，返回類型及參數(shù)。
函數(shù)定義: 提供了函數(shù)的實體。

函數(shù)定義

Swift 定義函數(shù)使用關(guān)鍵字 func。
定義函數(shù)的時候，可以指定一個或多個輸入?yún)?shù)和一個返回值類型。
每個函數(shù)都有一個函數(shù)名來描述它的功能。通過函數(shù)名以及對應(yīng)類型的參數(shù)值來調(diào)用這個函數(shù)。函數(shù)的參數(shù)傳遞的順序必須與參數(shù)列表相同。
函數(shù)的實參傳遞的順序必須與形參列表相同，-> 后定義函數(shù)的返回值類型。

語法
func funcname(形參) -> returntype
{
Statement1
Statement2
……
Statement N
return parameters
}

例如，以下我們定義了一個函數(shù)名為 runoob 的函數(shù)，形參的數(shù)據(jù)類型為 String，返回值也為 String：

func runoob(site: String) -> String {
   return (site)
}
print(runoob(site: "www.baidu.com"))

結(jié)果返回
www.baidu.com

函數(shù)調(diào)用

我們可以通過函數(shù)名以及對應(yīng)類型的參數(shù)值來調(diào)用函數(shù)，函數(shù)的參數(shù)傳遞的順序必須與參數(shù)列表相同。
以下我們定義了一個函數(shù)名為 runoob 的函數(shù)，形參 site 的數(shù)據(jù)類型為 String，之后我們調(diào)用函數(shù)傳遞的實參也必須 String 類型，實參傳入函數(shù)體后，將直接返回，返回的數(shù)據(jù)類型為 String。

函數(shù)參數(shù)

函數(shù)可以接受一個或者多個參數(shù)，這些參數(shù)被包含在函數(shù)的括號之中，以逗號分隔。
以下實例向函數(shù) runoob 傳遞站點名 name 和站點地址 site：

func runoob(name: String, site: String) -> String {
    return name + site
}
print(runoob(name: "輸入?yún)?shù)一：", site: "www.baidu.com"))
print(runoob(name: "輸入?yún)?shù)二：", site: "www.google.com"))

運行結(jié)果：
輸入?yún)?shù)一：www.baidu.com
輸入?yún)?shù)二：www.google.com

不帶參數(shù)函數(shù)
我們可以創(chuàng)建不帶參數(shù)的函數(shù)。

語法：
func funcname() -> datatype {
return datatype
}

func sitename() -> String {
    return "test"
}
print(sitename())

以上程序執(zhí)行輸出結(jié)果為：
test

元組作為函數(shù)返回值

函數(shù)返回值類型可以是字符串，整型，浮點型等。
元組與數(shù)組類似，不同的是，元組中的元素可以是任意類型，使用的是圓括號。
你可以用元組（tuple）類型讓多個值作為一個復(fù)合值從函數(shù)中返回。
下面的這個例子中，定義了一個名為minMax(_:)的函數(shù)，作用是在一個Int數(shù)組中找出最小值與最大值。

func minMax(array: [Int]) -> (min: Int, max: Int) {
    var currentMin = array[0]
    var currentMax = array[0]
    for value in array[1..<array.count] {
        if value < currentMin {
            currentMin = value
        } else if value > currentMax {
            currentMax = value
        }
    }
    return (currentMin, currentMax)
}

let bounds = minMax(array: [8, -6, 2, 109, 3, 71])
print("最小值為 \(bounds.min) ，最大值為 \(bounds.max)")

minMax(_:)函數(shù)返回一個包含兩個Int值的元組，這些值被標記為min和max，以便查詢函數(shù)的返回值時可以通過名字訪問它們。

以上程序執(zhí)行輸出結(jié)果為：

最小值為 -6 ，最大值為 109

如果你不確定返回的元組一定不為nil，那么你可以返回一個可選的元組類型。

你可以通過在元組類型的右括號后放置一個問號來定義一個可選元組，例如(Int, Int)?或(String, Int, Bool)?

注意
可選元組類型如(Int, Int)?與元組包含可選類型如(Int?, Int?)是不同的.可選的元組類型，整個元組是可選的，而不只是元組中的每個元素值。

前面的minMax(:)函數(shù)返回了一個包含兩個Int值的元組。但是函數(shù)不會對傳入的數(shù)組執(zhí)行任何安全檢查，如果array參數(shù)是一個空數(shù)組，如上定義的minMax(:)在試圖訪問array[0]時會觸發(fā)一個運行時錯誤。

為了安全地處理這個"空數(shù)組"問題，將minMax(_:)函數(shù)改寫為使用可選元組返回類型，并且當數(shù)組為空時返回nil：

func minMax(array: [Int]) -> (min: Int, max: Int)? {
    if array.isEmpty { return nil }
    var currentMin = array[0]
    var currentMax = array[0]
    for value in array[1..<array.count] {
        if value < currentMin {
            currentMin = value
        } else if value > currentMax {
            currentMax = value
        }
    }
    return (currentMin, currentMax)
}
if let bounds = minMax(array: [8, -6, 2, 109, 3, 71]) {
    print("最小值為 \(bounds.min)，最大值為 \(bounds.max)")
}

以上程序執(zhí)行輸出結(jié)果為：

最小值為 -6，最大值為 109

沒有返回值函數(shù)
下面是 runoob(_:) 函數(shù)的另一個版本，這個函數(shù)網(wǎng)址參數(shù)，沒有指定返回值類型，并直接輸出 String 值，而不是返回它：

import Cocoa

func runoob(site: String) {
print("官網(wǎng)：(site)")
}
runoob(site: "http://www.baidu.com")
以上程序執(zhí)行輸出結(jié)果為：

官網(wǎng)：http://www.baidu.com

可變參數(shù)
可變參數(shù)可以接受零個或多個值。函數(shù)調(diào)用時，你可以用可變參數(shù)來指定函數(shù)參數(shù)，其數(shù)量是不確定的。

可變參數(shù)通過在變量類型名后面加入（...）的方式來定義。

func vari<N>(members: N...){
    for i in members {
        print(i)
    }
}
vari(members: 4,3,5)
vari(members: 4.5, 3.1, 5.6)
vari(members: "Google", "Baidu", "Runoob")

以上程序執(zhí)行輸出結(jié)果為：

4
3
5
4.5
3.1
5.6
Google
Baidu
Runoob

使用函數(shù)類型
在 Swift 中，使用函數(shù)類型就像使用其他類型一樣。例如，你可以定義一個類型為函數(shù)的常量或變量，并將適當?shù)暮瘮?shù)賦值給它：

var addition: (Int, Int) -> Int = sum

"定義一個叫做 addition 的變量，參數(shù)與返回值類型均是 Int ，并讓這個新變量指向 sum 函數(shù)"。
sum 和 addition 有同樣的類型，所以以上操作是合法的。
現(xiàn)在，你可以用 addition 來調(diào)用被賦值的函數(shù)了：

import Cocoa

func sum(a: Int, b: Int) -> Int {
   return a + b
}
var addition: (Int, Int) -> Int = sum
print("輸出結(jié)果: \(addition(40, 89))")

以上程序執(zhí)行輸出結(jié)果為：

輸出結(jié)果: 129

函數(shù)類型作為參數(shù)類型、函數(shù)類型作為返回類型
我們可以將函數(shù)作為參數(shù)傳遞給另外一個參數(shù)：

import Cocoa

func sum(a: Int, b: Int) -> Int {
    return a + b
}
var addition: (Int, Int) -> Int = sum
print("輸出結(jié)果: \(addition(40, 89))")

func another(addition: (Int, Int) -> Int, a: Int, b: Int) {
    print("輸出結(jié)果: \(addition(a, b))")
}
another(addition: sum, a: 10, b: 20)

以上程序執(zhí)行輸出結(jié)果為：

輸出結(jié)果: 129
輸出結(jié)果: 30

函數(shù)嵌套
函數(shù)嵌套指的是函數(shù)內(nèi)定義一個新的函數(shù)，外部的函數(shù)可以調(diào)用函數(shù)內(nèi)定義的函數(shù)。

import Cocoa

func calcDecrement(forDecrement total: Int) -> () -> Int {
   var overallDecrement = 0
   func decrementer() -> Int {
      overallDecrement -= total
      return overallDecrement
   }
   return decrementer
}
let decrem = calcDecrement(forDecrement: 30)
print(decrem())

以上程序執(zhí)行輸出結(jié)果為：

-30

常量，變量及 I/O 參數(shù)
一般默認的參數(shù)傳遞都是傳值調(diào)用的，而不是傳引用。所以傳入的參數(shù)在函數(shù)內(nèi)改變，并不影響原來的那個參數(shù)。傳入的只是這個參數(shù)的副本。

當傳入的參數(shù)作為輸入輸出參數(shù)時，需要在參數(shù)名前加 & 符，表示這個值可以被函數(shù)修改。

import Cocoa

func swapTwoInts(_ a: inout Int, _ b: inout Int) {
    let temporaryA = a
    a = b
    b = temporaryA
}


var x = 1
var y = 5
swapTwoInts(&x, &y)
print("x 現(xiàn)在的值 \(x), y 現(xiàn)在的值 \(y)")

swapTwoInts(::) 函數(shù)簡單地交換 a 與 b 的值。該函數(shù)先將 a 的值存到一個臨時常量 temporaryA 中，然后將 b 的值賦給 a，最后將 temporaryA 賦值給 b。

需要注意的是，someInt 和 anotherInt 在傳入 swapTwoInts(::) 函數(shù)前，都加了 & 的前綴。

以上程序執(zhí)行輸出結(jié)果為：

x 現(xiàn)在的值 5, y 現(xiàn)在的值 1