Swift5 基础教程与进阶合集
一. 属性
Swift中跟实例相关的属性可以分为两大类:
存储属性(Stored Property)：
- 类似于成员变量这个概念
- 存储在实例的内存中
- 结构体、类可以定义存储属性
- 枚举不可以定义存储属性
计算属性(Computed Property):
- 本质就是方法(函数)
- 不占用实例的内存
- 枚举、结构体、类都可以定义计算属性
struct Circle{
//存储属性
var radius: Double
//计算属性
var diameter: Double{
set {
radius = newValue/2
}get{
radius * 2
}
}
}
存储属性
关于存储属性，Swift有个明确的规定
在创建类或结构体的实例时，必须为所有的存储属性设置一个合适的初始值
- 可以在初始化器里为存储属性设置一个初始值
- 可以分配一个默认的属性值作为属性定义的一部分
计算属性
- set传入的新值默认叫做newValue，也可以自定义
struct Circle{
var radius: Double
var diameter: Double{
set (newDiamater){
radius = newDiamater/2
}get{
radius * 2
}
}
}
- 定义计算属性只能用var，不能用let
let代表常量：值是一成不变的
计算属性的值是可能发生变化的(即使是只读计算属性)
- 只读计算属性：只有get，没有set
struct Circle{
var radius: Double
var diameter: Double{
get{
radius * 2
}
}
}
//只有get的话可以省略get关键字
struct Circle{
var radius: Double
var diameter: Double{
radius * 2
}
}
枚举rawValue的原理
枚举原始值rawValue的本质是：只读计算属性
enum TestEnum : Int {
case test1 = 1,test2,test3
//这里对rawValue进行了重写
var rawValue: Int{
switch self {
case .test1:
return 10
case .test2:
return 11
case .test3:
return 12
}
}
}
print(TestEnum.test3.rawValue)//12
延迟存储属性(Lazy Stored Property)
使用lazy可以定义一个延迟存储属性，在第一次用到属性的时候才会进行初始化
- lazy属性必须是var，不能是let，因为let必须在实例的初始化方法完成之前就拥有值
- 如果多条线程同时第一次访问lazy属性，无法保证属性只被初始化一次
class Car{
init() {
print("Car init")
}
func run() {
print("Car is running")
}
}
class Person{
lazy var car = Car()
init() {
print("Person init")
}
func goOut() {
car.run()
}
}
let p = Person()
p.goOut()
//打印结果
//Person init
//Car init
//Car is running
当结构体包含一个延迟存储属性时，只有var才能访问延迟存储属性。因为延迟属性初始化时需要改变结构体的内存
struct Point{
var x = 0
var y = 0
lazy var z = 0
}
//let的p无法访问到延迟存储属性
//let p = Point()
//print(p.z)
var p = Point()
print(p.z)//0
属性观察器
可以为非lazy的var存储属性设置属性观察器
struct Circle{
var radius: Double{
willSet{
print("willSet",newValue)
}
didSet{
print("didSet",oldValue)
}
}
init() {
radius = 1.0
print("Circle init")
}
}
var circle = Circle()
circle.radius = 2.5
print(circle.radius)
//打印结果
//Circle init
//willSet 2.5
//didSet 1.0
//2.5
- willSet会传递新值，默认叫newValue，也可以自定义
- didSet会传递旧值，默认叫oldValue，也可以自定义
- 在初始化器中设置属性值不会触发willSet和didSet
- 在属性定义时设置初始值也不会触发willSet和didSet
全局变量、局部变量
属性观察期、计算属性的功能，同样可以应用在全局变量、局部变量上
//全局计算属性
var num: Int{
get{
10
}
set{
print("setNum",newValue)
}
}
num = 22//setNum 22
print(num)//10 由于计算属性不具有存储功能，之前设置的值没有保存，所以还是直接拿的get返回的值
func test(){
var age = 10{
willSet{
print("willSet",newValue)
} didSet{
print("didSet",oldValue)
}
}
age = 11
}
test()
//willSet 11
//didSet 10
inout的再次研究
struct Shape{
var width: Int
var side: Int{
willSet{
print("willSetSide",newValue)
}didSet{
print("didSetSide",oldValue,side)
}
}
var girth: Int{
set {
width = newValue/side
print("setGirth",newValue)
}
get{
print("getGirth")
return width*side
}
}
func show() {
print("width=\(width),side=\(side),girth=\(girth)")
}
}
func test(_ num: inout Int){
num = 20
}
var s = Shape(width: 10, side: 4)
test(&s.width)
s.show()
print("-----------")
test(&s.side)
s.show()
print("-----------")
test(&s.girth)
s.show()
//打印结果
//getGirth
//width=20,side=4,girth=80
//-----------
//willSetSide 20
//didSetSide 4 20
//getGirth
//width=20,side=20,girth=400
//-----------
//getGirth
//setGirth 20
//getGirth
//width=1,side=20,girth=20
inout的本质总结：
- 如果实参有物理内存地址，且没有设置属性观察值，直接将实参的内存地址传入函数(实参进行引用传递)
- 如果实参是计算属性或者设置了属性观察值，采用了Copy In Copy Out的做法，即：
1.调用该函数时，先复制实参的值，产生副本(get)
2.将副本的内存地址传入函数(副本进行引用传递)，在函数内部可以修改副本的值
3.函数返回后，再将副本的值覆盖实参的值(set)
总结：inout的本质就是引用传递(地址传递)
类型属性(Type Property)
严格来说，属性可以分为：
实例属性(Instance Property):只能通过实例去访问
存储实例属性(Stored Instance Property):存储在实例的内存中，每个实例都有1份
计算实例属性(Computed Instance Property)类型属性(Type Property):只能通过类型去访问
存储类型属性(Stored Type Property):整个程序运行过程中，就只有1份内存(类似于全局变量)
计算类型属性(Computed Type Property)
可以通过static定义类型属性，如果是类，也可以用关键字class
struct Car{
static var count: Int = 0
init() {
Car.count += 1
}
}
let c1 = Car()
let c2 = Car()
let c3 = Car()
print(Car.count)//3
类型属性细节：
- 不同于存储实例属性，必须给存储类型属性设置初始值，因为类型没有像实例那样的init初始化器来初始化存储属性
- 存储类型属性默认就是lazy，会在第一次使用的时候才初始化，就算被多个线程同时访问，保证只会初始化一次；存储类型属性可以是let
- 枚举类型也可以定义类型属性(存储类型属性、计算类型属性)
单例模式
public class FileManager{
public static let shared = FileManager()
private init(){}
}
public class FileManager{
public static let shared = {
FileManager()
}()
private init(){}
}
二.方法
方法(Method)
- 枚举、结构体、类都可以定义实例方法、类型方法
- 实例方法(Instance Method):通过实例对象调用
- 类型方法(Type Method):通过类型调用，用static或者class关键字定义
struct Car{
static var count: Int = 0
init() {
Car.count += 1
}
//大括号中的count等价于self.count,Car.self.count,Car.count
static func getCount() -> Int { count }
}
let c1 = Car()
let c2 = Car()
let c3 = Car()
print(Car.getCount())//3
self:
- 在实例方法中代表实例对象
- 在类型方法中代表类型
mutating
结构体和枚举是值类型，默认情况下，值类型的属性不能被自身的实例方法修改
在func关键字前面加mutating可以允许这种修改行为
struct Point{
var x = 0.0
var y = 0.0
mutating func moveBy(deltaX: Double,deletaY: Double){
x += deltaX
y += deletaY
}
}
enum StateSwitch{
case low,middle,high
mutating func next(){
switch self {
case .low:
self = .middle
case .middle:
self = .high
case .high:
self = .low
}
}
}
@discardableResult
在func前面加个@discardableResult，可以消除：函数调用后返回值未被使用的警告
struct Point{
var x = 0.0
var y = 0.0
@discardableResult mutating func moveBy(deltaX: Double,deletaY: Double) -> Point{
x += deltaX
y += deletaY
return self
}
}
var p = Point()
p.moveBy(deltaX: 0.4, deletaY: 0.7)
@discardableResult func get() -> Int{
return 10
}
get()
三. 下标
下标(subscript)
使用subscript可以给任意类型(枚举、结构体、类)增加下标功能，有些地方也翻译为：下标脚本
subscript的语法类似于实例方法、计算属性，本质就是方法（函数）
class Point{
var x = 0.0
var y = 0.0
subscript(index: Int) -> Double{
set {
if index == 0 {
x = newValue
} else if index == 1 {
y = newValue
}
}
get{
if index == 0 {
return x
} else if index == 1 {
return y
}
return 0
}
}
}
var p = Point()
p[0] = 1.1
p[1] = 2.2
print("p.x=\(p.x),p.y=\(p.y),p[0]=\(p[0]),p[1]=\(p[1])")
//打印结果
//p.x=1.1,p.y=2.2,p[0]=1.1,p[1]=2.2
- subscript中定义的返回值类型决定了
get方法的返回值类型
set方法中newValue的类型
subscript可以接受多个参数，并且类型任意
subscript可以没有set方法，但必须有get方法，如果只有get方法，可以省略get
class Point{
var x = 0.0
var y = 0.0
subscript(index: Int) -> Double{
if index == 0 {
return x
} else if index == 1 {
return y
}
return 0
}
}
- 可以设置参数标签
class Point{
var x = 0.0
var y = 0.0
subscript(index i: Int) -> Double{
if i == 0 {
return x
} else if i == 1 {
return y
}
return 0
}
}
var p = Point()
p.y = 2.2
print(p[index: 1])//2.2
- 下标可以是类型方法
class Sum{
static subscript(v1: Int,v2: Int) -> Int{
v1 + v2
}
}
print(Sum[10,20])//30
结构体、类作为返回值
class Point{
var x = 0.0
var y = 0.0
}
class PointManager {
var point = Point()
subscript(index: Int) -> Point{
point
}
}
var pm = PointManager()
pm[0].x = 11
pm[0].y = 22
print(pm[0])//__lldb_expr_26.Point
print(pm.point)//__lldb_expr_26.Point
struct Point{
var x = 0.0
var y = 0.0
}
class PointManager {
var point = Point()
subscript(index: Int) -> Point{
set { point = newValue }
get { point }
}
}
var pm = PointManager()
pm[0].x = 11
pm[0].y = 22
print(pm[0])//Point(x: 11.0, y: 22.0)
print(pm.point)//Point(x: 11.0, y: 22.0)
接收多个参数的下标
class Grid{
var data = [
[0,1,2],
[3,4,5],
[6,7,8]
]
subscript(row: Int, column: Int) -> Int{
set{
guard row >= 0 && row < 3 && column >= 0 && column < 3 else {
return
}
data[row][column] = newValue
} get {
guard row >= 0 && row < 3 && column >= 0 && column < 3 else {
return 0
}
return data[row][column]
}
}
}
var grid = Grid()
grid[0,1] = 77
grid[1,2] = 88
grid[2,0] = 99
print(grid.data)//[[0, 77, 2], [3, 4, 88], [99, 7, 8]]