Swift001-數據類型 元組 枚舉 結構體

Swift001-數據類型 元組 枚舉 結構體

Swift 包含了 Objective-C 上所有基本數據類型，另外還增加了高階數據類型，如元組(Tuple)，還增加了可選類型(Optional)

變量與常量聲明方式

  • 變量用var聲明，如 var name = "LiLei"
  • 常量用let聲明，如 let home = "BeiJing"

整型

  • 有符號整型：Int，Int8，Int16，Int32，Int64

  • 無符號整型：UInt，UInt8，UInt16，UInt32，UInt64

    一般來說，不需要專門指定整數的長度。Swift中整數類型Int的長度與當前平臺的原生字長相同：

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

    用例

    /// 整型用例 Int and UInt
public class func testBasic() {
    let age: UInt = 18
    var count: Int = 10086
    count = 1008611
    print("\(age)") // 18
    print("\(count)") // 1008611
}

    隨機數

    arc4random() 這個全局函數會生成10位數的隨機整數（UInt32）。其生成的最大值是4294967295（2^32 - 1），最小值為0。

    // 用 arc4random 函數生成一個 1~100 的隨機數(包括1和100)
let temp = Int(arc4random()%100)+1
// 用 arc4random_uniform 函數生成一個 1~100 的隨機數（包括1和100）
let temp = Int(arc4random_uniform(100))+1

浮點型

  • Double: 表示64位浮點數。當你需要存儲很大或者很高精度的浮點數時請使用此類型。

  • Float: 表示32位浮點數。精度要求不高的話可以使用此類型。

    用例

    /// 浮點型用例 Float and Double
public class func testBasic() {
    let score: Float = 99.5
    var velocity: Double = 10.333333333
    velocity = 20.666666666
    print("\(score)") // 99.5
    print("\(velocity)") // 20.666666666
}

    為增強大數可讀性，Swift增加了下劃線來分隔數字(整數、浮點數)。

    let num1 = 10_000_000_000
let num2 = 1_000_000.000_000_1
var num3:Int = 1_0_0_0_1

布爾型

  • Bool: 用來表示邏輯上真(true)與假(false)，但不能用0和非0表示

    用例

    /// 布爾型用例 Bool
public class func testBasic() {
    var isSelected: Bool = false
    isSelected = true
    if isSelected {
        print("true") // true
    }
}

字符型

  • Character: 一般指單個字符

    用例

    let firstChar = "C"
print("\(firstChar)")

字符串

  • String: 是字符的序列集合

    Swift 中 String 與 OC 中 NSString對比：
    String 是一個結構體，性能更高
    NSString 是一個 OC 對象，性能略差
    String 支持直接遍歷

    用例

    /// 字符串用例
public class func testBasic() {
    var city = "BeiJing"
    // 用\(str) 方式包裹變量常量
    let message = "Welcome to \(city)"
    // 更改city為"ShangHai"但message中仍為"BeiJing"
    city = "ShangHai"
    // 大寫
    let changeStr1 = city.uppercased()
    // 小寫
    let changeStr2 = city.lowercased()
    // 首字母大寫
    let changeStr3 = city.capitalized
    // 判斷是否空字符串
    if message.isEmpty == false {
        // message.count得到字符數量
        print("\(message.count)") // 18
        print("\(city)") // ShangHai
        print(message) // Welcome to BeiJing
        print(changeStr1) // SHANGHAI
        print(changeStr2) // shanghai
        print(changeStr3) // Shanghai
    }
}

    截取字符串

    /// 取子字符串
public class func testSubString() {
    let message = "Welcome to BeiJing"
    // 取前三個字符
    let prefixStr = message.prefix(3) // Wel
    // 取后三個字符
    let suffixStr = message.suffix(3) // ing
    // 取限定范圍[3..<6]內字符
    let indexStart = message.index(message.startIndex, offsetBy: 3)
    let indexEnd = message.index(message.startIndex, offsetBy: 6)
    let midStr = message[indexStart..<indexEnd] // com
    // Wel ing com
    print("\(prefixStr) \(suffixStr) \(midStr)")
}

數組

  • Array: 是有序數據的集,分配常量得到不可變數組，分配變量得到可變數組

    數組使用有序列表存儲同一類型的多個值。相同的值可以多次出現在一個數組的不同位置中。

    Swift數組與OC數組區別：
    Array是一個結構體，而不是一個類
    可以放普通類型

    用例

    public class func testBasic() {
    // var arrayM = [String]()
    // var arrayM1:[String]
    // var arrayM2 = Array()
    // var array:Array<UIImage!> = []
    // var array:[UIImage!] = []
    // 一個數組的完成類型為：Array<ElementType>。ElementType表示數組中元素的類型
    let array1 = Array<Int>()
    // 一種精簡的表示法：Array[ElementType]
    let array2 = [Int]()
    // 聲明一個Double類型常量數組，創建10個元素，每個元素都是2.0
    let array3 = [Double](repeating: 2.0, count: 10)
    // 字面量方式聲明一個有4個元素的Int類型數組常量
    let array4 = [1, 2, 3, 4]
    // 聲明一個有2個元素的 Any 類型數組常量
    let array5 = [1, "two", true, 1.1] as [Any]
    print("\(array1) \(array2) \(array3) \(array4) \(array5)")
}

    基本操作

    public class func testHandle() {
    // 聲明一個空數組變量（let聲明為常量, var聲明變量，即可變數組）
    var testArray = [String]()
    // 追加元素 姿勢1
    testArray.append("six")
    // 追加元素 姿勢2
    testArray += ["seven"]
    // 指定位置添加元素
    testArray.insert("one", at:0)
    // 通過下標修改數組中的數據
    testArray[0] = "message"
    // 通過小標區間替換數據（前3個數據），沒有則追加
    testArray[0...2] = ["message","Apple","com"]
    // 交換元素位置
    testArray.swapAt(1, 2)
    // 刪除下標為2的數組
    testArray.remove(at: 2)
    // 刪除最后一個元素
    testArray.removeLast()
    // 刪除數組中所有元素 keepingCapacity：保持最大容量
    testArray.removeAll(keepingCapacity: true)
    // 數組組合
    let addStringArr = testArray + ["1", "2"]
    // 使用for in 實現數組遍歷
    for value in addStringArr {
        print("\(value)");
    }
    // 通過enumerate函數同時遍歷數組的所有索引與數據
    for (index, value) in addStringArr.enumerated() {
        print("index：\(index) data：\(value)");
    }
    // 過濾數組元素(元素長度小于6)
    let newTypes = addStringArr.filter { $0.count < 6 }
    // 創建包含100個元素的數組 ["條目0", "條目1" ... "條目5"]
    let intArray1 = Array(0..<6).map{ "條目\($0)"}
    // 創建1-10連續整數數組 姿勢1 閉區間
    let intArray2 = [Int](1...10)
    // 創建1-10連續整數數組 姿勢2 半閉半開區間
    let intArray3 = [Int](1..<11)
    // 獲取數組元素個數
    let testArrayCount = testArray.count
    // 判斷數組是否為空
    if testArray.isEmpty == false {
        print("\(testArray)")
        print("\(testArrayCount)")
        print("\(addStringArr)")
        print("\(newTypes)")
        print("\(intArray1)")
        print("\(intArray2)")
        print("\(intArray3)")
    }
}

    注意：數組字面量(例如:[1,2,3])，本身是一個常量，如果我們對數組字面量進行添加等操作，則會引起編譯器報錯。

字典

  • Dictionary: 是無序的鍵值對的集,分配常量得到不可變字典，分配變量得到可變字典

    字典是由鍵值 key:value 對組成的集合
    字典中的元素之間是無序的
    字典是由兩部分集合構成的，一個是鍵集合，一個是值集合
    字典是通過訪問鍵間接訪問值的
    鍵集合是不能有重復元素的，而值集合是可以重復的
    Swift中的字典類型是Dictionary，也是一個泛型集合
    使用let修飾的字典是不可變字典
    使用var修飾的字典是可變字典

    用例

    public class func testBasic() {
    // 建立個空字典變量（let聲明為常量, var聲明變量，即可變字典）
    var fruitPriceDict = [String: Int]() // Dictionary<String, Int>()
    fruitPriceDict = ["apple":10, "pear":9, "banana":8, "peach":11, "strawberry":30, "lemon":1]
    // 聲明一個字典變量，其key為String類型 value為Any類型
    var personDict = ["name":"LiLei", "age":18, "nickName":"XiaoLi", "score":100] as [String : Any]
    // 修改key對應value值（不存在則添加）姿勢1
    personDict.updateValue("city", forKey: "BeiJing China")
    // 修改key對應value值（不存在則添加）姿勢2
    personDict["city"] = "BeiJing"
    // 刪除key值及對應value值 姿勢1
    personDict.removeValue(forKey: "score")
    // 刪除key值及對應value值 姿勢2
    personDict["nickName"] = nil
    // 訪問字典的key集合
    let keysSet = personDict.keys
    // 訪問字典的values數組
    let valueArray = personDict.values
    print("\(keysSet)  \(valueArray)")
}

    遍歷字典

    public class func testEnumerated() {
    var personDict = ["name":"LiLei", "age":18, "nickName":"XiaoLi", "score":100] as [String : Any]
    // 遍歷字典 姿勢1
    for (key, value) in personDict {
        print("\(key):\(value)");
    }
    // 遍歷字典 姿勢2
    for keyAndValue in personDict {
        print("keyAndValue: \(keyAndValue)")
    }
    // 只遍歷字典的鍵（key）
    for key in personDict.keys {
        print("\(key)");
    }
    // 只遍歷字典的值（value）
    for value in personDict.values {
        print("\(value)");
    }
}

    過濾和合并

    public class func testFilterAndMerge() {
    // 建立個空字典變量（let聲明為常量, var聲明變量，即可變字典）
    let fruitPriceDict = ["apple":10, "pear":9, "banana":8, "peach":11, "strawberry":30, "lemon":1]
    // 過濾字典元素
    let fruitPriceDict2 = fruitPriceDict.filter { $0.value < 10 }
    print("\(fruitPriceDict2)")
    // 合并 姿勢1
    var dict1 = ["name":"000","age":18,"title":"888"] as [String : Any]
    let dict2 = ["name":"da","hegiht":190] as [String : Any]

    for e in dict2 {
        dict1[e.key] = dict2[e.key]
    }
    // 如果key存在會修改，key不存在會新增
    print(dict1)
    var dic = ["one": 10, "two": 20]
    // merge方法合并
    let tuples = [("one", 5),  ("three", 30)]
    dic.merge(tuples, uniquingKeysWith: min)
    print("dic：\(dic)")
    // merging方法合并
    let dic2 = ["one": 0, "four": 40]
    let dic3 = dic.merging(dic2, uniquingKeysWith: min)
    print("dic3：\(dic3)")
}

    字典合并

    • merge(_: uniquingKeysWith:)：這種方法會修改原始Dictionary
    • merging(_: uniquingKeysWith:)：這種方法會創建并返回一個全新的Dictionary

    另類創建方式

    public class func testCreateDictSomeMethod() {
    // 通過元組創建字典
    let tupleKeyValueArray = [("Monday", 30),  ("Tuesday", 25),  ("Wednesday", 27)]
    let dictFromTuple = Dictionary(uniqueKeysWithValues: tupleKeyValueArray)
    print(dictFromTuple) // ["Monday": 30, "Tuesday": 25, "Wednesday": 27]
    // 通過鍵值序列創建字典
    let keyArrayToDict = ["Apple", "Pear"]
    let valueArrayToDict = [7, 6]
    let keyValueArrayToDict = Dictionary(uniqueKeysWithValues: zip(keyArrayToDict, valueArrayToDict))
    print(keyValueArrayToDict)
    // 用鍵序列/值序列創建字典
    let arrayKeyOrValue = ["Monday", "Tuesday", "Wednesday"]
    let indexKeyDict = Dictionary(uniqueKeysWithValues: zip(1..., arrayKeyOrValue))
    let indexValueDict = Dictionary(uniqueKeysWithValues: zip(arrayKeyOrValue, 1...))
    print("\(indexKeyDict) \(indexValueDict)")
    // 數組分組成字典（比如下面生成一個以首字母分組的字典）
    let nameGroupArray = ["LiLei", "LiXiaolong", "LiuDehua", "HanMeimei", "HanLei", "SunWukong", "ErLangshen"]
    let dictFromNameGroup = Dictionary(grouping: nameGroupArray) { $0.first! }
    print(dictFromNameGroup)
}

    重復鍵處理

    public class func testHandleRepeatKey() {
    // 重復鍵的處理
    // zip配合速記+可以用來解決重復鍵的問題（相同的鍵值相加）
    let array = ["Apple", "Pear", "Pear", "Orange"]
    let dic1 = Dictionary(zip(array, repeatElement(1, count: array.count)), uniquingKeysWith: +)
    print(dic1)

    // 下面使用元組創建字典時，遇到相同的鍵則取較小的那個值
    let duplicatesArray = [("Monday", 30),  ("Tuesday", 25),  ("Wednesday", 27), ("Monday", 28)]
    let dic2 = Dictionary(duplicatesArray, uniquingKeysWith: min)
    print(dic2)
}

    默認值以及妙用用來統計字符串中每個單詞出現個數

    public class func testDefaultValue() {
    // swift4之前自己判斷并賦值
    let dic1 = ["apple": 1, "banana": 2]
    var orange1:Int
    if let value1 = dic1["orange"] {
        orange1 = value1
    }else{
        orange1 = 0
    }
    print(orange1)
    // swift4之后  給定即可
    let dic2 = ["apple": 1, "banana": 2 ]
    let orange2 = dic2["orange", default:0]
    print(orange2)
}
// 下面是統計一個字符串中所有單詞出現的次數?？梢钥吹搅擞辛四J值，實現起來會簡單許多
public class func testCharacterCountInStr() {
    let str = "apple banana orange apple banana"
    var wordsCount: [String: Int] = [:]
    for word in str.split(separator: " ") {
        wordsCount["\(word)", default: 0] += 1
    }
    print(wordsCount)
}

集合

  • Set: 是無序無重復數據的集,分配常量得到不可變集合，分配變量得到可變集合

    一個集合也能存放多個相同類型的元素，與數組不同的是：
    1:一個集合不允許出現兩個相同的元素
    2:集合中的元素是無序的
    3:并不是所有的類型對象都能作為集合的元素，不過swift的基本類型都可以

    public class func testInit() {
    // 一個集合的完整類型為：Set<Element: Hashable>，集合沒有精簡表示法。
    var set1 = Set<Int>()
    // 通過集合的不定參數個數的構造方法來創建一個含有指定元素的集合
    let set2 = Set<Int>(arrayLiteral: 1, 2, 3, 4)
    // 通過數組字面量來創建一個集合常量
    let set3: Set<Float> = [1.0, 0.5, 2.0]
    // 我們也可以用數組字面量來賦值一個集合
    set1 = [1, 2]
    print("\(set1) \(set2) \(set3)")
}

    元素集合的訪問不能像數組通過索引值，因為它是無序的，可以通過for-in循環，也可以通過flatMap方法，有選擇性的將集合元素取出。

    集合的數學操作

    public class func testMathCalculation() {
    let setA: Set<Float> = [1.0, 0.5, 2.0]
    let setB: Set<Float> = [1.0, 1.5, 2.0]
    print(setA.union(setB).sorted()) // 并集 [0.5, 1.0, 1.5, 2.0]
    print(setA.intersection(setB).sorted()) // 交集 [1.0, 2.0]
    print(setA.subtracting(setB).sorted()) // 取差值 [0.5]
    print(setA.symmetricDifference(setB).sorted()) // 去掉相同值 [0.5, 1.5]
}

    集合遍歷

    for item in favorite {
    print(item)
}
//按照首字母的順序輸出
for item1 in favorite.sorted() {
    print(item1)
}

    集合成員關系

    用 ==來判斷兩個集合是否包含全部相同的值
    用 isSubset(of:)來判斷一個集合中的值是否也被包含在另外一個集合中
    用 isSuperset（of:）來判斷一個集合中包含另一個集合所有的值
    用isStrictSubset(of:)或者isStrictSuperset(of:)方法來判斷一個集合是否是另外一個集合的子集合 或父集合并且兩個集合不相等

結構體

  • struct

    //創建一個結構體
struct BookInfo{
    var ID:Int = 0
    var Name:String = "Defaut"
    var Author:String = "Defaut"
}

var book1:BookInfo //默認構造器創建結構體實例
var book2 = BookInfo(ID:0021,Name:"蘋果",Author:"Apple")  //調用逐一構造器創建實例
book2.ID = 1234  //修改內部值

枚舉

  • enum

與OC只能整型不同，Swift支持更多枚舉方案:

  • 整型

  • 浮點數

  • 字符串

  • 布爾類型

  • 嵌套枚舉

    聲明

    // 常規枚舉
enum DDYSeason {
    case spring
    case summer
    case autumn
    case winter
}
// 整型枚舉
enum DDYIndex: Int {
    case first  = 1
    case second = 2
    case nine   = 9
}
// 帶內部方法的枚舉
enum DDYDirection {
    case up
    case down

    func description() -> String{
        switch(self) {
        case .up: return "向上"
        case .down: return "向下"
        }
    }
}
// 嵌套枚舉
enum Area {
    enum DongGuan {
        case NanCheng
        case DongCheng
    }

    enum GuangZhou {
        case TianHe
        case CheBei
    }
}
print(Area.DongGuan.DongCheng)

// 關聯值(case 傳值)
enum Trade {
    case Buy(stock:String,amount:Int)
    case Sell(stock:String,amount:Int)
}

let trade = Trade.Buy(stock: "003100", amount: 100)

switch trade {
    case .Buy(let stock,let amount):

        print("stock:\(stock),amount:\(amount)")

    case .Sell(let stock,let amount):
        print("stock:\(stock),amount:\(amount)")
    default:
    ()
}

// 遞歸枚舉
// 枚舉成員的關聯值為當前枚舉類型時稱為遞歸枚舉。indirect修飾整個枚舉時,所有成員均可遞歸(也可不遞歸)
indirect enum MyCalculateEnum {
    case number(Int)
    case addition(MyCalculateEnum, MyCalculateEnum)
    case multi(MyCalculateEnum, MyCalculateEnum)
}
// 調用
private class func testIndirectEnum() {
    let five = MyCalculateEnum.number(5)
    let four  = MyCalculateEnum.number(4)
    let sum = MyCalculateEnum.addition(five, four)
    let product = MyCalculateEnum.multi(sum, MyCalculateEnum.number(2))
    print("(5+4)*2 = \(product)")
}

    應用

    // 作為參數
private func testEnum(_ mySeason: DDYSeason) {
    print("\(mySeason)")
}

    調用

    
// 給變量(常量)賦值
var mySeason = DDYSeason.spring
mySeason = DDYSeason.summer
// 調用作為參數的方法
testEnum(DDYSeason.spring)
testEnum(mySeason)
testEnum(.winter) // 當明確聲明的枚舉類型后可以省略類型

// rawValue來獲取原始值
let indexValue = DDYIndex.nine.rawValue
// 由原始值獲取枚舉成員
let ddyIndex = DDYIndex(rawValue: 2)
// 9 Optional(DDYTest.DDYIndex.second)
print("\(indexValue) \(String(describing: ddyIndex))")
// 向上
print("\(DDYDirection.up.description())")

    用struct 遵循 OptionSet 協議 表示位移枚舉(OC中NS_OPTIONS)

    OC中的位移枚舉

    // 聲明定義
typedef NS_OPTIONS(NSInteger, DDYCertificateType) {
    DDYCertificateIDCard    = 1 << 0, // 身份證
    DDYCertificateLicense   = 1 << 1, // 營業執照
};
// 作為參數
- (void)refreshWithType:(DDYCertificateType)type {
    // 判斷
    if (type & DDYCertificateIDCard) {
    NSLog(@"身份證");
    }
}
// 調用
[self refreshWithType: DDYCertificateIDCard | DDYCertificateLicense];

    Swift中目前沒提供直接的位移枚舉
    但可以使用結構體(struct) 并結構體要遵從 OptionSet協議,以引入選項集合
    不能直接用枚舉(enum)表示

    struct DDYCertificateType: OptionSet {
    let rawValue: Int
    static let IDCard   = DDYCertificateType(rawValue: 1)
    static let License  = DDYCertificateType(rawValue: 2)
    static let BankCard = DDYCertificateType(rawValue: 4)
    static let Passport = DDYCertificateType(rawValue: 8)
    static let VehiclePlate = DDYCertificateType(rawValue: 16)
}

// 添加多個枚舉值條件不再是用| 而是用[.xxx,.xxx] 類似于數組的方式
let certificateType: DDYCertificateType = [.IDCard, .License, .BankCard]
// 判斷位移枚舉的變量是否存在不再是用& 而是用.contains()
print("\(certificateType.contains(.IDCard))") // true
print("\(certificateType.contains(.Passport))") // false

    OC中位移枚舉多值傳輸在Swift中的兩種姿勢

    // 姿勢一：通過rawValue方法賦值
self.tableView.autoresizingMask = UIViewAutoresizing(rawValue: UIViewAutoresizing.flexibleHeight.rawValue | UIViewAutoresizing.flexibleWidth.rawValue)

// 姿勢二：通過中括號的形式賦值
self.tableView.autoresizingMask = [.flexibleWidth, .flexibleHeight]

可選類型

  • Optional: 用來處理值可能缺失的情況,表示有值或沒有值 .

    可選類型是Swift的一個特色。它表示一個變量有可能有值，也可能沒有值（nil）。
    聲明的方式是“數據類型+問號”。
    而當要使用一個可選類型的變量是，要在后面加感嘆號“!”。

    var height:Int?  //聲明一個可選類型，默認值為nil
if height == nil{
    print("你有多高？")
} else {
    print("你有\(height!)高。")
}
height = 199 //給可選類型賦值

元組

目前Swift中唯一的一種復合類型，他可以將指定有限個數的任何類型一次整理為一個對象，元組中的每一種類型都可以是任何的結構體、枚舉或類類型，甚至也可以是一個元組以及空元組。元組中的每個元素我們稱為一個“分量”,一般以”元素“統稱

用例

/// 元組用例
    public class func testBasic() {
        // 給元組元素加標簽(不能數字開頭)，可通過標簽或索引下標來訪問元素
        let tupleTest1 = (gameName:"game", age:18, _:99, 10086, s0090990s:"666")
        let tupleSub0 = tupleTest1.gameName
        let tupleSub1 = tupleTest1.0
        // 聲明一個類型為(Int, Double, Bool)的元組常量,通過索引訪問元素(索引下標從0開始)
        let tupleTest2 = (10, 0.5, false)
        let tupleSub2 = tupleTest2.0
        print("\(tupleTest1)") // (gameName: "game", age: 18, 99, 10086, s0090990s: "666")
        print("\(tupleSub0)") // game
        print("\(tupleSub1)") // game
        print("\(tupleTest2)") // (10, 0.5, false)
        print("\(tupleSub2)") // 10
        // 一旦一個元組的某個元素帶上標簽，那么該元組類型相應的位置上也必須加上標簽
        // 一個元組中不需要給所有的元素都加上標簽，可以加一部分，指定標簽的元素
        // 如果給定標簽，我們可以通過標簽訪問也可以通過索引位置訪問
        // 元組往往用于一個函數返回多個不同類型的對象的場合
    }

萃取元素

/// 元組萃取元素
    public class func testGetElement() {
        // 聲明一個元組常量tupleTest, 元組也可以看作一個對象
        let tupleTest = (10, 0.5, true)
        // 這里同時聲明三個常量：a, b, c tupleTest的第一個元素對 a 初始化，b, c同理
        // let (a, b, c) 不是在聲明元組，而是同時聲明三個常量，用于萃取一個元組中的值
        let (a1, b1, c1) = tupleTest
        // 如果我們不想萃取元組中的某個元素，用_代替
        let (a2, _, c2) = (5.5, "hello", false)
        // 因為元組分解這一語法特性，可以通過元組字面量來交換兩個對象的值
        var a3 = 1, b3 = 2
        // 交換兩個對象的值，a3 ＝ 2， b3 ＝ 1
        (a3, b3) = (b3, a3)
        // a1:10 b1:0.5 c1:true a2:5.5 c2:false a3:2 b31
        print("a1:\(a1) b1:\(b1) c1:\(c1) a2:\(a2) c2:\(c2) a3:\(a3) b3\(b3)")
    }

元組比較

/// 元組比較
    public class func testCompara() {
        let tupleCompare1 = (1, 2, 3)
        let tupleCompare2 = (1, 2, 3)
        let tupleCompare3 = (6, 9, 3, 4)
        let tupleCompare4 = (6, 2, 5, 8)
        let tupleCompare5 = (true, 9, 3, 4)
        let tupleCompare6 = (false, 2, 5, 8)
        // 判斷元組 t1和t2 是否相等，結果為：t1 == t2? true
        print("t1 == t2? \(tupleCompare1 == tupleCompare2)")
        // 判斷元組 t3和t4 是否為小于關系，結果為：t3 < t4? false 因為t3的第二個元素大于t4的第二個元素
        print("t3 < t4? \(tupleCompare3 < tupleCompare4)")
        // 這里t1和t3比較，會直接報錯，因為不屬于同一個類型
        // print("tupleCompare1 = tupleCompare3? \(tupleCompare1 == tupleCompare3)")
        // 這里的tupleCompare5和tupleCompare6比較也會報錯，雖然元組類型一樣，因為Bool類型不遵循comparable協議
        // print("t5 < t6? \(tupleCompare5 < tupleCompare6)")
    }

注意: 一旦一個元組的某個元素帶上標簽，那么該元組類型相應的位置上也必須加上標簽，一個元組中不需要給所有的元素都加上標簽，可以加一部分，指定標簽的元素，我們可以通過索引位置訪問也可以通過標簽訪問; 元組往往用于一個函數返回多個不同類型的對象的場合。

我們能很容易的定義一個元組對象，我們也可以很容易的同時萃取一個元組中的相應元素，這也被稱為元組分解

// 聲明一個元組常量tuple
let tuple = (10, 0.5, true)
// 這里同時聲明三個常量：a, b, c
// tuple的第一個元素對 a 初始化，b, c同理
let (a1, b1, c1) = tuple
// 上面代碼 let (a, b, c) 不是在聲明元組，而是同時聲明三個常量，用于萃取一個元組中的值，元組也可以看作一個對象，上面的tuple就是名副其實的一個元組對象
// 如果我們不想萃取元組中的某個元素，用_代替
// a的值為：5.5， c的值為：false
let(a2, _, c2) = (5.5, "hello", false)

// 因為元組分解這一語法特性，可以通過元組字面量來交換兩個對象的值
// 定義 a和b兩個Int類型對象
var a3 = 1, b3 = 2
// 交換兩個對象的值，一個特殊用法，不用引入中間變量
(a3, b3) = (b3, a3) 
print("\(a1) \(b1) \(c1) \(a2) \(c2) \(a3) \(b3)")
// 10 0.5 true 5.5 false 2 1

元組比較

let tupleCompare1 = (1, 2, 3)
let tupleCompare2 = (1, 2, 3)
let tupleCompare3 = (6, 9, 3, 4)
let tupleCompare4 = (6, 2, 5, 8)
let tupleCompare5 = (true, 9, 3, 4)
let tupleCompare6 = (false, 2, 5, 8)
// 判斷元組 t1和t2 是否相等，結果為：true
print("t1 == t2? \(tupleCompare1 == tupleCompare2)")
// 判斷元組 t3和t4 是否為小于關系，結果為：false 因為t3的第二個元素大于t4的第二個元素
print("t3 < t4? \(tupleCompare3 < tupleCompare4)")
// 這里t1和t3比較，會直接報錯，因為不屬于同一個類型
// print("tupleCompare1 = tupleCompare3? \(tupleCompare1 == tupleCompare3)")
// 這里的tupleCompare5和tupleCompare6比較也會報錯，雖然元組類型一樣，因為Bool類型不遵循comparable協議
// print("t5 < t6? \(tupleCompare5 < tupleCompare6)")

簡單使用

// 寫法一:
let error = (404, "Not Found")
//下標訪問
print(error.0)
print(error.1)

// 寫法二:
let error = (errorCode : 404, errorInfo : "Not Found")
//別名訪問
print(error.errorCode)
print(error.errorInfo)

// 寫法三:
//定義元組變量接收元素的值
let (errorCode, errorInfo) = (404, "Not Found")
print(errorCode)
print(errorInfo)

Any、AnyObject

Any是一個空協議集合的別名，它表示沒有實現任何協議，因此它可以是任何類型，包括類實例與結構體實例。可以表示任何類型，包括函數類型。
AnyObject是一個成員為空的協議，任何對象都實現了這個協議?？梢员硎救魏晤愵愋偷膶嵗?/p>

類型轉化符號

is : 使用類型檢查操作符 （ is ）來檢查一個實例是否屬于一個特定的子類。如果實例是該子類類型，類型檢查操作符返回 true ，否則返回 false 。

as : 類型轉換操作符
as 從派生類轉換為基類，向上轉型（upcasts）
as! 向下轉型（Downcasting）時使用。由于是強制類型轉換，如果轉換失敗會報 runtime 運行錯誤。
as? 和 as! 操作符的轉換規則完全一樣。但 as? 如果轉換不成功的時候便會返回一個 nil 對象。成功的話返回可選類型值。由于 as? 在轉換失敗的時候也不會出現錯誤，所以對于如果能確保100%會成功的轉換則可使用 as!，否則使用 as?
.

Swift是強類型的語言，強類型語言也稱為強類型定義語言，是一種總是強制類型定義的語言，要求變量的使用要嚴格符合定義，所有變量都必須先定義后使用
Swift中任何一個變量/常量都有明確的類型
注意:

如果定義一個標識符時有直接進行賦值，那么標識符后面的類型可以省略
Swift有類型推導，會自動根據后面的賦值來決定前面的標識符的數據類型
可以通過option+鼠標左鍵來查看變量的數據類型






下一頁 Swift2-運算符和流程控制語句

最后編輯于 ：
?著作權歸作者所有,轉載或內容合作請聯系作者
平臺聲明：文章內容（如有圖片或視頻亦包括在內）由作者上傳并發布，文章內容僅代表作者本人觀點，簡書系信息發布平臺，僅提供信息存儲服務。
  • 人面猴
    序言：七十年代末，一起剝皮案震驚了整個濱河市，隨后出現的幾起案子，更是在濱河造成了極大的恐慌，老刑警劉巖，帶你破解...
    沈念sama閱讀 229,001評論 6贊 537
  • 死咒
    序言：濱河連續發生了三起死亡事件，死亡現場離奇詭異，居然都是意外死亡，警方通過查閱死者的電腦和手機，發現死者居然都...
    沈念sama閱讀 98,786評論 3贊 423
  • 救了他兩次的神仙讓他今天三更去死
    文/潘曉璐 我一進店門，熙熙樓的掌柜王于貴愁眉苦臉地迎上來，“玉大人，你說我怎么就攤上這事。” “怎么了？”我有些...
    開封第一講書人閱讀 176,986評論 0贊 381
  • 道士緝兇錄：失蹤的賣姜人
    文/不壞的土叔 我叫張陵，是天一觀的道長。 經常有香客問我，道長，這世上最難降的妖魔是什么？ 我笑而不...
    開封第一講書人閱讀 63,204評論 1贊 315
  • ?港島之戀（遺憾婚禮）
    正文 為了忘掉前任，我火速辦了婚禮，結果婚禮上，老公的妹妹穿的比我還像新娘。我一直安慰自己，他們只是感情好，可當我...
    茶點故事閱讀 71,964評論 6贊 410
  • 惡毒庶女頂嫁案：這布局不是一般人想出來的
    文/花漫 我一把揭開白布。 她就那樣靜靜地躺著，像睡著了一般。 火紅的嫁衣襯著肌膚如雪。 梳的紋絲不亂的頭發上，一...
    開封第一講書人閱讀 55,354評論 1贊 324
  • 城市分裂傳說
    那天，我揣著相機與錄音，去河邊找鬼。 笑死，一個胖子當著我的面吹牛，可吹牛的內容都是我干的。 我是一名探鬼主播，決...
    沈念sama閱讀 43,410評論 3贊 444
  • 雙鴛鴦連環套：你想象不到人心有多黑
    文/蒼蘭香墨 我猛地睜開眼，長吁一口氣：“原來是場噩夢啊……” “哼！你這毒婦竟也來了？” 一聲冷哼從身側響起，我...
    開封第一講書人閱讀 42,554評論 0贊 289
  • 萬榮殺人案實錄
    序言：老撾萬榮一對情侶失蹤，失蹤者是張志新（化名）和其女友劉穎，沒想到半個月后，有當地人在樹林里發現了一具尸體，經...
    沈念sama閱讀 49,106評論 1贊 335
  • ?護林員之死
    正文 獨居荒郊野嶺守林人離奇死亡，尸身上長有42處帶血的膿包…… 初始之章·張勛 以下內容為張勛視角 年9月15日...
    茶點故事閱讀 40,918評論 3贊 356
  • ?白月光啟示錄
    正文 我和宋清朗相戀三年，在試婚紗的時候發現自己被綠了。 大學時的朋友給我發了我未婚夫和他白月光在一起吃飯的照片。...
    茶點故事閱讀 43,093評論 1贊 371
  • 活死人
    序言：一個原本活蹦亂跳的男人離奇死亡，死狀恐怖，靈堂內的尸體忽然破棺而出，到底是詐尸還是另有隱情，我是刑警寧澤，帶...
    沈念sama閱讀 38,648評論 5贊 362
  • ?日本核電站爆炸內幕
    正文 年R本政府宣布，位于F島的核電站，受9級特大地震影響，放射性物質發生泄漏。R本人自食惡果不足惜，卻給世界環境...
    茶點故事閱讀 44,342評論 3贊 347
  • 男人毒藥：我在死后第九天來索命
    文/蒙蒙 一、第九天 我趴在偏房一處隱蔽的房頂上張望。 院中可真熱鬧，春花似錦、人聲如沸。這莊子的主人今日做“春日...
    開封第一講書人閱讀 34,755評論 0贊 28
  • 一樁弒父案，背后竟有這般陰謀
    文/蒼蘭香墨 我抬頭看了看天上的太陽。三九已至，卻和暖如春，著一層夾襖步出監牢的瞬間，已是汗流浹背。 一陣腳步聲響...
    開封第一講書人閱讀 36,009評論 1贊 289
  • 情欲美人皮
    我被黑心中介騙來泰國打工， 沒想到剛下飛機就差點兒被人妖公主榨干…… 1. 我叫王不留，地道東北人。 一個月前我還...
    沈念sama閱讀 51,839評論 3贊 395
  • 代替公主和親
    正文 我出身青樓，卻偏偏與公主長得像，于是被迫代替她去往敵國和親。 傳聞我的和親對象是個殘疾皇子，可洞房花燭夜當晚...
    茶點故事閱讀 48,107評論 2贊 375