面试IOS开发知识点

2020年iOS面试反思总结

2021-04-06  本文已影响0人  iOS王的男人

最近应该有很多小伙伴去跳槽面试的吧，相信各位有的已经顺利收到offer了，而有些则是碰壁了，那么我在这里给大家准备了相关面试资料，还有相关算法资料。想了解的可找我拿这篇文章给大家总结了在iOS面试的时候可能会遇到的技术面试题，以及这些面试题答案，这些答案只是给大家一些参考，大家可以再结合自己理解进行回答，有需要的朋友们下面来一起看看吧。

1. 给一个数组，要求写一个函数，交换数组中的两个元素

func swap(_ nums: inout [Int], _ p: Int, _ q: Int) {
    let temp = nums[p]
    nums[p] = nums[q]
    nums[q] = temp 
}

func swap<T>(_ nums: inout [T], _ p: Int, _ q: Int) {
    let temp = nums[p]
    nums[p] = nums[q]
    nums[q] = temp 
}

func swap<T>(_ nums: inout [T], _ p: Int, _ q: Int) {
    (nums[p], nums[q]) = (nums[q], nums[p])
}

同时对以上代码写上相应测试，检测各种边界情况，再确认无误后，才会说，这道题目我完成了。
这道题目看似简单，实际上考察了程序员的审题、交流、以及测试的意识。技术上考察了Swift的泛型和Tuple的性质。

2. 下面代码有什么问题

public class Node {
  public var value: Int
  public var prev: Node?
  public var post: Node?

  public init(_ value: Int) {
    self.value = value
  }
}

答案：应该在 var prev 或者 var post 前面加上 weak。
原因：表面上看，以上代码毫无问题。但是我这样一写，问题就来了：

let head = Node(0)
let tail = Node(1)
head.post = tail
tail.prev = head

此时，head 和 tail 互相指向，形成循环引用（retain cycle）。

3. 实现一个函数，输入是任一整数，输出要返回输入的整数 + 2

这道题很多人上来就这样写：

func addTwo(_ num: Int) -> Int {
    return num + 2
}

接下来面试官会说，那假如我要实现 + 4 呢？程序员想了一想，又定义了另一个方法：

func addFour(_ num: Int) -> Int {
    return num + 4
}

这时面试官会问，假如我要实现返回 + 6, + 8 的操作呢？能不能只定义一次方法呢？正确的写法是利用 Swift 的柯西特性：

func add(_ num: Int) -> (Int) -> Int {
  return { val in
    return num + val
  }
}

let addTwo = add(2), addFour = add(4), addSix = add(6), addEight = add(8)

4. 精简以下代码

func divide(dividend: Double?, by divisor: Double?) -> Double? { 
  if dividend == nil { 
    return nil 
  }  
  if divisor == nil { 
    return nil 
  } 
  if divisor == 0 { 
    return nil
  }  
  return dividend! / divisor!
}

这题考察的是guard let语句以及optional chaining，最佳答案是:

func divide(dividend: Double?, by divisor: Double?) -> Double? { 
    guard let dividend = dividend, let divisor = divisor, divisor != 0 else {
        return nil
    }

    return dividend / divisor
}

5. 以下函数会打印出什么？

var car = "Benz" 
let closure = { [car] in 
  print("I drive \(car)")
} 
car = "Tesla" 
closure()

因为 clousre已经申明将car 复制进去了（[car]），此时clousre 里的 car是个局部变量，不再与外面的car有关，所以会打印出”I drive Benz”。
此时面试官微微一笑，将题目略作修改如下：

var car = "Benz" 
let closure = {
  print("I drive \(car)")
} 
car = "Tesla" 
closure()

此时 closure没有申明复制拷贝car，所以clousre 用的还是全局的 car 变量，此时将会打印出 “I drive Tesla”

6. 以下代码会打印出什么？

protocol Pizzeria { 
  func makePizza(_ ingredients: [String])
  func makeMargherita()
} 

extension Pizzeria { 
  func makeMargherita() { 
    return makePizza(["tomato", "mozzarella"]) 
  }
}

struct Lombardis: Pizzeria { 
  func makePizza(_ ingredients: [String]) { 
    print(ingredients)
  } 
  func makeMargherita() {
    return makePizza(["tomato", "basil", "mozzarella"]) 
  }
}

let lombardis1: Pizzeria = Lombardis()
let lombardis2: Lombardis = Lombardis() 
lombardis1.makeMargherita()
lombardis2.makeMargherita()

答案：打印出如下两行

[“tomato”, “basil”, “mozzarella”]
[“tomato”, “basil”, “mozzarella”]
在Lombardis的代码中，重写了makeMargherita的代码，所以永远调用的是Lombardis中的 makeMargherita。

再进一步，我们把 protocol Pizzeria中的 func makeMargherita()删掉，代码变为

protocol Pizzeria {
  func makePizza(_ ingredients: [String])
}

extension Pizzeria {
  func makeMargherita() {
    return makePizza(["tomato", "mozzarella"])
  }
}

struct Lombardis: Pizzeria {
  func makePizza(_ ingredients: [String]) {
    print(ingredients)
  }
  func makeMargherita() {
    return makePizza(["tomato", "basil", "mozzarella"])
  }
}

let lombardis1: Pizzeria = Lombardis()
let lombardis2: Lombardis = Lombardis()
lombardis1.makeMargherita()
lombardis2.makeMargherita()

这时候打印出如下结果：
[“tomato”, “mozzarella”]
[“tomato”, “basil”, “mozzarella”]
因为lombardis1是Pizzeria，而 makeMargherita()有默认实现，这时候我们调用默认实现。

7. Swift 中定义常量和 Objective-C 中定义常量有什么区别？

一般人会觉得没有差别，因为写出来好像也确实没差别。
OC是这样定义常量的：

const int number = 0;

Swift 是这样定义常量的：

let number = 0

首先第一个区别，OC中用 const来表示常量，而 Swift 中用let来判断是不是常量。
上面的区别更进一步说，OC中 const 表明的常量类型和数值是在compilation time 时确定的；而 Swift 中 let只是表明常量（只能赋值一次），其类型和值既可以是静态的，也可以是一个动态的计算方法，它们在runtime时确定的。

8. Swift 中 struct 和 class 什么区别？举个应用中的实例

struct是值类型，class是引用类型。
看过WWDC的人都知道，struct 是苹果推荐的，原因在于它在小数据模型传递和拷贝时比 class 要更安全，在多线程和网络请求时尤其好用。我们来看一个简单的例子：

class A {
  var val = 1
}

var a = A()
var b = a
b.val = 2

此时 a 的 val 也被改成了 2，因为 a 和 b 都是引用类型，本质上它们指向同一内存。解决这个问题的方法就是使用 struct：

struct A {
  var val = 1
}

var a = A()
var b = a
b.val = 2

此时 A 是struct，值类型，b 和 a 是不同的东西，改变 b 对于 a 没有影响。

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

这里有一个iOS交流圈：[891 488 181] 有兴趣的都可以来了解，分享BAT,阿里面试题、面试经验，讨论技术，裙里资料直接下载就行， 大家一起交流学习成长！

Swift 既是面向对象的，又是函数式的编程语言。
说 Swift 是 Object-oriented，是因为 Swift 支持类的封装、继承、和多态，从这点上来看与 Java 这类纯面向对象的语言几乎毫无差别。
说 Swift 是函数式编程语言，是因为 Swift 支持 map, reduce, filter, flatmap这类去除中间状态、数学函数式的方法，更加强调运算结果而不是中间过程。

什么是多态?什么是分类?什么是协议?

答：
多态在面向对象语言中指同一个接口有多种不同的实现方式,在OC中,多态则是不同对象对同一消息的不同响应方式;子类通过重写父类的方法来改变同一方法的实现.体现多态性
通俗来讲: 多态就父类类型的指针指向子类的对象,在函数（方法）调用的时候可以调用到正确版本的函数（方法）。
多态就是某一类事物的多种形态.继承是多态的前提;

答：
分类: 在不修改原有类代码的情况下,可以给类添加方法
Categroy 给类扩展方法,或者关联属性, Categroy底层结构也是一个结构体:内部存储这结构体的名字,那个类的分类,以及对象和类方法列表,协议,属性信息
通过Runtime加载某个类的所有Category数据
把所有Category的方法、属性、协议数据，合并到一个大数组中后面参与编译的Category数据，会在数组的前面
将合并后的分类数据（方法、属性、协议），插入到类原来数据的前面

答：
协议：协议是一套标准，这个标准中声明了很多方法，但是不关心具体这些方法是怎么实现的，具体实现是由遵循这个协议的类去完成的。
在OC中，一个类可以实现多个协议，通过协议可以弥补单继承的缺陷但是协议跟继承不一样，协议只是一个方法列表，方法的实现得靠遵循这个协议的类去实现。

文章到这里就结束了，如果你有什么意见和建议欢迎给我留言。关于面试问题的资料有兴趣可以加我了解或者咨询问题

上一篇下一篇

猜你喜欢

热点阅读