Swift是苹果2014年推出的全新的编程语言，它继承了C语言、ObjC的特性，且克服了C语言的兼容性问题。Swift发展过程中不仅保留了ObjC很多语法特性，它也借鉴了多种现代化语言的特点，在其中你可以看到C#、Java、Javascript、Python等多种语言的影子。同时在2015年的WWDC上苹果还宣布Swift的新版本Swift2.0，并宣布稍后Swift即将开源，除了支持iOS、OS X之外还将支持linux。
本文将继续iOS开发系列教程，假设读者已经有了其他语言基础（强烈建议初学者从本系列第一章开始阅读，如果您希望从Swift学起，那么推荐你首先阅读苹果官方电子书《the swift programming language》 ），不会从零基础一点点剖析这门语言的语法，旨在帮助大家快速从ObjC快速过度到Swift开发中。即便如此，要尽可能全面的介绍Swift的语法特点也不是一件容易的事情，因此本文将采用较长的篇幅进行介绍。
基础部分
第一个Swift程序
数据类型
基础类型 集合类型 元组 可选类型
运算符 控制流
函数和闭包
函数 闭包
类
属性 方法 下标脚本 继承
协议 扩展
枚举和结构体
结构体 枚举
泛型 目 录
基础部分
第一个Swift程序
创建一个命令行程序如下：
1
2
3
4
5
6
import Foundation
println("Hello, World!")
从上面的代码可以看出：
Swift没有main函数，从top level code的上方开始往下执行（就是第一个非声明语句开始执行[表达式或者控制结构，类、结构体、枚举和方法等属于声明语句]），不能存在多个top level code文件(否则编译器无法确定执行入口，事实上swift隐含一个main函数，这个main函数会设置并调用全局 “C_ARGC C_ARGV”并调用由top level code构成的top_level_code()函数)；
Swift通过import引入其他类库（和Java比较像）；
Swift语句不需要双引号结尾（尽管加上也不报错），除非一行包含多条语句（和Python有点类似）；
数据类型
Swift包含了C和ObjC语言中的所有基础类型，Int整形，Float和Double浮点型，Bool布尔型，Character字符型，String字符串类型；当然还包括enum枚举、struct结构体构造类型；Array数组、Set集合、Dictionary字典集合类型；不仅如此还增加了高阶数据类型元组（Tuple），可选类型（Optinal）。
基础类型
Xcode 从6.0开始加入了Playground代码测试，可以实时查看代码执行结果，下面使用Playground简单演示一下Swift的基础内容，对Swift有个简单的认识：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
import Foundation
var a:Int=1
var b=2
var c:UInt=3
let d=a+b
println("d=\(d)")
let e=Int.max
var f:Float=1.0
var g=2.0
var h:String="hello "
var ????????="love and apple"
var i=h+????????
var j:Bool=true
var k:Character="c"
var l=00100
var m=10_000_000
Swift通过var进行变量定义，通过let进行常量定义（这和其他高级语言比较类似，例如F#）；
Swift添加了类型推断，对于赋值的常量或者变量会自动推断其具体类型；
Swift是强类型语言（应该说它比C#、Java等强类型语言控制还要严格），不同的数据类型之间不能隐式转化，如果需要转化只能强制转化；
在Swift中类型转换直接通过其类型构造函数即可，降低了API的学习成本；
集合类型
Swift提供了三种集合类型：数组Array、集合Set、字典Dictionary。和ObjC不同的是，由于Swift的强类型，集合中的元素必须是同一类型，而不能像ObjC一样可以存储任何对象类型,并且注意Swift中的集合是值类型而非引用类型（事实上包括String、结构体struct、枚举enum都是值类型）。
首先看一下Swift中的数组：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
var a:[String]=["hello","world"]
a[0]
var b=[Double]()
for i in a{
println("i=\(i)")
}
a.append("!")
a+=["I" ,"am" ,"Kenshin"]
println("a.count=\(a.count)")
a[3...5]=["I","Love","Swift"]
a.insert("New", atIndex: 5)
a.removeAtIndex(5)
for (index,element) in enumerate(a){
println("index=\(index),element=\(element)")
}
var c=[Int](count: 3, repeatedValue: 1)
Set表示没有顺序的集合：
1
2
3
4
5
6
7
8
9
10
11
12
13
var a:Set<String>=["hello","world"]
var b:Set=[1,2]
a.insert("!")
if !a.isEmpty {
a.remove("!")
}
if !a.contains("!"){
a.insert("!")
}
Dictionary字典同样是没有顺序的，并且在Swift中字典同样要在使用时明确具体的类型。和ObjC中一样，字典必须保证key是唯一的，而这一点就要求在Swift中key必须是可哈希的，不过幸运的是Swift中的基本类型（如Int、Float、Double、Bool、String）都是可哈希的，都可以作为key。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
var a:[Int:String]=[200:"success",404:"not found"]
var b=[200:"success",404:"not found"]
a[200]
a[404]="can not found"
a[500]="internal server error"
for code in a.keys{
println("code=\(code)")
}
for description in a.values{
println("description=\(description)")
}
for (code,description) in a{
println("code=\(code),description=\(description)")
}
注意：在Swift中集合的可变性不是像ObjC一样由单独的数据类型来控制的，而是通过变量和常量来控制，这一点和其他高级语言比较类似。
元组（Tuple）
在开发过程中有时候会希望临时组织一个数据类型，此时可以使用一个结构体或者类，但是由于这个类型并没有那么复杂，如果定义起来又比较麻烦，此时可以考虑使用元组。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
var point=(x:50,y:100)
point.x
point.y
point.0
point.1
let frame:(Int,Int,Int,Float)=(0,0,100,100.0)
println(frame)
var size=(width:100,25)
size.width
size.1
var httpStatus:(Int,String)=(200,"success")
var (status,description)=httpStatus
var (sta,_)=httpStatus
println("sta=\(sta)")
func request()->(code:Int,description:String){
return (404,"not found")
}
var result=request()
result.0
result.1
result.code
result.description
可选类型
所谓可选类型就是一个变量或常量可能有值也可能没有值则设置为可选类型。在ObjC中如果一个对象类型没有赋值，则默认为nil，同时nil类型也只能作为对象类型的默认值，对于类似于Int等基本类型则对应0这样的默认值。由于Swift是强类型语言，如果在声明变量或常量时没有进行赋值，Swift并不会默认设置初值（这一点和其他高级语言不太一样，例如C#虽然也有可选类型，但是要求并没有那么严格）。
1
2
3
4
5
6
7
8
9
10
11
12
13
var x:Float?
x=172.0
var y:Float=60.0
var z=x!+y
var age="29"
var ageInt=age.toInt()
Swift中类似于Int和Int?并不是同一种类型，不能进行相关运算，如果要运算只能解包；
可选类型其本质就是此类型内部存储分为“Some”和“None”两个部分，如果有值则存储到“Some”中，没有值则为“None”（早期Playground中可以看到两个部分，如今已经取消显示Some等描述了），使用感叹号强制解包的过程就是取出“Some”部分；
既然可选类型有可能有值，也可能没有值那么往往有时候就需要判断。可以使用if直接判断一个可选类型是否为nil，这样一来就可以根据情况进行强制解包（从Some部分取出值的过程）；另一个选择就是在判断的同时如果有值则将值赋值给一个临时变量或常量，否则不进入此条件语句，这个过程称之为“可选绑定”。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
var age="29"
var ageInt=age.toInt()
if ageInt==nil {
println("ageInt=nil")
}else{
println("ageInt=\(ageInt!)")
}
if let newAge=ageInt{
println("newAge=\(newAge)")
}else{
println("ageInt=nil")
}
通过前面的演示可以看出Swift中的可选绑定如果实际计算不得不进行强制解包，如果一个可选类型从第一次赋值之后就能保证有值 那么使用时就不必进行强制解包了，这种情况下可以使用隐式可选解析类型 （通过感叹号声明而不是问号）
1
2
3
4
5
6
7
8
9
10
11
12
var age:Int!=0
age=29
var newAge:Int=age
if var tempAge=age {
println("tempAge=\(tempAge)")
}else{
println("age=nil")
}
运算符
Swift中支持绝大多数C语言的运算符并改进以减少不必要的错误（例如等号赋值后不返回值），算术运算会检查溢出情况，必要时还能使用新增的溢出运算符。另外Swift中还可以对浮点数使用取余运算符，新增了区间运算符。对于基本的运算符这里不再一一介绍，简单看一下Swift中的区间运算符和溢出运算符。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
for i in 1...5 {
println("i=\(i)")
}<
客服电话
APP下载
官方微信
请发表评论