枚举 rawValue indirect
//Enumerations 枚举
//enumeration syntax 枚举语法 枚举的第一个单词大写
enum SomeEnumeration {
//enumeration definition goes here 枚举的定义
}
//枚举的case 在定义的时候没初始值 这点是与OC 不同的地方 也就是说North不等于0 South不等于1 。。。
enum CompassPoint{
case North
case South
case East
case West
}
//enumeration 的cases 在同一行的时候 用逗号隔开
enum Planet{
case Mercury, Venus, Earth, Mars, Jupiter , Saturn, Uranus, Neptune海王星
}
var directionTohead = CompassPoint.West
directionTohead = .West //directionToHead 在初始化为CompassPoint的某个值时， 可是省略枚举的名称使用点语法
//通过switch语句来匹配枚举的值 没有其他情况的时候不需要使用default
switch directionTohead{
case .North:
print("Lots of planets have a north")
case .South:
print("Watch out fir penguins")
case .East:
print("Where is sun rises")
case .West:
print("Where the skies are blue") //"Where the skies are blue\n"
}
//switch 使用default的时候
let somePlanet = Planet.Earth
switch somePlanet{
case .Earth:
print("Mostly harmless") //"Mostly harmless\n"
default:
print("Not a safe place for human")
}
//case后面没有冒号的情况
enum Barcode{
case UPCA(Int, Int, Int, Int)//代表是 Barcode枚举 可以拿到UPCA和type(Int, Int, Int, Int)结合的值 或者QRCode和string类型结合的值
case QRCode(String)
}
var productBarcode = Barcode.UPCA(8, 85909, 51226, 3) //UPCA(8, 85909, 51226, 3)
productBarcode = .QRCode("ABCDEFGHIJKLMOP")//QRCode("ABCDEFGHIJKLMOP")
switch productBarcode {
case .UPCA(let numberSystem, let manufacturer, let product, let check):
print("UPC-A: \(numberSystem), \(manufacturer), \(product), \(check).")
case .QRCode(let productCode):
print("QR code: \(productCode).") //"QR code: ABCDEFGHIJKLMOP.\n"
}
//如果枚举的cases 所有元素作为常量 或者全部的元素都是变量 那么可是在case的名字前有var或者let标志
switch productBarcode {
case let .UPCA(numberSystem, manufacturer, product, check):
print("UPC-A: \(numberSystem), \(manufacturer), \(product), \(check).")
case let .QRCode(productCode):
print("QR code: \(productCode).")
}
// Prints "QR code: ABCDEFGHIJKLMNOP."
//Raw Values 给case的名称赋初始值
enum ASCIIControlCharacter: Character{
case Tab = "\t"
case LineFeed = "\n"
case CarriageReturn = "\r"
}
ASCIIControlCharacter.Tab.rawValue//" "
enum Planets2: Int{
case Mercury = 1, Venus, Earth, Mars, Jupiter, Saturn, Uranus, Neptune //Planets2.Mercury有个明确的值是1，那么Mercury.Earth有个隐式的值是2以此类推
}
Planets2.Earth.rawValue //3
Planets2.Mercury.rawValue//1
//枚举是string类型的代表 case语句被赋了初始值
enum CompassPoint1: String {
case North = "Northe", South, East, West
}
CompassPoint1.West.rawValue //"West"
CompassPoint1.North.rawValue //"Northe"
enum CompassPoint2: String {
case North, South, East, West
}
CompassPoint2.West.rawValue //"West"
CompassPoint2.North.rawValue //"North"
//带初始值初始化 initializing from a raw value
let possiblePlanet = Planets2(rawValue: 7) //Uranus 并不是所有的int值可以找到对应的planet 所以raw value initializer总是返回一个可选的枚举的case 所以 possiblePlanet 是Planets2? 或者是optional Planets2 如果rawVlaue: 11 那么Planets2(rawValue: 11) 返回的就是空nil
let positionToFind = 11
if let somePlanet = Planets2(rawValue: positionToFind) {
switch somePlanet {
case .Earth:
print("Mostly harmless")
default:
print("Not a safe place for humans")
}
} else {
print("There isn't a planet at position \(positionToFind)")
}
// Prints "There isn't a planet at position 11"
//recursive Ennumerations 递归枚举 indirect 间接的
enum ArithmeticExpression{
case Nunber(Int)
indirect case Addition(ArithmeticExpression, ArithmeticExpression)
indirect case Multiplication(ArithmeticExpression, ArithmeticExpression)
}
//如果所有的case语句需要indirect的话 也可以吧indirect 放在 枚举的前面 enum的前面
indirect enum ArithmeticExpression1{
case Number(Int)
case Addition(ArithmeticExpression1,ArithmeticExpression1)
case Mutiplication(ArithmeticExpression1, ArithmeticExpression1)
}
let thre = ArithmeticExpression1.Number(3)
let four = ArithmeticExpression1.Number(4)
let sum = ArithmeticExpression1.Addition(thre, four)
let product = ArithmeticExpression1.Mutiplication(thre, four)
func evaluate(expression: ArithmeticExpression1) -> Int {
switch expression {
case let .Number(value):
return value
case let .Addition(left, right):
return evaluate(left) + evaluate(right)
case let .Mutiplication(left, right):
return evaluate(left) * evaluate(right)
}
}
print(evaluate(product))
// Prints "12"
