在数组的方括号内必须写上类型，或者在Array后面的尖括号<>内写上类型。

对于字典而言，你一共需要提供两个类型，一个用于键，而另一个用于值。

Swift要求所有的变量和常量都必须有值。你可以在声明它们的时候给它们指定一个值，也可以通过init方法给它们分配值。

有时，你需要一个变量可以没有值，这种情况，你需要将变量声明为可选型：

var checklistToEdit: Checklist?

你不能直接使用这种类型的变量；你必须在使用它们之前，侦测一下其中是否有值，这个行为就叫做可选型解包：

if let checklist = checklistToEdit {
  // “checklist” now contains the real object
} else {
  // the optional was nil
}

下面例子中的变量age就是一个可选型，因为没有任何保证说字典中存在一个名为"Jony Ive"的键，所以age的类型是Int?，而不是Int：

if let age = dict["Jony Ive"] {
// 使用age变量
}

如果你100%的确定字典中存在一个叫做"Jony Ive"的键的话，那么你就可以对age变量进行强制解包：

var age = dict["Jony Ive"]!

你使用感叹号来通知Swift，‘这个可选型不会为nil，我用我的名誉打赌！’，当然，如果你错了的话，这个变量的值为nil，那么app就会挂掉，你也就名誉扫地了，所以你在使用强制解包的时候一定要小心。

另一种稍微安全点的强制解包方式叫做可选型链接。例如，下面的语句会在navigationController为nil时把app挂掉。

navigationController!.delegate = self

但是像这样做则不会把app挂掉：

navigationController?.delegate = self

位于问号后面的任何东西，都会在navigationController为nil时把它忽视掉。这个使用问号强制解包的语句等价于下面的语句：

if navigationController != nil {
  navigationController!.delegate = self
}

在声明可选型的时候，也可以用感叹号来代替问号，这样就是一个隐式解包可选型了：

var dataModel: DataModel!

这样的变量会带来潜在的危险，因为你可以向使用常规变量那样直接使用它，并不需要先解包。如果它的值为空，那么app就挂了，而常规变量为空时，编译器会提示你怎么做。

可选型平时被包裹起来，以避免app崩溃，但是使用了感叹号以后，就解除了可选型的安全级别。

然而，有时使用隐式解包可选型比使用可选型要方便一些。当你无法给一个变量初始值，也无法用init方法对其初始化的时候，你就会需要到这种隐式解包可选型。

如果你给了一个变量一个值后，就不应该在使它为nil，如果一个变量可以从有值变为nil，那么你最好还是使用用问号声明的可选型。

方法与函数（Methods and functions）

你已经学习过这样的一种对象了，它是所有app的基础组成部分，同时具有数据和功能。实例变量及常量提供数据，方法提供功能。

当你调用一个方法，app就会跳转到方法中，逐条的执行其中的语句，当方法中最后一条语句被执行完毕后，app就会会到之前离开的地方：

let result = performUselessCalculation(314)
print(result)
...
func performUselessCalculation(_ a: Int) -> Int {
  var b = Int(arc4random_uniform(100))
  var c = a / 2
  return (a + b) * c
}

方法经常会返回一个值给调用者，比如一个计算结果或者从一个集合中找到的一个对象。返回值的类型会写在->符号的后面。在上面的例子中，返回值的类型是Int。如果不存在->这个符号，那么就是说这个方法不返回任何值。

方法就是属于某一特定对象的函数，Swift中也存在独立的函数，比如print()或者arc4random_uniform()。

函数和方法的工作原理一样，一个可重复使用的功能块，但是函数不属于任何对象。像这种函数也被称为自由函数或者全局函数。

下面是一些关于方法的例子：

// 这个方法没有返回值及参数的方法
override func viewDidLoad()

// 这个方法有一个slider参数，但是一样没有返回值
// 关键字@IBAction意味着这个方法可以被连接到界面建造器的控件上
@IBAction func sliderMoved(_ slider: UISlider)

// 这个方法没有参数，但是有一个Int型的返回值
func countUncheckedItems() -> Int

// 这个方法有两个参数，cell和item，但是没有返回值
// 注意一下，第一个参数有一个外部名称for，而第二个参数有一个外部名称with
func configureCheckmarkFor(for cell: UITableViewCell,
                           with item: ChecklistItem)

// 这个方法有两个参数, tableView和section. 并且有一个Int型的返回值。
// 第一个参数前的下划线代表这个参数没有外部名称。
override func tableView(_ tableView: UITableView,
                        numberOfRowsInSection section: Int) -> Int

// 这个方法有两个参数, tableView和indexPath.
// 问号代表它返回一个为可选型的IndexPath对象。
override func tableView(_ tableView: UITableView,
                    willSelectRowAt indexPath: IndexPath) -> IndexPath?

在一个对象上调用一个方法，语法是object.method(parameters)。例如：

// Calling a method on the lists object:
lists.append(checklist)
// Calling a method with more than one parameter:
tableView.insertRows(at: indexPaths, with: .fade)

你可以把调用方法想象为从一个对象向另一个对象传递消息：“嗨 lists，我从checklist对象中向你发送了append的消息。”

你调用消息所属的对象被称为消息的接收者。

从同一个对象中调用方法非常常见，下面的例子中，loadChecklists()调用了sortChecklists()。它们都是DataModel对象中的成员：

class DataModel {
fun loadChecklists() {
...
sortChecklists()
}
fun sortChecklists() {
...
  }
}

有时你会写为下面这个样子：

fun loadChecklists() {
...
self.sortChecklists()
}

关键字self清晰的表明了DataModel对象自己是这个消息的接受者。

⚠️：在我们的课程中，调用方法的时候，我省略了self关键字，因为并不是必须要这样做。Object-C开发者会非常乐意在每个地方都写上self，所以你也许会见到它在Swift中也被大量使用。到底写与不写，这是程序员间可以引发战争的一个话题，但是无论如何，app并不是太关心这点。

在一个方法的内部，你也可以使用self关键字来引用这个对象自己：

@IBAction fund cancel() {
delegate?.itemDetailViewControllerDidCancel(self)
}

这里cancel()方法将对象自身的引用发送给delegate，所以delegate知道谁发送了这个itemDetailViewControllerDidCancel()消息。

同时注意一下这里的可选型链接。这个delegate属性是个可选型，所以它可以为nil。在调用方法前使用一个问号来确保delegate为nil时，app不会挂掉。

方法经常会具有一个或多个参数，所以你可以让它们接收不同数据源上的数据工作。一个被限定了数据源的方法，可能不会非常有价值。看看下面的sumValuesFormArray()方法，它没有参数：

class MyObject {
  var numbers = [Int]()
  fun sunValuesFromArray() ->Int{
  var total = 0
  for number in numbers {
   total += number
  }
  return total
 }
}

这里，numbers是一个实例变量。方法sumValuesFromArray()被这个实例变量绑定死了，如果这个变量不存在，那么这个方法就没用了。

假设你在这个app中添加了第二数组，也想要应用上面的计算，那么其中一个方法是把这个方法复制一遍，重新命名为一个新的方法来处理这个新的数组。这样做确实可行，但是你也从此和聪明绝缘了。

另一个好一点的选择是，给这个方法一个参数，使得你可以传送任何你想要计算的数组，这样，这个方法就从实例变量中解放出来了：

func sumValues(from array: [Int])-> Int {
  var total = 0
  for number in array {
  total += number
  }
  return total
}

现在你可以用任何整数型的数组作为它的参数了。

这并不是说方法不应该使用实例变量，只是说你想要一个方法的应用更加广泛，那么给它一个参数是个很好的选择。

方法的参数经常会有两个名字，一个外部名称，一个内部名称，例如：

fun downloadImage(for searchResult: SearchResult,withTimeout timeout: TimeInterval,andPlaceOn button: UIButton) {
...
}

这个方法有三个参数：searchResult，timeout和button。这些是内部名称，你在方法的内部用这些名称来调用参数。

方法的外部名称是方法名称的一部分。所以这个方法的全名是downloadImage(for,withTimeout,andPlaceOn)，Swift中的方法名称经常会特别的长。

调用这个方法的时候，你需要使用外部名称：

downloadImage(for:result,withTimeout:10,andPlaceButton)

有时，你会看到一个方法它的第一个参数没有外部名称，取而代之的是一个下划线：

override func tableView(_ tableView: UITableView,numberOfRowsInSection section: Int)-> Int

这种情况经常出现在委托方法中，它是Object-C的遗留物，第一个参数的内部和外部名称都会被包含在方法名称中，比如在Object-C中downloadImage()方法的全名会是downloadImageForSearchResult。像这样的命名方式，以后会非常少见。如果是在Object-C中，这个方法的名称会是tableViewTableVIew，非常古怪是吧，而Swift 中，以下划线代替外部名称时，方法名称中就可以省略这个参数的外部名称，在Swift中，这个方法的全名是tableView(numberOfRowsInSection)。这样是不是容易明白多了？Swift在对方法命名时更加灵活，但它还是会保留一些旧的惯例。

在一个方法的内部，你可以做以下事情：

1、创建局部变量或者常量

2、进行基本的数学运算，比如加减乘除

3、将一个新的值放入变量（局部变量或实例变量）

4、调用其他方法

5、使用if或者switch作出判断

6、用for或者while进行循环处理

7、返回一个值给调用者

让我们来看看if和for语句的更多细节。

作出判断（Making decisions）

if语句的基本结构是这个样子的：

if count == 0 {
text = "No Items"
} else if count == 1 {
text = "1 Item"
} else {
text = "\(count) Items"
}

if后面的表达式称之为条件。如果条件为真，那么if后面花括号内的语句会被执行。如果没有一个条件为真，那么最后一个else后面的花括号内的语句会被执行。

你使用比较运算符来对两个值进行比较：

== 等于
!= 不等于
< 小于
<= 小于等于
大于 >
大于等于 >=

使用等于操作时，被比较的两个对象仅在相等时返回true，比如：

let a = "Hello,world"
let b = "Hello," + "world"
print(a == b) //打印结果为true

这个和Object-C有所不同，在Object-C中，必须两个对象是内存中的同一个实例，才会返回为true。而Switf中的==操作，仅仅是比较对象的值，而不管它在内存中是不是同一个对象，如果在Swift中像做这个操作的话，需要使用运算符 ===，三个等号。

你还可以使用逻辑操作符来连接两个表达式：

&& 与操作，a && b必须在a和b都为true时才返回true
||或操作符，a || b当a，b其中之一为true时，返回true

还有逻辑非操作符！，它的作用是将原本的true转为false，原本的false转为true。（不要和可选型弄混了，逻辑非操作符出现在对象的前面，而可选型的感叹号出现在对象的后面）

可以使用括号()来对表达式分组：

if ((this && that) || (such && so)) && !other {
...
}

它读作：

if ((this and that) or (such and so)) and not other {
...
}

为了看起来更加清晰一些，我们写的有层次一点：

if (
  (this and that)
  or
  (such and so)
)
and
  (not other)

当然，你弄的越复杂，越难记清楚自己在做什么！

Swift中还有一种非常强大的结构，可以用来做出判断，那就是switch语句：

switch condition {
  case value1:
    //语句
  case value2:
    //语句
  case value3:
    //语句
  default:
    //语句

它的效果和多个if else的效果是一致的，上面的代码等同于：

if condition == value1 {
  //语句
} else if condition == value2 {
  //语句
}else if condition == value3 {
  //语句
} else {
  //语句
}

相较之下，switch在这种情况中更加便利，而且意思清晰。而且Swift版的switc比Object-C版的更加强大。例如，你可以使用区间范围：

switch difference {
  case 0:
    title = "Perfect!"
  case 1..<5:
    title = "You almost had it!"
  case 5..<10:
    title = "Pretty good!"
  default:
    title = "Not even close..."

这里的..<是半开区间操作符。它可以创建两个值之间的区间，其中的值都是不重复的，半开区间1..<5等价于闭区间1...4。

你会在后面的课程中见到switch语句的实际用例。

注意一下，if语句中的reture会比方法中的returen更早的返回：

fun divide(_ a: Int, by b: Int) ->Int {
if b == 0 {
  print("不能除以0")
  return 0
}
return a / b
}

对于没有返回值的方法而言，if中的return甚至可以结束掉方法：

fun performDifficultCalculation(list: [Double]) {
if list.count < 2 {
    print("样本过少")
    return
  }
//这里执行复杂的运算
}

在这个例子中，return的意思就是“我们退出方法吧”。任何return后面的语句都会被忽略掉。

你也可以把上面的方法写成下面这个样子：

fun performDifficultCalculation(list: [Double]) {
if list.count < 2 {
    print("样本过少")
  } else {
//这里执行复杂的运算
 }
}

像这种只有两种可能的情况下，上面两个方法的作用一样，使用哪个都可以，我个人比较喜欢第二种。

有时你会看到下面这个样子的代码：

fun someMethod() {
  if condition1 {
    if condition2 {
      if condition3 {
        //语句
      } else {
        //语句
     }
  } else {
  //语句
 } else {
  //语句
 }
}

这种代码非常难读，我喜欢将它们重构为下面这个样子：

fun someMethod() {
 if !condition1 {
//语句
}

if !condition2 {
//语句
}

if !condition3 {
//语句
}

//语句
}

这两段代码的作用其实是一样的，但是后一种更加容易理解。（注意一下，第二种写法中使用了！逻辑非来转换了表达式的意思）

Swift中有一种特殊的语句，guard来帮助你处理这种复杂的情况，用guard重写一下上面的方法就是：

fun someMethod() {
  guard condition1 else {
  //语句
  return
  }

guard condition21 else {
  //语句
  return
  }

...

你要自己尝试这些方法，比较看看哪种可读性最好，哪种看起来最好，这样慢慢的你就会很有经验了。

循环（Loops）

你之前已经见识过了，如何用for in来历遍一个数组：

for item in items {
if !item.checked {
count += 1
}
}

也可以写作：

for item in items where !item.checked {
  count += 1
}

for in中的语句会对每个items数组中的对象执行一遍。

注意一下，变量item的仅在for语句中有效，你不能在外面引用它，它的生命期比局部变量还要短。

有些语言，也包括Swift 2，中的for语句是这个样子的：

for var i = 0;i<5;++i {
print(i)
}

当你运行这个代码，会得到如下结果：

0
1
2
3
4

然而，在Swift 3种，这种for循环已经被抛弃了，取而代之的是，你可以直接使用区间范围，就像下面这样：

for i in 0 ... 4 {
print(i)
}

顺便说一下，也可写作：

for i in stride(from: 0,to: 5,by: 1) {
print(i)
}

stride函数创建了一个专门的对象来代表从1到5，每次增加1。如果你只想要偶数，你可以把by参数改为2。如果你给by参数一个负数的话，那么stride就可以实现倒着数的功能。

for语句并不是唯一的执行循环的语句，另一个非常强大的循环结构就是while语句：

while something is true {
//语句
}

while语句会一直保持循环，知道条件为false为止。还可以使用下面这种形式：

repeat {
 //语句
} while something is true

在这种情况中，条件是在语句执行后才判断的，所以括号内的语句至少也会被执行一次。

你可以使用while语句重写一下循环Checklists中的对象：

var count = 0
var i = 0
while i < items.count {
 let item = items[i]
 if !item.checked {
 count += 1
 }
 i += 1
}

这些循环结构的作用大致相同，只是看起来有些不一样。每一种都可以使你重复执行一段语句，直到条件不符合为止。

然而，使用while会比for in要看起来复杂一些，所以大多数时候，我们都会使用for in。

使用for in、while、repeat并没有什么不同，只是可读性上有所区别。

⚠️：上面例子中的item.count和count是两种不同的东西，只是名字一样。item.count中的count是数组items中的属性用于返回数组中元素的个数；后面的一个count是一个局部变量，用于对没有激活对勾符号的item对象计数。

就你可以在方法中使用return退出方法一样，你可以使用break来提前退出循环：

var found = false
for item in array {
  if item == searchText {
    found = true
    break
  }
}

这个例子中，for语句在数组中循环，直到找到第一个与searchText的值相当的值后，将found设置为true，然后退出循环，不再查看数组中剩下的对象。因为你已经找到了你想要的东西，所以没有必要把整个数组都循环完毕。

还存在一个contiue语句，和break的作用正好相反。它的作用是立即跳到下一个迭代中，当你使用contiue时，你的意思就是“目前这个item已经结束了，我们去看看下一个吧！”

在函数编程中，循环经常会被map，filter或者reduce替代。它们是一些操作集合的函数，对集合中每一个元素执行一段代码，并且返回一个新的集合作为结果。

例如，在数组上使用filter，会保留符合某些条件的元素。比如要得到未激活对勾符号的ChecklistItem对象，你可以这样写：

var uncheckedItems = items.filter { item in !item.checked}

这样写比循环看起来要简单多了。函数编程是一个非常大的话题，所以在这里我们不会展开太多。

对象（Objects）

将功能和数据结合在一起的可重用单元，都是对象。

数据是由对象中的实例变量和实例常量组成。我们经常以对象的属性形式引用它们。功能由对象的方法提供。

在你的Swift程序中，你使用过已存在的对象，比如String，Array，Date，UITableView，以及你自己创建的对象。

定义一个新的对象，你需要一个新的Swift文件，比如MyObject.swift，并且包含一个类（class）。比如：

class MyObject {
 var text: String
 var count = 0
 let maximum = 100
 
init() {
    text = "Hello World"
 }

fun doSomething() {
  //语句
 }
}

在class的花括号内，你添加了属性（实例变量和实例常量）和方法。

属性有两种类型：

1、存储属性，它们通常是实例变量和实例常量。

2、计算属性，不存储东西，而是执行某些逻辑

下面是一个关于计算属性的例子：

var indexOfSelectedChecklist: Int {
  get {
    return UserDefaults.standard().integerForKey("ChecklistIndex")
  }
 set {
   UserDefaults.standard().set(newValue,forKey: "ChecklistIndex")
 }
}

indexOfSelectedChecklist属性并不存储一个值，取而代之的是，每次有人使用这个属性时，它执行get或者set内的代码。另一个选择是，分别写一个setIndexOfSelectedChecklist()和getIndexOfSelectedChecklist()方法，但是这样读起来不是很好。

关键字@IBOutlet的意思是，这个属性可以被界面建造器中的用户接口元素引用，比如label和button。这种属性通常都被声明为weak和可选型。类似的，@IBAction关键字被用于和用户交互时被触发的方法。

这里有三种类型的方法：

1、实例方法

2、类方法

3、init方法

你已经知道了方法就是属于某一个对象的函数。调用这种类型的方法你首先需要一个这个对象的实例：

let myInstance = MyObject()  //创建一个对象的实例
myInstance.doSomething()   //调用方法

你也可以创建一个类方法，这样就可以在没有实例的情况下使用这个方法。事实上，类方法经常被当作“工厂”方法使用，用来创建新的实例：

class MyObject {
...
class fun makeObject(text: String)-> MyObject {
    let m = MyObject()
    m.text = text
    return m
  }
}

let MyInstance = MyObject.makeObject(text: "Hello world")

init方法，或者叫做初始化设置，在创建一个新的对象实例的过程中被使用。你也可以使用init方法来取代上面的那个工厂方法：

class MyObject {
...
init(text: String) {
    self.text = text
 }
}

init方法的主要目的是将对象中的实例变量填满。任何没有值的实例变量和实例常量都必须在init方法中被给予一个值。

Swift不允许变量或者常量没有值（可选型例外），并且init方法是你给变量或者常量赋值的最后一次机会。

对象可以拥有一个以上的init方法；具体使用哪一个要依据具体情况而定。

例如，一个UITableViewController，从故事模版中自动被读取时，使用init?(coder)初始化，手工从nib文件中读取时，使用init(nibName,bundle)初始化，或者没有从故事模版和nib文件中构造时，使用init(style)初始化。有时你会用到这个，而有时你会用到那个。

当对象不再被使用时，你可以提供一个deinit方法。在对象被破坏掉前调用它。

顺便说一下，class并不是Swift中唯一定义对象的方法。还存在其他类型的对象，比如structs和enums。你会在后面学到这些，所以在这里，我们就点到为止了。

协议（Protocols）

一个协议就是一组方法名称的列表：

protocol MyProtocol {
  func someMethod(value: Int)
  func anotherMethod()-> String
}

协议就类似于工作列表。它列出了你的公司中每个具体职位的工作。

但是列表自己本身并不工作，它仅仅是打印出来给大家看的东西。所以你需要雇佣具体的员工来完成列表上的工作。而这些员工，就是具体的对象。

对象需要被指明自己需要遵守的协议：

class MyObject: MyProtocol {
 ...
}

这样，这个对象就需要完成协议中列出的所有方法。（否则，就炒了它）

此时，你就可以引用这个对象，同时还有协议：

var m1: MyObject = MyObject()
var m2: MyProtocol = MyObject()

对于代码中任何使用m2变量的部分，它是否是MyObject对象并不重要。m2类型是MyProtocol，不是MyObject。

所有你的代码看到的是，m2是某个遵守MyProtocol协议的对象，但是具体是什么样的对象并不重要。

换而言之，你并不关心你雇用的员工，是不是兼职其他工作，只要他和你需要的东西不冲突，你就可以雇佣他。

我们已经快速的回顾了一遍你所遇到的Swift语法知识。在结束了这些理论之后，是时候开始我们的app开发了。