"2022" 新 iOS 开发进阶+面试大全(二)

这篇文章可能有点长,所以分了三篇文章记录。内容来自网上的面试题以及自己面试过程中遇到的问题总结,也会定期更新,不合理的地方欢迎指正。

  • 更多技术题合集:

iOS技术题大全(上)

iOS技术题大全(中)

iOS技术题大全(下)

提升iOS开发技能学习网址:docs.qq.com/doc/DVWlQam9Qd3B1cEF2

为自己的面试,为自己的跳槽,加油吧 iOS开发

八、iOS 中内省的几个方法?

对象在运行时获取其类型的能力称为内省。内省可以有多种方法实现。

OC运行时内省的4个方法:

判断对象类型:

-(BOOL) isKindOfClass:            判断是否是这个类或者这个类的子类的实例
-(BOOL) isMemberOfClass:      判断是否是这个类的实例

判断对象/类是否有这个方法

-(BOOL) respondsToSelector:                      判读实例是否有这样方法
+(BOOL) instancesRespondToSelector:      判断类是否有这个方法

在 Objective-C 中,id类型类似于(void*) ,可以指向任何类的对象,但在运行时对象的类型不再是id,而是该对象真正所属的类。

Person *person = [[Person alloc] init];  
NSArray *arr = @[person];
id  obj = arr[0];    //OC集合中取出的对象都是id类型
此时可通过
BOOL  isPersonClass = [obj  isKindOfClass: [Person class] ];
来判断obj是否Person类型或其子类的对象。

在 Objective-C 中,用父类类型定义的指针,可以指向其子类的对象,但在运行时对象真实类型会是子类。

//例如 Boy是Person的子类,现定义:
Person  *p = [[Boy alloc] init];
可通过 BOOL  isBoy = [p  isMemberOfClass: [Boy class] ]; 
判断Person *类型的p是否是Boy类型。

九、class方法和objc_getClass方法有什么区别?

1.当参数obj为Object实例对象
object_getClass(obj)与[obj class]输出结果一直,均获得isa指针,即指向类对象的指针。
2.当参数obj为Class类对象
object_getClass(obj)返回类对象中的isa指针,即指向元类对象的指针;[obj class]返回的则是其本身。
3.当参数obj为Metaclass类对象
object_getClass(obj)返回元类对象中的isa指针,因为元类对象的isa指针指向根类,所有返回的是根类对象的地址指针;[obj class]返回的则是其本身。
4.obj为Rootclass类对象
object_getClass(obj)返回根类对象中的isa指针,因为跟类对象的isa指针指向Rootclass‘s metaclass(根元类),即返回的是根元类的地址指针;[obj class]返回的则是其本身。

总结:
经上面初步的探索得知,object_getClass(obj)返回的是obj中的isa指针;而[obj class]则分两种情况:一是当obj为实例对象时,[obj class]中class是实例方法:- (Class)class,返回的obj对象中的isa指针;二是当obj为类对象(包括元类和根类以及根元类)时,调用的是类方法:+ (Class)class,返回的结果为其本身。

十、在运行时创建类的方法objc_allocateClassPair的方法名尾部为什么是pair(成对的意思)?

// 创建一个新类和元类
Class objc_allocateClassPair ( Class superclass, const char *name, size_t extraBytes );
// 销毁一个类及其相关联的类
void objc_disposeClassPair ( Class cls );
// 在应用中注册由objc_allocateClassPair创建的类
void objc_registerClassPair ( Class cls );

objc_allocateClassPair 函数:如果我们要创建一个根类,则superclass指定为Nil。extraBytes通常指定为0,该参数是分配给类和元类对象尾部的索引ivars的字节数

十一、一个int变量被__block修饰与否的区别?

没有修饰,被block捕获,是值拷贝。
使用__block修饰,会生成一个结构体,复制int的引用地址。达到修改数据。

1、block截获自动变量(局部变量)值

对于 block 外的变量引用,block 默认是将其复制到其数据结构中来实现访问的。也就是说block的自动变量截获只针对block内部使用的自动变量, 不使用则不截获, 因为截获的自动变量会存储于block的结构体内部, 会导致block体积变大。特别要注意的是默认情况下block只能访问不能修改局部变量的值。

image

2、 __block 修饰的外部变量

对于用 __block 修饰的外部变量引用,block 是复制其引用地址来实现访问的。block可以修改__block 修饰的外部变量的值。

image

3、Block的存储域及copy操作

先来思考一下:Block是存储在栈上还是堆上呢?
其实,block有三种类型:

  • 全局块(_NSConcreteGlobalBlock)
  • 栈块(_NSConcreteStackBlock)
  • 堆块(_NSConcreteMallocBlock)

全局块存在于全局内存中, 相当于单例.
栈块存在于栈内存中, 超出其作用域则马上被销毁
堆块存在于堆内存中, 是一个带引用计数的对象, 需要自行管理其内存
简而言之,存储在栈中的Block就是栈块、存储在堆中的就是堆块、既不在栈中也不在堆中的块就是全局块。

遇到一个Block,我们怎么这个Block的存储位置呢?

(1)Block不访问外界变量(包括栈中和堆中的变量)

Block 既不在栈又不在堆中,在代码段中,ARC和MRC下都是如此。此时为全局块。

(2)Block访问外界变量

MRC 环境下:访问外界变量的 Block 默认存储栈中。
ARC 环境下:访问外界变量的 Block 默认存储在堆中(实际是放在栈区,然后ARC情况下自动又拷贝到堆区),自动释放。

4、防止 Block 循环引用
Block 循环引用的情况:
某个类将 block 作为自己的属性变量,然后该类在 block 的方法体里面又使用了该类本身,如下:

self.someBlock = ^(Type var){
    [self dosomething];
};

解决办法:

(1)ARC 下:使用 __weak

__weak typeof(self) weakSelf = self;
self.someBlock = ^(Type var){
   [weakSelf dosomething];
};

(2)MRC 下:使用 __block

__block typeof(self) blockSelf = self;
self.someBlock = ^(Type var){
   [blockSelf dosomething];
};

值得注意的是,在ARC下,使用 __block 也有可能带来的循环引用,如下:

// 循环引用 self -> _attributBlock -> tmp -> self
typedef void (^Block)();
@interface TestObj : NSObject
{
    Block _attributBlock;
}
@end

@implementation TestObj
- (id)init {
    self = [super init];
    __block id tmp = self;
    self.attributBlock = ^{
        NSLog(@"Self = %@",tmp);
        tmp = nil;
   };
}

- (void)execBlock {
    self.attributBlock();
}
@end

// 使用类
id obj = [[TestObj alloc] init];
[obj execBlock]; // 如果不调用此方法,tmp 永远不会置 nil,内存泄露会一直在

5、有时候我们经常也会被问到block为什么 常使用copy关键字?

block 使用 copy 是从 MRC遗留下来的“传统”,在 MRC 中,方法内部的 block 是在栈区的,使用 copy 可以把它放到堆区.在 ARC 中写不写都行:对于 block 使用 copy 还是 strong 效果是一样的,但写上 copy 也无伤大雅,还能时刻提醒我们:编译器自动对 block 进行了 copy 操作。
如果不写 copy ,该类的调用者有可能会忘记或者根本不知道“编译器会自动对 block 进行了 copy 操作”

十二、为什么在block外部使用__weak修饰的同时需要在内部使用__strong修饰?

ARC环境中使用weak 的修饰符来修饰一个变量,防止其在block中被循环引用,而有些特殊情况下,我们在block中又使用__strong 来修饰这个在block外刚刚用__weak修饰的变量,这是因为在block中调用self会引起循环引用,而在block中需要对weakSelf进行__strong,保证代码在执行到block中,self不会被释放,当block执行完后,会自动释放该strongSelf;

_weak是为了解决循环引用问题,(如果block和对象相互持有就会形成循环引用)
而__strong在Block内部修饰的对象,会保证,在使用这个对象在block内,
这个对象都不会被释放,strongSelf仅仅是个局部变量,存在栈中,会在block执行结束后回收,不会再造成循环引用。

__strong主要是用在多线程中,防止对象被提前释放。

十三、什么是离屏渲染?什么情况下会触发?该如何应对?

离屏渲染就是在当前屏幕缓冲区以外,新开辟一个缓冲区进行操作。

离屏渲染出发的场景有以下:

  • 圆角 (maskToBounds并用才会触发)
  • 图层蒙版
  • 阴影
  • 光栅化
为什么要有离屏渲染?

大家高中物理应该学过显示器是如何显示图像的:需要显示的图像经过CRT电子枪以极快的速度一行一行的扫描,扫描出来就呈现了一帧画面,随后电子枪又会回到初始位置循环扫描,形成了我们看到的图片或视频。

为了让显示器的显示跟视频控制器同步,当电子枪新扫描一行的时候,准备扫描的时发送一个水平同步信号(HSync信号),显示器的刷新频率就是HSync信号产生的频率。然后CPU计算好frame等属性,将计算好的内容交给GPU去渲染,GPU渲染好之后就会放入帧缓冲区。然后视频控制器会按照HSync信号逐行读取帧缓冲区的数据,经过可能的数模转换传递给显示器,就显示出来了。具体的大家自行查找资料或询问相关专业人士,这里只参考网上资料做一个简单的描述。

离屏渲染的代价很高,想要进行离屏渲染,首选要创建一个新的缓冲区,屏幕渲染会有一个上下文环境的一个概念,离屏渲染的整个过程需要切换上下文环境,先从当前屏幕切换到离屏,等结束后,又要将上下文环境切换回来。这也是为什么会消耗性能的原因了。

由于垂直同步的机制,如果在一个 HSync 时间内,CPU 或者 GPU 没有完成内容提交,则那一帧就会被丢弃,等待下一次机会再显示,而这时显示屏会保留之前的内容不变。这就是界面卡顿的原因。

为什么要避免离屏渲染?

CPU GPU 在绘制渲染视图时做了大量的工作。离屏渲染发生在 GPU 层面上,会创建新的渲染缓冲区,会触发 OpenGL 的多通道渲染管线,图形上下文的切换会造成额外的开销,增加 GPU 工作量。如果 CPU GPU 累计耗时 16.67 毫秒还没有完成,就会造成卡顿掉帧。

圆角属性蒙层遮罩 都会触发离屏渲染。指定了以上属性,标记了它在新的图形上下文中,在未愈合之前,不可以用于显示的时候就出发了离屏渲染。

  • 在OpenGL中,GPU有2种渲染方式

    • On-Screen Rendering:当前屏幕渲染,在当前用于显示的屏幕缓冲区进行渲染操作
    • Off-Screen Rendering:离屏渲染,在当前屏幕缓冲区以外新开辟一个缓冲区进行渲染操作
  • 离屏渲染消耗性能的原因

    • 需要创建新的缓冲区
    • 离屏渲染的整个过程,需要多次切换上下文环境,先是从当前屏幕(On-Screen)切换到离屏(Off-Screen);等到离屏渲染结束以后,将离屏缓冲区的渲染结果显示到屏幕上,又需要将上下文环境从离屏切换到当前屏幕
  • 哪些操作会触发离屏渲染?

    • 光栅化,layer.shouldRasterize = YES
    • 遮罩,layer.mask
    • 圆角,同时设置 layer.masksToBounds = YES、layer.cornerRadius大于0
    • 考虑通过 CoreGraphics 绘制裁剪圆角,或者叫美工提供圆角图片
    • 阴影,layer.shadowXXX,如果设置了 layer.shadowPath 就不会产生离屏渲染

十三、反射是什么?可以举出几个应用场景么?

系统Foundation框架为我们提供了一些方法反射的API,我们可以通过这些API执行将字符串转为SEL等操作。由于OC语言的动态性,这些操作都是发生在运行时的。

// SEL和字符串转换
FOUNDATION_EXPORT NSString *NSStringFromSelector(SEL aSelector);
FOUNDATION_EXPORT SEL NSSelectorFromString(NSString *aSelectorName);
// Class和字符串转换
FOUNDATION_EXPORT NSString *NSStringFromClass(Class aClass);
FOUNDATION_EXPORT Class __nullable NSClassFromString(NSString *aClassName);
// Protocol和字符串转换
FOUNDATION_EXPORT NSString *NSStringFromProtocol(Protocol *proto) NS_AVAILABLE(10_5, 2_0);
FOUNDATION_EXPORT Protocol * __nullable NSProtocolFromString(NSString *namestr) NS_AVAILABLE(10_5, 2_0);

通过这些方法,我们可以在运行时选择创建那个实例,并动态选择调用哪个方法。这些操作甚至可以由服务器传回来的参数来控制,我们可以将服务器传回来的类名和方法名,实例为我们的对象。

// 假设从服务器获取JSON串,通过这个JSON串获取需要创建的类为ViewController,并且调用这个类的getDataList方法。
Class class = NSClassFromString(@"ViewController");
ViewController *vc = [[class alloc] init];
SEL selector = NSSelectorFromString(@"getDataList");
[vc performSelector:selector];

反射机制使用技巧

假设有一天公司产品要实现一个需求:根据后台推送过来的数据,进行动态页面跳转,跳转到页面后根据返回到数据执行对应的操作。

遇到这样奇葩的需求,我们当然可以问产品都有哪些情况执行哪些方法,然后写一大堆if else判断或switch判断。
但是这种方法实现起来太low了,而且不够灵活,假设后续版本需求变了,还要往其他已有页面中跳转,这不就傻眼了吗....
这种情况反射机制就派上用场了,我们可以用反射机制动态的创建类并执行方法。当然也可以通过runtime来实现这个功能,但是我们当前需求反射机制已经足够满足需求了,如果遇到更加复杂的需求可以考虑用runtime来实现。
这时候就需要和后台配合了,我们首先需要和后台商量好返回的数据结构,以及数据格式、类型等,返回后我们按照和后台约定的格式,根据后台返回的信息,直接进行反射和调用即可。

假设和后台约定格式如下:

@{
     // 类名
     @"className" : @"UserListViewController", 
     // 数据参数
     @"propertys" : @{ @"name": @"liuxiaozhuang", 
                       @"age": @3 },
     // 调用方法名
     @"method" : @"refreshUserInformation"
 };

定义一个UserListViewController类,这个类用于测试,在实际使用中可能会有多个这样的控制器类。

#import 
// 由于使用的KVC赋值,如果不想把这两个属性暴露出来,把这两个属性写在.m文件也可以
@interface UserListViewController : UIViewController
@property (nonatomic,strong) NSString *name;/*!< 用户名 */
@property (nonatomic,strong) NSNumber *age;/*!< 用户年龄 */
/** 使用反射机制反射为SEL后,调用的方法 */
- (void)refreshUserInformation;
@end

下面通过反射机制简单实现了控制器跳转的方法,在实际使用中再根据业务需求进行修改即可。因为这篇文章主要是讲反射机制,所以没有使用runtime代码。

简单封装的页面跳转方法,只是做演示,代码都是没问题的,使用时可以根据业务需求进行修改。

- (void)remoteNotificationDictionary:(NSDictionary *)dict {
    // 根据字典字段反射出我们想要的类,并初始化控制器
    Class class = NSClassFromString(dict[@"className"]);
    UIViewController *vc = [[class alloc] init];
    // 获取参数列表,使用枚举的方式,对控制器属性进行KVC赋值
    NSDictionary *parameter = dict[@"propertys"];
    [parameter enumerateKeysAndObjectsUsingBlock:^(id  _Nonnull key, id  _Nonnull obj, BOOL * _Nonnull stop) {
        // 在属性赋值时,做容错处理,防止因为后台数据导致的异常
        if ([vc respondsToSelector:NSSelectorFromString(key)]) {
            [vc setValue:obj forKey:key];
        }
    }];
    [self.navigationController pushViewController:vc animated:YES];
    // 从字典中获取方法名,并调用对应的方法
    SEL selector = NSSelectorFromString(dict[@"method"]);
    [vc performSelector:selector];
}

十四、有哪些场景是NSOperation比GCD更容易实现的?

  • GCD是一套 C 语言API,执行和操作简单高效,因此NSOperation底层也通过GCD实现,这是他们之间最本质的区别.因此如果希望自定义任务,建议使用NSOperation;

  • 依赖关系,NSOperation可以设置操作之间的依赖(可以跨队列设置),GCD无法设置依赖关系,不过可以通过同步来实现这种效果;

  • KVO(键值对观察),NSOperation容易判断操作当前的状态(是否执行,是否取消等),对此GCD无法通过KVO进行判断;

  • 优先级,NSOperation可以设置自身的优先级,但是优先级高的不一定先执行,GCD只能设置队列的优先级,如果要区分block任务的优先级,需要很复杂的代码才能实现;

  • 继承,NSOperation是一个抽象类.实际开发中常用的是它的两个子类:NSInvocationOperation和NSBlockOperation,同样我们可以自定义NSOperation,GCD执行任务可以自由组装,没有继承那么高的代码复用度;

  • 效率,直接使用GCD效率确实会更高效,NSOperation会多一点开销,但是通过NSOperation可以获得依赖,优先级,继承,键值对观察这些优势,相对于多的那么一点开销确实很划算,鱼和熊掌不可得兼,取舍在于开发者自己;

  • 可以随时取消准备执行的任务(已经在执行的不能取消),GCD没法停止已经加入queue 的 block(虽然也能实现,但是需要很复杂的代码)

基于GCD简单高效,更强的执行能力,操作不太复杂的时候,优先选用GCD;而比较复杂的任务可以自己通过NSOperation实现.

十五、App 启动优化策略?最好结合启动流程来说

参考文章

App启动过程

  • 解析Info.plist
    加载相关信息,例如如闪屏
    沙箱建立、权限检查

  • Mach-O加载
    如果是胖二进制文件,寻找合适当前CPU类别的部分
    加载所有依赖的Mach-O文件(递归调用Mach-O加载的方法)
    定位内部、外部指针引用,例如字符串、函数等
    执行声明为attribute((constructor))的C函数
    加载类扩展(Category)中的方法
    C++静态对象加载、调用ObjC的 +load 函数

  • 程序执行
    调用main()
    调用UIApplicationMain()
    调用applicationWillFinishLaunching

在各种App性能的指标中,哪一此属于启动性能的范畴,哪一些则于App的流畅度性能?我认为应该首先把启动过程分为四个部分:

main()函数之前
main()函数之后至applicationWillFinishLaunching完成
App完成所有本地数据的加载并将相应的信息展示给用户
App完成所有联网数据的加载并将相应的信息展示给用户

  1. 移除不需要用到的动态库
  2. 移除不需要用到的类
  3. 合并功能类似的类和扩展(Category)
  4. 压缩资源图片
  5. 优化applicationWillFinishLaunching
  6. 优化rootViewController加载

十六、App 无痕埋点的思路了解么?你认为理想的无痕埋点系统应该具备哪些特点

参考:https://www.jianshu.com/p/b32b103356ea

十七、App 网络层有哪些优化策略?

https://casatwy.com/iosying-yong-jia-gou-tan-wang-luo-ceng-she-ji-fang-an.html

十八、你知道有哪些情况会导致app崩溃,分别可以用什么方法拦截并化解?

1、NSInvalidArgumentException 异常
向容器加入nil,引起的崩溃。hook容器添加方法,进行判断。
https://github.com/jasenhuang/NSObjectSafe

2、 SIGSEGV 异常

SIGSEGV是当SEGV发生的时候,让代码终止的标识。 当去访问没有被开辟的内存或者已经被释放的内存时,就会发生这样的异常。另外,在低内存的时候,也可能会产生这样的异常。

3、 NSRangeException 异常

造成这个异常,就是越界异常了,在iOS中我们经常碰到的越界异常有两种,一种是数组越界,一种字符串截取越界

4、SIGPIPE 异常

先解释一下什么是SIGPIPE异常,通俗一点的描述是这样的:对一个端已经关闭的socket调用两次write,第二次write将会产生SIGPIPE信号,该信号默认结束进程。

SIGABRT 异常 这是一个让程序终止的标识,会在断言、app内部、操作系统用终止方法抛出。通常发生在异步执行系统方法的时候。如CoreData、NSUserDefaults等,还有一些其他的系统多线程操作。 注意:这并不一定意味着是系统代码存在bug,代码仅仅是成了无效状态,或者异常状态。

https://www.jianshu.com/p/c7efbc283480

5、方法没有找到接受者异常

十九、你知道有哪些情况会导致app卡顿,分别可以用什么方法来避免?

参考 https://blog.ibireme.com/2015/11/12/smooth_user_interfaces_for_ios/

一、卡顿原因:

  • CPU 资源消耗原因和解决方案:
    1、对象创建
    不需要响应触摸事件的控件,用 CALayer 显示会更加合适、尽量推迟对象创建的时间,并把对象的创建分散到多个任务中去
    2、对象调整
    应该尽量减少不必要的属性修改
    3、对象销毁
    如果对象可以放到后台线程去释放,那就挪到后台线程去。这里有个小 Tip:把对象捕获到 block 中,然后扔到后台队列去随便发送个消息以避免编译器警告,就可以让对象在后台线程销毁了
NSArray *tmp = self.array;
self.array = nil;
dispatch_async(queue, ^{
    [tmp class];
});

4、布局计算
尽量提前计算好布局,在需要时一次性调整好对应属性,而不要多次、频繁的计算和调整这些属性。

5、文本计算、文本渲染
可以使用 CoreText 排版对象

6、 图像的绘制
这个最常见的地方就是 [UIView drawRect:] 里面了。由于 CoreGraphic 方法通常都是线程安全的,所以图像的绘制可以很容易的放到后台线程进行。一个简单异步绘制的过程大致如下(实际情况会比这个复杂得多,但原理基本一致):

- (void)display {
    dispatch_async(backgroundQueue, ^{
        CGContextRef ctx = CGBitmapContextCreate(...);
        // draw in context...
        CGImageRef img = CGBitmapContextCreateImage(ctx);
        CFRelease(ctx);
        dispatch_async(mainQueue, ^{
            layer.contents = img;
        });
    });
}

二十、优化UITableViewCell高度计算的那些事

http://blog.sunnyxx.com/2015/05/17/cell-height-calculation/

收录文章

你可能感兴趣的:("2022" 新 iOS 开发进阶+面试大全(二))