Swift

2021-10-31  本文已影响0人  想成为大牛的程旭元 
sizeof 不是函数，在汇编里面，没有掉callq
类型分类.png

@inline

内联-1.png 内联-2.png 内联-3.png

@inout

inout-1.png inout-3.png 可选绑定-1.png

空合并运算符 ??

空运算符-1.png 空运算符-2.png

guard语句

guard-1.png

隐式解包

隐式解包-1.png

enum

enum  TestEnum{
    case test1(Int,Int,Int)
    case test2(Int,Int)
    case test3(Int)
    case test4(Bool)
    case test5
}
var e = TestEnum(10,20,30);

mov $0xa, 0x4eb(%rip), //  rip存储的地址就是 0x4bdf
leaq 0x4bdf(%rip)

结构体和类区别

class Size{
 var width = 1;
  var height = 2;
}
var size = Size();
size是指针，放在内存的栈空间，占8个字节
size指针变量地址，在堆空间，Size对象的内存地址 ，占32个字节，看堆空间的绿色一共4个，4*8=32
1.png

图中蓝色和绿色 内存数据那块，一格表示8个字节。

对象堆空间申请内存过程

对象堆空间申请内存过程.png 值类型.png

闭包

闭包.png 闭包2.png 闭包3.png

全局变量

全局变量.png

闭包：函数+捕获的变量。

闭包-4.png
自动闭包
自动闭包.png ??运算符.png
属性
属性-1.png 存储属性.png

计算属性

计算属性.png
枚举
枚举.png

枚举变量占一个字节来存储对应的case。
那么原始值存储在哪？

延迟存储属性lazy

lazy.png lazy-2.png 延迟属性的特点-1.png

属性观察器

属性观察器-1.png 属性观察器-2.png 全局变量和局部变量.png
inout在各个属性之间的地址取值
代码-2.png 代码-3.png
存储属性 
test(&s.width)

计算属性

test(&s.girth)

属性观察器

test(&s.side)
inout总结
inout总结.png
类型属性
类型属性.png 类型属性-count.png
类型属性细节
类型属性细节.png

单例模式

单例.png 
class Car{
    static var count = 1;
}
Car.count = 11;

dispatch_once({
     Car.count = 1;
})

方法

方法.png self.png

mutating

mutating.png

discardableResult

discardableResult.png

下标--subscript

下标.png 下标-2.png

下标细节

细节-1.png 细节-2.png

结构体和类作为下标返回值区别

区别.png 
pm[0].x = 11;
等价于
pm[0].x = Point(x:11,y:pm[0].y);

pm[0].x = 掉的是set方法


pm[0].x = 11;

接收多个参数的下标

接收多个参数的下标.png 接收多个参数的下标-1.png
重写类型方法、下标
重写类型方法、下标.png 1.png 2.png 
var subCircle = SubCircle()
subCircle.radius = 10;
打印的结果为
SubCircle getRaius
Circle getRaius
SubCircle setRaius

从父类继承过来的存储属性，都是有存储空间的。不管要不要写成计算属性

重写实例属性
重写属性.png
重写类型属性
重写类型属性.png

属性观察器

属性观察器.png

打印的结果为 Circle getRadius 是 oldValue，因为在赋值之前，要拿到对应的值

final

final.png

结构体不存在继承，所以不存在重写，在编译阶段就把函数地址、属性写死了。

初始化器

初始化器.png

初始化器相互调用

初始化器相互调用.png

2段式初始化

2段式初始化.png
安全检查
安全检查.png 1.png 2.png

重写

重写第一条的解释.png 重写第二条的解释-1.png 重写第二条的解释-2.png
自动继承
自动继承.png 第一条规则的解释.png 第二条规则的解释.png

required

required.png

属性观察器

属性观察器.png

可失败初始化器

可失败初始化器.png

反初始化器 deinit

deinit.png

可选链 Opitional Chaining

可选链 .png

协议 Protocol

协议1.png 协议2.png

static class

static-class.png init-2.png

init 、init?、init!

init 、init?、init!.png 协议2.png 协议3.png

CaseIterable

CaseIterable.png

CustomStringConvertible CustomDebugStringConvertible

CustomDebugStringConvertible.png

Any AnyObject

Any AnyObject.png

**is as? as! as **


is as? as! as.png

X.self、X.Type、AnyClass

Person.self 放元类地址
跟person对象的前8个字节存储的地址一样
1.png

元类型的使用

元类型的使用.png

继承

继承.png
继承2.png

Self

Self-2.png 4句都调用了init.png
error 错误类型
开发错误.png
自定义错误
自定义错误-1.png
do-catch
do-catch.png

处理Error

处理Error.png 代码.png

try? try!

try? try!.png

rethrows

rethrows.png

defer

defer.png
泛型
泛型-1.png

泛型属性

泛型属性.png
关联类型(Associated Type)
关联类型.png
类型约束
类型约束-1.png 类型约束-2.png equal.png

协议类型的注意点

协议类型的注意点.png

泛型解决一

解决一.png
泛型解决二---不透明类型(Opaque Type) some-2.png

assert断言

assert.png

fatalError

fatalError.png
访问控制Access Control
class Person{
    public var name = ""
}
模块.png 
open class Person{
    open var name = ""
}

class Person{
    private var name = ""
}
访问控制.png
访问级别的访问准则
1.png 变量类型>= 变量的访问级别.png 父类型>=typealias.png 原始值类型.png 定义A类型.png
元组类型
元组类型.png
泛型类型
泛型类型.png
成员、嵌套类型
成员、嵌套类型.png 1.png 4.png

直接在全局作用域下定义的private等价于fileprivate

重点

5.png

问Person里面的dog.run()为啥不报错

6.png
getter setter
getter setter.png
初始化器
初始化器.png 结构体.png
枚举
枚举.png
协议
协议.png 
定义协议的访问级别  private
private protocol A{
      run()
}
class Person:A{
    实现协议的访问级别 public
    public run(){}
}
扩展
扩展.png 扩展1.png 第四条解释.png
扩展2
扩展2.png
将方法赋值给var/let
struct Person {
  var age:Int
  func run(_ v:Int){ print ("func run",age,v)}
  static func run(_ v:Int){ print ("static func run",v)}
}
let fn1 = Person.run;
fn1(10);  //static func run 10

let fn2:(Int)->() = Person.run;
fn2(20);  //static func run 20
将方法赋值给var、let-4.png

内存管理

内存管理.png 内存管理-2.png

自动释放池

自动释放池.png

循环引用

循环引用-1.png

闭包循环引用

闭包循环引用.png 闭包循环引用.png 闭包循环引用2.png 闭包循环引用3.png
@escaping
escaping.png
逃逸闭包注意点2
逃逸闭包.png
do
do.png

内存访问冲突(Conflicting Access to Memory)

内存访问冲突.png 内存访问冲突-2.png

指针

指针.png 代码-2.png
指针使用场景
指针使用场景-1.png

获得指向某个变量的指针

获得指向某个变量的指针.png

获得指向堆空间实例的指针

获得指向堆空间实例的指针.png 获得person的指针.png

创建指针

创建指针.png 创建指针-2.png 创建指针-3.png 创建指针-4.png 创建指针-5.png

指针转换

指针转换-1.png 指针转换-2.png

字面量(Literal)

字面量.png

字面量协议

字面量协议.png

字面量协议应用

字面量协议应用.png

模式匹配

通配符
通配符-规则.png 通配符--代码.png
标识符模式
标识符模式.png
值绑定模式
值绑定模式.png
元组模式
元组模式.png
枚举case模式
枚举case模式.png
可选模式
可选模式.png
类型转换模式
类型转换模式.png
自定义模式
自定义模式.png
自定义模式表达式
自定义模式表达式.png
where用处
where.png

OC到Swift

标记
标记.png
编译条件
编译条件--1.png 编译条件--2.png
系统版本检查
系统版本检查.png
API可用性
API可用性.png

Swift掉OC

Swift掉OC--1.png person.h.png person.m.png
Swift调用.png

Swift掉OC --- @silgen_name

Swift掉OC --- @silgen_name.png

OC掉Swift

OC掉Swift .png OC掉Swift -代码.png OC掉Swift-@objc.png

选择器Selector

选择器Selector.png

1. 为啥Swift暴露给OC的类最终要继承NSObject？

Call 0x0xxxx 找这个地址

下面的类里run怎么走？

Swift类.png

String

字符串一.png 插入和删除.png

Substring

Substring.png substring流程.png Substring.png

String相关协议

String相关协议.png 多行String.png
String和NSString
String和NSString.png
Swift和OC桥接转换表
Swift和OC桥接转换表.png

只能被class继承的协议

协议--1.png 协议--2.png

dynamic

dynamic.png

KVC、KVO

KVC、KVO.png

block版本的KVO

block版本的KVO.png

关联对象

关联对象.png

资源名管理

资源名管理-1.png 资源名管理-2.png

资源名管理的其他思路

资源名管理的其他思路.png

多线程开发---异步

多线程开发---异步.png

数组操作map

数组操作filter---过滤

数组操作reduce

reduce.png 截屏2021-10-25 下午2.13.47.png

map和flatmap区别

let array = ["Apple", "Orange", "Puple", ""]

let arr1 = array.map { a -> Int? in
    let length = a.characters.count
    guard length > 0 else { return nil }
    return length  
}
arr1 // [{some 5}, {some 6}, {some 5}, nil]

let arr2 = array.flatMap { a-> Int? in
    let length = a.characters.count
    guard length > 0 else { return nil}
    return length    
}    
arr2 // [5, 6, 5]

let array = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

let arr1 = array.map{ $0 }
arr1 // [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

let arr2 = array.flatMap{ $0 }
arr2 // [1, 2, 3, 4, 5, 6, 7, 8, 9]

let fruits = ["Apple", "Orange", "Puple"]
let counts = [2, 3, 5]

let array = counts.flatMap { count in
    fruits.map ({ fruit in
         return fruit + "  \(count)"            
    })   
}
array // ["Apple 2", "Orange 2", "Puple 2", "Apple 3", "Orange 3", "Puple 3", "Apple 5", "Orange 5", "Puple 5"]

compactMap

let arrayString = ["Ann", "Bob", "Tom", "Lily", "HanMeiMei", "Jerry"]
        let arrayInt = arrayString.compactMap { (str) -> Int? in
            return str.count
        }
        print("arrayInt: \(arrayInt)")
        // arrayInt: [3, 3, 3, 4, 9, 5]
        
        // 简化
        let arrayInt2 = arrayString.compactMap { $0.count }
        print("arrayInt2: \(arrayInt2)")
        // arrayInt2: [3, 3, 3, 4, 9, 5]
        
        let arrayI = arrayString.compactMap { $0.contains("i") ? $0 : nil }
        print("arrayI: \(arrayI)")
        // arrayI: ["Lily", "HanMeiMei"]

lazy的优化

lazy的优化.png lazy的优化-2.png

option的Map和flatMap区别

option的Map和flatMap区别.png
option的Map

高阶函数

高阶函数.png

柯里化Currying

柯里化.png

函子(Functor)

函子-1.png 函子-2.png

适用函子(Applicative Functor)

适用函子--1.png 适用函子--2.png

单子(Monad)

单子.png

面向协议编程

面向协议编程-1.png

OOP

OOP.png

OOP不足

OOP不足.png

POP解决方案上面不足

POP解决方案-1.png

POP注意点

POP注意点.png

计算属性

利用协议实现前缀

利用协议实现前缀-1.png Base代码.png

Base协议

利用协议判断类型

利用协议判断类型--1.png

响应式编程

响应式编程.png

RXSwift

RXSwift.png

RXSwift核心角色

RXSwift核心角色--总览.png
创建、订阅Observable1
创建、订阅Observable1.png 
Observable.just(1111)
等同于
// 发送消息
observable.onNext(22222)

// 发送多个消息，然后接收方 接收3次
Observable.of([1,2,3])
//  发送多个消息，然后接收方 接收3次
Observable.from([1,2,3])
Observable.of和Observable.from打印结果.png
创建、订阅Observable2
创建、订阅Observable2.png

Disposables

Disposables.png

创建Observer

创建Observer.png

扩展Binder属性

RXSwift的状态监听1

RXSwift的状态监听1.png

RXSwift的状态监听2

RXSwift的状态监听2.png

即是Obeservale又是Obeserver

1.png 即是Obeservale又是Obeserver.png

Swift源码

Swift源码简介-1.png
Swift源码地址.png

Array源码分析

map源码
map源码.png
filter源码
filter源码.png

flatMap compactMap reduce

flatMap

flatMap.png

compactMap

compactMap.png

Substring

Substring--1.png Substring--2.png Substring.png

Substring的append方法

Substring的append方法.png

Opition的map和flatMap源码

flatMap

flatMap.png

map

map.png

区别

Opition的==号

==代码1.png 
var age :Int? = 10
print(age == nil)

会触发上面的==代码

var age :Int? = 10
print(nil == age)

会触发下面的代码

==比较2个正常的值

==比较2个有值.png 
var age1 :Int??? = 10
var age2 :Int? = 10
var age3 :Int = 10

print(age1 == age3)
print(age1 == age2)
print(age2 == age3)

Opition的？？号 源码

var age1 :Int? = 10
var age2:Int? = 10
print(age1 ?? age2)
??代码1.png ??代码2.png

Metadata分析

class Person{}
var person  =  Person()

Metadata

Metadata--类型.png

ClassMetadata

class-metadata结构.png

反射

反射.png

关于Sting的考虑

关于Sting的考虑.png 
var str1 = "0123456789"
str1内存打印结果.png 
var str2 = '01234567890ABCDEF'
打印地址.png 
字符串真实地址 + 0x7fffffffffffffe0 = 0x800000010000a790
也可以
字符串真实地址 + 0x20 = 0x800000010000a790

字符串拼接 append

从编码到启动App

从编码到启动App.png

字符串拼接

字符串拼接.png 
str2 append之前后8个字节地址值 + 0x20 = 拼接后字符串地址值
字符串探讨.png

dyld_stud_bind 符号绑定

App加载流程.png mac-o加载.png 
var str1 = "0123456789"

str1.append('ABCDEF');
append调用可String.init()函数。

rip = 0x1000a3ce + 6 = 0x100000A3D4  
0x100000A3D4 + 0x2c4c = 0x100000D020

取出的地址：0x0100000A5F4

Array 值类型

var arr = [1,2,3,4]
Array的结构图.png

可选项本质

enum.png 
var age:Int? = 10
switch age {
    case let v:{
        print(v)
}

溢出运算符(OverFlow Operator)

var v1 =   UInt8.max;
v2 = v1.&+1;  
print(v2)  // 0


var v1 =   UInt8.min;
v2 = v1.&-1;  
print(v2)  // 255


var v1 =   UInt8.max;
v2 = v1.&*2;    == 255 &+255 

// 因为 255 &+1 = 0    255 &+2 = 1    ... 所以为254
print(v2)  // 254
溢出运算符-2.png

运算符重载(Operator Overload)

运算符重载.png 
++a;

a++;

Equatable

Equatable.png 
func equals <T:Equatable> (_ t1:T, _t2:T) ->Bool{ t1 == t2}

Comparable

Comparable--代码1.png Comparable--代码2.png

自定义运算符(Custom Operator)

自定义运算符-说明.png 
class Person{
      var age = 0
}
func getAge() -> Int{ 10 }
var p:Person = Person();
p?.age = getAge()

赋值优先级，上面代码 p? 要是p有值，getAge()计算出结果，才会赋值给age，如果p为nil，那么就不会赋值

associativity：结合性，

associativity.png

扩展(Extension)

扩展.png

协议、初始化器

协议、初始化器.png

上面最后一条解释 ---- 类实现required

上面最后一条解释.png

协议

协议1.png 协议2.png

泛型

泛型.png
上一篇 下一篇

猜你喜欢

热点阅读