iOS工程师必看的 20 道 面试题

前言

本文收录总结了常见的 Swift 和 Objective-C 的面试题，希望对大家有所帮助。

Objective-C Basics

1. 请说明并比较以下关键词：strong, weak, assign, copy

• strong表示指向并拥有该对象。其修饰的对象引用计数会增加1。该对象只要引用计数不为0则不会被销毁。当然强行将其设为nil可以销毁它。
• weak表示指向但不拥有该对象。其修饰的对象引用计数不会增加。无需手动设置，该对象会自行在内存中销毁。
• assign主要用于修饰基本数据类型，如NSInteger和CGFloat，这些数值主要存在于栈上。
• weak 一般用来修饰对象，assign一般用来修饰基本数据类型。原因是assign修饰的对象被释放后，指针的地址依然存在，造成野指针，在堆上容易造成崩溃。而栈上的内存系统会自动处理，不会造成野指针。
• copy与strong类似。不同之处是strong的复制是多个指针指向同一个地址，而copy的复制每次会在内存中拷贝一份对象，指针指向不同地址。copy一般用在修饰有可变对应类型的不可变对象上，如NSString, NSArray, NSDictionary。
• Objective-C 中，基本数据类型的默认关键字是atomic, readwrite, assign；普通属性的默认关键字是atomic, readwrite, strong。

2. 请说明并比较以下关键词：__weak，__block

• __weak与weak基本相同。前者用于修饰变量（variable），后者用于修饰属性（property）。__weak 主要用于防止block中的循环引用。
• __block也用于修饰变量。它是引用修饰，所以其修饰的值是动态变化的，即可以被重新赋值的。__block用于修饰某些block内部将要修改的外部变量。
• __weak和__block的使用场景几乎与block息息相关。而所谓block，就是Objective-C对于闭包的实现。闭包就是没有名字的函数，或者理解为指向函数的指针。

3. 请说明并比较以下关键词：atomatic, nonatomic

• atomic修饰的对象会保证setter和getter的完整性，任何线程对其访问都可以得到一个完整的初始化后的对象。因为要保证操作完成，所以速度慢。它比nonatomic安全，但也并不是绝对的线程安全，例如多个线程同时调用set和get就会导致获得的对象值不一样。绝对的线程安全就要用关键词synchronized。
• nonatomic修饰的对象不保证setter和getter的完整性，所以多个线程对它进行访问，它可能会返回未初始化的对象。正因为如此，它比atomic快，但也是线程不安全的。

4. 什么是ARC？

ARC全称是 Automatic Reference Counting，是Objective-C的内存管理机制。简单地来说，就是代码中自动加入了retain/release，原先需要手动添加的用来处理内存管理的引用计数的代码可以自动地由编译器完成了。

ARC的使用是为了解决对象retain和release匹配的问题。以前手动管理造成内存泄漏或者重复释放的问题将不复存在。

以前需要手动的通过retain去为对象获取内存，并用release释放内存。所以以前的操作称为MRC (Manual Reference Counting)。

5. 什么情况下会出现循环引用？

循环引用是指2个或以上对象互相强引用，导致所有对象无法释放的现象。这是内存泄漏的一种情况。举个例子：

class Father

@interface Father: NSObject
@property (strong, nonatomic) Son *son;

@end

class Son

@interface Son: NSObject
@property (strong, nonatomic) Father *father; 

@end

上述代码有两个类，分别为爸爸和儿子。爸爸对儿子强引用，儿子对爸爸强引用。这样释放儿子必须先释放爸爸，要释放爸爸必须先释放儿子。如此一来，两个对象都无法释放。

解决方法是将Father中的Son对象属性从strong改为weak。

内存泄漏可以用Xcode中的Debug Memory Graph去检查,同时Xcode也会在runtime中自动汇报内存泄漏的问题。

6. 下面代码中有什么bug？

- (void)viewDidLoad {
  UILabel *alertLabel = [[UILabel alloc] initWithFrame:CGRectMake(100,100,100,100)];
  alertLabel.text = @"Wait 4 seconds...";
  [self.view addSubview:alertLabel];

  NSOperationQueue *backgroundQueue = [[NSOperationQueue alloc] init];
  [backgroundQueue addOperationWithBlock:^{
    [NSThread sleepUntilDate:[NSDate dateWithTimeIntervalSinceNow:4]];
    alertLabel.text = @"Ready to go!”
  }];
}

Bug在于，在等了4秒之后，alertLabel并不会更新为Ready to Go。

原因是，所有UI的相关操作应该在主线程进行。当我们可以在一个后台线程中等待4秒，但是一定要在主线程中更新alertLabel。

最简单的修正如下：

- (void)viewDidLoad {
  UILabel *alertLabel = [[UILabel alloc] initWithFrame:CGRectMake(100,100,100,100)];
  alertLabel.text = @"Wait 4 seconds...";
  [self.view addSubview:alertLabel];

  NSOperationQueue *backgroundQueue = [[NSOperationQueue alloc] init];
  [backgroundQueue addOperationWithBlock:^{
    [NSThread sleepUntilDate:[NSDate dateWithTimeIntervalSinceNow:4]];
      [[NSOperationQueue mainQueue] addOperationWithBlock:^{
         alertLabel.text = @"Ready to go!”
      }];
  }];
}

7. 以scheduledTimerWithTimeInterval的方式触发的timer，在滑动页面上的列表时，timer会暂停，为什么？该如何解决？

原因在于滑动时当前线程的runloop切换了mode用于列表滑动，导致timer暂停。

runloop中的mode主要用来指定事件在runloop中的优先级，有以下几种：

• Default（NSDefaultRunLoopMode）：默认，一般情况下使用；
• Connection（NSConnectionReplyMode）：一般系统用来处理NSConnection相关事件，开发者一般用不到；
• Modal（NSModalPanelRunLoopMode）：处理modal panels事件；
• Event Tracking（NSEventTrackingRunLoopMode）：用于处理拖拽和用户交互的模式。
• Common（NSRunloopCommonModes）：模式合集。默认包括Default，Modal，Event Tracking三大模式，可以处理几乎所有事件。

回到题中的情境。滑动列表时，runloop的mode由原来的Default模式切换到了Event Tracking模式，timer原来好好的运行在Default模式中，被关闭后自然就停止工作了。

解决方法其一是将timer加入到NSRunloopCommonModes中。其二是将timer放到另一个线程中，然后开启另一个线程的runloop，这样可以保证与主线程互不干扰，而现在主线程正在处理页面滑动。示例代码如下：

// 方法1
[[NSRunLoop currentRunLoop] addTimer:timer forMode:NSRunLoopCommonModes];

// 方法2
dispatch_async(dispatch_get_global_queue(0, 0), ^{
    timer = [NSTimer scheduledTimerWithTimeInterval:1 target:self selector:@selector(repeat:) userInfo:nil repeats:true];
    [[NSRunLoop currentRunLoop] run];
});

image

Swift Basics

8. 类（class）和结构体（struct）有什么区别？

Swift 中，类是引用类型，结构体是值类型。值类型在传递和赋值时将进行复制，而引用类型则只会使用引用对象的一个"指向"。所以他们两者之间的区别就是两个类型的区别。

举个简单的例子，代码如下

class Temperature {
  var value: Float = 37.0
}

class Person {
  var temp: Temperature?

  func sick() {
    temp?.value = 41.0
  }
}

let A = Person()
let B = Person()
let temp = Temperature()

A.temp = temp
B.temp = temp

A.sick()

上面这段代码，由于 Temperature 是 class ，为引用类型，故 A 的 temp 和 B 的 temp指向同一个对象。A 的 temp修改了，B 的 temp 也随之修改。这样 A 和 B 的 temp 的值都被改成了41.0。如果将 Temperature 改为 struct，为值类型，则 A 的 temp 修改不影响 B 的 temp。

内存中，引用类型诸如类是在堆（heap）上，而值类型诸如结构体实在栈（stack）上进行存储和操作。相比于栈上的操作，堆上的操作更加复杂耗时，所以苹果官方推荐使用结构体，这样可以提高 App 运行的效率。

class有这几个功能struct没有的：

• class可以继承，这样子类可以使用父类的特性和方法
• 类型转换可以在runtime的时候检查和解释一个实例的类型
• 可以用deinit来释放资源
• 一个类可以被多次引用

struct也有这样几个优势：

• 结构较小，适用于复制操作，相比于一个class的实例被多次引用更加安全。
• 无须担心内存memory leak或者多线程冲突问题

9. Swift 是面向对象还是函数式的编程语言?

Swift 既是面向对象的，又是函数式的编程语言。

说 Swift 是面向对象的语言，是因为 Swift 支持类的封装、继承、和多态，从这点上来看与 Java 这类纯面向对象的语言几乎毫无差别。

说 Swift 是函数式编程语言，是因为 Swift 支持 map, reduce, filter, flatmap 这类去除中间状态、数学函数式的方法，更加强调运算结果而不是中间过程。

10. 请说明并比较以下关键词：Open, Public, Internal, File-private, Private

Swift 有五个级别的访问控制权限，从高到底依次为比如 Open, Public, Internal, File-private, Private。

他们遵循的基本原则是：高级别的变量不允许被定义为低级别变量的成员变量。比如一个 private 的 class 中不能含有 public 的 String。反之，低级别的变量却可以定义在高级别的变量中。比如 public 的 class 中可以含有 private 的 Int。

• Open 具备最高的访问权限。其修饰的类和方法可以在任意 Module 中被访问和重写；它是 Swift 3 中新添加的访问权限。
• Public 的权限仅次于 Open。与 Open 唯一的区别在于它修饰的对象可以在任意 Module 中被访问，但不能重写。
• Internal 是默认的权限。它表示只能在当前定义的 Module 中访问和重写，它可以被一个 Module 中的多个文件访问，但不可以被其他的 Module 中被访问。
• File-private 也是 Swift 3 新添加的权限。其被修饰的对象只能在当前文件中被使用。例如它可以被一个文件中的 class，extension，struct 共同使用。
• Private 是最低的访问权限。它的对象只能在定义的作用域内使用。离开了这个作用域，即使是同一个文件中的其他作用域，也无法访问。

11. 请说明并比较以下关键词：strong, weak, unowned

Swift 的内存管理机制与 Objective-C一样为 ARC（Automatic Reference Counting）。它的基本原理是，一个对象在没有任何强引用指向它时，其占用的内存会被回收。反之，只要有任何一个强引用指向该对象，它就会一直存在于内存中。

• strong 代表着强引用，是默认属性。当一个对象被声明为 strong 时，就表示父层级对该对象有一个强引用的指向。此时该对象的引用计数会增加1。
• weak 代表着弱引用。当对象被声明为 weak 时，父层级对此对象没有指向，该对象的引用计数不会增加1。它在对象释放后弱引用也随即消失。继续访问该对象，程序会得到 nil，不亏崩溃
• unowned 与弱引用本质上一样。唯一不同的是，对象在释放后，依然有一个无效的引用指向对象，它不是 Optional 也不指向 nil。如果继续访问该对象，程序就会崩溃。

加分回答：

weak 和 unowned 的引入是为了解决由 strong 带来的循环引用问题。简单来说，就是当两个对象互相有一个强指向去指向对方，这样导致两个对象在内存中无法释放。

weak 和 unowned 的使用场景有如下差别：

• 当访问对象时该对象可能已经被释放了，则用 weak。比如 delegate 的修饰。
• 当访问对象确定不可能被释放，则用 unowned。比如 self 的引用。
• 实际上为了安全起见，很多公司规定任何时候都使用 weak 去修饰。

13. 用 Swift 实现或（||）操作

这题解法很多，下面给出一种最直接的解法：

func ||(left: Bool, right: Bool) –> Bool {
  if left {
    return true
  } else {
    return right
  }
}

上面这种解法勉强正确，但是并不高效。或（||）操作的本质是当左边为真的时候，我们无需计算右边。而上面这种事先，是将右边默认值预先准备好，再传入进行操作。当右边值的计算十分复杂时会 造成了性能上的浪费。所以，上面这种做法违反了或（||）操作的本质。正确的实现方法如下：

func ||(left: Bool, right: @autoclosure () -> Bool) –> Bool {
  if left {
    return true
  } else {
    return right()
  }
}

autoclosure 可以将右边值的计算推迟到判定left 为 false 的时候，这样就可以避免第一种方法带来的不必要开销了。

14. 实现一个函数。求一个整型二维数组中所有元素之和

func sumPairs(_ nums: [[Int]]) -> Int {
  return nums.flatMap { $0 }.reduce(0) { $0 + $1 }
}

Swift 有函数式编程的思想。其中 flatMap, map, reduce, filter 是其代表的方法。本题中考察了 flatMap 的降维思路，以及 reduce 的基本使用。相比于一般的 for 循环，这样的写法要更加得简洁漂亮。

image

Swift vs. Objective-C

15. 说说Swift为什么将String，Array，Dictionary设计成值类型？

要解答这个问题，就要和Objective-C中相同的数据结构设计进行比较。Objective-C中，字符串，数组，字典，皆被设计为引用类型。

• 值类型相比引用类型，最大的优势在于内存使用的高效。值类型在栈上操作，引用类型在堆上操作。栈上的操作仅仅是单个指针的上下移动，而堆上的操作则牵涉到合并、移位、重新链接等。也就是说Swift这样设计，大幅减少了堆上的内存分配和回收的次数。同时copy-on-write又将值传递和复制的开销降到了最低。
• String，Array，Dictionary设计成值类型，也是为了线程安全考虑。通过Swift的let设置，使得这些数据达到了真正意义上的“不变”，它也从根本上解决了多线程中内存访问和操作顺序的问题。
• 设计成值类型还可以提升API的灵活度。例如通过实现Collection这样的协议，我们可以遍历String，使得整个开发更加灵活高效。

16. 在Swift和Objective-C的混编项目中，如何在Swift文件中调用Objective-C文件中已经定义的方法？如何在Objective-C文件中调用Swift文件中定义的方法？

• Swift中若要使用Objective-C代码，可以在ProjectName-Bridging-Header.h里添加Objective-C的头文件名称，Swift文件中即可调用相应的Objective-C代码。一般情况Xcode会在Swift项目中第一次创建Objective-C文件时自动创建ProjectName-Bridging-Header.h文件。
• Objective-C中若要调用Swift代码，可以导入Swift生成的头函数ProjectName-Swift.h来实现。
• Swift文件中若要规定固定的方法或属性暴露给Objective-C使用，可以在方法或属性前加上@objc来声明。如果该类是NSObject子类，那么Swift会在非private的方法或属性前自动加上@objc。

17. 用Swift 将协议（protocol）中的部分方法设计成可选（optional），该怎样实现？

@optional 和 @required 是 Objective-C 中特有的关键字。

Swift中，默认所有方法在协议中都是必须实现的。而且，协议里方法不可以直接定义 optional。先给出两种解决方案：

• 在协议和方法前都加上 @objc 关键字，然后再在方法前加上 optional 关键字。该方法实际上是把协议转化为Objective-C的方式然后进行可选定义。示例如下：

@objc protocol SomeProtocol {
  func requiredFunc()
  @objc optional func optionalFunc()
}

• 用扩展（extension）来规定可选方法。Swift中，协议扩展（protocol extension）可以定义部分方法的默认实现，这样这些方法在实际调用中就是可选实现的了。示例如下：

protocol SomeProtocol {
  func requiredFunc()
  func optionalFunc()
}

extension SomeProtocol {
  func optionalFunc() {
    print(“Dumb Implementation”)
  }
}

Class SomeClass: SomeProtocol {
  func requiredFunc() {
    print(“Only need to implement the required”)
  }
}

18. 要给一个UIButton增加一个点击后抖动的效果，该怎样实现?

解决方案有三种。个人推荐用protocol来解决。

• 实现一个自定义的UIButton类，在其中添加点击抖动效果的方法（shake方法）
• 写一个UIButton或者UIView的拓展（extension），然后在其中增加shake方法
• 定义一个protocol，然后在协议扩展（protocol extension）中添加shake方法

分析这三种方法：

• 在自定义的类中添加shake方法扩展性不好。如果shake方法被用在其他地方，又要在其他类中再添加一遍shake方法，这样代码复用性差。
• 在extension中实现虽然解决了代码复用性问题，但是可读性比较差。团队开发中并不是所有人都知道这个extension中存在shake方法，同时随着功能的扩展，extension中新增的方法会层出不穷，它们很难归类管理。
• 用协议定义解决了复用性、可读性、维护性三个难题。协议的命名（例如Shakeable）直接可以确定其实现的UIButton拥有相应shake功能；通过协议扩展，可以针对不同类实现特定的方法，可维护性也大大提高；因为协议扩展通用于所有实现对象，所以代码复用性也很高。

19. 试比较Swift和Objective-C中的初始化方法（init）有什么异同？

一言以蔽之，Swift中的初始化方法更加严格和准确。

• Objective-C中，初始化方法无法保证所有成员变量都完成初始化；编译器对属性设置并无警告，但是实际操作中会出现初始化不完全的问题；初始化方法与普通方法并无实际差别，可以多次调用。
• Swift中，初始化方法必须保证所有optional的成员变量都完成初始化。同时新增convenience和required两个修饰初始化方法的关键词。convenience只是提供一种方便的初始化方法，必须通过调用同一个类中designated初始化方法来完成。required是强制子类重写父类中所修饰的初始化方法。

20. 谈谈对Objective-C和Swift 动态特性的理解

runtime其实就是Objective-C的动态机制。runtime执行的是编译后的代码，这时它可以动态加载对象、添加方法、修改属性、传递信息等等。具体过程是在Objective-C中对象调用方法时，如self.tableview reload，发生了两件事。

• 编译阶段，编译器（compiler）会把这句话翻译成objc_msgSend(self.tableview,[@selector](https://xiaozhuanlan.com/u/undefined)(reload))，把消息发送给self.tableview。
• 运行阶段，接收者self.tableview会响应这个消息，期间可能会直接执行、转发消息，也可能会找不到方法崩溃。

所以整个流程是编译器翻译 –> 给接收者发送消息 –> 接收者响应消息三个流程。

如self.tableview reload中，self.tableview就是接收者，reload就是消息，所以方法调用的格式在编译器看来是receiver message。

其中接收者如何响应代码，就发生在运行时（runtime）。runtime执行的是编译后的代码，这时它可以动态加载对象、添加方法、修改属性、传递信息等等，runtime的运行机制就是Objective-C的动态特性。

Swift目前被公认为是一门静态语言。它的动态特性都是通过桥接OC来实现。如果要把动态特性写得更Swift一点，可以用protocol来处理，比如OC中的reflection这样写：

if ([someImage respondsToSelector:@selector(shake)]) {
  [someImage performSelector:shake];
}

Swift 中可以这样写：

if let shakeableImage = someImage as? Shakeable {
  shakeableImage.shake()
}