Swift常见面试题

Swift与Object-C的联系与区别？

Swift和Objective-C 共用一套运行时环境，Swift 的类型可以桥接到Objective-C（下面我简称OC），反之亦然。两者可以互相引用混合编程。

其次就是，OC 之前积累的很多类库，在 Swift 中大部分依然可以直接使用，当然，Swift3之后，一些语法改变了很多，不过还是有迹可循的。OC出现过的绝大多数概念，比如引用计数、ARC、属性、协议、接口、初始化、扩展类、命名参数、匿名函数等，在Swift中继续有效（可能最多换个术语）。Swift大多数概念与OC一样。当然Swift也多出了一些新兴概念，这些在OC中是没有的，比如范型、元组等。

Swift 比 Objective-C 有什么优势？

• Swift 容易阅读，语法和文件结构简易化。

• Swift 更易于维护，文件分离后结构更清晰。

• Swift 更加安全，它是类型安全的语言。

• Swift 代码更少，简洁的语法，可以省去大量冗余代码。

• Swift 速度更快，运算性能更高。

Swift目前存在的缺点

• 版本不稳定，之前升级Swift3大动刀，苦了好多人。

• 使用人数比例偏低，目前还是OC的天下。

• 社区的开源项目偏少，毕竟OC独大好多年，很多优秀的类库都不支持Swift，不过这种状况正在改变，现在有好多优秀的Swift的开源类库了。

• 公司使用的比例不高，很多公司以稳为主，还是在使用OC开发，很少一些在进行混合开发，更少一些是纯Swift开发。

• 偶尔开发中遇到的一些问题，很难查找到相关资料，这是一个弊端。

• 纯Swift的运行时和OC有本质区别，一些OC中运行时的强大功能，在纯Swift中变无效了。

• 对于不支持Swift的一些第三方类库，如果非得使用，只能混合编程，利用桥接文件实现。

Swift 相比 Objective-C 独有的语法

1. 范围运算符

   a...b 表示 [a,b] 包括a和b 。 （如3...5 就是范围取3，4，5）

   a..<b 表示 [a,b) 包括a，不包括b 。 （如3...5 就是范围取3，4）

   常见的如for循环：for i in 0...9{}

2. 独有的元组类型

   元组(tuples)把多个值组合成一个复合值。元组内的值可以使任意类型,并不要求是相同类型。

var value = (Int,String) = (x:15,y:"abc")

3. swift中使用let定义常量,var定义变量 使用常量,更加安全,不能够被修改,在需要对对象进行修改的时候 只能用var修饰。

4. if let 、 guard let 的用法 缩减代码量，安全处理数据逻辑。

Swift 相比 Objective-C 细节使用区别

• swift不分.h和.m文件 ，一个类只有.swift一个文件，所以整体的文件数量比起OC有一定减少。

• swift句尾不需要分号 ，除非你想在一行中写三行代码就加分号隔开。

• swift数据类型都会自动判断 ， 只区分变量var 和常量let

• 强制类型转换格式不同 OC强转：(int)a Swift强转：Int(a)

• 关于BOOL类型更加严格 ，Swift不再是OC的非0就是真，而是true才是真false才是假

• swift的 循环语句中必须加{} 就算只有一行代码也必须要加

• swift的switch语句后面可以跟各种数据类型了 ，如Int、字符串都行，并且里面不用写break（OC好像不能字符串）

• swift if后的括号可以省略: if a>b {}，而OC里 if后面必须写括号。

• swift打印 用print("") 打印变量时可以 print("(value)")，不用像OC那样记很多%@，d%等。

• Swift3的【Any】可以代表任何类型的值，无论是类、枚举、结构体还是任何其他Swift类型，这个对应OC中的【id】类型。

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

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

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

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

请说明并比较以下关键词：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 是最低的访问权限。它的对象只能在定义的作用域内使用。离开了这个作用域，即使是同一个文件中的其他作用域，也无法访问。

请说明并比较以下关键词：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 去修饰。

在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。

Swift 和OC 如何相互调用?

• Swift 调用 OC代码

  需要创建一个 Target-BriBridging-Header.h 的桥文件,在桥文件导入需要调用的OC代码头文件即可

• OC 调用 Swift代码 直接导入 Target-Swift.h文件即可, Swift如果需要被OC调用,需要使用@objc 对方法或者属性进行修饰

用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”)
  }
}

swift中,如何阻止一个方法属性,属性,下标被子类改写?

在类的定义中使用final关键字声明类、属性、方法和下标。final声明的类不能被继承，final声明的属性、方法和下标不能被重写。

swift中,实现一个将整形数组全部转化成对应的字符串数组(eg: [1,2,3,4,5] -> ["1","2","3","4","5"])

var sampleArray: [Int] = [1,2,3,4,5]
sampleArray.map {
    String($0)
}
//["1", "2", "3", "4", "5"]

swift中,关键字 guard 和 defer 的用法

guard也是基于一个表达式的布尔值去判断一段代码是否该被执行。与if语句不同的是，guard只有在条件不满足的时候才会执行这段代码。

guard let name = self.text else {  return }

defer的用法是，这条语句并不会马上执行，而是被推入栈中，直到函数结束时才再次被调用。

defer {
   //函数结束才调用
}

swift如何自定义运算符？

Swift可以自定义运算符。自定义的运算符可以在全局使用。需要使用operator关键字。使用prefix, infix or postfix标记运算符使用的位置。

prefix operator +++ {}
prefix func +++ (inout vector: Vector2D) -> Vector2D {
    vector += vector
    return vector
}

var toBeDoubled = Vector2D(x: 1.0, y: 4.0)
let afterDoubling = +++toBeDoubled
// toBeDoubled now has values of (2.0, 8.0)
// afterDoubling also has values of (2.0, 8.0)

自定义操作符，可以定义操作符的关联性associativity和优先级precedence。associativity有三个值：left, right, none,默认是none。precedence默认值是：100。

infix operator +- { associativity left precedence 140 }
func +- (left: Vector2D, right: Vector2D) -> Vector2D {
    return Vector2D(x: left.x + right.x, y: left.y - right.y)
}
let firstVector = Vector2D(x: 1.0, y: 2.0)
let secondVector = Vector2D(x: 3.0, y: 4.0)
let plusMinusVector = firstVector +- secondVector
// plusMinusVector is a Vector2D instance with values of (4.0, -2.0)

类(class) 和 结构体(struct) 有什么区别?

在 Swift 中,class 是引用类型(指针类型), struct 是值类型

值类型

• 值类型在传递和赋值时将进行复制; 赋值给var、let或者给函数传参，是直接将所有内容拷贝一份, 类似于对文件进行copy、paste操作，产生了全新的文件副本。属于深拷贝(deep copy)
• 值类型: 比如结构体,枚举,是在栈空间上存储和操作的

引用类型

• 引用类型只会使用引用对象的一个"指向"; 赋值给var、let或者给函数传参，是将内存地址拷贝一份,类似于制作一个文件的替身(快捷方式、链接)，指向的是同一个文件。属于浅拷贝(shallow copy)

• 引用类型: 比如 Class,是在堆空间上存储和操作的

class 和 struct 比较,优缺点?

class 有以下功能,struct 是没有的:

1. class可以继承,子类可以使用父类的特性和方法
2. 类型转换可以在运行时检查和解释一个实例对象
3. class可以用 deinit来释放资源
4. 一个类可以被多次引用

struct 优势:

1. 结构较小,适用于复制操作,相比较一个class 实例被多次引用,struct 更安全
2. 无需担心内存泄露问题

Swift 中,什么可选型(Optional)

• 在 Swift 中,可选型是为了表达一个变量为空的情况,当一个变量为空,他的值就是 nil
• 在类型名称后面加个问号? 来定义一个可选型
• 值类型或者引用类型都可以是可选型变量

var name: String? // 默认为 nil
var age: Int?     // 默认为nil
print(name, age) // 打印 nil, nil

Swift,什么是泛型?

• 泛型主要是为增加代码的灵活性而生的,它可以为对应的代码满足任意类型的变量或方法;
• 泛型可以将类型参数化，提高代码复用率，减少代码量

// 实现一个方法,可以交换实现任意类型
func swap<T>(a: inout T, b: inout T) {
    (a, b) = (b, a)
}

如何理解copy-on-write?

值类型(比如:struct),在复制时,复制对象与原对象实际上在内存中指向同一个对象,当且仅当修改复制的对象时,才会在内存中创建一个新的对象,

• 为了提升性能，Struct, String、Array、Dictionary、Set采取了Copy On Write的技术
• 比如仅当有“写”操作时，才会真正执行拷贝操作
• 对于标准库值类型的赋值操作，Swift 能确保最佳性能，所有没必要为了保证最佳性能来避免赋值

什么是属性观察?

属性观察是指在当前类型内对特性属性进行监测,并作出响应,属性观察是 swift 中的特性,具有2种, willset 和 didset

var title: String {
    willSet {
        print("willSet", newValue)

    }
    didSet {
        print("didSet", oldValue, title)
    }
}

• willSet会传递新值，默认叫newValue
• didSet会传递旧值，默认叫oldValue
• 在初始化器中设置属性值不会触发willSet和didSet

swift 为什么将 String,Array,Dictionary设计为值类型?

值类型和引用类型相比,最大优势可以高效的使用内存,值类型在栈上操作,引用类型在堆上操作,栈上操作仅仅是单个指针的移动,而堆上操作牵涉到合并,位移,重链接,Swift 这样设计减少了堆上内存分配和回收次数,使用 copy-on-write将值传递与复制开销降到最低。

比较Swift 和OC中的初始化方法 (init) 有什么不同?

swift 的初始化方法,更加严格和准确, swift初始化方法需要保证所有的非optional的成员变量都完成初始化, 同时 swfit 新增了convenience和 required两个修饰初始化器的关键字

• convenience``只提供一种方便的初始化器,必须通过一个指定初始化器来完成初始化
• required是强制子类重写父类中所修饰的初始化方法

比较 Swift和OC中的 protocol 有什么不同?

• Swift 和OC中的 protocol相同点在于: 两者都可以被用作代理;

• 不同点: Swift中的 protocol还可以对接口进行抽象,可以实现面向协议,从而大大提高编程效率,Swift中的protocol可以用于值类型,结构体,枚举;

swift 和OC 中的自省 有什么区别?

自省在OC中就是判断某一对象是否属于某一个类的操作,有以下2中方式

[obj iskinOfClass:[SomeClass class]]
[obj isMemberOfClass:[SomeClass class]]

在 Swift 中由于很多 class 并非继承自 NSObject, 故而 Swift 使用 is 来判断是否属于某一类型, is 不仅可以作用于class, 还是作用于enum和struct

什么是函数重载? swift 支不支持函数重载?

• 函数重载是指: 函数名称相同,函数的参数个数不同, 或者参数类型不同,或参数标签不同, 返回值类型与函数重载无关
• swift 支持函数重载

swift 中的枚举,关联值 和 原始值的区分?

• 关联值--有时会将枚举的成员值跟其他类型的变量关联存储在一起，会非常有用

// 关联值
enum Date {
case digit(year: Int, month: Int, day: Int)
case string(String)
}

• 原始值--枚举成员可以使用相同类型的默认值预先关联，这个默认值叫做:原始值

// 原始值
enum Grade: String {
  case perfect = "A"
  case great = "B"
  case good = "C"
  case bad = "D"
}

swift 中的闭包结构是什么样子的?

{
    (参数列表) -> 返回值类型 in 函数体代码
}

什么是尾随闭包?

• 将一个很长的闭包表达式作为函数的最后一个实参
• 使用尾随闭包可以增强函数的可读性
• 尾随闭包是一个被书写在函数调用括号外面(后面)的闭包表达式

// fn 就是一个尾随闭包参数
func exec(v1: Int, v2: Int, fn: (Int, Int) -> Int) {
    print(fn(v1, v2))
}

// 调用
exec(v1: 10, v2: 20) {
    $0 + $1
}

swift中, 存储属性和计算属性的区别?

Swift中跟实例对象相关的属性可以分为2大类

存储属性(Stored Property)

• 类似于成员变量这个概念
• 存储在实例对象的内存中
• 结构体、类可以定义存储属性
• 枚举不可以定义存储属性

计算属性(Computed Property)

• 本质就是方法(函数)
• 不占用实例对象的内存
• 枚举、结构体、类都可以定义计算属性

struct Circle {
    // 存储属性
    var radius: Double
    // 计算属性
    var diameter: Double {
        set {
            radius = newValue / 2
        }
        get {
            return radius * 2
        }
    }
}

什么是延迟存储属性(Lazy Stored Property)?

使用lazy可以定义一个延迟存储属性，在第一次用到属性的时候才会进行初始化(类似OC中的懒加载)

• lazy属性必须是var，不能是let

  • let必须在实例对象的初始化方法完成之前就拥有值

• 如果多条线程同时第一次访问lazy属性

  • 无法保证属性只被初始化1次

class PhotoView {
   // 延迟存储属性
   lazy var image: Image = {
       let url = "https://...x.png"        
       let data = Data(url: url)
       return Image(data: data)
   }() 
} 

什么可选链?

可选链是一个调用和查询可选属性、方法和下标的过程，它可能为 nil 。如果可选项包含值，属性、方法或者下标的调用成功；如果可选项是 nil ，属性、方法或者下标的调用会返回 nil 。多个查询可以链接在一起，如果链中任何一个节点是 nil ，那么整个链就会得体地失败。

• 多个?可以链接在一起
• 如果链中任何一个节点是nil，那么整个链就会调用失败

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

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

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

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

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

一般人会觉得没有差别，因为写出来好像也确实没差别。

OC是这样定义常量的：

const int number = 0;

Swift 是这样定义常量的：

let number = 0

首先第一个区别，OC中用 const 来表示常量，而 Swift 中用 let 来判断是不是常量。

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

Swift函数参数设置成引用传递类型的标签是？

inout

不通过继承，代码复用（共享）的方式有哪些？

在swift 文件里直接写方法，相当于一个全局函数。

extension 给类直接扩展方法。

map、filter、reduce 的作用?

• map : 映射 ， 将一个元素根据某个函数 映射 成另一个元素（可以是同类型，也可以是不同类型）
• filter : 过滤 ， 将一个元素传入闭包中，如果返回的是false ， 就过滤掉
• reduce ：先映射后融合（这样说容易理解） ， 将数组中的所有元素映射融合在一起。

map 与 flatmap 的区别?

map不能将元素映射成可选类型，flatmap可以

swift实现一个单例？

class SingleOne {
        //单例
        static let shared = SingleOne()
        private init() {}// 阻止其他对象使用这个类的默认的'()'初始化方法
    }

//全局的常量
let single = SingleThree()
class SingleThree {
    class var SharedInstance: SingleThree {
        return single
    }
}

class SingleFour {
    static var sharedInstance: SingleFour {
        struct Static {
            static let instance: SingleFour = SingleFour();
        }
        return Static.instance;
    }
}