A Swift Tour

按照惯例，我们一般学习一个新语言的时候，我们都习惯性的在屏幕上打印“Hello, World”，在Swift中，你可以用如下一个单独语句实现

println("Hello,World")

这个案例将给你足够的信息去开始swift代码的编写，会为你展现各种各样的编程任务。如果你不明白某些内容也不要担心，这个案例中的一些细节稍后会在本文档的后续部分一一解释。

注意！
为了达到更好的效果，请在Xcode里用playgound打开，因为它会编辑文章中列举的代码，还可以立即查看结果。
<a target=_blank href=http://www.mamicode.com/"http://download.csdn.net/detail/qhshiniba/7505269">Open Playground >
简单的赋值语句

用let定义常量，var定义变量。在编译的时候程序不需要知道常量的值，但是你必须一次性给它赋予正确的值(一次赋值，到处引用。哪个语言的特性？)，这意味着你可以用常量一次性定义一个值，但是可以在许多地方使用。

    var myVariable = 42
    myVariable = 50
    let myConstant = 42


一个常量或者变量必须有相同的类型来表示你想去定义的的值，你并不经常需要去显示的指示值类型。显示指示的目的是为了在程序编译时让编译器知道你所定义的值的类型。如上面的例子所示，myVariable你定义的是一个整型类型，所以你需要显示的指示该类型为Integer。
如果你在初始化该值的时候没有提供足够的信息（或者你没有初始化），特殊的类型指定，需要用冒号+类型的形式指定。

    let implicitInteger = 70
    let implicitDouble = 70.0
    let explicitDouble: Double = 70


如果定义个Float类型呢：
let explicitFloat:Float = 4

值不能隐式的转换为另一个类型，如果你想在不同类型之间进行转化，你需要显式定义你期望类型的实体。

    let label = "The width is "
    let width = 94
    let widthLabel = label + String(width)

可以试试把上面最后一行的String去掉，看会出现什么错

还有一个更简单的方式在字符串中包含其他类型的值。在小括号中写入该值，然后在小括号前面加一个反斜杠(\).例如：

    let apples = 3
    let oranges = 5
    let appleSummary = "I have \(apples) apples."
    let fruitSummary = "I have \(apples + oranges) pieces of fruit."


练习
将float类型的值包含在字符串中
let impfloat1 = 0.5
let impfloat2 = 1.4
let appleSummary = "I have \(impfloat1) apples."
let fruitSummary = "I have \(impfloat1 + impfloat2) pieces of fruit."
(对不对？)

用括号（[ ]）创建数组和字典(又类似python),想获得其值，和其他语言一样就在括号中填入索引或者key值就能获得相应的值。

    var shoppingList = ["catfish", "water", "tulips", "blue paint"]
    shoppingList[1] = "bottle of water"
    var occupations = [
    "Malcolm": "Captain",
    "Kaylee": "Mechanic",
    ]
    occupations["Jayne"] = "Public Relations"

要想定义空数组或者空字典，可以使用初始化语句：

    let emptyArray = String[]()
    let emptyDictionary = Dictionary<String, Float>()


如果类型信息可以被推断出来，那么你定义数组的话可以用[ ],定义字典的话可以用[:].如果你想定义数组：

    shoppingList = [] // Went shopping and bought everything.
    shoppingDic = [:]//我自己写的玩的。
 


控制语句


（和其他语言一样）用if/switch定义条件语句，用for-in,for,while和do-while来定义循环语句，围绕条件和循环变量的圆括弧不是必须的，但是花括号时必须要有的。

    let individualScores = [75, 43, 103, 87, 12]
    var teamScore = 0
    for score in individualScores {
    if score > 50 {
    teamScore += 3
    } else {
    teamScore += 1
    }
    }
    teamScore


在一个if语句中，条件必须是一个布尔表达式，必须if score{...}就是一个错误的语句，因为它不能隐式的和0做比较。

你可以用if和let一起来使用可能会丢失的值，那些值代表一些可选项。一个可选项的值机可以包含一个值，也可以包含缺省值nil。在类型后面加上问号（？）代表该值为可选值

    var optionalString: String? = "Hello"
    optionalString == nil
    var optionalName: String? = "John Appleseed"
    var greeting = "Hello!"
    if let name = optionalName {
    greeting = "Hello, \(name)"
    }


练习
如果把optionalName 变为nil.greeting的值是什么？添加一个else分句当optionalName为nil时设置不同的greeting（不会）

如果可选值为nil，条件为false而且会跳过花括号里的语句。否则可选值会被打开然后赋上let后的值，且该值为在花括号的代码中有效，可以使用。

switch支持不同类型的数据以及各式各样的比较操作，他们不局限于测试整数是否相等。

    let vegetable = "red pepper"
    switch vegetable {
    case "celery":
    let vegetableComment = "Add some raisins and make ants on a log."
    case "cucumber", "watercress":
    let vegetableComment = "That would make a good tea sandwich."
    case let x where x.hasSuffix("pepper"):
    let vegetableComment = "Is it a spicy \(x)?"
    default:
    let vegetableComment = "Everything tastes good in soup."
    }


练习
如果删除default，会出什么错误

switch执行条件代码然后匹配case语句，然后离开switch语句。程序不会执行后面的case语句，所以不需要在每个case语句块后写break来跳出switch语句。

使用for-in来递归遍历字典，通过为每个键值对提供2个名字。

    let interestingNumbers = [
    "Prime": [2, 3, 5, 7, 11, 13],
    "Fibonacci": [1, 1, 2, 3, 5, 8],
    "Square": [1, 4, 9, 16, 25],
    ]
    var largest = 0
    for (kind, numbers) in interestingNumbers {
    for number in numbers {
    if number > largest {
    largest = number
    }
    }
    }
    largest

练习
添加一个变量跟踪哪一个kind的值是最大的，以及最大的number数是多少

使用while去重复执行一个代码块，知道条件发生改变。循环的调价可以在最后改变，以确保循环语句至少执行一次。


    var n = 2
    while n < 100 {
    n = n * 2
    }
    n
    var m = 2
    do {
    m = m * 2
    } while m < 100
    m


你可以保持一个索引，通过使用..定义循环的范围或者通过定义一个显式初始化，条件和增量，上面2个循环可写成如下形式：

    var firstForLoop = 0
    for i in 0..3 {//0,1,2
    firstForLoop += i
    }
    firstForLoop
    var secondForLoop = 0
    for var i = 0; i < 3; ++i {
    secondForLoop += 1
    }
    secondForLoop


用..定义范围的话不包括最大值，用...包括所有值。

函数和组合体


用func去定义一个函数，调用函数可以通过其函数名加上参数(这个跟一般语言是一样的)。用->来将函数的参数命和类型与返回值的类型分开。

    func greet(name: String, day: String) -> String {
    return "Hello \(name), today is \(day)."
    }
    greet("Bob", "Tuesday")


练习
删除today参数，添加一个参数，该参数要办好午餐特殊问候的。

用元组的形式来返回相同类型的多个值

    func getGasPrices() -> (Double, Double, Double) {
    return (3.59, 3.69, 3.79)
    }
    getGasPrices()


函数也可以自带一个可变的参数，将其放在一个数组中。

    func sumOf(numbers: Int...) -> Int {
    var sum = 0
    for number in numbers {
    sum += number
    }
    return sum
    }
    sumOf()
    sumOf(42, 597, 12)


练习
写一个函数计算参数的平均数
func average(numbers:Int...)->Double<pre name="code" class="java">var sum = 0
var num = 0
for number in numbers{
sum += number
num++
}
return sum/num;

} 
average(230,23,22)
函数还可以嵌套（对于java可不能），嵌套函数可以访问外部函数定义的变量，你可以用嵌套的方式来组织一个代码很长、很复杂的函数。
    func returnFifteen() -> Int {
    var y = 10
    func add() {
    y += 5
    }
    add()
    return y
    }
    returnFifteen()


函数的返回值可以为另一个函数，因为函数是first-class的类型（理解为为一个数据类型就行了）。

    func makeIncrementer() -> (Int -> Int) {
    func addOne(number: Int) -> Int {
    return 1 + number
    }
    return addOne
    }
    var increment = makeIncrementer()
    increment(7)


函数的参数也可以是另一个函数（好变态的感觉！！）

    func hasAnyMatches(list: Int[], condition: Int -> Bool) -> Bool {
    for item in list {
    if condition(item) {
    return true
    }
    }
    return false
    }
    func lessThanTen(number: Int) -> Bool {
    return number < 10
    }
    var numbers = [20, 19, 7, 12]
    hasAnyMatches(numbers, lessThanTen)


函数是一个特殊的组合体实例，你可以写一个闭包，用花括号（{}）的方式而不需要命名，用in从函数主体中分拆参数和返回值类型

    numbers.map({
    (number: Int) -> Int in
    let result = 3 * number
    return result
    })

练习
重写组合体，当传入参数是奇数时，返回0

你有很多种方式使得编写组合体更方便，当一个组合体的类型是已知的时候，比如代理回调组合体。你可以省略其参数的类型，返回值的类型或者所有的类型。一条语句的组合体隐式返回它唯一语句的值。

numbers.map({ number in 3 * number })

你可以参考参数的数量来代替参数名称，在很短的组合体中这种方式显的特别有用。一个组合体可以作为函数的最后一个参数传递进去，方式是紧接着小括号的后面。

sort([1, 5, 3, 12, 2]) { $0 > $1 }

对象和类

在一个名称前面加上class来创建一个类。类中的属性声明和常量或变量的声明是一样的（类的上下文中除外），同样方法和函数也是一样的的定义方式。


    class Shape {
    var numberOfSides = 0
    func simpleDescription() -> String {
    return "A shape with \(numberOfSides) sides."
    }
    }


练习
用let增加一个常量，并添加一个具有一个参数的方法
Class Shape{
let num = 1024

func simpleDes(name:String)->String{
    return "A shape with \(name) sides"
}

} 

创建类的实例时，在类名后面加上一个括号（()）就行了。使用点（.）的形式来访问类的方法和属性。

    var shape = Shape()
    shape.numberOfSides = 7
    var shapeDescription = shape.simpleDescription()


上面的类Shape少了一个重要的东西，就是在实例化该类时做初始化设置的方法。需要用init来创建该初始化方法

    class NamedShape {
    var numberOfSides: Int = 0
    var name: String
    init(name: String) {
    self.name = name
    }
    func simpleDescription() -> String {
    return "A shape with \(numberOfSides) sides."
    }
    }


注意上面的self(java中的this)是用来区分初始化时系统的属性和方法参数的标识符。当你创建一个类的实例时，初始化器中的参数像函数调用一样传递进来。每一个属性都需要分配一个值，不管这个值是已经声明还是在初始化时才声明的。
如果在对象被释放之前，需要做一些清理工作，可以使用deinit来定义一个清理器。

定义一个子类时，父类要放在子类的后面，加冒号（:）隔开，对于继承标准根基类的类这不是必须的。所以你可以显式或隐式的处理类的继承。

子类要重写父类的接口，用override来标识，如果不写override编译器会当成一个错误拒绝编译。如果父类中没有该方法，你却添加了override这个标识符，编译器也会报错。

    class Square: NamedShape {
    var sideLength: Double
    init(sideLength: Double, name: String) {
    self.sideLength = sideLength
    super.init(name: name)
    numberOfSides = 4
    }
    func area() -> Double {
    return sideLength * sideLength
    }
    override func simpleDescription() -> String {
    return "A square with sides of length \(sideLength)."
    }
    }
    let test = Square(sideLength: 5.2, name: "my test square")
    test.area()
    test.simpleDescription()


练习
创建一个NamedShape的新的子类Circle。初始化时传入2个参数：name和radius.继承2个方法：area和describe。

除了保存简单的属性值以外，还要生成get和set方法。

    class EquilateralTriangle: NamedShape {
    var sideLength: Double = 0.0
    init(sideLength: Double, name: String) {
    self.sideLength = sideLength
    super.init(name: name)
    numberOfSides = 3
    }
    var perimeter: Double {
    get {
    return 3.0 * sideLength
    }
    set{
    sideLength = newValue / 3.0
    }
    }
    override func simpleDescription() -> String {
    return "An equilateral triagle with sides of length \(sideLength)."
    }
    }
    var triangle = EquilateralTriangle(sideLength: 3.1, name: "a triangle")
    triangle.perimeter
    triangle.perimeter = 9.9
    triangle.sideLength


在perimeter的set方法中，出现了一个隐式的新值newValue。如果你想显式的定义名称，可以在set方法的后面括号里给该值定义一个名称。[set(exValue:Double)? ]
注意EquilateralTriangle类中的初始化方法中的3句代码

1.设置子类中定义的属性值
2.调用父类中的初始器
3.改变父类中定义的属性值。任何额外的初始化工作比如使用方法，set/get方法都可以在该位置设置。

如果你不需要计算属性的值，但是在设置新值的前后又需要提供一些代码，可以使用willSet和didSet方法。举例说明：下面的确定三角形的边长的类和边长的平方类似。

    class TriangleAndSquare {
    var triangle: EquilateralTriangle {
    willSet {
    square.sideLength = newValue.sideLength
    }
    }
    var square: Square {
    willSet {
    triangle.sideLength = newValue.sideLength
    }
    }
    init(size: Double, name: String) {
    square = Square(sideLength: size, name: name)
    triangle = EquilateralTriangle(sideLength: size, name: name)
    }
    }
    var triangleAndSquare = TriangleAndSquare(size: 10, name: "another test shape")
    triangleAndSquare.square.sideLength
    triangleAndSquare.triangle.sideLength
    triangleAndSquare.square = Square(sideLength: 50, name: "larger square")
    triangleAndSquare.triangle.sideLength


类中的方法与函数有一个重要的不同点在于，函数的参数只作用于函数体内，而方法的参数也可以用于调用该方法的地方（除了第一个参数）。默认情况下，当你调用方法或者在方法体内部，方法中的参数都有同一个名称。你也可以在方法内部给它重新起一个名字。

    class Counter {
    var count: Int = 0
    func incrementBy(amount: Int, numberOfTimes times: Int) {
    count += amount * times
    }
    }
    var counter = Counter()
    counter.incrementBy(2, numberOfTimes: 7)

在处理可选值时(即该值可能为nil)，你可以在处理类似于方法、属性、下表前添加问号（？），如果在问号（？）前是个nil值，问号（？）后的任何值都会被忽略而且整个表达式的值都为nil。另外，可选值会被跳过，而且问号（？）后所有的值都作为the unwrapped value（开关值）。在以上情况下，表达式的值为一个可选值。
    let optionalSquare: Square? = Square(sideLength: 2.5, name: "optional square")
    let sideLength = optionalSquare?.sideLength

（以上的解释可能是说，对于可选值来说，你要想获得其值，就需要先打开其值的开关，用！打开）

枚举和结构体
（有点C的感觉了哈）

用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 = http://www.mamicode.com/ace.toRaw()>
练习
写一个函数通过比较2个Rank对象的原生值来比较他们 

在以上的例子中，枚举对象的原生值类型是Int类型，所以你只需要去指定第一个原生值，其余的原生值会被分配。你也可以用string或者浮点数作为枚举类型的原生类型。
用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()


练习
在Suit枚举中添加一个color方法，当spades和clubs返回"black"的值，当hearts和diamonds时返回"red"的值

注意上面的实例中，引用枚举的成员变量Hearts的两种方式：
当为hearts常量指定一个值时，枚举的成员变量Suit.Hearts会通过其全称而被引用，因为常量值没有一个显式的指定类型。而在Switch中，对Hearts的引用是通过简写形式.Hearts来引用的。因为self已经可以理解为一个Suit对象。所以在值的类型已知的任何场合，你都可以使用简写的方式。

用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中添加方法创造所有的扑克牌，每种级别和套装的组合出一张扑克

枚举类型中的每个成员的实例都可以拥有与实例相关的值。不同的枚举成员实例可以用不同的相关值。当你实例化时提供相关实例化值，相关值和原生值是不同的概念：一个枚举类型的成员的原生值对于所有实例都是一样的，而且当你定义枚举类型时你需要提供其原生值。
举例说明，考虑从服务器获取日出时间和日落时间，服务器会响应所请求的信息也可能返回错误信息。
    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)"
    }


练习
在switch中增加第三种情况
注意如何从服务器ServerResponse 值中提取出匹配Switch条件的日出和日落时间。

协议和扩展

用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


练习
写一个符合该协议的枚举类型

注意SimpleStructure结构体中的mutating关键字所标识的修改方法。而SimpleClass不需要将它的任何方法标为变异，因为在一个类中的方法是可以经常修改这个类的。

用extension给已知类型增加一个功能，比如新的方法和计算的属性。你也可以用一个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类型来处理。这就意味着你必须小心处理类中继承的不符合协议的方法或者属性。

泛型
（又有了java的感觉）
在尖括号中写一个名称当做一个泛型的函数或者类型。

    func repeat<ItemType>(item: ItemType, times: Int) -> ItemType[] {
    var result = ItemType[]()
    for i in 0..times {
    result += item
    }
    return result
    }
    repeat("knock", 4)
http://write.blog.csdn.net/postedit/31371451
http://write.blog.csdn.net/postedit/31371451

你可以编写统一形式的函数和方法，就如同类、枚举、结构体。

    // Reimplement the Swift standard library's optional type
    enum OptionalValue<T> {
    case None
    case Some(T)
    }
    var possibleInteger: OptionalValue<Int> = .None
    possibleInteger = .Some(100)


在类型名后加上where用来指定一个需求的列表，举例说明：为请求一个实现了某个协议的类型，请求2种相同的类型或者请求一个具有特殊父类的类
    func anyCommonElements <T, U <strong>where</strong> 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>.

声明：此文不允许任何人以任何形式偷偷转载！