Swift学习总结
语言基础
程序是指令的集合，写程序就是写一系列的指令去控制计算机做我们想做的事情。
编译：将程序设计语言转换成计算机能够理解的机器语言或者某种中间代码的过程。
冯洛伊曼体系结构的计算机：
- 使用二进制
- 程序存储执行
变量和常量
定义变量和常量是为了保存数据，变量和常量就是某种类型的值的存储空间。
var a: Int = 10
a = 100
var b: Int
b = 1000
var c = 10000
let d: Int = 10
// d = 100 // compiler error 编译错误
let e = 1000
说明：
- Swift有非常强大的类型推断，所以定义变量或常量时如果可以的话应该直接使用类型推断不用手动指定类型；
- 如果可以的花应该尽可能使用常量而不是变量
语言元素
var a: Int = 10
关键字：有特殊含义的单词
标识符：给变量、常量、函数、类、结构、协议、枚举、方法、属性等起的名字
- 字母(Unicode字符)、数字、下划线，数字不能开头
- 大小写敏感(区分大小写)
- 不能使用关键字做标识符
- 使用驼峰命名法（命名变量、常量、函数、方法、属性第一个单词小写，从第二个单词开始每个单词首字母大写；命名类、结构、协议、枚举每个单词首字母都要大写）
- 见名知意
- 命名私有的属性和方法时以下划线开头
运算符: Swift中的运算符其实都是函数
- 赋值运算符：=、+=、-=、*=、/=、%=、......
- 算术运算符：+、-、*、/、%
- 比较运算符：==、!=、<、<=、>、>=
- 逻辑运算符：&&、||、!
- 条件运算符：? :
- 其他运算符：[]、.、??、?、!
字面(常)量：
- 整数字面量：10、1_234_567、0x10、0o10、0b10
- 小数字面量：123.45、1.2345e2、0xab.cdp2
- 字符字面量："c"、"\n"、"\t"、"\u{41}"、"\u{9a86}"
- 字符串字面量："Hello"、"caf\u{e9}"
- 布尔字面量：true、false
- 空值字面量：nil
- 类型字面量：String.self、UILabel.self
分隔符：将不同的语言元素符号分开
说明：Swift中每个语句后面的分号是可写可不用写的，写代码时尽量保证一行只有一条语句这样就可以省略掉分号。
分支和循环
分支
- if...else...
下面的代码实现了判断是否闰年的功能。
let year = 2000
if year % 4 == 0 && year & 100 != 0 || year % 400 == 0 {
print("\(year)是闰年")
}
else {
print("\(year)不是闰年")
}
- switch...case...default
let score = 92.5
let level: String
switch score {
case 0..<60:
level = "E"
case 60..<70:
level = "D"
case 70..<80:
level = "C"
case 80..<90:
level = "B"
case 90...100:
level = "A"
default:
level = "输入错误"
}
print(level)
循环
- while
下面的程序实现了1-100求和
var sum = 0
var i = 1
while i <= 100 {
sum += i
i += 1
}
print(sum)
- repeat...while...
var sum = 0
var i = 1
repeat {
sum += i
i += 1
} while i <= 100
print(sum)
- for
var sum = 0
for i in 1...100 {
sum += i
}
print(sum)
穷举法：穷尽所有可能性直到找到正确答案。
下面的程序实现了"百钱百鸡"问题的求解
for x in 0...20 {
for y in 0...33 {
let z = 100 - x - y
if 5 * x + 3 * y + z / 3 == 100 && z % 3 == 0 {
print("公鸡: \(x)只，母鸡: \(y)只，小鸡: \(z)只")
}
}
}
公鸡: 0只，母鸡: 25只，小鸡: 75只
公鸡: 4只，母鸡: 18只，小鸡: 78只
公鸡: 8只，母鸡: 11只，小鸡: 81只
公鸡: 12只，母鸡: 4只，小鸡: 84只
说明：在循环中可以使用break关键字来提前终止循环，也可以使用continue关键字使循环直接进入下一轮，但是应该尽量减少对break和continue的使用，因为他们不会让你的程序变得更好
综合案例：Craps赌博游戏。
游戏规则：玩家摇色子，如果第一次摇出了7点或11点，玩家胜；如果摇出了2点、3点或12点，庄家胜；其他点数游戏继续。在继续的过程中玩家重新要色子，如果摇出了7点，庄家胜；如果摇出了第一次摇的点数，玩家胜；否则游戏继续
func roll() -> Int {
return Int(arc4random_uniform(6)) + 1
}
var money = 3000
repeat {
print("玩家总资产：￥\(money)元")
var debt: Int
repeat {
print("请输入下注金额：", terminator: "")
debt = inputInt()
} while debt <= 0 || debt > money
let firstPoint = roll() + roll()
var needsGoOn = false
print("第1次摇出了\(firstPoint)点")
switch firstPoint {
case 7, 11:
money += debt
print("玩家胜!!!")
case 2, 3, 12:
money -= debt
print("庄家胜!!!")
default:
needsGoOn = true
}
var index = 2
while needsGoOn {
let currentPoint = roll() + roll()
print("第\(index)次摇出了\(currentPoint)点")
if currentPoint == 7 {
money -= debt
print("庄家胜!!!")
needsGoOn = false
}
else if currentPoint == firstPoint {
money += debt
print("庄家胜!!!")
needsGoOn = false
}
index += 1
}
} while money > 0
if money <= 0 {
print("你破产了!!!")
}
容器
数组
- 创建数组
var array1: [Int] = []
var array2: Array<Int> = []
var array3 = [1, 2, 3, 4, 5]
var array4 = [Int](count: 5, repeatedValue: 0)
var array5 = Array<Int>(count: 5, repeatedValue: 0)
var array6 = [Int]()
var array7 = Array<Int>()
- 添加元素
array1.append(2)
array1.append(3)
array1.insert(1, atIndex: 0)
array1.insert(4, atIndex: array1.count)
array1 += [5]
array1 += [6, 7, 8]
- 删除元素
array1.removeAtIndex(2)
array1.removeFirst()
array1.removeFirst(2)
array1.removeLast()
array1.removeRange(1...2)
array1.removeAll()
- 修改元素
array3[0] = 100
array3[array3.count - 1] = 500
print(array3)
- 遍历数组
1.方式1
for i in 0..<array3.count {
print(array3[i])
}
2.方式2
for temp in array3 {
print(temp)
}
for temp in array3[1...3] {
print(temp)
}
说明：for-in循环是一个只读循环，这也就意味着在循环的过程中不能对循环进行修改
3.方式3
for (i, temp) in array3.enumerate() {
if i == 0 {
array3[i] = 1
}
print("\(i).\(temp)")
}
提醒: 操作数组时最重要的是不要越界访问元素。数组对象的count属性表明了数组中有多少个元素，那么有效的索引（下标）范围是0到count-1。
数组中的元素也可以是数组，因此我们可以构造多维数组。最常见的是二维数组，它相当于是一个有行有列的数组，数组中的每个元素代表一行，该数组中的每个元素代表里面的列。二维数组可以模拟现实世界中的表格、数学上的矩阵、棋类游戏中的棋盘、2D游戏中的地图，所以在实际开发中使用非常广泛。
下面程序是模拟学生各科成绩的二维数组
func randomInt(min: UInt32, max: UInt32) -> Int {
return Int(arc4random_uniform(max - min + 1) + min)
}
let namesArray = ["关羽", "张飞", "赵云", "马超", "黄忠"]
let coursesArray = ["语文", "数学", "英语"]
var scoresArray = [[Double]](count: namesArray.count, repeatedValue: [Double](count: coursesArray.count, repeatedValue: 0))
for i in 0..<scoresArray.count {
for j in 0..<scoresArray[i].count {
scoresArray[i][j] = Double(randomInt(0, max: 100))
}
}
for (index, array) in scoresArray.enumerate() {
var sum = 0.0
for score in array {
sum += score
}
let avg = sum / Double(coursesArray.count)
print("\(namesArray[index])的平均成绩为： \(avg)")
}
for i in 0..<coursesArray.count {
var sum = 0.0
for row in 0..<scoresArray.count {
sum += scoresArray[row][i]
}
let avg = sum / Double(namesArray.count)
print("\(coursesArray[i])课的平均成绩为： \(avg)")
}
集合
集合在内存中是离散的，集合中的元素通过计算Hash Code(哈希码或散列码) 来决定存放在内存中的什么位置，集合中不允许有重复元素。
- 创建集合
let set: Set<Int> = [1, 2, 1, 2, 3, 5]
for temp in set {
print(temp)
}
- 集合的添加和删除
set.insert(100)
set.remove(5)
set.removeFirst()
set.removeAll()
- 集合的运算 (交集，并集，差集)
var set: Set<Int> = [1, 2, 1, 2, 3, 5]
var set2: Set<Int> = [1, 3, 5, 7]
set.intersect(set2)
set.union(set2)
set.subtract(set2)
字典
字典是以键值对的方式保存数据的容器，字典中的每个元素都是键值对组合，通过键可以找到对应的值
- 创建字典
var dict: [Int: String] = [
1: "hello",
2: "good",
3: "wanderful",
5: "delicious"
]
- 字典添加、删除、修改元素
print(dict[1]!) // 有可能找不到
if let str = dict[1] {
print(str)
}
else {
print("找不到")
}
dict[3] = "libi"
dict[4] = "shit"
// dict.removeValueForKey(3)
dict[5] = nil
dict.count
- 遍历字典
for key in dict.keys {
print("\(key) ---> \(dict[key]!)")
}
for value in dict.values {
print(value)
}
for (key, value) in dict.enumerate() {
print("\(key). \(value.0) ---> \(value.1)")
}
重要操作
- 排序
- sort：不改变自身
- sortInPlace：改变自身
说明: 排序方法的参数是一个闭包(closure)，该闭包的作用是比较数据中两个元素的大小。
let array = [23, 45, 12, 89, 98, 55, 7]
array.sort ({ (one, two) -> Bool in
return one < two
})
array.sort { (one, two) in one < two }
array.sort { one, two in one < two }
array.sort ({ $0 < $1 })
array.sort { $0 < $1 }
array.sort (<)
- 过滤
let array = [23, 45, 12, 89, 98, 55, 7]
// 筛选掉不满足条件的数据
let newArray = array.filter{ $0 > 50 }
print(newArray) // [89, 98, 55]
- 映射
let array = [23, 45, 12, 89, 98, 55, 7]
// 通过映射对数据进行变换处理
let newArray = array.map{ sqrt(Double($0)) }
print(newArray)
- 归约（缩减）
let array = [23, 45, 12, 89, 98, 55, 7]
let newArray1 = array.filter{ $0 > 50 }
let newArray2 = newArray1.map{ $0 % 10 }
let result = newArray2.reduce(0, combine: +)
print(result)
函数和闭包
函数是独立的可重复使用的功能模块，如果程序中出现了大量的重复代码，通常都可以将这部分功能封装成一个独立的函数。在Swift中，函数是"一等公民"，可以作为类型来使用，也就是说函数可以赋值给一个变量或常量，可以将函数作为函数的参数或者返回值，还可以使用高阶函数
func 函数名([参数1：类型, 参数2：类型,...]) [throws|rethrows] [-> 返回类型] {
函数的执行体
[return 表达式]
}
- 外部参数名
// 函数的参数名
// 函数名(外部参数名 内部参数名: 类型, 外部参数名 内部参数名: 类型)
// 如果不写外部参数名那么内部参数名也是外部参数名
// 可以使用_来作为外部参数名表示省略外部参数名
func myMin(a x: Int, b y: Int) -> Int {
return x < y ? x : y
}
// 调用函数的时候要写函数的外部参数名
print(myMin(a: 3, b: 5))
- inout参数
func swap(inout a: Int, inout _ b: Int) -> Void {
(a, b) = (b, a)
}
var a = 300, b = 500
swap(&a, &b) // 注意这里要写地址符号&
- 可变参数列表
// Swift中函数的参数列表可以是可变参数列表(参数的个数是任意多个)
func sum(nums: Int...) -> Int {
var total = 0
for num in nums {
total += num
}
return total
}
print(sum())
print(sum(999))
print(sum(1, 2, 3))
print(sum(90, 82, 37, 68, 55, 11, 99))
闭包就是没有名字的函数或者称之为函数表达式(Lambda表达式), objective-C中与之对应的概念叫block。如果一个函数的参数类型是函数我们可以传入一个闭包；如果一个函数的返回类型是函数我们可以返回一个闭包；如果一个类的某个属性是函数我们也可以将一个闭包表达式赋值给它。
{ ([参数列表]) [-> 返回类型] in 代码 }
面向对象编程(OOP)
基本概念
对象：接收消息的单元，对象是一个具体的概念。
类：对象的蓝图和模板，类是一个抽象概念。
消息：对象之间通信的方式，通过给对象发消息可以让对象执行对应的操作来解决为题。
四大支柱
抽象：定义类的过程就是一个抽象的过程，需要做数据抽象和行为抽象，数据抽象找到对象的属性(保存对象状态的存储属性)，行为抽象找到对象的方法(可以给对象发消息)。
封装：
- 观点1：我们在类中写方法其实就是在封装API（编程接口），方法的内部实现可能会很复杂，但是这些对调用这来说是不可见的，调用只能看到方法有一个简单清晰的接口。
- 观点2：将对象的属性和操作这些属性的方法绑定在一起。
- 观点3：隐藏一切可以隐藏的实现细节，只提供简单清晰的接口(界面)。
继承：从已有的类创建新类的过程
多态：同样的对象类型(Pet类型)接收相同的消息(调用相同的方法)，但是做了不同的事情 这就是多态(polymorphism)
实现多态的关键步骤:
- 方法重写(子类在继承父类的过程中对父类已有的方法进行重写, 而且不同的子类给出各自不同的实现版本)
- 对象造型(将子类对象当成父类型来使用)
可以通过if+as?将父类型安全的转换成子类型然后再调用子类特有方法
if let dog = pet as? Dog {
dog.keepTheDoor()
}
重载 - overload
重写 - override
三个步骤
- 定义类
- 数据抽象
- 存储属性
- 行为抽象
- 方法（写到类里面的函数或者跟对象绑定的属性就是方法）
- 对象方法：给对象发的消息
- 类方法：给类发的消息，与对象的状态无关的方法
- 方法（写到类里面的函数或者跟对象绑定的属性就是方法）
- 构造器
- 指派构造器
- 遍历构造器(convenience)
- 必要构造器(required)
- 创建对象
- 给对象发消息
class Triange {
var a: Double
var b: Double
var c: Double
init(a: Double, b: Double, c: Double) {
self.a = a
self.b = b
self.c = c
}
// 类方法(发给类的消息与对象状态无关)
// 此处的static可以换成class，作用相同
static func isValid(a: Double, _ b: Double, _ c: Double) -> Bool {
return a + b > c && b + c > a && c + a > b
}
// class func isValid(a: Double, _ b: Double, _ c: Double) -> Bool {
// return a + b > c && b + c > a && c + a > b
// }
// 对象方法(发给对象的消息与对象状态有关)
func perimeter() -> Double {
return a + b + c
}
}
let a = 2.0
let b = 2.0
let c = 3.0
// 在创建对象前先调用类方法判定给定的三条边能否构成三角形
// 类方法是发给类的消息 所以不用创建对象直接通过类名调用
if Triange.isValid(a, b, c) {
let t = Triange(a: a, b: b, c: c)
// 对象方法是发给对象的消息 要先创建对象才能调用
print(t.perimeter())
}
else {
print("无法创建三角形")
}
相关内容
-
枚举
-
结构（体）
总结: 类和结构的区别到底有哪些？什么时候应该使用结构？什么时候使用类？
- 区别1: 结构的对象是值类型, 类的对象是引用类型，值类型在赋值的时候会在内存中进行对象的拷贝；引用类型在赋值的时候不会进行对象拷贝只是增加了一个引用
结论: 我们自定义新类型时优先考虑使用类而不是结构除非我们要定义的是一种底层的数据结构(保存其他数据的类型)，在定义底层数据类型的时候使用结构，在大多数情况下使用类 - 区别2: 结构会自动生成初始化方法
- 区别3: 结构中的方法在默认情况下是不允许修改结构中的属性除非加上mutating关键字
var age: Int
mutating func getOlder() {
age += 1
}
-
扩展(extension)
-
运算符重载
-
下标运算(subscript)
-
访问修饰符
- private
- internal
- public
面向协议编程(POP)
协议
protocol 协议名[: 父协议1，父协议2，...] {
// 方法的集合(计算属性相当于就是方法)
}
- 能力 - 遵循了协议就意味着具备了某种能力
- 约定 - 遵循了协议就一定要实现协议中的方法
- 角色 - 一个类可以遵循多个协议, 一个协议可以被多个类遵循, 遵循协议就意味着扮演了某种角色, 遵循多个协议就意味着可以扮演多种角色
依赖倒转原则
用协议实现委托回调
一个对象想做某件事情但是自身没有能力做这件事情，就可以使用委托回调，具体的步骤是：
- 设计协议，被委托方遵循协议并实现协议中的方法
- 委托方有一个属性是协议类型的，通过该属性可以调用协议中的方法
注意: 委托方的协议类型的属性通常是可空类型，因为要写成weak引用,避免循环引用
其它
- 协议组合：protocol<协议1，协议2，...>
- 可选方法
- 协议扩展：对协议中的方法给出默认实现
泛型
让类型不再是程序中的硬代码(hard code)
-
泛型函数
-
泛型类/结构/枚举
相关知识
- 泛型限定
- where子句
错误处理
enum MyErro: ErrorType {
case A
case B
case C
}
- throw
- throws / rethrows
- do
- catch
- try
边角知识
- ARC
- 正则表达式
- 嵌套类型
网友评论