Swift语言系统总结

Swift学习总结老师

语言基础

程序是指令的集合，写程序就是写一系列的指令去控制计算机做我们想做的事情。
编译：将程序设计语言转换成计算机能够理解的机器语言或者某种中间代码的过程。

冯诺依曼体系结构的计算机：

  1. 使用二进制
  2. 程序存储执行

变量和常量

定义变量和常量是为了保存数据，变量和常量就是某种类型的值的存储空间。

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

说明：1. Swift有非常强大的类型推断，所以定义变量或常量时如果可以的话应该直接使用类型推断不用手动指定类型；2. 如果可以的话应该尽可能使用常量而不是变量。

语言元素

var a: Int = 10

关键字：有特殊含义的单词
标识符：给变量、常量、函数、类、结构、协议、枚举、方法、属性等起的名字

  1. 字母（Unicode字符）、数字、下划线，数字不能开头
  2. 大小写敏感（区分大小写）
  3. 不能使用关键字做标识符
  4. 使用驼峰命名法（命名变量、常量、函数、方法、属性第一个单词小写，从第二个单词开始每个单词首字母大写；命名类、结构、协议、枚举每个单词首字母都要大写）
  5. 见名知意
  6. 命名私有的属性和方法时以下划线开头

运算符：Swift中的运算符其实都是函数

  1. 赋值运算符：=、+=、-=、……
  2. 算术运算符：+、-、*、/、%
  3. 比较运算符：==、!=、<、<=、>、>=
  4. 逻辑运算符：&&、||、!
  5. 条件运算符：?:
  6. 其他运算符：[]、.、??、?、!

字面(常)量：

  1. 整数字面量：10、1_234_567、0x10、0o10、0b10
  2. 小数字面量：123.45、1.2345e2、0xab.cdp2
  3. 字符字面量："c"、"\n"、"\u{41}"、"\u{9a86}"
  4. 字符串字面量："Hello"、"caf\u{e9}"
  5. 布尔字面量：true、false
  6. 空值字面量：nil
  7. 类型字面量：String.self、UILabel.self

分隔符：将不同的语言元素符号分开

说明：Swift中每个语句后面的分号是可写可不写的，写代码时尽量保证一行只有一条语句这样就可以省略掉分号。

分支和循环

分支

  • if...else...

下面的程序实现了分段函数求值。

let x = 3.2
let y: Double
if x < -1 {
    y = 3 * x + 5
}
else if x <= 1 {
    y = 5 * x - 3
}
else {
    y = 7 * x + 1
}
print("f(\(x))=\(y)")
  • switch...case...default

下面的程序实现了将百分制的成绩转换成A-E的等级。

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...

下面的程序实现了1-100求和。

var sum = 0
var i = 1
repeat {
    sum += i
    i += 1
} while i <= 100
print(sum)
  • for

下面的程序实现了1-100求和。

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

说明：在循环中可以使用break关键字来提前终止循环，也可以使用continue关键字使循环直接进入下一轮，但是应该尽量减少对break和continue的使用，因为它们不会让你的程序变得更好。

综合案例：Craps赌博游戏。

游戏规则：玩家摇两颗色子，如果第一次摇出了7点或11点，玩家胜；如果摇出2点、3点或12点，庄家胜；其他点数游戏继续。在继续的过程中玩家重新摇色子，如果摇出了7点，庄家胜；如果摇出了第一次摇的点数，玩家胜；否则玩家继续摇色子直到分出胜负。

func roll() -> Int {
    return Int(arc4random_uniform(6)) + 1
}

let firstPoint = roll() + roll()
print("玩家摇出了\(firstPoint)点")
var needsGoOn = false
switch firstPoint {
case 7, 11: print("玩家胜!")
case 2, 3, 12: print("庄家胜!")
default: needsGoOn = true
}
while needsGoOn {
    let currentPoint = roll() + roll()
    print("玩家摇出了\(currentPoint)点")
    if currentPoint == 7 {
        print("庄家胜!")
        needsGoOn = false
    }
    else if currentPoint == firstPoint {
        print("玩家胜!")
        needsGoOn = false
    }
}

容器

数组

数组是使用连续的内存空间保存多个同类型的元素的容器，因为数组中的元素在内存中是连续的，所以可以使用下标运算来访问数组中的元素，实现随机存取。

  • 创建数组
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)
  • 添加元素
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
  • 遍历数组
  1. 方式1
for i in 0..<array3.count {
    print(array3[i])
}
  1. 方式2
for temp in array3 {
    print(temp)
}
for temp in array3[1...3] {
    print(temp)
}

说明：for-in循环是一个只读循环，这也就意味着再循环的过程中不能对数组中的元素进行修改

  1. 方式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(50, 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（哈希码或散列码）来决定存放在内存中的什么位置，集合中不允许有重复元素。

  • 创建集合
var set: Set<Int> = [1, 2, 1, 2, 3, 5]
  • 添加和删除元素
set.insert(100)

set.remove(5)
set.removeFirst()
set.removeAll()
  • 集合运算（交集、并集、差集）
var set1: Set<Int> = [1, 2, 1, 2, 3, 4, 5]
var set2: Set<Int> = [1, 3, 5, 7]

set1.intersect(set2)
set1.union(set2)
set1.subtract(set2)

字典

字典是以键值对的方式保存数据的容器，字典中的每个元素都是键值对组合，通过键可以找到对应的值。

  • 创建字典
var dict = [
    1: "hello",
    2: "good",
    3: "wonderful",
    5: "delicious"
]
  • 添加、删除、修改元素
dict[3] = "terrible"
dict[4] = "shit"
dict[5] = nil
  • 遍历元素
for key in dict.keys {
    print("\(key) ---> \(dict[key]!)")
}
for value in dict.values {
    print(value)
}
for (index, value) in dict.enumerate() {
    print("\(index). \(value.0) ---> \(value.1)")
}

重要操作

  • 排序
  1. sort
  2. sortInPlace

说明：排序方法的参数是一个闭包(closure)，该闭包的作用是比较数组中两个元素的大小。

let array = [23, 45, 12, 89, 98, 55, 7]
array.sort({ (one: Int, two: Int) -> 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 { $0 % 10 }
print(newArray)
  • 归约
let array = [23, 45, 12, 89, 98, 55, 7]
let result = array.reduce(0, combine: +)
print(result)

函数和闭包

函数是独立的可重复使用的功能模块，如果程序中出现了大量的重复代码，通常都可以将这部分功能封装成一个独立的函数。在Swift中，函数是"一等公民"，可以作为类型来使用，也就是说函数可以赋值给一个变量或常量，可以将函数作为函数的参数或者返回值，还可以使用高阶函数。

func 函数名([参数1: 类型, 参数2: 类型, ...]) [throws|rethrows] [-> 返回类型] {
    函数的执行体
    [return 表达式]
}
  • 外部参数名
func foo(a a: Int,b: Int){
a + b
}
foo(a: 10,b: 11)
  • inout参数
func sum(inout a: Int, inout _ b: Int) {
     a + b
}
  • 可变参数列表
func m(a: Int...) -> Int{
    return a[0]
}


print(m(1,2,3))

闭包就是没有名字的函数(匿名函数)或者称之为函数表达式(Lambda表达式)，Objective-C中与之对应的概念叫block。如果一个函数的参数类型是函数我们可以传入一个闭包；如果一个函数的返回类型是函数我们可以返回一个闭包；如果一个类的某个属性是函数我们也可以将一个闭包表达式赋值给它。

{ ([参数列表]) [-> 返回类型] in 代码 }

面向对象编程(OOP)

基本概念

对象：接收消息的单元，对象是一个具体的概念。

类：对象的蓝图和模板，类是一个抽象概念。

消息：对象之间通信的方式，通过给对象发消息可以让对象执行对应的操作来解决问题。

四大支柱

抽象：定义类的过程就是一个抽象的过程，需要做数据抽象和行为抽象，数据抽象找到对象的属性（保存对象状态的存储属性），行为抽象找到对象的方法（可以给对象发的消息）。

封装：

  • 观点1: 我们在类中写方法其实就是在封装API，方法的内部实现可能会很复杂，但是这些对调用这来说是不可见的，调用只能看到方法有一个简单清晰的接口。
  • 观点2: 将对象的属性和操作这些属性的方法绑定在一起。
  • 观点3: 隐藏一切可以隐藏的实现细节，只提供简单清晰的接口（界面）。

继承：指一个对象直接使用另一对象的属性和方法

多态：在面向对象语言中，接口的多种不同的实现方式即为多态。引用Charlie Calverts对多态的描述——多态性是允许你将父对象设置成为一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作（摘自“Delphi4 编程技术内幕”）。

三个步骤

  1. 定义类
  • 数据抽象
    • 存储属性
  • 行为抽象
    • 方法（写到类里面的函数或者说跟对象绑定的行为就是方法）
      • 对象方法：给对象发的消息
      • 类方法：给类发的消息，与对象的状态无关的方法
    • 计算属性
  • 构造器
    • 指派构造器
    • 便利构造器(convenience)
    • 必要构造器(required)
  1. 创建对象
  2. 给对象发消息
class Triangle {
    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
    }
    // 对象方法(发给对象的消息与对象状态有关)
    func perimeter() -> Double {
        return a + b + c
    }
}

let a = 1.0
let b = 2.0
let c = 3.0
// 在创建对象前先调用类方法判定给定的三条边能否构成三角形
// 类方法是发给类的消息所以不用创建对象直接通过类名调用
if Triangle.isValid(a, b, c) {
    let t = Triangle(a: a, b: b, c: c)
    // 对象方法是发给对象的消息要先创建对象才能调用
    print(t.perimeter())
}
else {
    print("无法创建三角形")
}

相关内容

  • 枚举

  • 结构(体)

总结：类和结构的区别到底有哪些？什么时候应该使用结构？什么时候应该使用类？

// 区别1: 结构的对象是值类型, 类的对象是引用类型
// 值类型在赋值的时候会在内存中进行对象的拷贝
// 引用类型在赋值的时候不会进行对象拷贝只是增加了一个引用
// 结论: 我们自定义新类型时优先考虑使用类而不是结构除非我们要定义的是一种底层的数据结构(保存其他数据的类型)

// 引用类型的类
//let stu1 = Student1(name: "骆昊", age: 35)
//var stu3 = stu1     // 此处内存中仍然只有一个学生对象
//stu3.name = "罗小号"
//stu3.age = 18
//print(stu1.name)
//print(stu1.age)
//
// 值类型的结构
// 区别2: 结构会自动生成初始化方法
//let stu2 = Student2(name: "骆昊", age: 35)
//var stu4 = stu2     // 此处内存中会复制一个新的学生对象
//stu4.name = "王大锤"
//stu4.age = 18
//print(stu2.name)
//print(stu2.age)

// 在Swift中同名函数只要参数列表不同是可以共存的 这个叫函数的重载
func changeName(inout name: String) {
    name = "王大锤"
}

// 参数前面加var的做法在Swift 3中肯定是要废掉的
func changeName(var stu: Student2) {
    stu.name = "王大锤"
}


// 计算机的硬件由五大部件构成:
// 运算器、控制器、存储器、输入设备、输出设备
// 运算器 + 控制器 => CPU (中央处理器)
// 存储器 => 内存 (RAM - Random Access Memory)

// 程序员可以使用的内存大致分为五块区域:
// 栈 (stack) - 我们定义的局部变量/临时变量都是放在栈上
//  - 特点: 小、快
// 堆 (heap) - 我们创建的对象都是放在堆上的
//  - 特点: 大、慢
// 静态区 (static area)
//  - 数据段 - 全局量
//  - 只读数据段 - 常量
//  - 代码段 - 函数和方法
  • 扩展(extension)
class Name {
    func a() {
        
    }
}

extension Name {
    func c () {
        
    }
}

let a = Name()
a.c()
  • 运算符重载
func *(one: Fraction,two: Fraction) -> Fraction {
    
    return one.cheng(two)
}

  • 下标运算(subscript)

  • 访问修饰符

    • private
    • internal
    • public

面向协议编程(POP)

协议

protocol 协议名[: 父协议1, 父协议2, ...] {
    // 方法的集合(计算属性相当于就是方法)
}
  1. 能力：
  2. 约定：
  3. 角色：

总结// 少用继承多用协议
// 协议是方法的集合（计算属性相当于就是方法）
// 可以把看似不相关的对象的公共行为放到一个协议中
// 协议在swift开发中大致有三种作用
// 1. 能力 － 遵循了协议就意味着具备了某种能力
// 2. 约定 － 遵循了协议就一定要实现协议中的方法
// 3. 角色 － 一个类可以遵循多个协议，一个协议可以被多个类遵循，遵循协议就意味着扮演了某种角色，遵循多个协议就意味着可以扮演多种角色
// swift中的继承是单一继承（一个类只能有一个父类），如果希望让一个类具备多重能力可以使用协议来实现（c++里面是通过多重继承来实现的，这是一种非常狗血的做法）

依赖倒转原则

  1. // 依赖倒转原则（面向协议编程）
    // 1. 声明变量的类型时应该尽可能使用协议类型
    // 2. 声明方法参数类型时应该尽可能使用协议类型
    // 3. 声明方法返回类型时应该尽可能使用协议类型
  2. 依赖倒置原则（Dependence Inversion Principle）是程序要依赖于抽象接口，不要依赖于具体实现。简单的说就是要求对抽象进行编程，不要对实现进行编程，这样就降低了客户与实现模块间的耦合。

用协议实现委托回调

一个对象想做某件事情但是自身没有能力做这件事情就可以使用委托回调，具体的步骤是：

  1. 设计一个协议，让被委托方遵循协议并实现协议中的方法
  2. 委托方有一个属性是协议类型的，通过该属性可以调用协议中的方法

注意：委托方的协议类型的属性通常是可空类型，因为要写成弱引用(weak)。

其他

  • 协议组合：protocol<协议1, 协议2, ...>
    1.// 协议的组合
    let array: [protocol <Flyable,Fightable>] = [
    // Bird(),
    Superman()
    // Airplane(),
    ]

  • 可选方法

  • 协议扩展：对协议中的方法给出默认实现

  1. protocol Fightable {
    func fight()
    }

// 协议扩展 － 可以在协议扩展中给协议中的方法提供默认实现
// 也就是说如果某个类遵循了协议但是没有实现这个方法就直接使用默认实现
// 那么这个方法也就....
extension Fightable {
func fight() {
print("正在打架")
}
}

泛型

让类型不再是程序中的硬代码(hard code)，可以设计出更通用的代码。

  • 泛型函数
// 定义一个虚拟类型T, 调用函数时根据传入的参数类型来决定T到底是什么
func mySwap<T>(inout a: T, inout _ b: T) {
    let temp = a
    a = b
    b = temp
}
  • 泛型类/结构/枚举
// Swift中的类、结构和枚举都可以使用泛型
struct Stack<T> {
    var data: [T] = []
    
    // 入栈
    mutating func push(elem: T) {
        data.append(elem)
    }
    
    // 出栈
    mutating func pop() -> T {
        return data.removeLast()
    }
    
    var isEmpty: Bool {
        get { return data.count == 0 }
    }
}

var stack = Stack<String>()
stack.push("hello")
stack.push("good")
stack.push("zoo")

while !stack.isEmpty {
    print(stack.pop())
}

相关知识

  • 泛型限定
// 泛型限定
// <T: Comparable>限定T类型必须是遵循了Comparable协议的类型
func bubbleSort<T: Comparable>(array: [T]) -> [T] {
    var newArray = array
    for i in 0..<newArray.count - 1 {
        var swapped = false
        for j in 0..<newArray.count - 1 - i {
            if newArray[j] > newArray[j + 1] {
                mySwap(&newArray[j], &newArray[j + 1])
                swapped = true
            }
        }
        if !swapped {
            break
        }
    }
    return newArray
}
  • where子句

错误处理

enum MyError: ErrorType {
    case A
    case B
    case C
}
  • throw
  • throws / rethrows
  • do
  • catch
  • try

边角知识

  • ARC
  • 正则表达式
  • 嵌套类型
最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 204,732评论 6赞 478
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 87,496评论 2赞 381
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 151,264评论 0赞 338
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 54,807评论 1赞 277
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 63,806评论 5赞 368
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 48,675评论 1赞 281
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 38,029评论 3赞 399
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 36,683评论 0赞 258
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 41,704评论 1赞 299
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 35,666评论 2赞 321
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 37,773评论 1赞 332
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 33,413评论 4赞 321
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 39,016评论 3赞 307
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 29,978评论 0赞 19
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 31,204评论 1赞 260
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 45,083评论 2赞 350
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 42,503评论 2赞 343

推荐阅读更多精彩内容

  • swift3.0 基础知识点
    importUIKit classViewController:UITabBarController{ enumD...
    明哥_Young阅读 3,771评论 1赞 10
  • Swift 4.0 编程语言（七）
    132.转换错误成可选值 通过转换错误成一个可选值,你可以使用 try? 来处理错误。当执行try?表达式时,如果...
    无沣阅读 1,235评论 0赞 3
  • 了解阅读的四种类型，让你找到阅读下去的动力
    从小到大，我们都是活在别人的期望中，不管是工作中做的事，还是学生时期读的书都是被人安排的，这样的我们实质上就是一个...
    造价女侠阅读 3,466评论 2赞 1
  • 天路旅客
    这样，耶和华独自引导他，并无外邦神与他同在。 32:13 耶和华使他乘驾地的高处，得吃田间的土产。又使他从磐石中咂...
    喜乐盐泉阅读 431评论 0赞 0
  • 我的大一大二
    我的大学 转眼现在的我已经是一个即将踏入大三的腊肉了，不再是刚刚来到学校时的那个青涩，对一切都很好奇的所谓的小学弟...
    涛书生阅读 124评论 0赞 0