2021年iOS基础知识汇总-初步学习篇

agan11423

已于 2022-03-05 10:51:54 修改

阅读量445

点赞数 1

分类专栏： swift OC 文章标签： ios objective-c 开发语言

于 2021-03-23 10:39:54 首次发布

本文链接：https://blog.csdn.net/u014275966/article/details/115111974

版权

OC 同时被 2 个专栏收录

5 篇文章 0 订阅

订阅专栏

swift

4 篇文章 0 订阅

订阅专栏

Category类

struct category_t {
    const char *name;
    classref_t cls;
    struct method_list_t *instanceMethods;
    struct method_list_t *classMethods;
    struct protocol_list_t *protocols;
    struct property_list_t *instanceProperties;
    // Fields below this point are not always present on disk.
    struct property_list_t *_classProperties;

    method_list_t *methodsForMeta(bool isMeta) {
        if (isMeta) return classMethods;
        else return instanceMethods;
    }

    property_list_t *propertiesForMeta(bool isMeta, struct header_info *hi);
};

OC的类信息存放在哪里？

对象方法、属性、成员变量、协议信息，存放在class对象中

类方法，存放在meta-class对象中

成员变量的具体值，存放在instance对象
对象的isa指针指向哪里？

instance对象的isa指针指向class对象

class对象的isa指针指向meta-class对象

meta-class对象的isa指针指向基类的meta-class对象
如何扩大button的点击面积

runtime 消息转发机制（最详细流程）

// 动态解析
+ (BOOL)resolveInstanceMethod:(SEL)sel {
//    NSLog(@"动态方法解析");
//    NSString *methodName = NSStringFromSelector(sel);
//
//    if ([methodName isEqualToString:@"callMyName:"]) {
//        return class_addMethod(self, sel, (IMP)callMyName, "v@:@");
//    }
//
    return NO;
}

- (id)forwardingTargetForSelector:(SEL)aSelector {
//    NSString *methodName = NSStringFromSelector(aSelector);
//    if ([methodName isEqualToString:@"sendMessage:"]) {
//        return [Animal new];
//    }
    
    return [super forwardingTargetForSelector:aSelector];
}

- (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector {
    NSString *methodName = NSStringFromSelector(aSelector);
    if ([methodName isEqualToString:@"sendMessage:"]) {
        return [NSMethodSignature signatureWithObjCTypes:"v@:@"];
    }
    return [super methodSignatureForSelector:aSelector];
}

- (void)forwardInvocation:(NSInvocation *)anInvocation{
    SEL sel = anInvocation.selector;
    Animal *child = [Animal new];
    if ([child respondsToSelector:sel]) {
        [anInvocation invokeWithTarget:child];
    }else {
        [super forwardInvocation:anInvocation];
    }

}

- (void)doesNotRecognizeSelector:(SEL)aSelector {
    NSLog(@"最终并未识别");
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ylVYpA0k-1616467169065)(/Users/ibrotherliyanbing/Library/Application Support/typora-user-images/image-20210323092843103.png)]

Swift的语言优势

https://zhuanlan.zhihu.com/p/21755854

Swift 是一个多范式（Multi-paradigm）的编程语言。它基本涵盖了函数式编程（Functional Programming）语言和面向对象编程语言的所有特性。可以进行函数式编程，或者 Protocol-Oriented Programming 等，而不局限于某种特定编程的范式。

基本的现代化语言特性
- 简洁的 class、extension 和 property 定义方式。 OC 定义一个 class 至少需要 4 行，而 swift 只需要两行。新建类的成本大大降低，可以避免因为书写成本高而没有使用类的情况，而此时新建类通常使代码更加整洁。
- 命名空间。基于 module (Xcode target) 的命名空间，避免使用类前缀来防止命名冲突这种原始的方式。
- 函数重载。避免了 numberWithInteger: numberWithDouble 这么啰嗦的命名了。所以 Swift 版的 Masonry 的 equalTo 方法可以传对象和也可以传基本类型，而不需要使用宏。
- override 修饰符。避免了无意间重写父类方法。
- Tuple（元组）。低成本且使用方便的数据集合。它提供了函数多个返回值功能。
- nested functions。在函数里面定义函数，直接在语法上限定只在局部使用的函数，使代码更清晰简洁。（虽然 OC 能使用 block 来代替实现，但写起来好难看）
- 简洁的闭包写法。{ a in … } 比 C/OC 中丑陋的 block 写法好很多。
- 运算符重载。例如我们定义了一个<|> 运算符，它的输入时两个函数使得 ( f <|> g )(x) 等同于 f(g(x)) 这样多重的嵌套 f(g(h(x))) ，就可以写成 (f<|>g<|>h)(z) 这样的线性表达式了。
- 不用写分号！
kvo原理图

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VqgTkm3e-1616467169068)(/Users/ibrotherliyanbing/Library/Application Support/typora-user-images/image-20210321103816100.png)]

多线程问题

死锁发生条件：当前串行队列添加同步任务

条件：当前、同步、串行不满足不会死锁

下文中的queue.sync就属于1线程中，然后在开同步，这么会导致sync死锁，修改方式是修改为并行队列

func gcdTest() {
    print("=================")
//    self.perform(#selector(self.pri), with: nil, afterDelay: 1.0)
    let queue = DispatchQueue(label: "serial")
    queue.async {
      print(Thread.current)
      print(1)
//      self.perform(#selector(self.pri), with: nil, afterDelay: 1.0)
//      self.perform(#selector(self.pri))
//      RunLoop.current.run()
      queue.sync {
        print(2)
      }
      print(3)
    }
    print(4)

  }

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8aGLv1ev-1616467169076)(/Users/ibrotherliyanbing/Library/Application Support/typora-user-images/image-20210321184908724.png)]

iOS 主队列同步造成死锁的原因

如果在主线程中运用主队列同步，也就是把任务放到了主线程的队列中。
而同步对于任务是立刻执行的，那么当把第一个任务放进主队列时，它就会立马执行。
可是主线程现在正在处理 syncMain 方法，任务需要等 syncMain 执行完才能执行。
syncMain 执行到第一个任务的时候，又要等第一个任务执行完才能往下执行第二个和第三个任务。
这样 syncMain 方法和第一个任务就开始了互相等待，形成了死锁。

iOS存储

1、Documents 目录：您应该将所有的应用程序数据文件写入到这个目录下。这个目录用于存储用户数据。该路径可通过配置实现iTunes共享文件。可被iTunes备份。

2、AppName.app 目录：这是应用程序的程序包目录，包含应用程序的本身。由于应用程序必须经过签名，所以您在运行时不能对这个目录中的内容进行修改，否则可能会使应用程序无法启动。

3、Library 目录：这个目录下有两个子目录：
Preferences 目录：包含应用程序的偏好设置文件。您不应该直接创建偏好设置文件，而是应该使用NSUserDefaults类来取得和设置应用程序的偏好.
Caches 目录：用于存放应用程序专用的支持文件，保存应用程序再次启动过程中需要的信息。
可创建子文件夹。可以用来放置您希望被备份但不希望被用户看到的数据。该路径下的文件夹，除Caches以外，都会被iTunes备份。

4、tmp 目录：这个目录用于存放临时文件，保存应用程序再次启动过程中不需要的信息。该路径下的文件不会被iTunes备份。
KVO的实现原理

在KVO_MyObject类中，重写了一些方法，举例如
- setter方法：在重写的setter方法中调用了willChangeValueForKey:方法和didChangeValueForKey:方法，在这两个方法中则会调用observeValueForKeyPath:ofObject:change:context方法，这个方法就是接受通知的回调方法。
- class方法：重写的class方法返回的是MyObject类对象而不是KVO_MyObject类对象，其目的是欺骗使用者。
Runtime 消息转发

meta-class是类对象的类，每个类都有自己单独的meta-class。所有的类对象并不会属于同一个meta-class。
meta-class要保证类对象具有继承体系中基类的所有实例和类方法，以及继承体系中的所有中间类方法。对于所有NSObject继承体系下的类，NSObject的实例方法和协议方法对他们和他们meta-class的对象都要有效。
所有的meta-class使用基类的meta-class作为自己的基类，对于顶层基类的meta-class也是一样，只是它指向自己而已。

为了可以调用类方法，这个类的isa指针必须指向一个包含这些类方法的类结构体。
这样就引出了meta-class的概念：meta-class是一个类对象的类。

简单解释下：
当你向一个对象发送消息时，runtime会在这个对象所属的那个类的方法列表中查找。
当你向一个类发送消息时，runtime会在这个类的meta-class的方法列表中查找。
meta-class之所以重要，是因为它存储着一个类的所有类方法。每个类都会有一个单独的meta-class，因为每个类的类方法基本不可能完全相同。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OEzHzWVd-1616467169084)(/Users/ibrotherliyanbing/Library/Application Support/typora-user-images/image-20210309140542885.png)]

当一个方法找不到的时候，Runtime 提供了 消息动态解析、消息接受者重定向、消息重定向 等三步处理消息，具体流程如下图所示：
消息机制的基本原理

Objective-C 语言 中，对象方法调用都是类似 [receiver selector]; 的形式，其本质就是让对象在运行时发送消息的过程。

我们来看看方法调用 [receiver selector]; 在『编译阶段』和『运行阶段』分别做了什么？
1. 编译阶段：
```
[receiver selector];
```
  方法被编译器转换为:
  1. objc_msgSend(receiver，selector) （不带参数）
  2. objc_msgSend(recevier，selector，org1，org2，…)（带参数）
2. 运行时阶段：消息接受者 recevier寻找对应的 selector。
  1. 通过 recevier 的 isa 指针 找到 recevier 的 Class（类）；
  2. 在 Class（类） 的 cache（方法缓存） 的散列表中寻找对应的 IMP（方法实现）；
  3. 如果在 cache（方法缓存） 中没有找到对应的 IMP（方法实现） 的话，就继续在 Class（类） 的 method list（方法列表） 中找对应的 selector，如果找到，填充到 cache（方法缓存） 中，并返回 selector；
  4. 如果在 Class（类） 中没有找到这个 selector，就继续在它的 superClass（父类）中寻找；
  5. 一旦找到对应的 selector，直接执行 recevier 对应 selector 方法实现的 IMP（方法实现）。
  6. 若找不到对应的 selector，消息被转发或者临时向 recevier 添加这个 selector 对应的实现方法，否则就会发生崩溃。
block都有哪些类型，并且都是在什么环境下的：
NSOperation介绍
一个整数的二进制中1的个数

常规解法。
思路：将整数n与1进行与运算，当整数n最低位是1时，则结果非零，否则结果为0。
然后将1左移一位，继续与n进行与运算，当次低位是1时，结果非零，否则结果为0。
循环以上操作，记录非零的次数即可。
代码如下：

`public static int times1(int n ){
```
    int count = 0;
    int flag = 1;
    while(flag <= n){
        if((n&flag) != 0)
            count++;
        flag = flag<<1;
    }
    return count;
}
```
`

优化的解法
思路：
1.对一个整数n，比如10，它的二进制是1010。
2.将10减一变为9，9的二进制是1001.
3.比较10和9的二进制数，对10减一操作就等于将10的二进制的最低位上的1以及后面的位取反，前面的数不变。
总结：把一个整数减去1，再和原整数做与运算，会把该整数最右边1一个1变成0。那么一个整数的二进制表示中有多少个1，就可以进行多少次这样的操作。从而可以减少比较的次数。
public static int times2(int n){ int count = 0; while(n!=0){ count++; n = n&(n-1); } return count; }
Weak-Strong搭配使用的误解

在使用Block时，我们可以使用weak关键字来避免外部变量被Block强引用而导致的循环引用，同时为了Block中的代码能够正常执行，许多开发者提出了Weak-Strong搭配使用的方式，类似如下：

{ __weak typeof(self) weakSelf = self; self.block = ^{ __strong typeof(weakSelf) strongSelf = weakSelf; [strongSelf test1]; [strongSelf test2]; }; }

以上代码相对于单独使用weak来说还是有好处的，在单独使用weak时，可以保证在执行 [weakSelf test1]或 [weakSelf test2]单条语句时，weakSelf所指的self不会被释放或self已经释放而直接向nil发送消息。

若使用Weak-Strong搭配的方式的话，可以保证在执行 [strongSelf test1]和 [strongSelf test2]时，是向同一对象发送消息。

为什么这么说呢？当开始执行Block语句时，若self还存在，那么strongSelf可以保证在整个Block代码块中不会被释放，即使Block中调用无数次strongSelf，strongSelf也不会因为多线程而在半途被释放；若开始执行Block时，self已经被释放，那么之后所有的消息都会被发送至nil。所以Weak-Strong搭配可以保证Block中语句被处理为一个事务。

所以说，Weak-Strong并不能保证Block中语句一定会被执行，它只能保证Block中语句作为一个事务被发送到同一对象处。只要理解了weak实现原理，我们就能明白何时单独使用weak也能完成代码功能，而何时必须使用Weak-Strong来保证代码事务能力。
weak，__unsafe_unretained, unowned 与 assign区别

__unsafe_unretained: 不会对对象进行retain,当对象销毁时,会依然指向之前的内存空间(野指针)

weak: 不会对对象进行retain,当对象销毁时,会自动指向nil

assign: 实质与__unsafe_unretained等同

unsafe_unretained也可以修饰代表简单数据类型的property，weak也不能修饰用来代表简单数据类型的property。

__unsafe_unretained 与 weak 比较，使用 weak 是有代价的，因为通过上面的原理可知，__weak需要检查对象是否已经消亡，而为了知道是否已经消亡，自然也需要一些信息去跟踪对象的使用情况。也正因此，__unsafe_unretained 比 __weak快,所以当明确知道对象的生命期时，选择__unsafe_unretained 会有一些性能提升，这种性能提升是很微小的。但当很清楚的情况下，__unsafe_unretained 也是安全的，自然能快一点是一点。而当情况不确定的时候，应该优先选用 __weak 。

unowned使用在Swift中，也会分 weak 和 unowned。unowned 的含义跟 __unsafe_unretained 差不多。假如很明确的知道对象的生命期，也可以选择 unowned。

作者：Colleny_Z
链接：https://www.jianshu.com/p/3c5e335341e0
assign可以修饰OC对象么？

可以，但不会增加该对象的引用计数，当没有强引用持有该对象时，该对象就会被释放，如果此时再向该对象发消息，会导致崩溃问题。
weak 实现原理的概括

Runtime维护了一个weak表，用于存储指向某个对象的所有weak指针。weak表其实是一个hash（哈希）表，Key是所指对象的地址，Value是weak指针的地址（这个地址的值是所指对象指针的地址）数组。

作者：逍遥晨旭
链接：https://www.jianshu.com/p/13c4fb1cedea
weak 的实现原理可以概括一下三步

1、初始化时：runtime会调用objc_initWeak函数，初始化一个新的weak指针指向对象的地址。
2、添加引用时：objc_initWeak函数会调用 objc_storeWeak() 函数， objc_storeWeak() 的作用是更新指针指向，创建对应的弱引用表。
3、释放时，调用clearDeallocating函数。clearDeallocating函数首先根据对象地址获取所有weak指针地址的数组，然后遍历这个数组把其中的数据设为nil，最后把这个entry从weak表中删除，最后清理对象的记录。

Clang之后的结果如下：

id __attribute__((objc_ownership(weak))) obj1 = obj;

1、初始化时：runtime会调用objc_initWeak函数，初始化一个新的weak指针指向对象的地址。

2、添加引用时：objc_initWeak函数会调用 objc_storeWeak() 函数， objc_storeWeak() 的作用是更新指针指向，创建对应的弱引用表。

3、释放时，调用clearDeallocating函数。clearDeallocating函数首先根据对象地址获取所有weak指针地址的数组，然后遍历这个数组把其中的数据设为nil，最后把这个entry从weak表中删除，最后清理对象的记录。

作者：Colleny_Z
链接：https://www.jianshu.com/p/3c5e335341e0
来源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
weak基本用法

agan11423

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
2021年iOS基础知识汇总-初步学习篇

Category类struct category_t { const char *name; classref_t cls; struct method_list_t *instanceMethods; struct method_list_t *classMethods; struct protocol_list_t *protocols; struct property_list_t *instanceProperties; // Field..
复制链接

扫一扫