一、Swift简介
2010年的夏天，苹果公司的开发人员Chris Lattne接到了一个特别的任务，为OS X 和iOS平台开发下一代的编程语言，也就是Swift。
苹果公司于2014年WWDC（苹果开发者大会）发布的新开发语言Swift，可与Objective-C共同运行于Mac OS和iOS平台，用于搭建基于苹果平台的应用程序。
2015年的WWDC开发者大会上，苹果公司推出了Swift2.0版本，并且Swfit完全开源。
自从Swift发布以来，在http://www.tiobe.com中的排行一直处于上升的状态。
二、声明变量和常量
在Swift中使用“let”修饰一个常量，使用“var”修饰一个变量;
let修饰常量的值是不可以更改的；
var修饰的变量的值是可以更改的；
在声明常量和变量的时候可以使用表情符号、中文等命名常量名和变量名。
Swift里不会自动给常量变量赋初始值，也就是说常量变量不会有默认值，所以定义常量的时候一定要给定初始值
Swift定义变量或者常量的时候，需要标识出变量或者常量的类型，如果不标识，会根据初始值自动推断。
因为swift是强类型语言，所以不同类型的变量不能相加，如果想要相加，可以强制类型转换
1、声明常量变量
1 // MARK: - 定义常量变量：变量类型的隐式转换 2 3 // 在Swift中如果不给定变量常量的类型，该常量变量的类型就是其初始值的类型 4 var name = "Jack" // 隐式转换为String类型 5 6 var name1 : String = "Rose" // 给定name1的类型为String，不能赋值其他类型 7 8 var age : Int = 18 // 整型变量 9 10 var age1 : Int? // ?表示age1的类型为可选类型，其值可以为空 11 print(age1) 12 13 var gender : Character = "f" // 字符变量，字符用""括起来，""中只能写一个字符 14 15 var flag : Bool = true // Bool类型，其值只有true 和 false
2、定义字符串，以及常用到的函数
1. String是有序的字符集合，例如“Hello World”
2. Swift中的字符串通过String类型表示，当然也可以看成Character字符类型的集合
1 // MARK: - 字符串
2 // 1、创建一个空的字符串
3 var str_empty = ""
4 var str2_empty = String()
5
6 // 2、判断字符串是否为空
7 if str_empty.isEmpty {
8 print("空")
9 } else {
10 print("非空")
11 }
12
13 // 3、字符串的拼接
14 var url : String = "http://"
15 var str : String = "www.baidu.com"
16 // 方式1：
17 //url.appendContentsOf(str)
18 // 方式2：
19 var newUrl = url + str
20 // 方式3：字符串插值 -- \(变量名)
21 var newURL = "百度网址:\(newUrl)"
22
23 print(newURL)
24
25 // 4、获取字符串长度
26 var str1 : String = "abcdef"
27 print(str1.characters.count)
28
29 // 5、字符串的比较
30 var str2 : String = "MBBoy"
31 var str3 : String = "GBLW"
32 if str2 == str3 {
33 print("\(str2)和\(str3)相等")
34 } else if str2 > str3 {
35 print("\(str2)大于\(str3)")
36 } else {
37 print("\(str3)大于\(str2)")
38 }
3、Float 和 Double
1 // MARK: - float与double
2 var num1 = 3.14 // 不指定类型，默认是double类型
3 // 如果想定义float类型的变量，必须要指定类型
4 var num2 : Float = 2.14
5 // 因为swift是强类型语言，所以不同类型的变量不能相加，如果想要相加，可以强制类型转换
6 //var sum = num1 + num2 // 报错
7 var sum = num1 + Double(num2) // 不会报错
8 print("和是\(sum)")
4、小结
- 常量或者变量的类型必须和你赋给它们的值的类型一样;
- 声明时类型是可选的，声明的同时赋值的话，编译器会自动推断类型;
- 如果初始值没有提供足够的信息（或者没有初始值），那你需要在变量后面声明类型，用冒号分割;
- 使用let来声明常量，使用var来声明变量;
- 常量只能赋值一次，使用的时候可以直接获取到这个值;
- 数据只能进行显示类型转换;
三、声明一个数组、字典
在Swift中使用“let”或者“var”声明一个数组或者字典;
数组必须指定数据类型，如果没有指定类型则会根据数组的初值去推断数据类型;
字典所有的key值必须是同一数据类型;
字典所有的value必须是同一数据类型。
1、数组
1 // MARK: - 数组
2 // Swift中数组的元素类型必须相同，如果想存放不同类型的元素，用OC
3
4 // 定义一个数组
5 var nameArray = ["yuanyuan", "GBLW", "WYW"]
6 print(nameArray)
7
8 // 指定数组元素类型
9 var ageArray : Array<Int> = [1, 4, 5]
10 print(ageArray)
11
12 // 定义一个空数组
13 // 方式1：
14 var carArray = Array<String>()
15 // 方式2：
16 var carArray1 = [Int]()
17 print(carArray)
18
19 // 访问数组元素
20 print(nameArray[1])
21
22 // 给数组添加元素
23 carArray.append("bb")
24 print(carArray)
25
26 // 使用运算符添加数组元素，可以添加多个
27 carArray += ["cc", "dd"]
28 print(carArray)
29
30 // 插入元素到具体位置
31 carArray.insert("aa", atIndex: 0)
32 print(carArray)
33
34 // 移除某个元素
35 carArray.removeAtIndex(2)
36 print(carArray)
37
38 // 移除所有元素
39 carArray.removeAll()
40 print(carArray)
41
42 // 数组排序
43 print(nameArray)
44 nameArray.sortInPlace()
45 print(nameArray)
2、字典
1 // MARK: - 字典
2 // 定义一个字典类型的变量
3 var dic : Dictionary<String,Int> = ["a" : 18, "b" : 33, "c" : 38]
4 print(dic)
5
6 // 定义空字典
7 // 方式1
8 var dic_empty = Dictionary<String, Int>()
9 // 方式2
10 var dic_empty2 : Dictionary<String, Int> = [:]
11
12 // 向字典中添加键值对
13 dic["d"] = 66
14 print(dic)
15
16 // 修改字典中的值
17 dic["d"] = 9
18 print(dic["d"])
19
20 // 删除一个键值对
21 dic.removeValueForKey("a")
22 print(dic)
四、元组
元组是Swift里面独有的一种数据格式。
是一个可以返回多个值的数据格式。
在Swift里面声明的时候使用“（）”声明。
元组可以通过下标去访问元素，也可以通过key值去访问元素;
整体的数据结构有点类似于C语言里面的结构体。
1 // MARK: - 元组
2
3 // 定义一个元组
4 // 方法1：直接初始化一个元组，使用Swift隐式转换
5 var tuples = ("水果",["香蕉", "苹果", "西瓜"])
6 // 方法2：初始化元组的时候给元组指定类型
7 var tuples1 : (String, Array) = ("动物", ["🐶", "🐱", "🐯"])
8 print(tuples1)
9
10
11 // 取值
12 // 方式1: 直接把元组赋给另外一个常量，根据相关标记进行取值，
13 let newTuples : (animals : String, pet : Array) = tuples1
14 print("\(newTuples.animals)里有\(newTuples.pet[0])、\(newTuples.pet[1])、\(newTuples.pet[2])")
15
16 // 也可以在定义元组的时候给单个元素命名
17 var tuples2 = (city : "北京", area : ["海淀区", "朝阳区"])
18 // 取值时可以直接用名字来获取元素的值
19 print("\(tuples2.city)包括\(tuples2.area[0]),\(tuples2.area[1])")
20
21 // 常量名可以省略, 要忽略的元组元素可直接用_表示
22 let (_, fruit) = tuples
23 print(fruit)
24
25 // 方式2：直接根据下标取值
26 print("\(tuples.0)里有\(tuples.1[0]),\(tuples.1[1]),\(tuples.1[2])")
五、循环结构和分支结构
Swift里面的循环结构包含：for、for-in、while、repeat-while
Swift里面的分支结构包含：if、if－else
1、循环结构
1 var nameArray = ["yuanyuan", "GBLW", "WYW"]
2 var dic : Dictionary<String,Int> = ["a" : 18, "b" : 33, "c" : 38]
3 // MARK: - 循环结构
4 // 1、for 循环
5 // 第一种:
6 // i++后面不能直接接{ 会报错，要打一个空格或者换行
7 for var i = 1; i < 10; i++ {
8 print(i)
9 }
10
11 // 第二种: ..< 半闭集范围操作符
12 for number in 1..<10 {
13 print(number) // 不包括10
14 }
15
16 // 第三种: ... 闭集范围操作符
17 for number in 1...10 {
18 print(number) // 包括10
19 }
20
21 // 2、while 循环
22 var i = 8
23 while i > 0 {
24 print(i)
25 i--
26 }
27
28 // repeat...while 相当于do...while，限制性一此循环体，再去判断条件语句，循环体至少走一次
29 repeat {
30 print("我爱你们")
31 }while 1 < 0
32
33 // 使用循环遍历数组
34 for newName in nameArray {
35 print(newName)
36 }
37
38 // 使用循环遍历字典
39 // 第一种：
40 for newAge in dic {
41 print(newAge)
42 }
43 // 第二种
44 for (key, value) in dic {
45 print("key = \(key), value = \(value)")
46 }
2、分支结构
switch分支结构：在Swift里面，switch的每个case后面会自动的添加一个break，所以不需要手动的去添加了。Swift里面的枚举是可以范围枚举的，系统会根据给定的数据自动的匹配相近的范围
1 // MARK: - 分支结构
2 // if
3 let flag1 = true
4 if flag1 == true {
5 print("是真哒！")
6 } else {
7 print("嘿嘿，假哒，骗你哒")
8 }
9
10 // switch
11 // 要求每个分支必须有代码
12 // switch形式使用fallthrough关键字，实现OC中没有break关键字的情况，每个case都执行
13 // 不写fallthrough，实现OC中有break关键字的情况
14 let value = 0
15 switch value {
16 case 0 :
17 print("0")
18 fallthrough
19 case 1 :
20 print("1")
21 // fallthrough
22 default :
23 print("other")
24 }
25
26 // case 后面可以使用一个范围
27 switch value {
28 case 0..<10 :
29 print("0 - 9")
30 case 10...20 :
31 print("10 - 20")
32 default :
33 print("额，不在范围内")
34 }
35
36 // case 后面可以使用常量或者变量
37 switch value {
38 case var i where value >= 0 && value <= 6 : i = 99
39 print(i)
40 default :
41 print("other")
42 }
43
44 // case 后面还可以使用元组
45 let point = (1, 10)
46 switch point {
47 case (10, 0) :
48 print("x = 10, y = 0")
49 case (2, 10) :
50 print("x = 2, y = 10")
51 case (_, 10) :
52 print("x = ?, y = 10")
53 default :
54 print("没")
55 }
六、枚举
C 语言中，枚举类型将枚举名和一个整型值相对应。
Swift 中的枚举更加灵活，不必给每一个枚举成员提供一个确定的值。
如果给枚举成员提供一个值（称为“原始”值），则该值的类型可以是字符串，字符，或是一个整型值或浮点数。
注意：只有枚举值是Int类型时才会有递增
1 // MARK: - 枚举(enum)
2
3 // 原始类型为int
4 enum Direction : Int {
5 case east = 0
6 case south = 1
7 case west = 2
8 case north = 3
9 }
10 // rawValue -- 枚举的原始值
11 print(Direction.east.rawValue)
12
13 // 原始类型为string
14 enum Seasen : String {
15 case spring = "春天"
16 case summer = "夏天"
17 case autumn = "秋天"
18 case winter = "冬天"
19 }
20 print(Seasen.spring.rawValue)
21
22 // 根据原始值获取相对应的枚举
23 print(Direction(rawValue: 2))
七、函数
Swift里面用 func 表示声明一个函数。
Swift的文件格式里面没有类似于OC的.h文件。所以，如果需要定义一个私有的函数，可以在func前面添加private 修饰。
- 函数类型：函数定义格式
- 无参无返回值
- 无参有返回值
- 有参无返回值
- 有参有返回值
- 有参多个返回值（返回一个元组）
func 函数名（参数名：参数类型，参数名：参数类型....）->返回值类型 {
函数实现
return 返回值
}
- 外部参数和内部参数
Swift中，一个参数有两个名字，内部参数名和外部参数名
内部参数名：在函数内部使用的参数名称。
外部参数名：在函数调用时候，显示的参数名称
- 忽略外部参数
默认情况下，函数的第一个参数，不显示外部参数名，其余参数，显示外部参数名，并且和内部参数名一致
如果不想要显示外部参数名，可以使用“_”忽略掉
注意：函数的第一个参数不能使用“_ ”忽略掉外部参数名。
- 函数嵌套
函数嵌套：Swift里面可以函数嵌套定义
注意：作用域问题，嵌套在函数1里的函数2不能在函数1外部调用，函数2是函数1私有的
- inout参数
inout参数:
1.参数默认是用let修饰,即常量
2.在参数前面添加var,就可以在函数内部修改参数的值,但不能改变实参变量的值.
3.如果参数使用inout来修饰,就成了输入输出参数,在函数内部修改参数,可以影响实参变量的值.此时实参必须是变量，且调用函数的时候传的参数是实参的地址
1 // MARK: - 函数
2 // 表示函数的关键字 func
3 // 函数的类型有五种：
4 // 1、无返回值无参数 ->Void 可省略
5 func function1() -> Void {
6
7 }
8
9 // 2、无返回值有参数 ->Void 可省略
10 func function2(str: String) -> Void {
11 print(str)
12 }
13
14 function2("baekhyun")
15
16 // 3、有返回值无参数
17 func function3() -> String {
18 return "boom sky"
19 }
20
21 print(function3())
22
23 // 4、有返回值有参数
24 func function4(num1 : Int, num2 : Int) -> Int {
25 return num1 + num2
26 }
27
28 print(function4(1, num2: 2))
29
30 // 5、有参，返回值为元组类型
31 func function5(a : Int, b : Int) -> (Int, Int, Int, Int) {
32 return (a - b, a + b, a * b, a / b)
33 }
34
35 print(function5(5, b: 6))
36
37 // 外部参数和内部参数
38 // 内部参数名：在函数内部使用的参数名
39 // 外部参数名：在函数调用的时候，显示的参数名
40 func function6(first one : Int, second two : Int) {
41 print(one, two)
42 }
43
44 function6(first: 2, second: 5)
45
46 // 忽略外部参数
47 // 默认情况下，函数调用时，函数的第一个参数不显示外部参数名，其余参数显示外部参数名，并且和内部参数名一致，如果不想要显示外部参数名，可以使用 _ 忽略掉
48 // 注意：函数的第一个参数不能使用 _ 忽略掉外部参数名
49 func function7(one : Int, _ two : Int) {
50 print(one, two)
51 }
52 function7(3, 6)
53
54 // 函数嵌套 : Swift里函数可以嵌套定义
55 // 注意：作用域问题，嵌套在函数1里的函数2不能在函数1外部调用，函数2是函数1私有的
56 func function8() {
57 print("第一层")
58 func function9() {
59 print("第二层")
60 }
61 // 调用function9, 不调用的话function9不会执行
62 function9()
63 }
64
65 function8()
66
67 // inout参数
68 // 如果形参使用inout来修饰，就变成了输入输出参数，在函数内部改变形参的值，实参的值也会变
69 func function10 (inout name : String) {
70 name = "Baek"
71 print(name)
72 }
73 // 实参要定义为变量，不能定义成常量，否则不能传参给输入输出参数
74 var myName = "Hyun"
75 function10(&myName) // 传入的是个地址
76 print("myName : " + myName)
补充：
Swift中导入类库使用import，不再使用<>。不需要导入自定义类。
语句结尾的分号可有可无
来源：https://www.cnblogs.com/fearlessyyp/p/5512963.html