Swift Basic 3

为什么80%的码农都做不了架构师？>>>   

枚举类型和结构体

使用enum创建一个枚举类型

1. 枚举类型的 Raw Value 是一个Int 类型

2. 使用toRaw() & fromRaw(Int) 相互转换

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      //返回“ace”
let aceRawValue = ace.toRaw()   //返回 1
if let convertedRank = Rank.fromRaw(11) {
    let threeDescription = convertedRank.simpleDescription() //返回jack
}

使用Struct创建一个结构体

//来感受一下
//定义扑克牌数值A,2,3,4,5,6,7,8,9,10,J,Q,K

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()

//定义扑克牌花色
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()

//-------------------------------
//定义结构体扑克牌
struct Card {
    //属性1 数字
    var rank: Rank
    //属性2 花色
    var suit: Suit
    //方法1 输出扑克牌名称
    func simpleDescription() -> String {
        return "The \(rank.simpleDescription()) of \(suit.simpleDescription())"
    }
}
let threeOfSpades = Card(rank: .Three, suit: .Spades)
let threeOfSpadesDescription = threeOfSpades.simpleDescription()

协议和扩展

使用protocol申明一个协议

Classes, enumerations, structs 可以继承协议

使用extension向已存在的类型中添加属性和方法

//声明一个协议
protocol ExampleProtocol {
    var simpleDescription: String { get }
    mutating func adjust()
}
//Classes, enumerations, and structs can all adopt protocols.
//声明一个类继承该协议
class SimpleClass: ExampleProtocol {
    var simpleDescription: String = "A very simple class."
    var anotherProperty: Int = 69105
    //不需要关键字mutating,一个类随时可以更改它的方法
    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修改结构体继承的方法
    mutating func adjust() {
        simpleDescription += " (adjusted)"
    }
}
//-------------------------------------
var b = SimpleStructure()
b.adjust()
let bDescription = b.simpleDescription
//-------------------------------------
//创建该协议的扩展
extension Int: ExampleProtocol {
    var simpleDescription: String {
        return "The number \(self)"
    }
    mutating func adjust() {
        self += 42
    }
}
//-------------------------------------
7.simpleDescription

//实例化一个protocol
let protocolValue: ExampleProtocol = a
protocolValue.simpleDescription

Generics

1.使用 Generics_Name<param> 创建一个Generics‍

Generics是程序设计语言的一种技术，指将程序中数据类型进行参数化，它本质上是对程序的数据类型进行一次抽象，扩展语言的表达能力，同时支持更大粒度的代码复用。

对于一些数据类型参数化的类和方法来说，它们往往具有更好的可读性、可复用性和可靠性。在设计集合类和它们的抽象操作时，往往需要将它们定义为与具体数据类型无关，在这种情况下，使用Generics就是非常适合的。

如果需要设计一个TestGenerics类，有时需要元素为int类型的TestGenerics，有时可能需要元素为Boolean或者Object类型的TestGenerics。如果不使用Generics，我们通常需要定义不同的多个类，或者通过继承来实现。通过继承实现往往引起数据类型的转换问题。如果使用Generics技术，将TestGenerics的元素类型进行参数化，那么TestGenerics类的只需要实现一个版本，当需要某元素类型的Stack时，可以将类型作为参数来创建TestGenerics对象。

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

2.可以用函数,枚举,结构体的形式使用Generics

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

3.where用在参数后对参数进行约束

func anyCommonElements <T, U where T: SequenceType, U: SequenceType, T.Generator.Element: Equatable, T.Generator.Element == U.Generator.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])     //true
anyCommonElements([1, 2, 3], [4])     //flase

转载于:https://my.oschina.net/arunu/blog/311191