一，Swift 介绍

Swift 是一门由苹果公司于2014年WWDC 苹果开发者大会上发布的新的开发语言，可与Objective-C*共同运行于Mac OS和iOS平台，用于搭建基于苹果平台的应用程序。

其优点：Swift 有类似 Python 的易用性，又有较强的运行效率。既有Objective C的运行时动态支持，和基于编译期引用计数的内存管理模型，又具备Ruby灵活优雅的语法，C++的严格编译期检查、Javascript和Ruby的closure。Swift还支持与Objective C 混编，完美支持IOS/Mac 的SDK。

历史版本：

Swift 4.1 is available as part of Xcode 9.3.

Swift 4.0.3

Swift 4.0.2

Swift 4.0

Swift 3.1.1

Swift 3.1

Swift 3.0.2

Swift 3.0.1

Swift 3.0

Swift 2.2.1

Swift 2.2

二，简单示例代码

print(“Hello, world!”)、

1，变量和常量

使用 let来声明一个常量，用 var来声明一个变量。常量的值在编译时并不要求已知，但是你必须为其赋值一次。这意味着你可以使用常量来给一个值命名，然后一次定义多次使用。

var myVariable = 42

myVariable = 50

let myConstant = 42

2，控制流

使用 if和 switch来做逻辑判断，使用 for-in， for， while，以及 repeat-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)

3，函数和闭包

使用 func来声明一个函数。通过在名字之后在圆括号内添加一系列参数来调用这个方法。使用 ->来分隔形式参数名字类型和函数返回的类型。

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

greet(person: “Bob”, day: “Tuesday”)

4，对象和类

通过在 class后接类名称来创建一个类。在类里边声明属性与声明常量或者变量的方法是相同的，唯一的区别的它们在类环境下。同样的，方法和函数的声明也是相同的写法。

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

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.rawValue)
            
        }
        
    }
    
}

init() {
        
        let ace = Rank.ace
        
        let aceRawValue = ace.rawValue
    }

6，协议和扩展

使用 protocol来声明协议。

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

类，枚举以及结构体都兼容协议。

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

class SimpleClass:ExampleProtocol {
    
    var simpleDescription:String="A very simple class."
    
    var anotherProperty:Int=69105
    
    func adjust(){
    
        simpleDescription += "  Now 100% adjusted."
    
    }
    
}

struct SimpleStructure: ExampleProtocol {
    
    var simpleDescription:String="A simple structure"
    
    func adjust(){
        
        // Left side of mutating operator isn't mutable: 'self' is immutable
    
    }
    
}

class test {
    
    init() {
        
        var a = SimpleClass()
        
        a.adjust()
        
        let aDescription = a.simpleDescription
        
        var b = SimpleStructure()
        
        b.adjust()
        
        let bDescription = b.simpleDescription
    }
    
    
}

7，错误处理

你可以用任何遵循 Error协议的类型来表示错误。

enum PrinterError: Error {
    
    case outOfPaper
    
    case noToner
    
    case onFire
    
}

使用 throw来抛出一个错误并且用 throws来标记一个可以抛出错误的函数。如果你在函数里抛出一个错误，函数会立即返回并且调用函数的代码会处理错误。

func send(job: Int, toPrinter printerName: String) throws -> String {
        
        if printerName == "Never Has Toner"{
            
            throw PrinterError.noToner
            
        }
        
        return"Job sent"
    }

有好几种方法来处理错误。一种是使用 do-catch。在 do代码块里，你用 try来在能抛出错误的函数前标记。在catch代码块，错误会自动赋予名字 error，如果你不给定其他名字的话。

do {

let printerResponse = try send(job:1040, toPrinter:"Bi Sheng")

print(printerResponse)

} catch {

print(error)

}

8，泛型

把名字写在尖括号里来创建一个泛型方法或者类型。

class Item {
    
    var a = "a"
    var b = "b"
}

func makeArray(repeating item: Item, numberOfTimes: Int) -> [Item] {

        var result = [Item]()

        //for _ in 0..

        result.append(item)

        return result

}
    
init() {
        var item = Item()
        makeArray(repeating:item, numberOfTimes:4)
 }

你可以从函数和方法同时还有类，枚举以及结构体创建泛型。

// Reimplement the Swift standard library’s optional type

enum OptionalValue {
        
        case none
        
        case some(Int)
        
}

init() {
    
        var possibleInteger: OptionalValue = .none
        
        possibleInteger = .some(100)
 }

在类型名称后紧接 where来明确一系列需求——比如说，判断两个数组中否包含有相同的对象(不是地址相等,是内容相等

func anyCommonElements<T: Sequence, U: Sequence>(_ lhs: T, _ rhs: U) -> Bool
        where T.Iterator.Element: Equatable, T.Iterator.Element == U.Iterator.Element {
            for lhsItem in lhs {
                for rhsItem in rhs {
                    if lhsItem == rhsItem {
                        return true
                    }
                }
            }
            return false
    }

返回获取相交的数据

func anyCommonElements<T: Sequence, U: Sequence >(_ lhs: T, _ rhs: U) -> Array<T.Iterator.Element>
        where T.Iterator.Element: Equatable, T.Iterator.Element == U.Iterator.Element{
            var array:[T.Iterator.Element] = Array()
            for lhsItem in lhs {
                for rhsItem in rhs {
                    if lhsItem == rhsItem {
                        array.append(lhsItem)
                    }
                }
            }
            return array
    }