Swift 入門與其它程序語言入門是一樣的我們要學習簡單的語法了，在這裡我們來看小編整理的一篇Swift 入門教程之：簡單基本語法吧，具體的步驟細節如下文介紹。

一.基礎語法:

 

Swift 是 iOS 和 OS X 應用開發的一門新語言。然而，如果你有 C 或者 Objective-C 開發經驗的話，你會發現 Swift 的很多內容都是你熟悉的。

Swift 的類型是在 C 和 Objective-C 的基礎上提出的，Int是整型；Double和Float是浮點型；Bool是布爾型；String是字符串。Swift 還有兩個有用的集合類型，Array和Dictionary，請參考集合類型。

就像 C 語言一樣，Swift 使用變量來進行存儲並通過變量名來關聯值。在 Swift 中，值不可變的變量有著廣泛的應用，它們就是常量，而且比 C 語言的常量更強大。在 Swift 中，如果你要處理的值不需要改變，那使用常量可以讓你的代碼更加安全並且更好地表達你的意圖。

除了我們熟悉的類型，Swift 還增加了 Objective-C 中沒有的類型比如元組（Tuple）。元組可以讓你創建或者傳遞一組數據，比如作為函數的返回值時，你可以用一個元組可以返回多個值。

Swift 還增加了可選（Optional）類型，用於處理值缺失的情況。可選表示“那兒有一個值，並且它等於 x ”或者“那兒沒有值”。可選有點像在 Objective-C 中使用nil，但是它可以用在任何類型上，不僅僅是類。可選類型比 Objective-C 中的nil指針更加安全也更具表現力，它是 Swift 許多強大特性的重要組成部分。

Swift 是一個類型安全的語言，可選就是一個很好的例子。Swift 可以讓你清楚地知道值的類型。如果你的代碼期望得到一個String，類型安全會阻止你不小心傳入一個Int。你可以在開發階段盡早發現並修正錯誤。

變量和常量:
常量和變量把一個名字（比如maximumNumberOfLoginAttempts或者welcomeMessage）和一個指定類型的值（比如數字10或者字符串"Hello"）關聯起來。常量的值一旦設定就不能改變，而變量的值可以隨意更改。

聲明常量和變量:

常量和變量必須在使用前聲明，用let來聲明常量，用var來聲明變量。下面的例子展示了如何用常量和變量來記錄用戶嘗試登錄的次數：

--------------------------------------------------------------------------------

let maximumNumberOfLoginAttempts = 10

var currentLoginAttempt = 0

--------------------------------------------------------------------------------

數值型字面量:

 

整數字面量可以被寫作：

一個十進制數，沒有前綴

一個二進制數，前綴是0b

一個八進制數，前綴是0o

一個十六進制數，前綴是0x

下面的所有整數字面量的十進制值都是17:

let decimalInteger = 17

let binaryInteger = 0b10001 // 二進制的17

let octalInteger = 0o21 // 八進制的17

let hexadecimalInteger = 0x11 // 十六進制的17

浮點字面量可以是十進制（沒有前綴）或者是十六進制（前綴是0x）。小數點兩邊必須有至少一個十進制數字（或者是十六進制的數字）。浮點字面量還有一個可選的指數(exponent)，在十進制浮點數中通過大寫或者小寫的e來指定，在十六進制浮點數中通過大寫或者小寫的p來指定。

如果一個十進制數的指數為exp，那這個數相當於基數和$10^{exp}$的乘積：

1.25e2 表示 $1.25 × 10^{2}$，等於 125.0。

1.25e-2 表示 $1.25 × 10^{-2}$，等於 0.0125。

如果一個十六進制數的指數為exp，那這個數相當於基數和$2^{exp}$的乘積：

0xFp2 表示 $15 × 2^{2}$，等於 60.0。

0xFp-2 表示 $15 × 2^{-2}$，等於 3.75。

下面的這些浮點字面量都等於十進制的12.1875：

let decimalDouble = 12.1875

let exponentDouble = 1.21875e1

let hexadecimalDouble = 0xC.3p0

數值類字面量可以包括額外的格式來增強可讀性。整數和浮點數都可以添加額外的零並且包含下劃線，並不會影響字面量：

--------------------------------------------------------------------------------

let paddedDouble = 000123.456

let oneMillion = 1_000_000

let justOverOneMillion = 1_000_000.000_000_1

--------------------------------------------------------------------------------

元組
元組（tuples）把多個值組合成一個復合值。元組內的值可以使任意類型，並不要求是相同類型。

下面這個例子中，(404, "Not Found")是一個描述 HTTP 狀態碼（HTTP status code）的元組。HTTP 狀態碼是當你請求網頁的時候 web 服務器返回的一個特殊值。如果你請求的網頁不存在就會返回一個404 Not Found狀態碼。

let http404Error = (404, "Not Found") // http404Error 的類型是 (Int, String)，值是 (404, "Not Found")

(404, "Not Found")元組把一個Int值和一個String值組合起來表示 HTTP 狀態碼的兩個部分：一個數字和一個人類可讀的描述。這個元組可以被描述為“一個類型為(Int, String)的元組”。

你可以把任意順序的類型組合成一個元組，這個元組可以包含所有類型。只要你想，你可以創建一個類型為(Int, Int, Int)或者(String, Bool)或者其他任何你想要的組合的元組。

你可以將一個元組的內容分解（decompose）成單獨的常量和變量，然後你就可以正常使用它們了：

let (statusCode, statusMessage) = http404Error

println("The status code is \(statusCode)")

// 輸出 "The status code is 404"

println("The status message is \(statusMessage)")

// 輸出 "The status message is Not Found"

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

let (justTheStatusCode, _) = http404Error

println("The status code is \(justTheStatusCode)")

// 輸出 "The status code is 404"

此外，你還可以通過下標來訪問元組中的單個元素，下標從零開始：

println("The status code is \(http404Error.0)") // 輸出 "The status code is 404"

println("The status message is \(http404Error.1)") // 輸出 "The status message is Not Found"

你可以在定義元組的時候給單個元素命名：

let http200Status = (statusCode: 200, description: "OK")

給元組中的元素命名後，你可以通過名字來獲取這些元素的值：

println("The status code is \(http200Status.statusCode)") // 輸出 "The status code is 200"

println("The status message is \(http200Status.description)") // 輸出 "The status message is OK"

作為函數返回值時，元組非常有用。一個用來獲取網頁的函數可能會返回一個(Int, String)元組來描述是否獲取成功。和只能返回一個類型的值比較起來，一個包含兩個不同類型值的元組可以讓函數的返回信息更有用。請參考[函數參數與返回值(06_Functions.html#Function_Parameters_and_Return_Values)。

注意：元組在臨時組織值的時候很有用，但是並不適合創建復雜的數據結構。如果你的數據結構並不是臨時使用，請使用類或者結構體而不是元組。請參考類和結構體。

二 ，swif運算符

一.循環
常見的循環有:for/while/do while

1.for循環
1.1 OC中的for循環寫法

for (int i = 0; i < 10; i++) {

 }
1.2 swift中的寫法

// 區間遍歷 0..<10 0...9

for i in 0..<10 {
    print(i)
}

for i in 0...9 {
    print(i)
}
// 如果一個標識符不需要使用, 那麼可以通過 _ 來代替

for _ in 0..<10 {
    print("hello world")
}
2.while循環
2.1 OC中的寫法

 int a = 20
 while (a) {
 }
2.2 swift中的寫法

2.2.1while後面的()可以省略

2.2.2沒有非0(nil)即真

var i = 10
while i > 0 {
    print(i)
    i -= 1
}
3.do while循環
// 區別: 不再使用do while --> repeat while
var m = 0
repeat {
    print(m)
    m += 1
} while m < 10
二.字符串
1.字符串的介紹
1.1字符串在任何的開發中使用都是非常頻繁的

1.2OC和Swift中字符串的區別

在OC中字符串類型時NSString,在Swift中字符串類型是String
OC中字符串@"",Swift中字符串""

1.3使用 String 的原因

String 是一個結構體，性能更高
NSString 是一個 OC 對象，性能略差
String 支持直接遍歷
String 提供了 String 和 NSString之間的無縫轉換

2.字符串的定義
2.1定義不可變字符串

let str = "hello swift"
2.2定義可變字符串

var strM = "hello world"
strM = "hello china"
3.獲取字符串的長度
先獲取字符集合,再獲取集合的count屬性

let length = str.characters.count
4.遍歷字符串
for c in str.characters {
    print(c)
}
5.字符串的拼接
5.1字符串之間的拼接

let str1 = "Hello"
let str2 = "World"
let str3 = str1 + str2
5.2字符串和其它標識符間的拼接
let name = "lgp"
let age = 18
let height = 1.98
let infoStr = "my name is (name), age is (age), height is (height)"

 5.3字符串格式化
比如時間:03:04 如果顯示 3 : 4 就不好.所以需要格式化

let min = 3
let second = 4
let timeStr = String(format: "%02d:%02d", arguments: [min, second])
6.字符串的截取
6.1簡單的方式是將String轉成NSString來使用
在標識符後加:as NSString即可

// 1.方式一: 將String類型轉成NSString類型, 再進行截取

// (urlString as NSString) --> NSString
let header = (urlString as NSString).substringToIndex(3)
let footer = (urlString as NSString).substringFromIndex(10)
let range = NSMakeRange(4, 5)
let middle = (urlString as NSString).substringWithRange(range)
6.2Swift中提供了特殊的截取方式
該方式非常麻煩
Index創建較為麻煩

// 2.方式二: Swift原生方式進行截取

let headerIndex = urlString.startIndex.advancedBy(3)
let header1 = urlString.substringToIndex(headerIndex)

let footerIndex = urlString.endIndex.advancedBy(-3)
let footer1 = urlString.substringFromIndex(footerIndex)

let range1 = headerIndex.advancedBy(1)..<footerIndex.advancedBy(-1)
let middle1 = urlString.substringWithRange(range1)
三.數組的使用
1.數組的介紹
1.1 數組（Array）是一串有序的由相同類型元素構成的集合

1.2 數組中的集合元素是有序的，可以重復出現

1.3 Swift中的數組
swift數組類型是Array，是一個泛型集合

2.數組的初始化
2.1 定義不可變數組,使用let修飾
注意:不可變數組要在定義的同時初始化,否則沒有意義

 let array = ["why", "yz"]
2.2 定義可變數組,使用var修飾
注意:數組是泛型集合,必須制定該數組中存放元素的類型

 基本寫法
 var arrayM = Array<String>()
 簡單寫法
 var arrayM = [String]()
3.對可變數組的基本操作(增刪改查)
3.1 添加元素

arrayM.append("ljp")
3.2 刪除元素

let removeItem = arrayM.removeAtIndex(1)  返回值為刪除的元素
arrayM.removeAll()
3.3 修改元素

arrayM[0] = "why"
3.4 查找元素(根據下標獲取元素)

let item = arrayM[0]
4.數組的遍歷
4.1 遍歷下標值

for i in 0..<array.count {
    print(array[i])
}
4.2遍歷元素

for name in array {
    print(name)
}
4.3遍歷下標值和元素

for (index, name) in array.enumerate() {
    print(index)
    print(name)
}
5.數組的合並
相同類型的數組可以相加進行合並
可變數組和不可變的數組也能合並

let array1 = ["why", "yz"]
let array2 = ["lmj", "lnj"]
let resultArray = array1 + array2
四.字典的使用
1.字典的介紹
1.1字典允許按照某個鍵來訪問元素

1.2字典是由兩部分集合構成的，一個是鍵（key）集合，一個是值（value）集合

1.3鍵集合是不能有重復元素的，而值集合是可以重復的，鍵和值是成對出現的

1.4Swift中的字典
Swift字典類型是Dictionary，也是一個泛型集合

2.字典的初始化
2.1 定義不可變字典,使用let修飾
注意:不可變字典要在定義的同時初始化,否則沒有意義
系統會根據[]中存放的是鍵值對,還是一個個元素,來判斷該[]是一個數組還是字典

  let dict = ["name" : "why", "age" : 18, "height" : 1.88]
2.2 定義可變字典,使用var修飾
注意:字典是泛型集合,必須制定該數組中存放元素的類型

 基本寫法
  var dictM = Dictionary<String, NSObject>()
 簡單寫法
  var dictM = [String : NSObject]() // 常見
3.對可變字典的基本操作(增刪改查)
3.1 添加元素

dictM.updateValue("why", forKey: "name")
3.2 刪除元素

dictM.removeValueForKey("age")
3.3 修改元素

//如果原有沒有對應的key/value, 那麼就添加鍵值對
// 如果原有已經有對應的key/value, 那麼直接修改

dictM.updateValue("1.77", forKey: "height")
dictM["name"] = "why"
3.4 查找元素(獲取元素)

let item = dictM["name"]
4.字典的遍歷
4.1 遍歷字典中所有的key

for key in dict.keys {
    print(key)
}
4.2 遍歷字典中所有的value

for value in dict.values {
    print(value)
}
4.3 遍歷字典中所有的key / value

for (key, value) in dict {
    print(key)
    print(value)
}
5.字典的合並
相同類型的字典也不可以相加進行合並
可以把其中一個字典改為可變的,遍歷不可變得字典,把元素一個一個的添加到另一個不可變字典中

let dict1 = ["name" : "why", "age" : 18]
var dict2 = ["height" : 1.88, "phoneNum" : "+86 110"]

for (key, value) in dict1 {
    dict2[key] = value
}
五.元組的使用
1.元組的介紹
1.1元組是Swift中特有的,OC中並沒有相關類型

1.2它是什麼呢?
1.2.1 它是一種數據結構，在數學中應用廣泛
1.2.2 類似於數組或者字典
1.2.3 可以用於定義一組數據
1.2.4 組成元組類型的數據可以稱為“元素”

2.為什麼使用元組?
如果字典或數組保存多種數據類型,那麼從字典會數組取出來的數據類型是NSObject,我們使用的時候很不方便,要先轉換為真實類型

元組保存多種數據類型,取出來就是該數據的真實類型,不需要轉換就能直接使用

3.元組的定義
let infoTuple = ("why", 18, 1.88, "+86 110")
// 使用元組描述一個人的信息
("1001", "張三", 30, 90)
// 給元素加上元素名稱,之後可以通過元素名稱訪問元素
(id:"1001", name:"張三", english_score:30, chinese_score:90)

 

構造函數基礎

構造函數 是一種特殊的函數，主要用來在創建對象時初始化對象，為對象 成員變量 設置初始值，在 OC 中的構造函數是 initWithXXX，在 Swift 中由於支持函數 重載 ，所有的構造函數都是  init

構造函數的作用

分配空間  alloc
設置初始值  init
必選屬性

自定義  Person  對象
class Person: NSObject {

    /// 姓名
    var name: String
    /// 年齡
    var age: Int
}
提示錯誤 Class 'Person' has no initializers ->  'Person' 類沒有實例化器s

原因：如果一個類中定義了必選屬性，必須通過構造函數為這些必選屬性分配空間並且設置初始值

重寫  父類的構造函數
/// `重寫`父類的構造函數
override init() {

}
提示錯誤 Property 'self.name' not initialized at implicitly generated super.init call ->  屬性 'self.name' 沒有在隱式生成的 super.init 調用前被初始化

手動添加  super.init()  調用
/// `重寫`父類的構造函數
override init() {
    super.init()
}
提示錯誤 Property 'self.name' not initialized at super.init call ->  屬性 'self.name' 沒有在 super.init 調用前被初始化

為必選屬性設置初始值
/// `重寫`父類的構造函數
override init() {
    name = "張三"
    age = 18

    super.init()
}
小結

非 Optional 屬性，都必須在構造函數中設置初始值，從而保證對象在被實例化的時候，屬性都被正確初始化
在調用父類構造函數之前，必須保證本類的屬性都已經完成初始化
Swift 中的構造函數不用寫  func
子類的構造函數

自定義子類時，需要在構造函數中，首先為本類定義的屬性設置初始值
然後再調用父類的構造函數，初始化父類中定義的屬性
/// 學生類
class Student: Person {

    /// 學號
    var no: String

    override init() {
        no = "001"

        super.init()
    }
}
小結

先調用本類的構造函數初始化本類的屬性
然後調用父類的構造函數初始化父類的屬性
Xcode 7 beta 5之後，父類的構造函數會被自動調用，強烈建議寫  super.init() ，保持代碼執行線索的可讀性
super.init()  必須放在本類屬性初始化的後面，保證本類屬性全部初始化完成
Optional 屬性

將對象屬性類型設置為  Optional
class Person: NSObject {
    /// 姓名
    var name: String?
    /// 年齡
    var age: Int?
}
可選屬性 不需要設置初始值，默認初始值都是 nil
可選屬性 是在設置數值的時候才分配空間的，是延遲分配空間的，更加符合移動開發中延遲創建的原則
重載構造函數

Swift 中支持函數重載，同樣的函數名，不一樣的參數類型
/// `重載`構造函數
///
/// - parameter name: 姓名
/// - parameter age:  年齡
///
/// - returns: Person 對象
init(name: String, age: Int) {
    self.name = name
    self.age = age

    super.init()
}
注意事項

如果重載了構造函數，但是沒有實現默認的構造函數  init() ，則系統不再提供默認的構造函數
原因，在實例化對象時，必須通過構造函數為對象屬性分配空間和設置初始值，對於存在必選參數的類而言，默認的  init()  無法完成分配空間和設置初始值的工作
調整子類的構造函數

重寫 父類的構造函數
/// `重寫`父類構造函數
///
/// - parameter name: 姓名
/// - parameter age:  年齡
///
/// - returns: Student 對象
override init(name: String, age: Int) {
    no = "002"

    super.init(name: name, age: age)
}
重載 構造函數
/// `重載`構造函數
///
/// - parameter name: 姓名
/// - parameter age:  年齡
/// - parameter no:   學號
///
/// - returns: Student 對象
init(name: String, age: Int, no: String) {
    self.no = no

    super.init(name: name, age: age)
}
注意：如果是重載的構造函數，必須 super 以完成父類屬性的初始化工作

重載 和 重寫

重載 ，函數名相同，參數名／參數類型／參數個數不同
重載函數並不僅僅局限於 構造函數
函數重載是面相對象程序設計語言的重要標志
函數重載能夠簡化程序員的記憶
OC 不支持函數重載，OC 的替代方式是  withXXX...
重寫 ，子類需要在父類擁有方法的基礎上進行擴展，需要  override  關鍵字