IOS开发【Swift编程语言】
初识
学习mac电脑的使用
- 下载app
- appstore；
- 通过网页下载（安装只需要将软件图标拖动到资料夹）。
- 移除app
Finder-》应用程式【拖动到右下角的垃圾桶即可】 - 滑鼠、触控板
滑鼠右键 - 自动备份
外接硬盘，使用时光机勾选自动备份。 - 键盘
- Ctrl =》 Command、 Alt =》 Option
- del =》Command + Backspace
- mac的选单在屏幕最上方。不在软件界面内
- 强制结束程式 Option + Command + ESC
- Mac中终止一个程式 Command + Q【杀后台，一般不需要（只需要使用Command + W 关闭即可）】
- 视窗最大化【绿色按钮直接全屏显示】保留下方菜单栏 【Option + 绿色按钮】
- 三指向上滑动 后台软体
- 档案的移动和删除
- 移动 Command + C, Command + Option + V
- 删除 Command + Backspace
- Command + Ctrl + D 使用apple自带的字典
- Command + Ctrl + 空格键 添加表情符号
- Shift + Command + 3 截取全屏
- Shift + Command + 4 自由截取
- Shift + Command + 5 录屏
- Spotlight 强大的搜寻工具 Command + 空格键
Hello, swift！
开源项目
开发windows、ios平台、服务器端、数据科学（机器学习、深度学习）。
使用软件：Swift Playgrounds + Xcode
Swift 简介
Swift是苹果于2014年在WWDC上发布的一门新的编程语言，可以用于编写IOS、OS X和watchOS 6应用程序。
Swift特性
- 安全性 Swift提供了多种安全措施，比如值使用前初始化、自动内存管理等；
- 快速性 Swift使用LLVM作为他的编译器框架，运行速度很快；
- 表现力 Swift将强大的类型推断和模式匹配与现代、轻量级的语法相结合，允许以清晰简洁的方式表达复杂的想法。因此代码不仅更便于编写，而且更易于阅读和维护；
- 兼容性 Swift可以兼容Objective-C的代码，同时Swift也继承了C语言以及Objective-C的特性，克服了C语言的兼容性问题。
此外，Swift还具有以下特点：
5. Swift中并没有加入宏系统，其协议和扩展都源自Objective-C;
6. Swift采用var声明变量，用let声明常量；
7. Swift没有显示指针，而是像C#语言一样，依赖于值类型/引用类型；
8. Swift支持本地类型推断、整理数据类型，但不支持隐式强制转换，所有的代码需要转化为显式类型。
notes:
9. Swift强大的字符集【允许变量名、常量名等标识符使用中文名称，也可以包含表情等其他字符】；
10. Swift支持代码预览，就是一边写代码一边进行编译的，而不需要等到整个程序写完了才编译代码，可以帮助我们及时发现一些错误。
编程名词
Operators 操作符
variables and constants 变量和常量
types 数据类型
collections 集合【数组、列表、字典】
control flow 流程控制
Functions 函数
Enumerations 枚举类型
Structures 结构体（值类型）【类（引用类型）可以继承，结构体不可以】
Protocols 协议【Java中接口】
简单代码编写
class Pizza {
var name = "Pepperoni"
func showName(){
print("The pizza is a \(name)")
}
func makeHawaiian(){
name = "Hamaiian"
}
func makeVegetarian(){
name = "Vegetarian"
}
}
let myPizza = Pizza() // 初始化方法
myPizza.showName()
- 与JavaScript不同，swift是强类型语言，但是没必要声明变量具体是什么类型，因为swift可以根据赋值自动识别出类型。
class Message {
var message: String = "Message is: 'Hello from Swift!'"
var timesDisplayed = 0
func display() {
print(message)
timesDisplayed += 1
}
func setMessage(to newMessage: String) {
message = "Message is: '\(newMessage)'"
timesDisplayed = 0
}
func reset() {
timesDisplayed = 0
}
}
let msg = Message()
msg.display()
msg.timesDisplayed
msg.display()
msg.timesDisplayed
msg.setMessage(to: "Swift is the future!")
- 按回车自动补全
- 引入可选值，使代码更安全
- swift中没有main方法
- swift代码中没有分号
Swift基础语法
编程准备
- 打开Xcode；
- 左上角选择 File -> New -> Playground;
- 选择Blank，双击或点击Next；
- 输入文件名称，选择文件路径。
Hello Swift！
print("Hello, swift!")
一、简单值
1. 变量与常量【常量与变量必须在使用前声明，Swift使用var声明变量，使用let声明变量。】
var a = 20 // 变量声明
a = 30
let b = 50 // 常量声明
与JavaScript不同，swift是强类型语言，但是没必要声明变量具体是什么类型，因为swift可以根据赋值自动识别出类型。
Swift不要求在每条语句的结尾编写“;” （如果添加了，编译器也不会报错）。但是，如果要在一行中编写多个单独的语句，则需要分号。
与C语言类似。Swift的单行注释以“//”开头，多行注释使用“ / ∗ . . . ∗ / /*... */ /∗...∗/”。【但是Swift中允许多行注释嵌套使用】
如果要在一行中声明多个常量或多个变量，需要使用“;”分隔
var x = 0.0, y = 0.0, z = 0.0
2. 类型
类型可以让编译器去推断，但是我们也可以使用类型注释指定变量与常量的类型。
var a: Int = 20
a = 15
let b:Float = 3.8
Swift的基本数据类型包括Int、Float、Double、Bool（取值范围：true、false）、Character、String等。
Swift要求二元运算符（+ - * / %等）两端空格。此外，考虑到代码风格的统一，赋值号两端最好也有空格。
3. 字符串
Swift定义了字符串类型为String
let label: String = "The width is "
let width = 94
let widthLabel = label + String(width)
Swift没有隐式转换，如果需要将值转换为不同的类型，必须使用显示转换。（强制转换）
如果需要在字符串中包含值，可以在字符串中采用【(表达式)】的写法，将括号中表达式的值转义
let width = 50
let widthLabel = "The width is \(width)"
如果一个字符串占用多行，需要使用三个双引号"""将字符串包裹起来。注意删除每个引用行开头的缩进
let quotation = """
I said "I have \(apples) apples."
And then I said "I have \(apples + oranges) pieces of fruit."
"""
4. 数组、字典、集合以及元组
- 数组是有序的元素序列，是包含相同元素的集合。
// 创建数组
var shoppingList = ["catfish", "water", "tulips"]
/*var shoppingList:[String] = ["catfish", "water", "tulips"]*/
shoppingList[1] = "bottle of water"
我们可以使用append往数组中添加元素，数组会自动增长
shoppingList.append("blue paint")
- 字典可以理解为键值对（key-value），可以通过某个特定的词语（键），从而找到它的定义（值）。
// 创建字典
var occupations = [
"Malcolm": "Caption",
"Kaylee": "Mechanic",
]
occupations["Jayne"] = "Public Relations"
如果要创建一个空数组或空字典，需要采用下面的写法：
let shoppingList:[String] = []
let occupations: [String: Float] = [:]
- 集合是一组无序不重复的相同类型元素构成的整体，与数学中集合的概念类似。
var favoriteGenres: Set<String> = ["Rock", "Classical", "Hip hop"]
- 元组是可以由不同类型元素构成的集合
var aturple = (18, 175, 60, "healthy", true)
5. 可选类型Optional
可选类型Optional是Swift特有的数据类型，可选类型的值可能是某个类型的值也可能是nil（表示没有值）。
可选类型的定义，在类型后面加“?”
var str: String?
可选类型在使用时必须要拆包，下面提供Optional的三种使用方式：
- 隐式拆包
在定义可选类型的时候使用“!”，后面使用该可选类型的时候不需要强制解包
let x : String! = "Hello"
let y = x
- 强制解包
使用可选类型变量时，在其后加“!”，如果使用不合法编译器会报错。
let x : String? = "hello"
let y = x!
- If-let 可选绑定
使用 If let 临时常量 = 可选类型 来判断可选类型是否包含值，如果包含就把值赋给临时常量，否则（可选类型为nil时） If语句判断为假。
var optionalName: String? = "John Applsseed"
var greeting = "Hello!"
if let name = optionalName {
greeting = "Hello, \(name)"
}
二、控制流
1. 条件语句
If分支语句
if score > 50 {
teamScore += 3
} else {
teamScore += 1
}
switch 分支语句
var vegetable = "red peper"
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.")
}
// Prints "Is it a spicy red pepper?"
2. 循环语句
for循环
var total = 0
for i in 0..<4 {
total += i
}
print(total)
// Prints "6"
// 0..<表示半闭合区间[0, 4)，0...4表示闭合区间[0, 4]
如果不需要区间序列内每项的值，可以用下换线“_”替代变量名
let base = 3, power = 10
var answer = 1
for _ in 1...power {
answer *= base
}
取数组里的值
let individualScores = [8, 18, 98, 88, 68]
var teamScore = 0
for score in individualScores {
if score > 50 {
teamScore += 3
} else {
teamScore += 1
}
}
print(teamScore)
// Prints "11"
取字典里的值
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 (_, numbers) in interestingNumbers {
for number in numbers {
if number > largest {
largest = number
}
}
}
print(largest)
// Prints "25"
while循环（当型循环）
var n = 2
while n < 100 {
n *= 2
}
print(n)
// Prints "128"
while-repeat循环（直到型循环：循环体至少执行一次）
var m = 2
repeat {
m *= 2
} while m < 100
print(m)
// Prints "128"
三、函数和闭包
1. 函数
函数声明的格式：
func 函数名（参数名称1：类型，参数名称2：类型，…）-> 返回类型 {}
func greet(Person: String, day: String) -> String {
return "Hello \(person), today is \(day)."
}
greet(person: "Bob", day: "Tuesday")
// personhe day 是参数标签，同时也是参数名称
默认情况喜爱，函数使用其参数名称作为其参数的标签。如果参数标签与参数名称不同，需要在定义函数时把自定义参数标签写入参数名称之前，或写入_表示（函数调用是）不使用参数标签。【起别名】
func greet(_ person: String, on day: String) -> String {
return "Hello \(person), today is \(day)."
}
greet("John", on: "Wednesday")
如果函数有多个返回值，可以把元组作为返回值：
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"
prints(statistics.2)
// Prints "120"
2. 嵌套函数
Swift的函数可以嵌套定义，嵌套函数可以访问在外部函数声明的变量。我们可以使用嵌套函数在较长或复杂的函数中组织代码。
func returnFifteen() -> Int {
var y = 10
func add() {
y += 5
}
add()
return y
}
returnFifteen()
一个函数的返回值可以是另一个函数
func makeIncremmenter() -> ((Int) -> Int) {
func addOne(number: Int) -> Int {
return 1 + number
}
return addOne
}
var increment = makeIncrementer()
increment(7)
一个函数的参数可以是另一个函数
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)
3. 输入输出参数
一般情况喜爱不允许修改函数参数的值，试图在函数体中更改参数值将编译错误。
如果要修改参数的值，需要在函数定义时，使用inout关键字；在函数调用时，参数名前加“&”
func swap(first a : inout Int, second b :inout Int) {
let temp = a
a = b
b = temp
}
var x = 10, y = 20
swap(first: &x, second: &y)
print(x, y)
4. 可变参数
可变参数可以接受0个或多个值，需要在函数定义参数时类型后面加“…”
func arithmeticMean(_ numbers: Double...) -> Double {
var total: Double = 0
for number in numbers {
total += number
}
return total / Double(numbers.count)
}
arithmeticMean(1, 2, 3, 4, 5)
// returns 3.0
arithmeticMean(3, 8.25, 18.75)
// returns 10.0
5. 闭包
函数实际上时闭包的一种特殊情况：可以稍后调用的代码块
闭包是自包含的功能块，可以在代码中传递和使用。全局和嵌套函数实际上也是特殊的闭包，闭包采取如下三种形式之一：
- 全局函数是一个有名字但不会捕获任何值的闭包；
- 嵌套函数是一个有名字并可以捕获其封闭函数域内值的闭包；
- 闭包表达式是一个利用轻量级语法所写的可以捕获其上下文中变量或常量值的没有名字的闭包。
闭包表达式的格式：
{(参数) -> 返回类型 in
声明
}
numbers.map({ (number: Int) -> Int in
let result = 3 * number
return result
})
四、对象和类
Swift支持面向对象的编程。C++、Java等语言通过类实现面向对象，而在Swift中，类、枚举以及结构体都具有面向对象的特性。
类（class）是用户自定义的数据类型，包含属性（特征）和方法（行为）两部分。对象是类的实例化。
可以这么理解，类是对某一种事物的抽象，是概念；对象是某一个具体的个体，是实体。例如：猫是一个类，每只猫都有名字（属性），猫的行为（方法）有吃饭、睡觉等。
1. 类定义的语法
class 类名 {
属性
方法
}
// 类定义
class cat {
var name: String?
func eat() -> Void {
if let mycatname = name {
print("\(mycatname) is eating.")
}
}
func sleep() -> Void {
if let mycatname = name {
print("\(mycatname) is sleeping.")
}
}
}
// 创建对象
var mycat = cat()
mycat.name = "Jiaozi"
mycat.eat()
mycat.sleep()
2. 初始化程序 init
通常，一个完整的类会包含初始化程序init，在创建对象的时候对类的一些属性进行初始化。
class cat {
var name: String
init(name: String) {
self.name = name // 使用self区别类的属性与参数标签
}
func eat() -> Void {
print("\(mycatname) is eating.")
}
func sleep() -> Void {
print("\(mycatname) is sleeping.")
}
}
var mycat = cat(name: "Jiaozi")
mycat.eat()
mycat.sleep()
3. 子类
子类可以继承父类的属性和方法，如果子类需要重写父类的方法，需要使用override关键字。
//父类NamedShape
class NameShape {
var numberOfSides: Int = 0
var name: String
init(name: String) {
self.name = name
}
func simpleDescription() -> String {
return "A shape with \(numberOfSides) sides."
}
}
// 子类Square
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()
4. 可选值与类和对象
我们可以在创建对象时，在类名后面加“?”，表示这个对象是一个可选值。也可以在对象、属性、方法后面加“?”，如果"?"之前的值为nil，则忽略“?”后面的内容并使整条表达式的值为nil；否则可选值被解包。
let optionalSquare: Square? = Square(sideLength: 2.5, name: "optional square")
let sideLength = optionalSquare?.sideLength
五、枚举和结构
Swift中，类、枚举也具有面向对象的特性，也可以包含方法。
1. 枚举
默认情况下枚举类型的原始类型为Int，原始值从0开始分配，每次递增1。但也可以显示指定枚举类型的值，同时还可以使用字符串或浮点数作为枚举的原始类型。
enum Rank: Int {
case ace = 1
case two, three, four, five, 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 //rawValue: 访问枚举实例的原始值
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()
六、协议和扩展
在Swift2.0引入对协议拓展的特性之后，苹果成Swift是一门“面向协议的编程语言”。
1. 协议
协议用于统一属性和方法的名称，没有具体的视线，在其他语言中通常叫做接口。一个类只能继承一个父类，但是可以遵循多个协议。
protocol ExampleProtocol {
var simpleDescription: String { get }
mutating func adjust() // 方法的声明需要使用mutating关键字
}
类、枚举、结构都可以遵守协议
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
默认情况下，枚举和结构的实例方法（init以外的方法）不可以修改属性的值。在使用mutating关键字后实例方法可修改属性的值。
2. 扩展
拓展用于向现有类型添加功能，例如新方法和计算属性。可以使用扩展将协议一致性添加到在别处声明的类型，甚至添加到从库或框架导入的类型。
extension Int: ExampleProtocol {
var simpleDescription: String {
return "The number \(self)"
}
mutating func adjust() {
self += 42
}
}
print(7.simpleDescription)
// Prints "The number 7"
七、错误处理
1. 错误的抛出
可以采用Error协议的类型来表示错误
enum PrintError: Error {
case outOfPaper
case noToner
case onFire
}
可以使用throw关键字来抛出错误，并使用throws标记可能抛出错误的函数。如果在函数中抛出错误，该函数将立即返回。
func send(job: Int, toProter printName: String) throws -> String {
if printerName == "Never Has Toner" {
throw PrinterErro.noToner
}
return "Job send"
}
2. 错误的处理
处理错误的一种方法是使用do-catch。do块中，需要在可能出错的代码之前加上try关键字；
catch块中，默认把错误命名为error，同时也允许我们自定义错误的名称。
do {
let printerResponse = try send(job: 1040, toPrinter: "Bi Sheng")
print(printerResponse)
} catch {
print(error)
}
//Prints "Job send"
每个catch可以处理特定的一个错误，可以使用多个catch来应对多个错误的情况。
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)
}
// Prints "Job sent"
处理错误的另一种方法是使用“try?”将结果转换为可选项。如果函数抛出错误，则丢弃特定错误，令结果为nil。否则，结果是一个包含函数返回值的可选项。
let printerSuccess = try? send(job: 1884, toPrinter: "Mergenthaler")
let printerFailure = try? send(job: 1885, toPrinter: "Never Has Toner")
八、泛型
泛型是 Swift 最强大的特性之一，Swift 标准库的大部分内容都是用泛型代码构建的。我们在尖括号内写一个名称以创建通用函数或类型。
func makeArray<Item>(repeating item: Item, numberOfTimes: Int) -> [Item] {
var result: [Item] = []
for _ in 0..<numberOfTimes {
result.append(item)
}
return result
}
makeArray(repeating: "knock", numberOfTimes: 4)