深入iOS开发：实战笔记解析

图1. 打开游乐场

效果如下图：

图2. Playground 执行效果图

注意：Swift 1.x 中的println 函数在Swift 2.x 中已重命名为print 。

变量、常量和字符串

稍微懂点编程知识的人都知道，程序需要存储数据，并对数据进行各种计算（操作）。因此，我们的程序中就会有很多变量和常量。变量相当于内存中的一块存储空间。可以存储一个值并且可以更改该值；常量也是内存中的一个存储空间，但其值在第一次赋值后就不能改变。

vargreeting:String="你好，世界！"print（问候语）

上面的代码中，greeting是一个变量，它的类型是String。既然是变量，就意味着它的值是可以修改的，如下图：

vargreeting:String="你好，世界！"print(greeting)greeting="再见世界！"print(greeting)

当然，声明变量时也可以这样写：

vargreeting="你好，世界！"

如果这样做，编译器将执行类型推断并根据您分配给变量的值确定变量的类型。在上面的代码中，变量greeting的类型被推断为字符串。相信这并不难理解。当然，由于类型推断的存在，Swift 是一种静态类型语言，这意味着编译器会在编译过程中检测到类型错误，并提示开发人员尽快纠正程序中的问题。

vargreeting="你好，世界！"问候语=123print(问候语)

对于上面的代码，编译器会在第2 行报告错误“Cannot allocate value of type "Int" to type "String""”。

建议：您可以省略类型标签并尽可能使用类型推断，以使代码更短并获得更好的可读性。

让num=123num=321

esmp；上面的代码中，我们用let替换了声明变量的关键字var，这样num就不再是一个变量而是一个常量，这意味着它的值在第一次赋值后就不能再被修改了，所以上面的代码会报错“第2 行将报告无法分配给value: "num" 是一个let 常量”。

建议：只要有可能，您应该声明常量而不是变量。这样做不仅会让你的代码更加健壮，而且编译器还可以进一步优化代码以获得更好的性能。

Swift 允许你在一行代码中声明多个变量时将type 标签放在最后，如下所示：

var x, y, z: 双精度；

另一点需要注意的是，对于命名常量和变量，Swift 可以使用几乎任何Unicode 字符，除了空格、数学符号、箭头、特殊用途或无效的Unicode 字符。如果名字中有数字，数字可以放在第一个字母中。外面的任何地方。请看下面的例子：

let =3.1416let hello="你好，世界"let="猪"

注意：从上面的例子中不难发现中文、希腊字母甚至Emoji字符都可以作为变量名。在Xcode 中，您可以选择通过编辑菜单中的“Emoji Symbols”菜单项输入Emoji 字符，也可以使用快捷键Control++Space 启用Emoji 字符输入。

图3. 表情符号

分号

很多语言都使用分号作为语句分隔符，而有些语言则要求一行上只能写一条语句（相当于使用换行符作为语句分隔符）。在这一点上，斯威夫特做出了妥协。如果一行中只写一条语句，则不需要使用分号来表示该语句的结束；如果一行中有多个语句，则各语句之间需要用分号分隔。代码如下所示：

var x=10；打印（x）

建议：在Swift 编程中，尝试每行一条语句而不使用分号。分号会占用一个字符的空间，但对你的程序没有任何帮助。

数值类型和类型转换

var 半径=4let PI=3.1416

上面的代码创建了一个数值变量和一个数值常量，其类型分别为Int 和Double。 Swift 中有多种类型的整数，例如：Int8（8 位有符号整数）、UInt16（16 位无符号整数），Float 也用于表示十进制类型。需要指出的是，除非你的程序有特殊需要，否则整数和小数类型应首选Int和Double。大多数应用程序都可以使用Int 和Double 来处理所有值，编译时会根据您的系统是32 位还是64 位来决定Int 类型的大小（占用多少字节内存）。

在Swift 中，您可以在编写数字文字时使用下划线来增强数值的可读性，如下所示：

var 百万=1_000_000

当然，给变量赋值时允许使用运算符来计算值，但运算中涉及到的各部分的类型需要保持一致，如下所示：

var 半径=4let PI=3.1416var 面积=半径* 半径* PI

上面的代码会报编译错误“二元运算符‘*’不能应用于‘Int’和‘Double’类型的操作数”。在Swift 中，所有运算符本质上都是函数。上面的错误告诉我们乘法函数不能接受Int 类型作为左值和Double 类型作为其右值。正确的代码如下：

var 面积=Double(半径) * Double(半径) * PI

你可能认为上面的操作就是所谓的类型转换，但事实并非如此。代码Double(radius) 创建一个新的Double 对象，然后使用半径值对其进行初始化。如果您不知道这意味着什么，没关系，请继续阅读。

提示：可以按住键盘上的Command键，点击Swift中的类型，查看头文件中类型、函数、协议等的定义。

当变量的值超出变量的表示范围时，Swift会报告编译错误以阻止此类操作。这是Swift 实现编程安全的方法。

布尔值

Swift 中有一个Boolean 类型，Boolean 类型只有两个值，true 或false。以下代码演示了如何创建布尔类型的常量：

让alwaysTrue=true

布尔类型常用于循环和分支结构中。在Swift中，循环和分支结构中的条件只能使用布尔值，这与C、C++和Objective-C不同。

元组

元组是由多个值组成的单一类型。与类和结构不同，您不需要定义元组类型即可使用它。

var address=(610000, "四川成都")print(address.0)print(address.1)address.0=618000address.1="四川德阳"let(邮政编码，城市)=addressprint(邮政编码)print(城市)

上面的代码使用类型推断来获取元组的数据类型。当然，你也可以编写如下代码来指定元组中数据对应的数据类型：

var address:(Int, String)=(610000, "四川成都")

此外，您可以按如下方式命名元组中的数据：

var address=(zipcode: 610000, city: "成都四川")print(address.zipcode)print(address.city)

提示：元组只适合快速构造简单的复合数据类型。更多时候，我们需要类和结构。

字符串插值

如果你用过其他语言中字符串连接的操作，你就能体会到Swift 中字符串插值是多么方便。这是在Objective-C 中连接字符串所必需的。

NSInteger a=123;NSInteger b=321;NSLog(@"%ld + %ld=%ld", a, b, a + b);

不过，在Swift中你可以使用字符串插值来优雅地完成上述操作，代码如下：

var a=123var b=321print("(a) + (b)=(a+b)")

过程控制

如果您有任何其他编程语言的经验，您一定会熟悉过程控制的概念。无论你使用什么语言，无论你的程序是简单还是复杂，程序中的代码都只有三种结构：顺序结构、分支结构和循环结构。相信顺序结构并不难理解，就是一步步执行，从第一步到最后一步；分支结构是程序中需要做出决策的地方。如果决策的结果不同，程序就会沿着不同的分支执行，比如编写一个程序控制机器人从流水线上取出生产出来的球。如果是红色，则放入A盒，如果是蓝色，则放入B盒。判断球的颜色就是决定的地方，将球放入A盒或B盒是两个不同的分支；循环结构是指程序中的某些步骤需要重复执行。例如，球会被不断地送到流水线上的机器人手上，然后机器人就会重复刚才的动作。根据球的颜色连续将球放入A盒或B盒中。

以下是对1-100 求和的最简单程序，用于演示Swift 中的循环。

for循环

var sum1: Int=0for var i=1;我=100; i++ { sum1 +=i}print(sum1)

可以在for循环中使用范围运算符，代码如下：

var sum2: Int=0for i in 1.100 { sum2 +=i}print(sum2)

var sum2: Int=0for i in 1.101 { sum2 +=i}print(sum2)

while 循环

var sum3: Int=0var i=1while i=100 { sum3 +=i++}print(sum3)

重复while循环

var sum4: Int=0var j=1repeat { sum4 +=j++} while j=100print(sum4)

提示：repeat-while 循环是在Swift 2.x 中引入的，并取代了do-while 循环，因为do 关键字在Swift 2.x 中具有新的含义和用法。

我们再看一下Swift 中的分支结构。

if-else

以下代码实现分段函数求值。

var x=1.5var y: Doubleif x -1 { y=3 * x + 5}else if x=1 { y=x}else { y=5 * x - 3}print(y)

switch-case-默认值

var dir="up"switch dir { case "down": print("往下走！") case "up": print("往上走！") default: print("哪儿也不去！")}

对于有其他语言编程经验的程序员来说，上面的代码并不困难。事实上，无论开发程序员以前做过什么，总能从Swift 中找到自己熟悉的语言的影子，所以对于非零基础的初学者来说，上手Swift 是比较容易的。不过，Swift中的循环和分支结构仍然有自己的特点。首先，省略了使用括号来设置条件（这与C、C++、C#、Java 和Objective-C 不同）。另外，条件只能是Boolean类型值（这一点与C、C++、Objective-C不同，但与Java、C#一致）。另外，switch-case-default不需要在每个case后面都写break。只有一种情况或者default才会执行，必须写default；如果执行完一个case后确实想继续执行后续的case，可以在case后面写fallthrough；并且每种情况都可以编写多个与switch 中的常量或范围匹配的表达式进行相等匹配，并且switch 接受的表达式也可以是Swift 中的元组类型。

让工资=18000switch工资{ case 0: print("流浪者") case 1.3000: print("代码动物") case 3001.6500: print("代码农民") case 6501.10000: print(" IT农民工") case 10001.20000: print("IT工程师") case 20001.50000: print("IT人才") default: print("IT精英")}

可空类型

使用过C或者C++的程序员一定都被空指针问题所困扰过。我们可以在程序中声明一个指针，并将其默认值设置为NULL。然而，在后续的程序中我们可能会忘记初始化和使用指针。这样的程序在运行时（注意是运行时）会遇到异常情况。 Swift 1 中没有运行时异常机制。很容易纠正，修改代码的成本更小）。为了避免空指针引起的运行时异常，Swift 引入了可空类型的概念（可选），我们通过以下代码进行说明。

var str="你好，世界"print(str)

上面的代码会输出Hello, world，这是大家都熟悉的，但是如果我们尝试去掉第一行代码中的赋值语句，看看编译器会说什么。

var strprint(str)

编译器将报告“模式中缺少类型注释”错误。在没有赋值语句的情况下，我们需要为变量指定类型，因为无法从分配给变量的值推断出变量的类型。让我们尝试为str 变量指定其类型，看看编译器会说什么。

var str: 字符串打印(str)

这次，编译器在打印时报告错误，指出“变量‘str’在初始化之前使用”。显然str没有初始化，编译器不会让这样的代码运行。但是我们可能需要一个变量暂时具有空值，但是当我们尝试将代码更改为以下内容时，编译器有话要说。

var str: 字符串=nilprint(str)

这次，编译器说“nil Cannotinitialized type "String"”（nil值不能初始化String类型），即字符串不能被赋值为nil。如果您确实想这样做，可以使用可空类型，如下所示：

var str: 字符串？ print(str)

我们可以通过在类型标记后添加问号来将变量声明为可空类型，并且不需要为其指定nil 值。它的值已经是nil了，所以我们可以在需要的时候给这个变量赋值。完整代码如下所示：

var str: String?print(str)str="你好，世界"print(str?uppercaseString)print(str!uppercaseString)

Playground中的执行如下图所示：

图4. 可空类型

你可以使用！强制可空类型恢复为变量的原始类型。当然，如果变量的值为nil，就会出现运行时错误。如果变量值不为nil，则可以顺利恢复。您还可以通过以下方式获取可为空变量的值。

var str: 字符串？="你好，世界"if let newstr=str { print(newstr.uppercaseString)}

提示：出于某种未知的原因，Swift 2.x 引入了异常机制，并且还添加和修改了一系列关键字。最莫名其妙的是do关键字改变了它的含义。异常机制的语法类似，本文暂时不介绍Java和C#中的语法。

容器

许多语言都提供容器类型的数据结构。顾名思义，容器就是承载其他对象的对象，也就是说，它是一个对象的持有者。最常见的容器是数组、字典和集合（就像我们数学书中提到的集合一样，不允许有重复的元素）。当然，有些地方容器也被称为集合框架（这个名字很容易与数学中的集合混淆，所以这里我们称之为对象持有者容器）。在Objective-C Foundation 框架中，最常用的容器是NSArray 和NSDictionary，这两个容器在Swift 中也可用。

大批

与许多其他语言一样，Swift 中的数组也是元素的有序集合。注意，这里所说的顺序并不是指从小到大或者从大到小的顺序，而是指元素是相邻的。他们有自己的序列号（索引）。下面的代码演示了如何创建和使用数组。

var array=[12, 7, 38, 65]print(array[2]) //38array.append(93)print(array) //[12, 7, 38, 65, 93]array.appendContentsOf(100.103)print(array) //[12, 7, 38, 65, 93, 100, 101, 102, 103]array.removeAtIndex(0)print(array) //[7, 38, 65 93, 100 、101、102、103]

上面使用文字语法创建了一个数组对象。如果您愿意，还可以使用以下方法创建数组对象并指定数组元素的类型。

var myArray=Array(count: 5,repeatedValue: 0)myArray[4]=1000print(myArray) //[0,0,0,0,1000]var thyArray=[Int](count: 5,repeatedValue: 100)thyArray[2]=55print(thyArray) //[100, 100, 55, 100, 100]

字典

顾名思义，存储在称为字典的容器中的元素不是单个值，而是键和值的组合。通常称为键值对映射，如《新华字典》。上面每一个可以搜索到的单词都是一个Key，这个单词的解释就是value。

var myDict=[1: "狗", 2: "猫"]print(myDict[2]) //可选("猫")var yourDict: [Int: String]=[1: "飞机", 2: "坦克"]print(yourDict [3]) //无

上面的代码创建了两个字典，其键均为Int 类型，值均为String 类型。需要注意的是，当我们要从字典容器中取出数据时，需要使用key通过下标操作得到key对应的值，但是这个值可能不存在，就像你编的单词一样字典。找不到，所以如果有key对应的value，取出来的value是可空类型的。如果key没有对应的value，则获取nil。

您可以定义一个常量容器。这样的容器只有在定义的时候才能被初始化。以后不能添加元素、删除元素或修改元素的值。

可以通过循环遍历容器中的元素，请看下面的代码。

var myArray=[12, 7, 38, 65]for x in myArray { print(x)} var myDict=[1: "狗", 2: "猫", 31: "飞机", 32: "坦克"] for x in myDict .keys { print("(x) ---(myDict[x])")}

函数和闭包

函数是现代编程语言中最重要的构建块，允许您将执行特定任务的业务逻辑封装到独立的、可重用的工作单元中。对于调用者来说，函数就像一个独立的黑匣子，调用者在使用函数提供的功能时不需要了解其内部实现。 Swift 支持全局函数和方法，它们是与特定类型的类或对象关联的函数。 Swift 还提供了对闭包、匿名函数等的支持，这些在Swift 中被视为一等公民。

我们先看一个例子。您可以创建一个Playground 项目并键入以下代码。

导入Foundationlet a=3.0, b=4.0let c=sqrt(a * a + b * b)print(c)

你可能已经注意到，Swift 中没有内置的计算平方的函数，但我们可以自己编写一个。上面的代码可以重写如下。

导入Foundationfunc square(x:Double) -Double { return x * x}let a=3.0, b=4.0let c=sqrt(square(a) + square(b))print(c)

上面的square 函数接受一个Double 类型参数并返回一个Double 类型值。定义函数的关键字是func，后面跟函数的名称。函数的命名也遵循标识符命名的规则，同时要由名称可知其含义。这些应该是常识，不需要解释。函数具有零个或多个参数以及返回值或无返回值。 Swift 中所有称为函数的东西都是全局的。如果在类或接口中定义了一个函数，并且该函数绑定到某个类型或对象，我们通常将其称为方法。

Swift 中的函数是一等公民。 Swift 中函数的使用与JavaScript 非常相似。您可以将函数分配给变量或常量。当然，你也可以使用一个函数作为另一个函数的参数。代码如下所示：

import Foundationfunc square(x:Double) -Double { return x * x}let f=square //使用类型推断获得变量f 的类型let a=3.0, b=4.0let c=sqrt(f(a) + f( b) ) 打印(c)

你可能会觉得上面的代码其实挺熟悉的，这很好，因为这种写法就相当于C语言中的函数指针。还有一点需要说明的是，上述代码中常量f的类型是通过类型推断得到的。如果想完整给出常量f的类型，代码可以写如下。

var f:(Double) -Double=方形

当然，你也可以像函数指针一样声明一个新的变量类型，然后将一个函数赋给这个新类型的变量。 Swift 中声明类型别名的关键字是typealias。代码如下：

typealias FType=(Double) -Doublevar f:FType=方形

提示：如果你想在Xcode中查看某个函数的定义，可以按住Command键并单击该函数，让代码跳转到函数定义处。

Swift 支持函数重载。所谓重载，就是同名的函数有不同的参数列表，因此可以和平共处。重载也是实现编译时多态性的重要手段。看看下面的代码。

func assertEquals(value: Int, Expected: Int, message: String) { 如果预期!=value { print(message) }} func assertEquals(value: String, Expected: String, message: String) { 如果预期!=value { print(message) }}断言Equals（100，expected: 1000，message:"两个整数不相等！"）assertEquals（"Hello"，expected:"好"，message:"两个字符串不相等！"）

当然，如果重载函数与上面相同但参数不同但执行相同的代码，那么将来对这些代码的维护将是一场噩梦。编程大师Martin Fowler 在《重构改进现有代码的设计》（《重构：改进现有代码的设计》）中写道。

计》）一书中指出：“代码有很多种坏味道，重复是最坏的一种”。要消除重复代码，可以使用泛型来改写上面的函数，如下所示。 func assertEquals(value: T, expected: T, message: String) { if expected != value { print(message) }}assertEquals(100, expected: 1000, message: "Two integers are not equal!")assertEquals("Hello", expected: "Good", message: "Two strings are not equal!") 上面的代码中T是泛型参数，相当于定义了一种虚拟的类型，冒号后面的Equatable是对泛型的限定（如果不理解可以先不管他，后面会讲到这个知识），这种类型在编译时会根据传入该函数的实际参数的类型来决定，就如上面的代码中，第一次调用assertEquals函数时，T被替换成Int类型；而第二次调用时，T被替换成String类型。提示：在Swift 2.x中，函数调用传参时从第二个参数开始必须要给出外部参数名，这一点从某种程度上来讲照顾了Objective-C程序员的代码书写习惯。 Swift中，函数的参数可以是inout参数，所谓inout参数是指可以在函数中被修改并影响到调用者的参数（这一点应该是借鉴了C#的语法，C#中方法的参数可以设置为ref参数或out参数）。先看看下面的代码。 func swap(inout x: Int, inout y: Int) { let temp: Int = x; x = y; y = temp;}func bubbleSort(inout x: [Int]) { var swapped:Bool = true for var i = 1; swapped && i<= x.count - 1; i++ { swapped = false for var j = 0; j< x.count - i; j++ { if x[j] >x[j + 1] { swap(&x[j], &x[j + 1]) swapped = true } } }}var x = [34, 12, 85, 7, 96, 63, 40]bubbleSort(&x)print(x) 上面的代码中有两个函数，swap函数实现交换两个参数的值，下面的bubbleSort函数实现冒泡排序，如果没有inout参数，你只能修改函数参数在函数内部的拷贝而不会影响到调用者，但是有了inout参数一切就不同了，调用者在传入参数的时候用在参数前加上&，有C或者C++开发经验的都知道，这种语法叫做传指针（引用）而不是简单的传值。当然，对于inout参数的使用还是应当小心，因为不是所有的时候我们都希望通过函数调用来修改传入的参数并影响调用者，一定要警惕这种形式的参数所带来的副作用。 Swift1.x中，如果要为函数的参数指定内部参数名和外部参数名，可以按照下面的方式来做。 // greeting是第一个参数的外部参数名// g是第一个参数的内部参数名func say(greeting g: String, name n: String, counter c: Int) { for var i = 0; i< c; ++i { print("(g), (n)") }}say(greeting: "Hello", name: "Jack", counter: 3) 提示：Swift 1.x中可以通过在内部参数名前加#让内部参数和外部参数同名，Swift 2.x默认内部参数名就是外部参数名。如果不愿意在调用函数时书写外部参数名，可以在函数的参数列表的内部参数名前添加一个下划线，第一个参数除外。如果需要使用外部参数名，比较好的做法是让参数的外部名字和内部名字保持一致，在Swift 2.x中可以使用下面的写法。 func say(greeting greeting: String, name: String, counter: Int) { for var i = 0; i< counter; ++i { print("(greeting), (name)") }}say(greeting: "Hello", name: "Jack", counter: 3) 说明：这种语法对于使用Objective-C的开发人员来说一点都不陌生，但是对于使用Java或C#这样编程语言的程序员来说可能会觉得比较别扭。在类或结构中定义的函数我们通常称之为方法，这一点稍后予以讲解。 Swift既然支持函数式编程，那么不可避免的要支持闭包（closure）。关于闭包一词，你可能会听到各种各样的解释，下面给出其中的一种：“闭包是可以包含自由（未绑定到特定对象）变量的代码块；这些变量不是在这个代码块内或者任何全局上下文中定义的，而是在定义代码块的环境中定义（局部变量）。闭包一词来源于以下两者的结合：要执行的代码块（由于自由变量被包含在代码块中，这些自由变量以及它们引用的对象没有被释放）和为自由变量提供绑定的计算环境（作用域）”。闭包最常见的一种用法就是用闭包表达式实现匿名函数的功能，我们用下面的代码来加以说明。 var animals = ["fish", "cat", "panda", "dog"]func compare(one: String, two: String) ->Bool { return one< two;}animals.sortInPlace(compare)print(animals) 上面的代码实现了对字符串数组的排序，我们将一个包含排序规则的函数作为数组sort方法的参数传入，sort方法就能够完成对数组的排序。事实上，完全不需要单独定义这样的一个函数，因为这个函数想表达的就是一个临时的排序规则，我们可以用下面的方式将代码修改得更加简短。 var animals = ["fish", "cat", "panda", "dog"]animals.sortInPlace({ (one: String, two: String) ->Bool in return one< two })print(animals) 当然，这样看起来仍然不够简单明了。如果你还记得Swift有强大的类型推断能力，那么上面的代码就可以做出如下的改进。 var animals = ["fish", "cat", "panda", "dog"]animals.sortInPlace({ (one, two) ->Bool in return one< two })print(animals) 你甚至还可以省略掉那个return，代码仍然可以很好的工作。还有什么可以省略吗？答案是肯定的，既然有类型推断，这次我们连返回类型也一并省去。 var animals = ["fish", "cat", "panda", "dog"]animals.sortInPlace({ (one, two) in one< two })print(animals) 写到这我们已经觉得做到极致了，似乎已经没有什么办法可以让代码写得更简单了。不，Swift还能做到更加的简单明了。 var animals = ["fish", "cat", "panda", "dog"]animals.sortInPlace({ $0< $1 })print(animals) OMG！参数名都可以省略掉，$0很明显表示匿名函数的第一个参数，而$1则是匿名函数的第二个参数。对于那种只有一行代码的闭包，这样写不是更简单明了吗。我们不能不感叹，Swift算是把简单即美践行到极致了，但是，事情还没完，继续看。 var animals = ["fish", "cat", "panda", "dog"]animals.sortInPlace(<)print(animals) 最后还有一个很特殊的东西叫尾随闭包（tailing closure）需要提一下，请看下面的代码。 var animals = ["fish", "cat", "panda", "dog"]animals.sortInPlace() { $0< $1 }print(animals) 闭包另一个重要的用途是将其所在的代码块中的常量或变量的生命周期延长，在离开代码块以后，我们还能够访问到这些常量或变量的值。我们可以在一个函数中返回一个闭包表达式，这相当于返回了一个匿名函数，在这个匿名函数中我们还能使用刚才返回这个闭包的函数（有的地方称之为封闭函数）中的局部变量或常量，专业的说法称之为“捕获值”（capturing value）。 typealias StateMachineType = () ->Intfunc makeStateMachine(maxState: Int) ->StateMachineType { var currentState: Int = 0 return { currentState++; if currentState >maxState { currentState = 1 } return currentState }}let myStateMachine = makeStateMachine(3)for i in 1...10 { print(myStateMachine())} 上面的代码中，makeStateMachine函数返回了一个匿名函数（闭包表达式），由于这个闭包的存在，本来是函数局部变量的currentState和参数maxState可以在函数的生命周期结束以后仍然被继续使用。闭包让你免除了对全局变量的使用（因为全局变量总是让你的代码变得糟糕，因为你不知道这个变量什么时候会被哪段代码意外的修改），但是它通过延长局部变量生命周期的方式让你以可控制的方式使用这些值。最后，我们对闭包做一个小小的总结：全局函数都是闭包，有名字但是不能捕获任何值。嵌套函数都是闭包，有名字也能捕获封闭函数内的值。闭包表达式都是匿名函数，可以根据上下文环境捕获值。 Swift中的闭包较之其他语言更简单更优秀，主要表现在：可以根据上下文推断参数和返回值的类型。对于单行闭包表达式，可以省略return，隐式返回。可以省略掉参数名而使用$0, $1, ... 替换之。提供了尾随闭包的语法，让代码更自然。类和结构体前面我们曾经提到过Swift支持面向对象的编程范式。所谓面向对象的编程理念，就是用对象来组织数据以及操作数据的方法，这也就意味着数据和操作数据的方法在逻辑上是一个整体，从而保证了操作的有效性和数据的完整性。面向对象编程和函数编程是目前最流行的两种编程范式，Swift对两种编程范式都提供了很好的支持。我们先看看面向对象编程。定义和使用类在Swift中，除了可以使用Swift已有的数据类型还可以自定义数据类型，类和结构体都是实现自定义数据类型的手段。例如，Swift没有一种类型来描述现实世界中的人，但是我们可以通过类或结构体来定义一种新的类型叫人，而且在人这种新类型中可以包含拥有的属性和方法。我们先看看如何定义和使用类。类是对象的蓝图和模板。当我们把世界上一类对象共同的特征抽取出来的时候，我们就可以定义一个类。例如，我们把人的共同特征抽象出来的时候，我们就可以定义人类。创建类的过程就是一个抽象的过程，我们需要做两种抽象：数据抽象和行为抽象。所谓数据抽象就是找到对象的静态属性；所谓行为抽象就是找到对象动态属性，也就是对象能够执行的动作。例如：人的静态属性有名字和年龄等，人的动态属性有吃饭、睡觉、行走等。这些静态属性会成为类中的字段，而动态属性会成为类中的方法。下面的代码定义了人类。 /人类/class Person { var name: String // 姓名 var age: Int // 年龄 /初始化方法/ init(name: String, age: Int) { self.name = name; self.age = age; } /吃饭/ func eat() { print("(name)正在吃饭") } /看片/ func watchJapaneseAV() { if age< 18 { print("(name)不能观看岛国爱情动做片") } else { print("(name)正在观看岛国爱情动作片") } }} 上面的代码用class关键字定义了名为Person的类，其中有name和age两个属性，类型是字符串和整型，分别代表人的姓名和年龄；接下来的代码中用func关键字定义了两个方法，分别代表了人吃饭和看片的行为。除此之外，在Person类中还有一个名为init的代码块，它是类的初始化方法（在C++、Java和C#中通常将其称为构造器或构造方法），承担了创建并初始化对象的职责，当程序中需要创建Person类的对象时，就可以调用该初始化器，初始化器有两个参数，前者是姓名，后者是年龄，在初始化器中我们把这两个参数分别赋值给了类的name和age字段。由于字段名和初始化器的参数名完全一致，为了加以区分，我们使用self关键表示类的字段，而没有self.前缀的则是参数。接下来可以创建人类的对象，也就是一个具体的人，然后让他执行吃饭和行走的行为，代码如下所示： var p = Person(name: "王大锤", age: 20)p.eat()p.watchJapaneseAV() 有C++或Java编程经验的程序员都知道，类中的构造器可以重载，这样的话可以根据需要选择某个构造器来创建对象。Swift中使用初始化器来创建并初始化对象，而且提供了一种叫做便利初始化器（convenience initializer）的语法，便利初始化器会调用初始化器（通常称之为非便利初始化器或指派初始化器[designated initializer]）器来创建对象，代码如下所示。 /人类/class Person { var name: String // 姓名 var age: Int // 年龄 /便利初始化器/ convenience init(name: String) { self.init(name: name, age: 20) } /初始化器/ init(name: String, age: Int) { self.name = name self.age = age } /吃饭/ func eat() { print("(name)正在吃饭") } /*看片/ func watchJapaneseAV() { if age< 18 { print("(name)不能观看岛国爱情动做片") } else { print("(name)正在观看岛国爱情动作片") } }}var p1 = Person(name: "骆昊", age: 35)print("姓名: (p1.name)n年龄: (p1.age)")p1.eat()var p2 = Person(name: "王大锤")print("姓名: (p2.name)n年龄: (p2.age)")p2.watchJapaneseAV() 继承继承是面向对象编程中一个重要的概念，它是从已有的类创建新类的过程。提供继承信息的类被称为父类，而得到继承信息的类被称为子类。下面我们试着用继承从刚才的人类（Person）派生出老师（Teacher）类和学生类（Student）。 import Foundation/老师/class Teacher: Person { var title: String // 职称 /初始化器/ init(name: String, age:Int, title: String) { self.title = title super.init(name: name, age: age) // 调用父类初始化器 } /教学/ func teach(courseName: String) { print("(name)(title)正在教(courseName)") }}/学生/class Student: Person { var grade: String // 年级 /初始化器/ init(name: String, age:Int, grade: String) { self.grade = grade super.init(name: name, age: age)// 调用父类初始化器 } /学习/ func study(courseName: String) ->Int { print("(name)选修了(courseName)") return Int(arc4random() % 101) }}var t = Teacher(name: "骆昊", age: 35, title: "砖家")var s = Student(name: "王大锤", age: 20, grade: "大二")t.eat()t.teach("iOS开发")s.watchJapaneseAV()var score:Int = s.study("Swift")print("(s.name)得到了(score)分") 在上面的例子中，Teacher类和Student类从Person类得到了继承信息，因此它们是子类，Person类是父类。子类通常也称为派生类，而父类通常称为超类或基类。子类和父类之间的关系是“IS-A”关系，我们可以说老师是人，学生是人。通过继承Teacher类和Student类复用了Person类中的代码，即学生和老师作为人的那些属性和行为，因此继承是复用代码的手段之一。在Swift中，继承的语法是定义子类时在子类后面跟一个冒号再跟父类的名字。在上面的例子中，Teacher类和Student类继承了Person的name和age静态属性，还继承到了eat和watchJapaneseAV方法，因此子类不用再重新定义这些属性和方法。当然，子类在继承父类的过程中还可以定义自己特有的属性和方法，比如Teacher中的title属性和Student中的grade属性，此外Teacher类中还有teach方法，学生类中有study方法这些都是子类对父类的扩展。显然，子类拥有比父类更多的能力，也就是说，继承一定是让子类扩展父类的能力而绝不会缩小父类的能力。就好比让猫继承狗之后，猫没有狗看门的行为，子类就要去掉父类的这项功能，这种继承明显是错误的；同理，如果让狗继承猫，狗没有猫爬树的行为，这种继承显然也是错误的。还有一点，子类的初始化器中必须调用父类的初始化器，而且必须调用父类的非便利初始化器。在Swift中，还可以通过协议（protocol）来扩展类的能力，所谓协议就是定义了遵循该协议的类要遵守的规范。我们可以为刚才的程序添加下面的代码来看看如何使用协议来扩展类。 // 协议protocol MoreInfo { var info: String { get }}// 类扩展extension Person: MoreInfo { var info: String { get { return String("(name): (age)") } }}var t = Teacher(name: "骆昊", age: 35, title: "砖家")var s = Student(name: "王大锤", age: 20, grade: "大二")print(t.info) // 显示老师信息print(s.info) // 显示学生信息当我们对Person类做出扩展以后，它的子类Student和Teacher也继承到了它扩展的内容。多态多态简单的说是同样的同样的方法执行了不同的行为，就好比猫和狗都有发出叫声的行为，但是发出的声音是完全不一样的。多态有两种实现方式：方法的重载（overload）和方法的重写（override）。方法的重载是在一个类中同名的方法有不同的参数列表，而方法重写是在继承过程，子类对父类已有的方法重新做出实现，不同的子类给出不同的实现版本。函数的重载

func add(a: Int, b: Int) ->Int { return a + b}func add(a: Int, b: Int, c: Int) ->Int { return a + b + c}print(add(1, b: 2)) // 3print(add(1, b: 2, c: 3)) // 6/猫/class Cat { func makeSound() { print("喵...") }}/狗/class Dog { func makeSound() { print("汪...") }}func foo(animal: Cat) { animal.makeSound() }func foo(animal: Dog) { animal.makeSound() }foo(Cat()) // 喵...foo(Dog()) // 汪... 方法的重写 /图形/class Shape { /计算面积/ func area() ->Double { return 0 } /计算周长/ func perimeter() ->Double { return 0 }}/圆形/class Circle : Shape { var radius: Double // 半径 init(radius: Double) { self.radius = radius } // 方法重写 override func area() ->Double { return M_PI * radius * radius } // 方法重写 override func perimeter() ->Double { return 2 * M_PI * radius; }}/*矩形/class Rectangle: Shape { var width, height: Double // 宽、高 init(width: Double, height: Double) { self.width = width self.height = height } // 方法重写 override func area() ->Double { return width * height } // 方法重写 override func perimeter() ->Double { return (width + height) * 2 }}var shapeArray:[Shape] = [Circle(radius: 3), Rectangle(width: 5, height: 6)]for currentShape in shapeArray { print("面积: (currentShape.area())") print("周长: (currentShape.perimeter())")} 在上面的例子中，父类Shape定义了两个方法一个计算图形周长（perimeter方法）一个计算图形面积（area方法），但是Shape类中并不能计算出图形的周长和面积，因为尚不知道是哪种类型的图形，因此这两个方法需要在子类中进行重写。子类在重写父类方法时需要用override关键字进行说明，而且重写的方法需要与父类被重写的方法拥有相同的方法签名（方法名和参数列表）和相同的返回类型。重载实现的多态性是编译期的多态性，编译器会根据函数（或方法）的参数来决定调用哪个函数（或方法）；重写实现的多态性是运行期的多态性，编译器并不知道应该调用哪个子类重写过的方法，只有在运行时当确定了对象的类型后，不同的子类对象会调用自己重写过的方法。这样，虽然都是同种类型的引用，调用的也是相同的方法，但是会做不同的事情（圆周长和面积的计算方法完全不同于矩形周长和面积的计算方法）。如果不希望一个类被继承，可以在声明类的class关键字前加上final。上面的程序更好的做法不是使用类的继承而是协议，代码如下所示。 import Foundationprotocol Shape { var area: Double { get } var perimeter: Double { get }}/圆/class Circle : Shape { var radius: Double init(radius: Double) { self.radius = radius } var area: Double { return M_PI * radius * radius } var perimeter: Double { return 2 * M_PI * radius }}/矩形/class Rectangle: Shape { var width, height: Double init(width: Double, height: Double) { self.width = width self.height = height } var area: Double { return width * height } var perimeter: Double { return (width + height) * 2 }}var shapeArray:[Shape] = [ Circle(radius: 3), Rectangle(width: 5, height: 6)]for currentShape in shapeArray { print("面积: (currentShape.area)") print("周长: (currentShape.perimeter)")} 运算符重载在上面的例子中，我们将各种图形装在一个Shape类型的数组中，我们可以对这个数组做一次排序，然后再将排序后的结果遍历一次。但是如何对象图形对象进行排序呢？我们可以规定面积较小的图形排在前面，面积较大的图形排在后面，于是我们可以通过运算符重载的方式定义两个图形比较大小的规则，代码如下所示。 import Foundationprotocol Shape { var area: Double { get } var perimeter: Double { get }}// 为遵循Shape协议的类型重载<运算符func<(a: Shape, b: Shape) ->Bool { return a.area< b.area}/圆/class Circle : Shape { var radius: Double init(radius: Double) { self.radius = radius } var area: Double { return M_PI * radius * radius } var perimeter: Double { return 2 * M_PI * radius }}/矩形/class Rectangle: Shape { var width, height: Double init(width: Double, height: Double) { self.width = width self.height = height } var area: Double { return width * height } var perimeter: Double { return (width + height) * 2 }}var shapeArray:[Shape] = [Circle(radius: 3), Rectangle(width: 5, height: 6), Circle(radius: 2), Rectangle(width: 2, height: 8)]shapeArray.sortInPlace(<);// 按面积从小到大输出图形的面积和周长for currentShape in shapeArray { print("面积: (currentShape.area)") print("周长: (currentShape.perimeter)")} 提示：Swift 2.x中，如果要在原数组上进行排序需要调用sortInPlace方法，Swift 1.x中做这件事情是调用sort方法。访问控制迄今为止，我们在类中声明的变量和方法只要在同一个源文件中，它们可以在任何地方被访问。当然，如果你不希望这样，也可以使用访问修饰符来控制变量和方法的访问权限。在Swift中有三个访问修饰符： private：私有，只有当前源文件中能够访问。 internal：默认的访问修饰符，除了当前源文件中的代码，同一个应用程序或者同一个库文件中的其他代码也能访问。 public：可以在任何地方被访问。建议：在一个源文件中只写一个类，对于类中不允许外界访问的变量和方法都应该加上private修饰符，如果要自定义库文件或自己写框架让别人调用，那么应该将类中需要暴露的编程接口都加上public修饰符。结构体在Swift中，还可以使用结构体来实现自定义数据类型，结构体和类非常相似，我们可以像上面的例子中定义类那样定义结构体，下面的代码定义了一个结构体来描述复数，复数由实部（real）和虚部（image）构成，还有一个toString方法将复数转换成字符串，此外可以重载了+运算符实现复数的加法运算。 /*复数/struct Complex { var real: Double // 实部 var img: Double // 虚部 var description: String { return "(real) + (img)i" }}// 重载复数类型的加法运算符func +(a: Complex, b: Complex) ->Complex { return Complex(real: (a.real + b.real), img: (a.img + b.img))}var c1 = Complex(real: 3, img: 5)var c2 = Complex(real: 2, img: -3)print((c1 + c2).description) // 5.0 + 2.0i 结构体和类最大的不同在于结构体是值类型（value type）而类是引用类型（reference type），我们可以通过下面的例子来了解这二者到底有什么区别。 class Cat { var name = "Kitty"}struct Dog { var name = "Wangcai"}var cat1 = Cat()var dog1 = Dog()var cat2 = cat1var dog2 = dog1cat2.name = "Mimi"dog2.name = "Xiaoqiang"print(cat1.name) // Mimiprint(dog1.name) // Wangcai 在上面的代码中，var cat2 = cat1定义了一个引用类型的变量cat2，它和cat1引用内存中同一个Cat对象，因为Cat是一个类，所以cat1是引用类型。当我们用cat2.name修改了Cat对象的name属性后再打印cat1.name，打印出来的应该是修改过后的结果。此外，我们用var dog2 = dog1时，由于Dog是结构体，Dog的实例是一个值类型的对象，执行该语句会在内存中复制出另一个Dog实例，dog2和dog1代表的是不同的对象，当我们用dog2.name修改了Dog对象的name属性后再打印dog1.name，仍然是原来的值。我们再看一个例子。 var a1: Int = 5, a2: Int = 10func swap(var x: Int, var y: Int) { let temp = x; x = y; y = temp;}swap(a1, y: a2)print("a1 = (a1), a2 = (a2)") 在这里例子中，我们试图用通过swap函数来交换两个参数的值，但是程序的结果仍然是“a1 = 5, a2 = 10”。注意，swap函数的参数前要加上var关键字，否则在默认的情况下，函数的参数是常量，其值是无法修改的（这个设计是非常好的，因为可以防止意外的修改了参数的值，其他很多语言在默认情况下函数参数都是变量类型，如果需要处理成常量要自己加修饰符，比如Java中可以用final来修饰函数的参数使其变成一个常量）。几乎所有的语言函数的参数传递都是值传递，Swift也不例外。在上面的代码中，a1将它的值传给了x，a2将它的值传给了y，在swap函数中，不管对x和y做什么操作，都不会影响到a1和a2。再看个例子吧。 class Cat { var name: String init(name: String) { self.name = name }}var c = Cat(name: "Kitty")func change(cat: Cat, name: String) { cat.name = "Mimi"}print(c.name) // Kittychange(c, name: "Mimi")print(c.name) // Mimi 函数change的第一个参数是引用类型，当我们将Cat的引用c传入change函数并在函数中修改所引用对象的name属性时，由于c和函数中的cat引用了内存中的同一个对象，因此调用函数后再次打印c.name时，结果是“Mimi”。不要着急，还有一个例子。 class Cat { var name: String init(name: String) { self.name = name }}var c = Cat(name: "Kitty")func change(var cat: Cat, name: String) { cat = Cat(name: name)}print(c.name) // Kittychange(c, name: "Mimi")print(c.name) // Kitty 注意这个例子和上一个例子的区别，然后想一想为什么调用了change函数后打印c.name看到的仍然是Kitty。结构体和类最重要的区别我们已经说过了，但是它们的区别还不止于此。一个类可以被其他类继承，但是结构体是不能够被继承的；一个类通常需要自己写初始化器，但是结构体会有隐式的初始化器，隐式的初始化器的参数会根据结构体中的属性自动生成；结构体中的属性也是值类型的，在对一个结构体赋值时，它的属性也会完成值的拷贝。枚举枚举是定义符号常量的手段，它把一堆相似的值组织在一起。例如你在指定文字对齐方式的时候通常有三种可选的值：左对齐、右对齐和居中对齐；你在处理游戏中的方法时可能的取值有东、西、南、北。Swift中的枚举比你了解的其他语言的枚举更加强大，它的行为类似于类和结构体，它甚至可以有自己的方法，包括构造器。创建枚举我们先通过一个简单的例子来认识一下枚举。玩过扑克牌的都知道，扑克有四种花色，分别是黑桃（spade）、红心（heart）、草花（club）和方块（diamond），如果我们要做一个扑克游戏，那么就可以用枚举来描述这四种花色，代码如下所示： enum Suite { case Spade case Heart case Club case Diamond} 又比如我们要做一个绘图软件，该软件支持绘制矩形、圆形和三角形，那么可以用下面的枚举来表示不同类型的图形。 enum ShapeType { case Rectangle case Triangle case Circle} 在switch多分支结构中使用枚举我们可以使用switch多分支结构来处理枚举类型的值，如下所示： var shapeType:ShapeType = ShapeType.Circleswitch(shapeType) {case .Rectangle: print("You choose a rectangle")case .Triangle: print("You choose a triangle")case .Circle: print("You choose a circle")} Swift中的switch语句要求必须覆盖所有可能的情况，如果你将上面的代码修改成下面的样子，就会产生一个编译错误：“switch must be exhaustive, consider adding a default clause.”（switch必须是穷尽的，考虑添加一个default语句）。 enum ShapeType { case Rectangle case Triangle case Circle}var shapeType:ShapeType = ShapeType.Circleswitch(shapeType) {case .Triangle: print("You choose a triangle")case .Circle: print("You choose a circle")} 按照错误提示，我们可以添加一个default分支来消除此编译错误，当所有的case都没有匹配成功时，就会执行default分支。 enum ShapeType { case Rectangle case Triangle case Circle}var shapeType:ShapeType = ShapeType.Circleswitch(shapeType) {case .Triangle: print("You choose a triangle")case .Circle: print("You choose a circle")default: print("You choose a rectangle")} 当然也可以在一个case中书写多种可能性，这一点也是Swift对switch结构的改进，不同于Java、C#等语言，代码如下所示： enum ShapeType { case Rectangle case Square case Diamond case Triangle case Circle case Oval}var shapeType:ShapeType = ShapeType.Circleswitch(shapeType) {case .Triangle: print("You choose a triangle")case .Circle, .Oval: print("You choose a circle or an oval")case .Rectangle, .Square, .Diamond: print("You choose a quadrilateral")} 枚举类型在Swift中，枚举在某些程度上跟类和结构体非常类似，它和结构体有相同的值语义，因此也是基于栈分配存储空间。如果需要，枚举甚至可以有成员方法，如下所示： import Foundationenum Shape { case Rectangle(width: Double, height: Double) case Square(side: Double) case Triangle(base: Double, height: Double) case Circle(radius: Double) func area() ->Double { var result:Double = 0; switch(self) { case .Rectangle(let width, let height): result = width * height case .Square(let side): result = side * side case .Triangle(let base, let height): result = base * height case .Circle(let radius): result = M_PI * radius * radius } return result }}var circle = Shape.Circle(radius: 5)circle.area() 我们还可以在枚举中添加一个工厂方法来创建枚举类型的变量，如下所示： import Foundationenum Shape { case Rectangle(width: Double, height: Double) case Square(side: Double) case Triangle(base: Double, height: Double) case Circle(radius: Double) func area() ->Double { var result:Double = 0; switch(self) { case .Rectangle(let width, let height): result = width * height case .Square(let side): result = side * side case .Triangle(let base, let height): result = base * height case .Circle(let radius): result = M_PI * radius * radius } return result } static func factory(shapeType: String) ->Shape? { var shape:Shape? switch(shapeType) { case "rectangle": shape = Shape.Rectangle(width: 5, height: 10) case "square": shape = Shape.Square(side: 5) case "triangle": shape = Shape.Triangle(base: 5, height: 10) case "circle": shape = Shape.Circle(radius: 5) default: shape = nil } return shape }}var rect = Shape.factory("rectangle")rect!.area() 函数式编程面向对象编程和函数式编程是目前最主流的两种编程范式，而关于这两种范式孰优孰劣的讨论一直都没有停止过。事实上，真正理解两种编程范式的程序员不会武断的说这二者孰优孰劣，因为任何编程语言都没有什么灵丹妙药让其使用者成为优秀的程序员。其实，像Java这样很经典的面向对象的编程语言，也能够看到函数式编程的影子，如果你使用过访问者模式、命令模式，如果你使用过接口回调，你实际上已经使用了函数式编程的理念，而且在新版本的Java中，已经开始支持Lambda表达式和函数式接口，这些都是Java为了支持函数式编程所作出的改进。同样，我们也可以用C语言写出面向对象风格的代码，如果你对Objective-C的运行时有所了解的话，你就知道面向对象的本质是什么了。其实，只要在适当的地方使用适当的编程范式就能够写出优质的代码，我们不应该让自己的程序囿于某一种编程范式，就如同一个优秀的程序员绝不会声称自己效忠于某种语言。函数式编程有如下一些特性：高阶函数：函数可以作为函数的参数传给函数。一等公民：可以将函数视为变量来使用。闭包：可以使用匿名函数。函数式编程的例子我们写一段将数组中的偶数求和的代码，传统的做法是这样的： var array = [11, 23, 10, 8, 6, 5, 97, 12]var evenSum = 0for num in array { if num % 2 == 0 { evenSum += num }}print(evenSum) 用函数式编程的方式，代码如下所示： var array = [11, 23, 10, 8, 6, 5, 97, 12]var sum = array.filter{ $0 % 2 == 0 }.reduce(0){ $0 + $1 }print(sum) 上面的代码用到了我们之前提到过的尾随闭包，将两个匿名函数分别作为过滤（filter）和归约（reduce）方法的参数。柯里化（currying）柯里化就是把接受多个参数的方法变成接受第一个参数的方法，然后返回接受余下的参数并返回结果的新方法的过程。柯里化是一种产生模板方法的手段，要理解这一点，我们先看看下面的例子。 import Foundationlet data = "5,7;3,4;55,6"// ["5,7", "3,4", "55,6"]print(data.componentsSeparatedByString(";"))// ["5", "7;3", "4;55", "6"]print(data.componentsSeparatedByString(",")) 在上面的例子中，我们使用字符串的componentsSeparatedByString()方法根据指定的字符（串）将字符串拆分成字符串的数组。有些时候，我们可能需要用指定的字符（串）反复的对出现的字符串进行拆分，于是我们可以如下修改我们的代码。 import Foundationlet data = "5,7;3,4;55,6"func createSplitter(separator: String) ->(String ->[String]) { func split(source: String) ->[String] { return source.componentsSeparatedByString(separator) } return split // 将函数作为函数的返回值}let commaSplitter = createSplitter(",")// ["5", "7;3", "4;55", "6"]print(commaSplitter(data))let semiColonSplitter = createSplitter(";")// ["5,7", "3,4", "55,6"]print(semiColonSplitter(data)) 明显，按照上面的做法，我们可以重复的使用两种拆分器commaSplitter和semiColonSplitter对字符串进行拆分，而不用每次调用字符串的拆分函数并指定拆分字符（串）。这种编程理念通常称之为“partial application”，其原理是将函数中的一个或多个参数先固定下来，创建出一个新的函数，再调用这个新的函数传入后续参数。让我们再来看一个例子吧。 func add(one: Int, two: Int, three: Int) ->Int { return one + two + three}let sum = add(1, 2, 3)print(sum) 我们也可以这样来写改写add()函数。 func add(one: Int)(two: Int)(three: Int) ->Int { return one + two + three}let step1 = add(1)let step2 = step1(two: 2)let step3 = step2(three: 3)print(step3) 上面的例子纯粹为了告诉大家什么是柯里化，当然它并有什么意义和价值。下面换一个例子，希望他能够帮助你理解柯里化的用法和意义。 import Foundation// 柯里化的字符串填充函数func stringPadding(startIndex: Int, paddingString: String) (source: String, length: Int) ->String { return source.stringByPaddingToLength(length, withString: paddingString, startingAtIndex: startIndex)}let text = "Swift"let dottedPadding = stringPadding(0, paddingString: ".")let paddingText = dottedPadding(source: text, length: 10)print(paddingText) // Swift.....

关于深入iOS开发：实战笔记解析，的介绍到此结束，希望对大家有所帮助。