Swift 5.6 学习之旅

发表于

基本语法

1
print("Hello,world")

Note
声明的结尾不需要写分号

简单值

字段 含义 外延 用例
let 定义一个常量constant 在编译时不需要被知道
但必须精确的赋值一次

一次定义多次使用		 let myConstant = 42
var 定义一个变量variable var myVariable = 10
myVarible = 20

Type Infer: 类型推断

含义：编译器compiler会根据给定的值（constant、variable）自动推断value的类型。

1
2
let implicitInteger = 70 // 自动推断值是一个整型
let implicitDouble = 70.0 // 自动推断值是一个double类型

如何初始值没有提供足够的信息（或没有一个初始值），那么通过在变量后面写具体的类型类指定数据类型，中间用冒号分割。

1
let explicitDouble:Double = 79

值不会隐式转换为另一个类型，需要显式的创建一个类型的实例

1
2
3
let label = "The width is "
let width = 94
let widthLable = label + String(width)

移除String（），将会报错：
Binary operator ‘+’ cannot be applied to operands of type ‘String’ and ‘Int’

数字转字符串的写法总结

写法 用例
String（） let width = 98
let label = “The width is “
let width = label + String(width)
\ () let appples = 3
let appleSummary = “I have \ (apples) apples”

数组和字典

创建：使用方括号[]

1
2
3
4
5
var shoppingList = ["fish", "water", "vegitables"]
var occupations = [
	"Mal": "Caption",
  "Sel":"Machine",
]

创建空数组或字典

1
2
let emptyArray:[String] = []
let emptyDictionay: [String: Float] = [:]

访问：

  1. 使用index
  2. 使用key值
1
2
shoppingList[1] = "air"
occupations[Sel] = "Plbulic"

数组添加元素

数组会自动增长

1
shoppingList.append("blue paint")

流程控制

条件：if、switch

循环：for-in、while、repeat-while

条件和循环变量周围的圆括号可以省略，但body体周围的花括号是必须的

1
2
3
4
5
6
7
8
9
let individualScores = [56,59,60,34,12]
var teamScore = 0
for score in individualScores {
	if score > 50 {
		teamScore += 4
	} else {
		teamScore += 1
	}
}

if声明的注意事项

条件判断必须为一个布尔表达式，if score {…} 是错误的写法

if的其他用法：可选值?与??操作符

if和let一起表示值可能丢失

什么是可选值optional

value 可能有值也可以是nil

可选值写法：在一个类型后面加问号表示该值为可选值

1
var optionalString: String? = "Hello"
1
2
3
4
5
var optionalName: String? = "John Appleseed"
var greeting = "Hello!"
if let name = optionalName {
	greeting = "Hello, \(name)"
}

代码执行逻辑

  1. optionalName 为nil,条件为false, 花括号中的代码将被跳过。
  2. 否则，可选值将会被解包，分配给let后面的常量，此时解包的name值在代码块内可用。

处理可选值的方法？？操作符

??操作符

?? 用于提供默认值，如果可选值丢失，使用默认值代替

1
2
3
let nickname: String? = nil
let fullName: String = "John Appleseed"
let informalGreeting = "Hi \(nickname ?? fullName)"

Switch的用法

支持任何类型的数据和各种各样的比较操作符，不限于整数和相等性测试

1
2
3
4
5
6
7
8
9
10
11
let vegetable = "red pepper"
switch vegetable {
  case "celery":
  	print("Add some raisins and make ants on a log.")
  case "cucumber", "wattercress":
  	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.")
}

switch用法注意点：

  1. default 关键字是必须有的，因为switch循环需要穷尽所有情况；
  2. let能够被用在模式中匹配模式给一个常量
  3. 一旦case被匹配，执行将退出，不再执行下一个case，所以不需要break声明。

for-in

可用于通过key-value对遍历数组

特点

  1. 无序集合，所以键值遍历是任意的顺序
1
2
3
4
5
6
7
8
9
10
11
12
13
14
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)

“_”代码占位符

.. < 表示索引循环

1
2
3
4
5
var total = 0
for i in 0..< 4 {
  total += i
}
print(tatal)
符号 含义 示例
.. < 忽略大值 0..< 4
… 同时包含两个值 0…4

while

作用：while用于重复一段代码块直到条件改变。

条件在结尾：如果循环的条件放在结尾，那么会保证循环至少执行一次。

1
2
3
4
5
6
7
8
9
10
11
var n = 2
while n < 100 {
	n *= 2
}
print(n)

var m = 2
repeat {
	m *= 2
} while m < 100
print(m)

函数和闭包

函数

声明关键字 调用 分离参数名和返回值类型
func functionName(param1: “ab”, param2: “cd”) -> 
1
2
3
4
func greet(person:String, day: String) -> String {
	retrun "Hello \(person), today is \(day)."
}
greet(person: "Bob", day: "Tuesday")

标签名命名规则

Note

默认情况下使用参数名作为参数的标签名，但可以在参数名前面自定义标签名，或者写“_”表示没有标签名

1
2
3
4
func greet(_ person: String, on day: String) -> String {
	return "Hello \(person), today is \(day)."
}
greet("John", on: "Wednesday")

元组

作用 元组元素访问
组成复合值 通过名字或者索引数字 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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)
print(statistics.2)

嵌套函数

  1. 函数可以被嵌套
  2. 被嵌套的函数可以访问外部函数的变量
  3. 嵌套函数可以用来组织长函数或复杂函数
1
2
3
4
5
6
7
8
9
func returnFifteen() -> Int {
	var y = 10
  func add() {
    y += 5
  }
  add()
  return y
}
returnFifteen()

函数是一等公民

意味着函数可以返回一个函数作为它的值

1
2
3
4
5
6
7
8
func makeINcrementer() -> ((Int) -> Int) {
  func addOne(number: Int) -> Int {
    return 1 + number
  }
  return addOne
}
var increment = makeIncrementer()
increment(7)

函数作为函数的参数

1
2
3
4
5
6
7
8
9
10
11
12
13
func hasAnyMatches(list: [Int], condition: (Int)-> Bool) -> Bool {
  for item in list {
    if condition(item) {
      return ture
    }
  }
  return false
}
func lessThanTen(number: Int) -> Bool {
  return number < 10
}
var numbers = [20,19,17,2]
hasAnyMatches(list: numbers, condition:lessThanTen)

如何创建闭包

函数是一种特殊的闭包，如何创建没有名称的闭包

  1. 使用{}将没有名称的闭包括起来
  2. 使用in将函数和返回值与主体分开
1
2
3
4
number.map({(number: Int) -> Int in
	let result = 3 * number
  return result
})

闭包的简化写法1

当一个闭包的类型是已知的，那么可以省略闭包的参数类型或返回类型或者两者。只声明闭包并隐式的返回它的值。

1
2
let mappedNumbers = numbers.map({number in 3 * number})
print(mappedNumbers)

闭包的简化写法2

  • 可以通通过数字而不是名称引用参数
  • 当闭包是函数的唯一参数是，可以完全省略圆括号
1
2
let sortedNumbers = numbers.sorted { $0  > $1 }
print(sortedNumbers)

对象和类

如何声明一个类

  1. class关键字后面跟着一个类名
  2. 类中属性的声明与常量和变量的生命相同，只是作用域是在类中
  3. 类中方法、函数的声明也一样
1
2
3
4
5
6
class Shape {
  var numberOfSides = 0
  func simpleDescription() -> String {
    	return "A shape with \(numberOfSides) sides."
  }
}

如何创建一个实例

操作 方法
创建实例 类名后面跟着一个圆括号
如何调用实例的属性和方法 使用点语法 
1
2
3
var shape = Shape()
shape.numbersOfSides = 7
var shapeDescription = shape.simpleDescription()

创建一个带初始化器的实例

当实例创建的时候，初始化器被创建，使用init创建初始化器

1
2
3
4
5
6
7
8
9
10
11
12
class NamedShape {
  var numberOfSides: Int = 0
  var name: String
  
  init (name: String) {
    self.name = name
  }
  
  func simpleDescription() -> String {
    return "A shape with \(numberOfSides) sides."
  }
}

Note:

每一个属性都需要赋值，要么在声明中，如numberOfSides, 要么在初始化器中，如name

self用于区分属性名和传给初始化器的参数名

当创建类的实例的时候初始化器会想函数的参数一样被传递

deinit析构器

创建析构器，如果你需要在对象销毁的时候执行一些清理操作

如何包含父类

  • 在子类名称的后面包含父类名，以冒号区隔
  • 包含父类不是必须的，所以可以根据需要决定是否添加

关于子类方法的复写

  • 子类要复写父类方法，需要添加关键字override
  • 如果没有添加 override，会出现编译错误
  • 如果添加了override，也会出现编译错误
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class Square: NameShapre {
  var sideLength: Double
  
  init(sideLength: Double, name: String) {
    	self.sideLength = sideLength
      super.init(name:name)
    	numberOfSides = 4
  }
  
  func area() -> Double {
    	return sideLength * sideLenth
  }
  
  override func simpleDescription() -> String {
    return "A square with sides of length \(sideLeght)."
  }
}
let test = Square(sideLength: 5.2, name: "my test square")
test.area()
test.simpleDescription()

属性的getter和setter

除了简单的属性存储，属性能有getter和setter

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class EquilateralTriangle: NamedShape {
  init(sideLength: Double, name Stirng) {
    self.sideLength = sideLength
    super.init(name: name)
    numberOfSides = 3
  }
  var perimeter: Double {
      get {
        return 3.0 * sideLength
      }
      set {
        sideLength = newValue / 3.0
      }
   }
  override func simpleDescirption() -> String {
      return "An equilateral triangle with sides of length \(sideLength)."
  }
}
var triangle = EquilateralTriangle(sideLength: 3.1, name: "a triangle")
triangle.perimeter = 9.9
print(triangle.sideLength)

Note

  1. 对于perimeter的setter,有一个隐式的名称 newValue,你可以在set后面加圆括号提供一个名字
  2. 注意 EquilateralTriangle有3个不同的步骤：
    1. 设置子类声明的属性值
    2. 调用父类的初始化器
    3. 改变在父类定义的属性值。任何使用方法、getter或setter的附加设置工作也在这里完成。

属性的willSet和didSet

如果你不需要计算属性，但仍然需要在设置一个新值之前或之后提供代码，可以使用 willSet 和 didSet。

当值在初始化器之外变化是，就会运行你提高的代码。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class TriangleAndSquare {
  var triangle: EquilaterTriangle {
    willSet {
      square.sideLength = newValue.sideLength
    }
  }
  var square: Square {
    willSet {
      triangle.sideLength = newValue.sideLength
    }
  }
  init(size: Double, name: String) {
    square = Square(sideLength: size, name: name)
    triangle = EquilateralTriangle(sideLength: size, name: name)
  }
}
var triangleAndSquare = TriangleAndSquare(size: 100, name: "another test shape")
print(riangleAndSquare.square.sideLength)
print(riangleAndSquare.triangle.sideLength)
triangleAndSquare.square(sideLength: 50, name: "larger square")
print(triangleAndSquare.trianlge.sideLength)

可选值的使用与计算逻辑

当使用可选值时，你可以在方法、属性和下标操作前写 ？，如果 ？前面的值为nil，那么 ？后面的会被忽略，整个表达式的值为nil.否则，可选值被解包，获取解包值，在这种情况下，整个表达式的值是一个可选值。

1
2
let optionalSquare: Square? = Square(sideLength: 2.5, name：'optional square')
let sideLegnth = optionalSquare?.sideLength

枚举和结构体

如何创建一个枚举

使用 enum创建一个枚举，像类与其他命名类型一样，枚举有与他们相关联的方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
enum Rank: Int {
  case ace = 1
  case two, three, four, five, six, serven, eight, nine, ten
  case jack, queen, king
  
  func simepleDescirption() -> 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

Note
1.默认行的值从0开始，然后依次增长，但你能够通过复制改变。上面的例子ace被赋值为1，剩下的按递增顺序分配。

2.rawValue还可以是字符串或Float类型，此时每个case都需要声明，无法像数字一样按顺序增长

3.case的方法依然使用rawValue属性

4.注意一下，以上case, three的rawValue为3，jack的rawValue为11

枚举初始化器

使用init?(rawValue:)去从一个rawValue初始化实例。

  • 当rawValue匹配时返回一个枚举case
  • 当rawValue不匹配时，返回nil
1
2
3
if let convertedRank = Rank(rawValue: 11) {
  canvertedRank.simpleDescription()
}

枚举的rawValue不是必须的

枚举的case值是实际的值，并不是raw values的另一种写法，因此，在没有一个有意义的raw value的情况下，你可以不用提供。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
enum Suit {
  case spades, hearts, diamond, clubs
  
  func simpleDescription() -> String {
    switch self {
      case .spades: 
      	return "spades"
      case .hearts:
      	return "hearts"
      case .diamonds: 
      	return "diamond"
      case .clubs: 
      	return "clubs"
    }
  }
}
let hearts = Suit.hearts
let heartsDescripton = hearts.simpleDescription()

什么时候用省略形式

hearts常量的赋值使用的是全名Suit.hearts

但在switch内部，case使用的是简略形式.hearts,因为self与之相配

在其他任何时候，只要是指的类型是已知的，都可以使用缩略形式

实例决定的枚举值

如果枚举值有rawValues,这些值被决定作为声明的一部分，意味着每一个实例的某个case总有相同的枚举值。

另一种选择是让case和case的值相关联，这样值由实例决定，不同的实例它的case值是不同的。可以认为这些值是枚举实例的存储属性。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
enum ServerResponse {
  case result(String, String)
  case failure(String)
}

let success = ServerResponse.result("6:00 am", "8:09 pm")
let failure = ServerResponse.failure(Out of cheese.)

switch success {
  case let .result(sunrise, sunset):
  	print("Sunrise is at \(sunrise) and sunset is at \(sunset).")
  case let .failure(message):
  	print("Failure... \(message)")
}

结构体

struct关键字用于创建结构体，struct支持很多和类相同的行为，包含方法和初始化器。

structures 和 classes有什么不同

structures总是被copied

当类在代码中传递时，它传递的是引用

协议和扩展

使用protocol声明协议

1
2
3
4
protocol ExampleProtocol {
  var simpleDescription: String { get }
  mutating func adjust()
}

类、枚举、结构体都可以遵守协议

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
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 aDescirption = a.simpleDescription

struct SimpleStucture: ExampleProtocol {
  var simpleDescription: String = "A simple structure"
  mutating func adjust() {
    simpleDescription += " (adjusted)"
  }
}
var b = SimpleStructure()
b.adjust()
let bDescription = b.simpleDescription

Note

mutating关键字声明在struct 表示修改，在class中不用声明这个关键字，因为class中本来就可以修改。

extension关键字：拓展类型的功能

使用extension给已经存在的类型添加功能，例如一个新方法或者计算属性，可以使用extension添加协议一致性给在其他地方声明的类型，或一个库或框架中导入的类型。

1
2
3
4
5
6
7
8
9
extension Int: ExampleProtocol {
  var simpleDescription: String {
    retrun "The number \(self)"
  }
  mutating func adjust() {
    self +=42
  }
}
print(7.simpleDescription)

用协议声明的属性不能使用协议外定义的方法

你可以使用protocol想使用其他任何被命名的类型一样，例如，去创建一个有不同类型的集合对象，但是他们都遵守同一个协议。当处理类型为协议类型的值是，协议之外的方法不可用。

1
2
3
4
5
6
7
8
9
10
11
class SimpleClass: ExampleProtocol {
  var simpleDescription:String = "A very simple class."
  var anotherProperty: Int = 3455
  func adjust() {
    simpleDescription += " Now 100% ajusted."
  }
}
var a = SimpleClass()
let protocolValue: ExampleProtocol = a
print(protocolValue.simpleDescription)
// print(protocolValue.anotherProperty) // Uncomment to see error

Note
虽然protocolValue变量有一个运行时类型SimpleClass，但编译器处理它作为被给的类型ExmapleProtocol ,这意味着你不能方法协议之外，遵守该协议的类实现的属性或方法。

错误处理

错误的表示

使用遵守Error协议的任何类型表示错误

1
2
3
4
5
enum PrinterError: Error {
  case outOfPaper
  case noToner
  case onFire
}

定义一个可以抛出错误的函数

关键字 含义
throw 抛出一个错误
throws 定义一个可以抛出错误的函数

如果你在函数内抛出一个错误，函数会立即返回并调用处理函数错误的代码。

1
2
3
4
5
6
func send(job: Int, toPrinter printerName: String) throws -> String {
  if printerName == "Never Has Toner" {
    throw PrinterError.noToner
  }
  return "Job sent"
}

处理错误的方法：do-catch

do： 代码块内在一个能抛出错误的代码前面标记try

catch ：代码块内自动给一个error名字，你可以用一个不同的名字

1
2
3
4
5
6
do {
  let printerResponse = try send(job: 1040, toPrinter: "Never Has Toner")
  print(printerResponse)
} catch {
  print(error)
}

catch可以写多个用于处理具体的错误

catch之后写case和switch之后是一样的。

1
2
3
4
5
6
7
8
9
do {
  let printerResponse = try send(job: 111, toPrinter: "Tne")
} catch PrinterError.onFire {
  print("I'll just put this over here.")
} catch let printerError as PrinterError {
  print("Printer error: \(printerError).")
} catch {
  print(error)
}

错误处理方法try？

使用try？具体的错误将被放弃，并将返回nil

如果有值，则该值被返回

1
2
let printerSuccess = try? send(job:111, toPrinter: "Merge") // Job sent
let printerFalure = try? send(job:1993, toPrinter: "Never Has Toner")  // nil

defer的用法

defer的含义

见字如意，延迟代码执行，会在函数内的所有其他代码执行完成之后执行,因此可以将构建代码和清理代码写在一起，虽然他们会执行在不同的时间。

1
2
3
4
5
6
7
8
9
10
11
12
13
var fridgeOpen = false
let fridgeContent = ["milk","eggs","leftovers"]

func fridgeContains(_ food: String) -> Bool {
  defer {
    fridgeIsOpen = false
  }
  fridgeIsOpen = true
  let result = fridgeContent.contains(food)
  return result
}
fridgeContains("banana")
print(fridgeIsOpen)

泛型

如何定义一个泛型

: 在尖括号内一个名字，组成泛型函数或类型, name名字自定义

1
2
3
4
5
6
7
8
func makeArray<Item>(repeating item: Ele, numberOfTimes: Int) -> [Item] {
  var result: [Item] = []
  for _ in 0..<numberOfTimes {
    result.append(item)
  }
  return result
}
makeArray(repeating: "knock", numberOfTimes: 4)

函数function、方法method、类class、枚举enum、结构体struct都可以使用泛型

1
2
3
4
5
6
enum OptionalValue<Wrapped> {
  case none
  case some(Wrapped)
}
var possibleInteger: OptionalValue<Int> = .none
possbileInteger = .some("100")

where的用法

where可用于在body前面指定一些条件，比如实现一个protocal,要求两个类型相同，或者要求一个类有特殊的父类。

1
2
3
4
5
6
7
8
9
10
11
func anyCommonElements<T: Sequence, U: Sequence>(_ lhs: T, _ rhs: U) -> Bool 
where T.Element: Equatable, T.Element == U.Element{
  for lhsItem in lhs {
    for rhsItem in rhs {
      if lhsItem == rhsItem {
        return true
      }
    }
  }
  return false
}

Note
<T: Equatable> 与 … where T: Equatable是相同的。

大纲概览

Swfit5.6 a tour

reference
a swift tour