苹果编程语言Swift简介

Swift是什么？

Swift是苹果于WWDC 2014发布的编程语言，The Swift Programming Language的原话：

Swift is a new programming language for iOS and OS X apps that builds on the best of C and Objective-C, without the constraints of C compatibility.

Swift adopts safe programming patterns and adds modern features to make programming easier, more flexible and more fun.

Swift’s clean slate, backed by the mature and much-loved Cocoa and Cocoa Touch frameworks, is an opportunity to imagine how software development works.

Swift is the first industrial-quality systems programming language that is as expressive and enjoyable as a scripting language.

简单的说：

Swift用来写iOS和OS X程序。（估计也不会支持其它屌丝系统）

Swift吸取了C和Objective-C的优点，且更加强大易用。

Swift可以使用现有的Cocoa和Cocoa Touch框架。

Swift兼具编译语言的高性能（Performance）和脚本语言的交互性（Interactive）。

Swift语言概览

基本概念

注：这一节的代码源自The Swift Programming Language中的A Swift Tour。

Hello, world

类似于脚本语言，下面的代码即是一个完整的Swift程序。

println("Hello, world") 变量与常量

Swift使用var声明变量，let声明常量。

 var myVariable =
 myVariable =
 let myConstant = 

类型推导

Swift支持类型推导（Type Inference），所以上面的代码不需指定类型，如果需要指定类型：

let explicitDouble : Double = 

Swift不支持隐式类型转换（Implicitly casting），所以下面的代码需要显式类型转换（Explicitly casting）：

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

字符串格式化

Swift使用\(item)的形式进行字符串格式化：

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

数组和字典

Swift使用[]操作符声明数组（array）和字典（dictionary）：

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

一般使用初始化器（initializer）语法创建空数组和空字典：

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

如果类型信息已知，则可以使用[]声明空数组，使用[:]声明空字典。

控制流

概览

Swift的条件语句包含if和switch，循环语句包含for-in、for、while和do-while，循环/判断条件不需要括号，但循环/判断体（body）必需括号：

let individualScores = [, , , , ]
var teamScore =
for score in individualScores {
    if score >  {
        teamScore +=
    } else {
        teamScore +=
    }
}

可空类型

结合if和let，可以方便的处理可空变量（nullable variable）。对于空值，需要在类型声明后添加?显式标明该类型可空。

var optionalString: String? = "Hello"
optionalString == nil

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

灵活的switch

Swift中的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."
 }

其它循环

for-in除了遍历数组也可以用来遍历字典：

let interestingNumbers = [
     "Prime": [, , , , , ],
     "Fibonacci": [, , , , , ],
     "Square": [, , , , ],
 ]
 var largest =
 for (kind, numbers) in interestingNumbers {
     for number in numbers {
         if number > largest {
             largest = number
         }
    }
 }
 largest

while循环和do-while循环：

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

Swift支持传统的for循环，此外也可以通过结合..（生成一个区间）和for-in实现同样的逻辑。

var firstForLoop =
 for i in .. {
     firstForLoop += i
 }
 firstForLoop
 var secondForLoop =
 for var i = ; i < 3; ++i {
     secondForLoop +=
 }

注意：Swift除了..还有...：..生成前闭后开的区间，而...生成前闭后闭的区间。

函数和闭包

函数

Swift使用func关键字声明函数：

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

通过元组（Tuple）返回多个值：

func getGasPrices() -> (Double, Double, Double) {
     return (., ., .)
 }
 getGasPrices()

支持带有变长参数的函数：

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

函数也可以嵌套函数：

func returnFifteen() -> Int {
     var y =
     func add() {
         y +=
     }
     add()
     return y
 }
 returnFifteen()

作为头等对象，函数既可以作为返回值，也可以作为参数传递：

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

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 <
 }
 var numbers = [, , , ]
 hasAnyMatches(numbers, lessThanTen)
 

闭包

本质来说，函数是特殊的闭包，Swift中可以利用{}声明匿名闭包：

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

当闭包的类型已知时，可以使用下面的简化写法：

numbers.map({ number in  * number })

此外还可以通过参数的位置来使用参数，当函数最后一个参数是闭包时，可以使用下面的语法：

sort([, , , , ]) { $ > $ } 类和对象 创建和使用类

Swift使用class创建一个类，类可以包含字段和方法：

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

创建Shape类的实例，并调用其字段和方法。

 var shape = Shape()
 shape.numberOfSides =
 varshapeDescription = shape.simpleDescription()

通过init构建对象，既可以使用self显式引用成员字段（name），也可以隐式引用（numberOfSides）。

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

使用deinit进行清理工作。

继承和多态

Swift支持继承和多态（override父类方法）：

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

注意：如果这里的simpleDescription方法没有被标识为override，则会引发编译错误。

属性

为了简化代码，Swift引入了属性（property），见下面的perimeter字段：

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

注意：赋值器（setter）中，接收的值被自动命名为newValue。

willSet和didSet

EquilateralTriangle的构造器进行了如下操作：

为子类型的属性赋值。 调用父类型的构造器。 修改父类型的属性。

如果不需要计算属性的值，但需要在赋值前后进行一些操作的话，使用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: , name: "another test shape")
 triangleAndSquare.square.sideLength
 triangleAndSquare.square = Square(sideLength: , name: "larger square")
 triangleAndSquare.triangle.sideLength

从而保证triangle和square拥有相等的sideLength。

调用方法

Swift中，函数的参数名称只能在函数内部使用，但方法的参数名称除了在内部使用外还可以在外部使用（第一个参数除外），例如：

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

注意Swift支持为方法参数取别名：在上面的代码里，numberOfTimes面向外部，times面向内部。

?的另一种用途

使用可空值时，?可以出现在方法、属性或下标前面。如果?前的值为nil，那么?后面的表达式会被忽略，而原表达式直接返回nil，例如：

 let optionalSquare: Square? = Square(sideLength: 2.5, name: "optional
 square")
 let sideLength = optionalSquare?.sideLength

当optionalSquare为nil时，sideLength属性调用会被忽略。

枚举和结构

枚举

使用enum创建枚举——注意Swift的枚举可以关联方法：

enum Rank: Int {
     case Ace =
     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()

使用toRaw和fromRaw在原始（raw）数值和枚举值之间进行转换：

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

注意枚举中的成员值（member value）是实际的值（actual value），和原始值（raw value）没有必然关联。

一些情况下枚举不存在有意义的原始值，这时可以直接忽略原始值：

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

除了可以关联方法，枚举还支持在其成员上关联值，同一枚举的不同成员可以有不同的关联的值：

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)"
 }

结构

Swift使用struct关键字创建结构。结构支持构造器和方法这些类的特性。结构和类的最大区别在于：结构的实例按值传递（passed by value），而类的实例按引用传递（passed by reference）。

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

协议（protocol）和扩展（extension） 协议

Swift使用protocol定义协议：

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

类型、枚举和结构都可以实现（adopt）协议：

class SimpleClass: ExampleProtocol {
     var simpleDescription: String = "A very simple class."
     var anotherProperty: Int =
     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

扩展

扩展用于在已有的类型上增加新的功能（比如新的方法或属性），Swift使用extension声明扩展：

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

泛型（generics）

Swift使用<>来声明泛型函数或泛型类型：

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

Swift也支持在类、枚举和结构中使用泛型：

enum OptionalValue{
     case None
     case Some(T)
 }
 var possibleInteger: OptionalValue= .None
 possibleInteger = .Some()

有时需要对泛型做一些需求（requirements），比如需求某个泛型类型实现某个接口或继承自某个特定类型、两个泛型类型属于同一个类型等等，Swift通过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([, , ], [])

Swift语言概览就到这里。参考资料如下：

Swift 教程

Apple 官方教程《The Swift Programming Language》

PDF/ePUB/Kindle 格式下载 Markdown 版 中文版（翻译中）

Apple Swift 编程语言入门教程（@明哥选C）

摘录、提取自《The Swift Programming Language》

系列教程：使用 Swift 开发 iOS 应用 (Jameson Quave)

此为第一部分，第二部分、第三部分、第四部分、第五部分。

Swift 视频

Apple Swift 语言基础教程（@极客学院_jikexueyuan）

共计 11 课时

Swift 开发视频教程【入门篇】（@51CTO学院）

共计 40 课时

从 0 开始学 Swift（@传课网）

共计 25 课时

Swift 系列视频教程 (Skip Wilson)

已完成 4 部分，需梯子。

Swift 资料

Swift 编程语言资料大合集 (@CSDN_CODE)

内容不错

Swift 学习资源（刘兰涛）

分类细致

Swift 新手入门汇集帖 (@CocoaChina)

内容不少

Swift 速查表 (Ray Wenderlich)

PDF 下载地址

[PDF] Swift vs Scala 2.11

对比详细

Swift 项目

Flappy Bird（Swift 版）

目前 GitHub 上最火的开源 Swift 项目

2048（Swift 版）

Star 数不少

GitHub 上的开源 Swift 项目

已有近 500 个项目

Swift 网站

LearnSwift.tips

内容不少

Learn Swift

一个 Swift 博客，文章质量不错。

So So Swift

一个 Swift 教程网站

Swift China（@老甘）

中文网站

雨燕中文（@罗罗磊磊）

中文网站

Let's Swift

中文网站