IOS APP开发学习记录--第0篇（语言篇）
IOS app开发学习记录–第0篇（语言篇）
写在前面
刚刚考研结束，终于可以可以做自己喜欢做想做的事情了，想想大学四年来学到的东西不少，但零零散散的缺乏记录和总结，所以觉得应该找个方式记录下来，就开始写博客，希望能以这种方式记录我的学习进步过程，也希望能帮助其他人避开一些坑。
关于ios开发
ios开发只是这一学期选的一门选修课，但因为一学期一直在准备考研，所以一直也没怎么去听课，所以ios基础可以说从零开始，所以这一系列应该只是简单的新手教程，大部分的开发过程的学习都是直接从苹果官网上翻译过来的，所以，所以除了一些个人的体会以外的开发部份相关内容都，不是原创！不是原创！不是原创！
本篇内容
内容适用人群：有最最最基础的编程知识即可
PS：只适合ios开发新手，大佬请绕道
本篇主要用于介绍一下ios开发语言:Swift语言
必要时可以点到原文下载官网提供的Playground用以练习，下载Playground的好处是能够随意修改原文给出的样例代码并能立刻得到结果反馈。
原文链接
正文
ios开发一开始使用的是object-c语言，后来升级为swift语言，个人认为swift语言可以说是我接触过语言中最友好的语言，语法上来说，比较接近javascript。
1.变量与常量定义
var用于变量定义，let用于常量定义
var myVariable = 42
myVariable = 50
let myConstant = 42
当没有指定变量类型时，编译器会根据初值判断变量类型，如上述类型都为int,当需要将手动确定变量类型时需要用":类型"来确定。
let myConstant: Double = 42
当需要转化变量类型时，必须显示声明，否则会报错
let label = "The width is "
let width = 94
let widthLabel = label + String(width)
当然，有更为简单的字符串拼接的方法
let apples = 3
let oranges = 5
let appleSummary = "I have \(apples) apples." //等价于“I have 3 apples”
let fruitSummary = "I have \(apples + oranges) pieces of fruit."//等价于“I have 8 apples”
更友好的是，swift支持多行编辑
let quotation = """
Even though there's whitespace to the left,
the actual lines aren't indented.
Except for this line.
Double quotes (") can appear without being escaped.
I still have \(apples + oranges) pieces of fruit.
"""
关于数组和字典的创建。
var shoppingList = ["catfish", "water", "tulips"]
shoppingList[1] = "bottle of water"
var occupations = [
"Malcolm": "Captain",
"Kaylee": "Mechanic",
]
occupations["Jayne"] = "Public Relations"//该行效果为为字典加入一组元素
occupations["Kaylee"] = "Public Relations"//该行效果为改变字典中关键字为“Kaylee”的一项的值
动态增加数组元素
shoppingList.append("blue paint")
空数组和字典的创建
let emptyArray = [String]()
let emptyDictionary = [String: Float]()
当变量类型可以被推断出来（比如给一个类型确定的变量赋值，或函数传参），数组和字典的类型信息可以被省略，写成如下形式：
shoppingList = []
occupations = [:]
2.程序控制
程序流程控制部分与大部分流行的编程语言类似，以下只举例列出一些swift中比较特别的细节。
（1）判断语句
样例1：
var a=0
if a>0 {
print(a)
}
第一点：无论条件语句还是循环语句，判断条件的括号是可选的，即可以写也可以不写，但是花括号是必须的必须写花括号。
第二点：判断条件必须是一个bool表达式，如样例中“a>0”不能写成"a",因为swift不支持隐式的转换，必须写成显式的形式。
样例2：
1.var optionalString: String? = "Hello"
2.print(optionalString == nil)
3.// Prints "false"
4.
5.var optionalName: String? = "John Appleseed"
6.var greeting = "Hello!"
7.if let name = optionalName {
8. greeting = "Hello, \(name)"
9.}
首先要先认识swift语言中一种比较特别的类型：optional类型
optional类型指的是一个变量可能有值，或者可能为空，比如样例中“optionalString”在定义其类型时写成“String?”的形式，其中“？”就指明optionalString可能为空或可能有值。
这一类型的一个重要如样例中第7行所示，这一行表示，如果optional类型的变量optionalName不为空，就把其值赋给name并且执行if语句，否则跳过。
optional类型的另一用法是利用“??”操作符
let nickName: String? = nil
let fullName: String = "John Appleseed"
let informalGreeting = "Hi \(nickName ?? fullName)"
上述代码第三行表示，如果nickName为空，则将“Hi John Appleseed”赋给informalGreeting,否则将"Hi"+nickName
赋给informalGreeting
样例3：
let vegetable = "red pepper"
switch vegetable {
case "celery":
print("Add some raisins and make ants on a log.")
case "cucumber", "watercress":
print("That would make a good tea sandwich.")
case let x where x.hasSuffix("pepper"):
print("Is it a spicy \(x)?")
default:
print("Everything tastes good in soup.")
}
第一点，注意关键字"let"在各种判断，循环语句中的灵活应用，如“if let”,“for let”等等。
第二点，swift中的switch语句不需要在每一种情况后加"break",遇到匹配情况，执行完后会自动跳出。
（2）循环语句
样例1：
let interestingNumbers = [
"Prime": [2, 3, 5, 7, 11, 13],
"Fibonacci": [1, 1, 2, 3, 5, 8],
"Square": [1, 4, 9, 16, 25],
]
var largest = 0
for (kind, numbers) in interestingNumbers {
for number in numbers {
if number > largest {
largest = number
}
}
}
print(largest)
// Prints "25"
swift中的"for in"语句等价于用for后面的变量遍历in后面的一组数据。
样例2：
var n = 2
while n < 100 {
n *= 2
}
print(n)
// Prints "128"
var m = 2
repeat {
m *= 2
} while m < 100
print(m)
// Prints "128"
while语句与repeat语句的用法如上
样例3：
var total = 0
for i in 0..<4 {
total += i
}
print(total)
可以用“0…<4”来表示从0到3
用“0…<4”来表示从0到4
故样例中输出为6，若改为“0…<4”，则输出为10
3.函数和闭包
一个完整的函数定义：
func 函数名（函数外使用变量名1 函数内使用变量名1：类型1，……）->返回值类型{ 函数体 }
样例1：
func greet(_ person: String, on day: String) -> String {
return "Hello \(person), today is \(day)."
}
greet("John", on: "Wednesday")
样例1中有一个函数外变量名为“_”，表示该函数外变量名为默认值，则在调用该函数时这一个参数不需要加函数外变量名。
其中，函数内使用变量名也可以被省略如下，这时函数内变量名和函数外变量名相同（一般会使用这种写法）
样例2：
func greet(person: String, day: String) -> String {
return "Hello \(person), today is \(day)."
}
greet(person: "Bob", day: "Tuesday")
注意这种情况下函数调用的时候不能省略函数外使用名。
样例3：
func calculateStatistics(scores: [Int]) -> (min: Int, max: Int, sum: Int) {
var min = scores[0]
var max = scores[0]
var sum = 0
for score in scores {
if score > max {
max = score
} else if score < min {
min = score
}
sum += score
}
return (min, max, sum)
}
let statistics = calculateStatistics(scores: [5, 3, 100, 3, 9])
print(statistics.sum)
// Prints "120"
print(statistics.2)
// Prints "120"
当需要多返回值时，可按照样例3的方法构造返回值
样例4：函数捕获
func returnFifteen() -> Int {
var y = 10
func add() {
y += 5
}
add()
return y
}
returnFifteen()
函数捕获意味着，函数内部可以定义一个函数，这个函数可以使用其外层函数定义的变量，如样例4中，add函数中的y变量并非该函数内部的变量，而是函数外的变量。
样例5：函数作为返回值
func makeIncrementer() -> ((Int) -> Int) {
func addOne(number: Int) -> Int {
return 1 + number
}
return addOne
}
var increment = makeIncrementer()
increment(7)
样例5中返回值为一个函数，该函数带一个int类型的参数，该函数的返回值为int
样例6：函数作为参数
func hasAnyMatches(list: [Int], condition: (Int) -> Bool) -> Bool {
for item in list {
if condition(item) {
return true
}
}
return false
}
func lessThanTen(number: Int) -> Bool {
return number < 10
}
var numbers = [20, 19, 7, 12]
hasAnyMatches(list: numbers, condition: lessThanTen)
样例6第一个函数的第二个参数为一个参数是int,返回值是bool的函数，第二个函数定义了一个判断数字是否小于10的函数，最后的函数调用将第二个函数作为参数传给第一个参数，用以判断list中是否存在小于10的数。
样例7：闭包
numbers.map({ (number: Int) -> Int in
let result = 3 * number
return result
})
函数的实质其实就是一个带参数和返回值的代码块，当你需要调用的时候才会用到函数名，可是很多情况下我们并不需要很多次的使用该函数，只是需要将它作为某一次执行的参数，这个时候如果再为这一次执行写一个函数，每次执行的时候调用一次这个函数会浪费很多的栈空间，代码的复用率也不高，这个时候就不需要函数名，而是将代码打包成一个块，这就是函数闭包（在C++中叫匿名函数）
样例7中的numbers.map调用需要一个类型为函数的参数，这个时候可以用“{()}”来定义一个代码块，作为函数闭包传参，其中"(number:Int)"为参数，“->Int”为返回值，函数体与返回值之间用“in”分割。
当该闭包的参数类型和返回类型已知的时候（比如说在调用该闭包的函数定义中已经声明），则可以省略该闭包的参数和返回值的声明。如
let mappedNumbers = numbers.map({ number in 3 * number })
print(mappedNumbers)
甚至在某些比较短的闭包中，可以用序号代替参数名，如：
let sortedNumbers = numbers.sorted { $0 > $1 }
print(sortedNumbers)
其中，“$0”代表第一个参数，“$1”代表第二个参数
4.类与对象
这一部分大部分也和主流面向对象的程序语言类似，只举例说明一些特殊的细节
样例1：类的创建和调用
class NamedShape {
var numberOfSides: Int = 0
var name: String
init(name: String) {
self.name = name
}
func simpleDescription() -> String {
return "A shape with \(numberOfSides) sides."
}
}
构造函数：init(参数……)
样例2：子类的创建和函数覆盖
class Square: NamedShape {
var sideLength: Double
init(sideLength: Double, name: String) {
self.sideLength = sideLength
super.init(name: name)
numberOfSides = 4
}
func area() -> Double {
return sideLength * sideLength
}
override func simpleDescription() -> String {
return "A square with sides of length \(sideLength)."
}
}
let test = Square(sideLength: 5.2, name: "my test square")
test.area()
test.simpleDescription()
用冒号分割子类名与父类名，覆盖父类中的函数在函数定义时加一个“override”前缀
样例3：属性的getter和setter
class EquilateralTriangle: NamedShape {
var sideLength: Double = 0.0
init(sideLength: Double, name: String) {
self.sideLength = sideLength
super.init(name: name)
numberOfSides = 3
}
var perimeter: Double {
get {
return 3.0 * sideLength
}
set {
sideLength = newValue / 3.0
}
}
override func simpleDescription() -> String {
return "An equilateral triangle with sides of length \(sideLength)."
}
}
var triangle = EquilateralTriangle(sideLength: 3.1, name: "a triangle")
print(triangle.perimeter)
// Prints "9.3"
triangle.perimeter = 9.9
print(triangle.sideLength)
// Prints "3.3000000000000003"
注意每一属性的setter都有一个默认的参数“newValue”用以表示该属性要赋的值。
注意构造函数中的顺序，每一个子类的定义都要遵循这一顺序：
首先初始化子类中特有的变量
再调用父类的构造函数
再更改父类的某些属性
5.枚举类型和结构体
样例1：
enum Rank: Int {
case ace = 1
case two, three, four, five, six, seven, eight, nine, ten
case jack, queen, king
func simpleDescription() -> String {
switch self {
case .ace:
return "ace"
case .jack:
return "jack"
case .queen:
return "queen"
case .king:
return "king"
default:
return String(self.rawValue)
}
}
}
let ace = Rank.ace
let aceRawValue = ace.rawValue
枚举类型如果没有设定，则每一个变量的值从0开始每次增1，样例中ace到king会是0到12，但样例中ace赋值为1，故实际上为1到13。
样例2：
struct Card {
var rank: Rank
var suit: Suit
func simpleDescription() -> String {
return "The \(rank.simpleDescription()) of \(suit.simpleDescription())"
}
}
let threeOfSpades = Card(rank: .three, suit: .spades)
let threeOfSpadesDescription = threeOfSpades.simpleDescription()
结构体和类基本上没有区别，他们唯一的区别在于，在传参时结构体时值传递，而类传的是引用（这一点如果不理解可以看看其他相关资料）
6.协议与扩展
样例1：
protocol ExampleProtocol {
var simpleDescription: String { get }
mutating func adjust()
}
class SimpleClass: ExampleProtocol {
var simpleDescription: String = "A very simple class."
var anotherProperty: Int = 69105
func adjust() {
simpleDescription += " Now 100% adjusted."
}
}
var a = SimpleClass()
a.adjust()
let aDescription = a.simpleDescription
struct SimpleStructure: ExampleProtocol {
var simpleDescription: String = "A simple structure"
mutating func adjust() {
simpleDescription += " (adjusted)"
}
}
var b = SimpleStructure()
b.adjust()
let bDescription = b.simpleDescription
第一，协议也是一种类，用于规范其他的类的行为，用关键字“protocol”来创建
第二，继承协议的子类或者结构体必须完善协议中规定的方法。
第三，对样例中关键字“mutating”的说明，在上一部分说过结构体与类之间的区别是值传递和引用传递，那么如果是一个结构体继承了某一协议，那么在覆盖其方法的过程中需要改变内部属性的值，但因为结构体是值传递所以无法改变，这时就可以用“mutating”前缀来实现改变属性的值。所以可以注意到在类中覆盖协议中的方法并没有使用mutating关键字。
样例2：关于类扩展
extension Int: ExampleProtocol {
var simpleDescription: String {
return "The number \(self)"
}
mutating func adjust() {
self += 42
}
}
print(7.simpleDescription)
// Prints "The number 7"
可以用extension来对某一已经存在的类或协议或结构体等类型添加方法或属性。
7.异常处理
样例1：
enum PrinterError: Error {
case outOfPaper
case noToner
case onFire
}
可以继承"Error"协议来定义一个异常
样例2：
func send(job: Int, toPrinter printerName: String) throws -> String {
if printerName == "Never Has Toner" {
throw PrinterError.noToner
}
return "Job sent"
}
发生异常时实用关键字“throw”来抛出异常，异常抛出后，该函数立刻结束，返回调用该函数的函数来进行异常处理，会抛出异常的函数在定义时要加“throws”关键字
样例3：
do {
let printerResponse = try send(job: 1440, toPrinter: "Gutenberg")
print(printerResponse)
} catch PrinterError.onFire {
print("I'll just put this over here, with the rest of the fire.")
} catch let printerError as PrinterError {
print("Printer error: \(printerError).")
} catch {
print(error)
}
第一，在调用可能抛出异常的函数时，将可能抛出异常的函数用do-catch结构写出来。
第二，可能抛出异常的函数调用前加关键字“try”.
对于异常的处理，除了do-catch还有另一种处理方式
let printerSuccess = try? send(job: 1884, toPrinter: "Mergenthaler")
利用“try？”,若函数发生异常，则异常被抛弃，printerSuccess值为空，若正常，则printerSuccess值为返回结果。