The Swift Programming Language中文版 ----A Swift Tour（二）

/*

接着昨天的内容。继续翻译。。。。

*/

5.枚举和结构体

使用 enum 可以创建一个枚举，就像创建一个类和它全部的类型名一样，枚举可以通过方法将它们联系起来。

enum Rank: Int {
    case Ace = 1
    case Two, Three, Four, Five, Six, Seven, Eight, Nine, Ten
    case Jack, Queen, King
    func simpleDescription() -> String {
        switch self {
        case .Ace:
            return "ace"
        case .Jack:
            return "jack"
        case .Queen:
            return "queen"
        case .King:
            return "king"
        default:
            return String(self.toRaw())
        }
    }
}
let ace = Rank.Ace
let aceRawValue = ace.toRaw()

尝试： 编写一个函数，通过比较其原始值来比较两个 Rank 的值。

在如上例子中，原始值的类型是 Int 所以可以只指定第一个原始值。其后的原始值都是按照顺序赋值的。也可以使用字符串或浮点数作为枚举的原始值。使用 toRaw 和 fromRaw 函数可以转换原始值和枚举值。

if let convertedRank = Rank.fromRaw(3) {
    let threeDescription = convertedRank.simpleDescription()
}

枚举的成员值就是实际值，而不是其他方式写的原始值。实际上，有些情况是原始值，就是你不提供的时候。

enum Suit {
    case Spades, Hearts, Diamonds, Clubs
    func simpleDescription() -> String {
        switch self {
        case .Spades:
            return "spades"
        case .Hearts:
            return "hearts"
        case .Diamonds:
            return "diamonds"
        case .Clubs:
            return "clubs"
        }
    }
}
let hearts = Suit.Hearts
let heartsDescription = hearts.simpleDescription()

尝试：添加一个 color 方法到 Suit 并在 spades 和 clubs 时返回 "black" ，并且给 hearts 和 diamounds 返回 "red" 。

注意上面引用Hearts成员的两种方法：当赋值到 hearts 常量时，枚举成员 Suit.Hearts 通过全名引用，因为常量没有明确的类型。在 switch 中，枚举通过 .Hearts 引用，因为 self 的值是已知的。你可以在任何时候使用方便的方法。

使用 struct 创建结构体。结构体支持多个与类相同的行为，包括方法和构造器。一大重要的区别是代码之间的传递总是用拷贝(值传递)，而类则是传递引用。

struct Card {
    var rank: Rank
    var suit: Suit
    func simpleDescription() -> String {
        return "The \(rank.simpleDescription()) of \(suit.simpleDescription())"
    }
}
let threeOfSpades = Card(rank: .Three, suit: .Spades)
let threeOfSpadesDescription = threeOfSpades.simpleDescription()

添加方法到 Card 类来创建一桌的纸牌，每个纸牌都有合并的rank和suit。(就是个打字员的活二，by gashero)。

一个枚举的实例成员可以拥有实例的值。相同枚举成员实例可以有不同的值。你在创建实例时赋值。指定值和原始值的区别：枚举的原始值与其实例相同，你在定义枚举时提供原始值。

例如，假设情况需要从服务器获取太阳升起和降落时间。服务器可以响应相同的信息或一些错误信息。、

enum ServerResponse {
    case Result(String, String)
    case Error(String)
}
 
let success = ServerResponse.Result("6:00 am", "8:09 pm")
let failure = ServerResponse.Error("Out of cheese.")
 
switch success {
case let .Result(sunrise, sunset):
    let serverResponse = "Sunrise is at \(sunrise) and sunset is at \(sunset)."
case let .Error(error):
    let serverResponse = "Failure...  \(error)"
}

尝试：给 ServerResponse 添加第三种情况来选择。

注意日出和日落时间实际上来自于对 ServerResponse 的部分匹配来选择的。

6.协议和延展

使用 protocol 可以定义一个协议

protocol ExampleProtocol {
    var simpleDescription: String { get }
    mutating func adjust()
}

类别、枚举和结构体都可以采用协议。

class SimpleClass: ExampleProtocol {
    var simpleDescription: String = "A very simple class."
    var anotherProperty: Int = 69105
    func adjust() {
        simpleDescription += "  Now 100% adjusted."
    }
}
var a = SimpleClass()
a.adjust()
let aDescription = a.simpleDescription
 
struct SimpleStructure: ExampleProtocol {
    var simpleDescription: String = "A simple structure"
    mutating func adjust() {
        simpleDescription += " (adjusted)"
    }
}
var b = SimpleStructure()
b.adjust()
let bDescription = b.simpleDescription

尝试：写一个遵循这个协议的枚举。

注意：在使用关键词mutating声明simpleStructure时，应标明修改结构体的方法。SimpleClass的声明并不需要它的任何方法标记为mutating，因为在一个类中的方法可以随时修改类。

使用extension给现有的类型添加新的功能，如新的方法和计算性能。你可以使用延展在其他地方为一个类型添加一个协议，甚至是一个库或框架导入的类型。

extension Int: ExampleProtocol {
    var simpleDescription: String {
    return "The number \(self)"
    }
    mutating func adjust() {
        self += 42
    }
}
7.simpleDescription

尝试：写一个延展，用于给Double类型添加一个absoluteValue属性。

你可以使用的协议名称，就像任何其他类型的命名，例如，可以创建具有不同类型的对象的集合，但都符合一个单一的协议。当你使用协议类型的值时，协议定义之外的方法不可用。

let protocolValue: ExampleProtocol = a
protocolValue.simpleDescription
// protocolValue.anotherProperty  // Uncomment to see the error

即使变量protocolValue有SimpleClass的运行时的类型，编译器会将其视为给定类型ExampleProtocol的。这意味着你不能访问方法或类，除了该协议一致实现的属性。

7. 泛型

用一个带尖括号的名字来定义泛型函数或类型。

func repeat<ItemType>(item: ItemType, times: Int) -> ItemType[] {
    var result = ItemType[]()
    for i in 0..times {
        result += item
    }
    return result
}
repeat("knock", 4)

你可以定义一个由函数和方法，以及类，枚举和结构组成的泛型。

enum OptionalValue<T> {
    case None
    case Some(T)
}
var possibleInteger: OptionalValue<Int> = .None
possibleInteger = .Some(100)

在类型名后使用 where 来指定具体的参数列表。例如，所需要的类型来执行一个协议，规定两种类型是相同的，或者需要一个类都具有一个特定的超类。

func anyCommonElements <T, U where T: Sequence, U: Sequence, T.GeneratorType.Element: Equatable, T.GeneratorType.Element == U.GeneratorType.Element> (lhs: T, rhs: U) -> Bool {
    for lhsItem in lhs {
        for rhsItem in rhs {
            if lhsItem == rhsItem {
                return true
            }
        }
    }
    return false
}
anyCommonElements([1, 2, 3], [3])

尝试：修改anyCommonElements函数，使它返回的任何两个具有共同元素的数组”。 

在简单情况下，可以省略 where 关键词，例如<T: Equatable>与<T where T: Equatable>的效果是一样的。

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

文档的第一部分翻译完了。由于水平有限，再加上时间仓促，没来得及仔细思考。所以很多地方翻译的不够准确。希望跪求各位大神能够及时指出不足之处～