Swift3.0 - 真的很簡單
Swift3.0 - 數據類型
Swift3.0 - Array
Swift3.0 - 字典
Swift3.0 - 可選值
Swift3.0 - 集合
Swift3.0 - 流控制
Swift3.0 - 對象和類
Swift3.0 - 屬性
Swift3.0 - 函數和閉包
Swift3.0 - 初始化和釋放
Swift3.0 - 協議protocol
Swift3.0 - 類和結構體的區別
Swift3.0 - 枚舉
Swift3.0 - 擴展
Swift3.0 - 下標
Swift3.0 - 泛型
Swift3.0 - 異常錯誤
Swift3.0 - 斷言
Swift3.0 - 自動引用計數(strong,weak,unowned)
Swift3.0 - 檢測API
Swift3.0 - 對象的標識
Swift3.0 - 注釋
Swift3.0 - 元類型
Swift3.0 - 空間命名
Swift3.0 - 對象判等
Swift3.0 - 探究Self的用途
Swift3.0 - 類簇
Swift3.0 - 動態調用對象(實例)方法
Swift3.0 - 文本輸出
Swift3.0 - 黑魔法swizzle
Swift3.0 - 鏡像
Swift3.0 - 遇到的坑

基本用法

• 最簡單的定義

a.多行寫法

  enum CompassPoint {
    case north
    case south
    case east
    case west
  }

b.單行寫法

 enum CompassPoint {
    case north,south,ease,west
}

提示:

Swift 3.0 開始,定義枚舉值,統一小寫

• 指定枚舉類型的原始數據類型

enum Rank: Int{ // Int 設置枚舉值的類型
// 定義枚舉值設置值
case ace
// 可以case 后面一次定義多個枚舉值
case two, three, four, five, six, seven, eight, nine, ten
case jack, queen, king

// 定義函數 如果多人合作的時候,可以使用這個讓別人更加了解你定義的屬性的含義
    func simpleDescription() -> String {
        switch self { // self 就是這個枚舉本身
            case .ace:
                return "ace1"
            case .jack:
                return "jack1"
            case .queen:
                return "queen1"
            case .king:
                return "king1"
            default:
                return String(self.rawValue)
        }
    } 
}

注意

枚舉類型可以Int String等基本類型的值,對象是不可以的,官方說必須是實現RawRepresentable 協議的類型才可以

• 使用

  let ace = Rank.ace // 非可選值
  let rank = Rank(rawValue: 1)

提示

第二種創建的枚舉為可選類型,這樣設計的原因是,你有可能創建一個nil對象,處于安全考慮它也必須是可選值,使用的時候要解包

• 給枚舉設置原始值

enum CompassPoint {
    case north = "1"
    case south = "2"
    case east = "3"
    case west = "4"
}

提示:

你認為上面這樣定義是否是正確的,答案是否定的,因為系統不知道你枚舉的原始值是什么類型的,這里系統沒有進行類型推斷,所有我們要給枚舉添加原始值之前,必須指定枚舉原始值的類型,如下

enum CompassPoint:Character{
    case north = "1"
    case south = "2"
    case east = "3"
    case west = "4"
}

• 獲取原始值

let aceRawValue = ace.rawValue

提示

1.如果你沒有定義枚舉的原始值類型,你不能通過上述方法獲取原始值
2.輸入定義的是數字類型 ，原始值對應的是數字本身，
3.如果定義的是字符串類型,但你沒有給它賦值,這個時候,你獲取的原始值就是你定義的名字

高級用法

• 提供值創建枚舉

enum ServerResponse {
  case result(String, String)
  case failure(String)
}
let success = ServerResponse.result("6:00 am", "8:09 pm")
let failure = ServerResponse.failure("Out of cheese.")

提示

這個方式定義的枚舉 不能使用 == 來做判斷處理,我們應該使用模式匹配的方式處理,這種定義方式強調的是傳值,如下

switch success {
case let .result(sunrise, sunset): // 模式匹配
    print("Sunrise is at \\(sunrise) and sunset is at \\(sunset).")
case let .failure(message):
    print("Failure...  \\(message)")
}

// 或者
switch success {
case  .result(let sunrise, let sunset): // 模式匹配
    print("Sunrise is at \\(sunrise) and sunset is at \\(sunset).")
case  .failure(let message):
    print("Failure...  \\(message)")
}

• indirect 使用方法
  使用場景:

主要用于遞歸枚舉,看下面例子,你應該很清楚怎么使用

a.使用方式1

enum ArithmeticExpression {
case number(Int)
indirect case addition(ArithmeticExpression, ArithmeticExpression)
indirect case multiplication(ArithmeticExpression, ArithmeticExpression)
}

let expression =     ArithmeticExpression.addition(ArithmeticExpression.number(3),     ArithmeticExpression.number(4))

b.使用方式2

 indirect enum ArithmeticExpression {
    case number(Int)
    case addition(ArithmeticExpression, ArithmeticExpression)
    case multiplication(ArithmeticExpression, ArithmeticExpression)
}

let expression =     ArithmeticExpression.addition(ArithmeticExpression.number(3), ArithmeticExpression.number(4))

結論:

如果你定義的枚舉是遞歸的形式,必須有關鍵字indirect 修飾,不然系統會編譯報錯哦!

• 重新實現SWIFT標準庫的可選類型(使用泛型技術)

enum OptionalValue<Wrapped> {
    case none
    case some(Wrapped)
}
var possibleInteger: OptionalValue<Int> = .none
possibleInteger = .some(100)

• 枚舉可以繼承協議

protocol Skill{
    mutating func modifyMusic(name:String)
}

enum Type:String,Skill{
case name = "123"
mutating internal func modifyMusic(name: String) {
    self = Type(rawValue: "123")!
}
}

• 枚舉不能包含存儲屬性,但是可以包含靜態變量和計算屬性

enum SomeEnumeration:Int {
    case one = 2
    case two = 345
    // 靜態變量
    static  var storedTypeProperty = "Some value."
    // 靜態計算屬性
    static var computedTypeProperty: Int {
        return 6
    }
    // 計算屬性
    var getRaw:Int{
        return self.rawValue
    }
}

• 一般人都不知道的神級操作

enum Locale {
    case none
    case base
    case language(String)
 }

我們創建一個變量

let locale = Locale.language("english")

問題: 我們怎么判斷它是什么類型呢?

if locale == Locale.base {
}// 錯誤的判斷方式

編譯錯誤,如果沒有 case language(String) 這種賦值枚舉,可以使用上面的方式,一點問題也沒有,但是如果有這種類型,系統不允許使用 == 進行數據判斷的

我們可以提供下面的方式進行判斷

switch locale{
    case Locale.base : print(locale)
    case Locale.none : print(locale)
    case Locale.language("english"): print(locale)
    case Locale.language(let x):print(x)
}

為了判斷一個類型我們寫這么一個判斷是在是有點不雅,下面就體驗一下關鍵字case 的神奇用法

我們重新寫一下上面的枚舉,使用case 寫出優雅的代碼

enum Locale {
    case none
    case base
    case language(String)
    // 判斷是否是漢語
    var isChinese:Bool{
        if case .language("chinese") = self {
            return true
        }
      return false
    }
    // 是否是其他語言
     var isLanguage:Bool{
      if case .language = self {
          return true
      }
        return false
    }

    var isBase: Bool {
        if case .base = self {
            return true
        }
    
        return false
    }

    var isNone: Bool {
        if case .none = self {
            return true
        }
        return false
    }
}

我們看一下如何調用

let locale = Locale.language("english")
print(locale.isChinese)