Swift语言入门之旅

Swift语言入门之旅 









学习一门新的计算机语言，传统来说都是从编写一个在屏幕上打印“Hello world”的程序開始的。那在





Swift，我们使用一句话来实现它：





println("Hello, world")





假设你编写过C或者Objective-C语言，Swift中的这个语法看起来便非常熟悉，这句话却是一个完整的程序





。你无须为了得到输入/输出或字符串处理去导入一个独立的功能库。编写全局代码通经常使用于程序的进入





点。你不须要写一个main函数，你也不须要为每一个语句写个逗号作为结尾。





这个入门之旅将给你足够的信息去開始编写Swift代码，你能够实现很多的编程任务。这个过程中假设你





有些内容不理解也不要操心，我们将在本书的其它章节细节处为您解释。 





批注：





为了更好的体验开发，请在Xcode中使用playground编辑这个章节的代码。Playgrounds同意你在一边编





辑代码的同一时候看到代码的即时执行结果。





简单赋值：





用于你把一个常量和变量作为成变量。常量的值不必每次都传给编译器，但你必须提前赋个数值给它。





就是说常量能够赋值一次而多处引用。





var myVariable = 42





myVariable = 50





let myConstant = 42





同样的类型才干进行常量和变量的赋值，可是，你不用每次都显式地定义类型，编译器能够自己主动推断。





创建常量或变量的时候顺便赋值能够让编译器知道它属于什么类型。上面的样例，编译器指定





myVariable变量属于整数类型，由于它用一个整数进行初始化。





假设初始值不能表达足够的类型信息（或没有初始值），则在变量后面加一个冒号和指定的类型。





let implicitInteger = 70





let implicitDouble = 70.0





let explicitDouble: Double = 70





练习：





显式创建一个值为4的浮点类型的常量





 赋值不会自己主动隐式地变成第二种类型，假设你须要把一个赋值变更到第二种类型，你须要显式地创





建目标类型的实例。





let label = "The width is "





let width = 94





let widthLabel = label + String(width)





练习： 





试着把最后一行的字符串转换声明去掉，看看会出什么错误？





这里有更简便的方法把数值包括在字符串里面：把数值写在括号中面，把斜杠写在括号前面，示比例如以下





：





let apples = 3





let oranges = 5





let appleSummary = "I have \(apples) apples."





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





试验：





在字符串中使用 \()包括一个浮点计算结果，同一时候也包括对某个人的名字和祝词。





使用方括号([])创建数组和字典，然后在方括号里使用索引下标存取各元素的值。





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 = []   // 购物和放置各种东西.





控制流：





使用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{...}, score不





会隐式地返回零值。





你能够一起使用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. 请看那个输出祝福语句的结果有什么变化？推断optionName是空值时加上其





他子句设置输出不同的祝语。





假设可选值是nil,条件推断为假，大括号里的代码也将不会被运行。假设可选项不是nil的话，数值将被





赋值给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 case选项，看看会得到什么错误。





当运行完相应的case分支代码后，程序将退出switch语句，不再接着遍历下一个case，所以也不用在每





个case分支的结尾声明跳转出switch。你能够使用for-in来遍历全部的字典里面的分项。





l





largest





试验：





和程序里面检查最大数字的变量相类似，在程序中增加另外一个变量跟踪哪类的数字是最大的。





我们使用while语句以反复一个代码块的运行，直到条件变化而退出。循环的条件能够放置在语句块的最





后面，仅仅要语句运行到最后就能够击发推断。





var n = 2





while n < 100 {





    n = n * 2





}





n





var m = 2





do {





    m = m * 2





} while m < 100





m





你能够在循环中使用一个循环指标，使用两个点 (“..”) 来隔开起始值和终值表述它范围或者明白定





义它的起始值，终止条件或步进值，以下是两个同样功能的循环语句。





var firstForLoop = 0





for i in 0..3 {





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





试验：





移除名称为day 的输入參数，增加一个參数，使函数返回今天的特殊祝福语句。





使用元组来表达函数返回多个值





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





函数是一个特例的闭包，你能够使用大括号包括一段没有名字的代码闭包。输入參数和输出參数之间应





使用in语法隔开函数的主体。





numbers.map({





    (number: Int) -> Int in





    let result = 3 * number





    return result





    })





试验：





请重写上面的代码段推断输入值为奇数则返回零值。





你有更几个更简练的方法编写代码闭包，当闭包的类型是确定的，比方是一个回调或代理代码，你能够





忽略输入參数的类型或返回的类型。单个语句的代码闭包隐含地返回语句的值（不须return）。





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语法添加一个常量属性，添加另外一个带有一个參数的方法。





创建类的实例就是在类名后面加上一对圆括号。 使用点语法存储这个类实例的属性和程序方法。





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修饰符来差别类的name属性和构造函数的name输入參数。创建一个类的实例，參数传





给类的构造函数就象调用普通函数一样。类中全部的属性须要附于指定值，能够在定义的时候赋值，比





如上面代码中的numberOfSides，也能够在类实例初始化过程中赋值，比方上文的name。





我们使用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，使用半径值和名字作为构造函数的參数。和上面的代码类





似，实现Circle类的area和describe方法。





类属性除了存储，我们还能够定义的getter和setter，即写入的方法和读取的方法。





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，你能够提供显式的名字在set符号后面的





圆括号里。 





请注意 EquilateralTriangle类的构造函数有下面三个步骤的内容：





1、初始化继承后的各子类属性。





2、调用父类的构造函数。





3、更新父类定义的属性值、完毕全部其它初始化工作，比方调用其它方法，其它getter和setter读取与





设置方法都能够在这里实现。





假设你不须要计算属性的值，而是要在代码执行之前或设置新数值之后执行其它代码，那就要使用





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)。不为空值的话，该值将解包，全部的在问号之





后的值将生效和附值。对于整个表达式来说，以上两种情况使整个表达式的值变成可选值。





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





let sideLength = optionalSquare?.sideLength





枚举和结构:





使用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 = ace.toRaw()





实验：





写一个通过对照枚举的裸数值来对照它的序列值的函数。





在上文的演示样例程序中，枚举的裸值类型是整数，所以你仅仅要指定好第一个枚举的裸值，其它剩余的数值





将按序存放，当然你也能够使用字符串和浮点数值作为枚举的裸值类型。





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





试验：





加入一个color方法到suit枚举中，相应spades和clubs返回”black”，相应hearts和diamonds返回”





red”





注意这里的两种hearts枚举成员引用的方式： 当对hearts常量附值的时候，枚举成员suit.hearts是使





用枚举全名，由于常量没有显式指定类型（所以无法推断是否来自枚举）。而在switch里面，枚举使用





简写的.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()





试验：





Add a method to Card that creates a full deck of cards, with one card of each combination 





of rank and suit.





枚举成员的实例能够有相应的数值，名字同样的枚举成员能够有不同值。你能够在创建它们的时候再给





予不同的值。枚举的别名数值和裸值是不同的：裸值对全部的枚举实例来说都是同样值，你能够在定义





枚举的时候就提供裸值。





比如，我们写一个server程序提供获取太阳的升起和日落的时间计算功能，程序返回计算结果或返回计





算错误信息，程序例如以下





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





}





试验：





为ServerResponse和 switch加入第三个case。





请注意代码中经过switch推断，从ServerResponse返回的surise和sunset times的过程机制。





协议和扩展： 





我们使用protocolkeyword定义协议





protocol ExampleProtocol {





    var simpleDescription: String { get }





    mutating func adjust()





} 





类、枚举和结构能够採用和声明协议(protocols)。





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





试验：





编写一个遵守这个protocol的枚举类型。





注意上文程序中使用mutatingkeyword在SimpleStructure结构中对方法进行改动（结构是静态的）。而 





SimpleClass类不须要使用 mutatingkeyword修饰 adjust 主要是由于类中就能够进行类的改动（类是动





态的）。





使用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是 ExampleProtocol的实例，而 ExampleProtocol有一个继承类叫SimpleClass，但





编译把它当然是独立的解释ExampleProtocol的类型，并非对协议的扩展，你不能在独立实例化





ExampleProtocol的ProtocolValue中调用它的方法和属性。





泛型





在一对尖括号之间的命名代表泛化的类型或函数





func repeat<ItemType>(item: ItemType, times: Int) -> ItemType[] {





    var result = ItemType[]()





    for i in 0..times {





        result += item





    }





    return result





}





repeat("knock", 4)





你能够编写泛化后的函数和方法，也能够编写泛化类、泛化枚举、结构。





// 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命令来指定类型必须满足的条件，比方以下的代码是要实现一个协议接口，须要满





足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([1, 2, 3], [3])





试验：





改动anyCommonElements函数，实现把两个序列的共同元素组成数组并返回。





在简单的情况下，你能够忽略where命令简单把protocol或类名写在冒号后面。编写 <T: Equatable>是





和 <T where T: Equatable>.相等同的。