Swift语法知识整理

Swift介绍

Swift 是一种新的编程语言，用于编写iOS，OSX和watchOS应用程序。Swift 结合了 C 和 Objective-C 的优点并且不受 C 兼容性的限制。Swift 采用安全的编程模式并添加了很多新特性，这将使编程更简单，更灵活，也更有趣。Swift 是基于成熟而且倍受喜爱的 Cocoa 和 Cocoa Touch 框架，它的降临将重新定义软件开发。 Swift 的开发从很久之前就开始了。为了给 Swift 打好基础，苹果公司改进了编译器，调试器和框架结构。我们使用自动引用计数(Automatic Reference Counting, ARC)来简化内存管理。我们在 Foundation 和 Cocoa 的基础上构建框架栈并将其标准化。Objective-C 本身支持块、集合语法和模块，所以框架可以轻松支持现代编程语言技术。正是得益于这些基础工作，我们现在才能发布这样一个用于未来苹果软件开发的新语言。 Objective-C 开发者对 Swift 并不会感到陌生。它采用了 Objective-C 的命名参数以及动态对象模型，可以无缝对接到现有的 Cocoa 框架，并且可以兼容 Objective-C 代码。在此基础之上，Swift 还有许多新特性并且支持过程式编程和面向对象编程。 Swift 对于初学者来说也很友好。它是第一个既满足工业标准又像脚本语言一样充满表现力和趣味的编程语言。它支持代码预览，这个革命性的特性可以允许程序员在不编译和运行应用程序的前提下运行 Swift 代码并实时查看结果。 Swift 将现代编程语言的精华和苹果工程师文化的智慧结合了起来。编译器对性能进行了优化，编程语言对开发进行了优化，两者互不干扰，鱼与熊掌兼得。Swift 既可以用于开发 “hello, world” 这样的小程序，也可以用于开发一套完整的操作系统。所有的这些特性让Swift对于开发者和苹果来说都是一项值得的投资。 Swift是编写 iOS，OSX和watchOS应用的极佳手段，并将伴随着新的特性和功能持续演进。

简单值

let来声明常量，var来声明变量

var myVariable = 42 
myVariable = 50
let myConstant = 42

控制流

使用 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
        } 
}
print(teamScore)

函数和闭包

使用 func 来声明一个函数，使用名字和参数来调用函数。使用 -> 来指定函数返回值。

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

使用元组来让一个函数返回多个值。该元组的元素可以用名称或数字来表示。

func calculateStatistics(scores: [Int]) -> (min: Int, max: Int, sum: Int){ 
var min = scores[0]
var max = scores[0]
var sum = 0
    for score in scores { 
      if score > max {
            max = score
      } else if score < min {
         min = score 
      }
          sum += score 
    }
     return (min, max, sum) 
}
let statistics = calculateStatistics([5, 3, 100, 3, 9])     print(statistics.sum)
print(statistics.2)

函数可以嵌套。被嵌套的函数可以访问外侧函数的变量，你可以使用嵌套函数来重构一个太长或者太复杂的函数。

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

函数是第一等类型，这意味着函数可以作为另一个函数的返回值。

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,condition: lessThanTen)

函数实际上是一种特殊的闭包，你可以使用 {} 来创建一个匿名闭包。使用 in 将参数和返回值类型声明与闭包函数体进行分离。

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

对象和类

使用 class 和类名来创建一个类。类中属性的声明和常量、变量声明一样，唯一的区别就是它们的上下文是类。同样，方法和函数声明也一样。

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

子类的定义方法是在它们的类名后面加上父类的名字，用冒号分割。创建类的时候并不需要一个标准的根类，所以你可以忽略父类。

枚举和结构体

使用 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 default:
    return
    }
    }
}
let ace = Rank.Ace
let aceRawValue = ace.rawValue

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

协议和扩展

使用 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

泛型

在尖括号里写一个名字来创建一个泛型函数或者类型。

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