1.Swift与Objective-C的区别

2.Struct与Class的区别

3.Swift中常量与Objective-C中常量的区别

• OC中常量定义如下

const int number = 0;

ObjC中const表明的常量类型和数值是在编译时确定的；

• Swift中常量定义如下

let number = 0

Swift 中 let 只是表明常量（只能赋值一次），其类型和值既可以是静态的，也可以是一个动态的计算方法，它们在 runtime 运行时确定

4.!、?、??、is、as、as!、as?的定义

• !强制解包，如果值为nil，会报错crash掉
• ?用来声明可选值，如果变量未初始化则自动初始化nil；在操作可选值时，如果可选值时nil则不响应后续的操作；使用as?进行向下转型操作
• ?? 用来判断左侧可选值非空（not nil）时返回左侧值可选值，左侧可选值为空（nil）则返回右侧的值
• is判断某个对象是否为某个特定类的对象
• as从子类对象转换为父类对象，向上转型使用；消除二义性，数值类型转换；switch语句中进行模式匹配
• as!父类对象强制转为子类对象，如果失败会crash，属于向下转型
• as?父类对象转为子类对象，转型不成功会返回一个nil对象，成功返回可选类型(optional),需要拆包

5.Swift中final、class、static的用法

• static修饰存储属性、计算属性、类型方法，且修饰的方法不能被继承
• class修饰计算属性、类方法，修饰的方法可以继承
• final修饰的类、方法、变量是不能被继承或重写的，且通过它可以显示的指定函数的派发机制。

6.Swift中单例

class Tools {
  static let share = Tools()
  private init() {
  }
}
let tools = Tools.shared

7.Swift中延迟加载（Lazy）

    lazy var iOSResumeDescription: String = {
        return "I am an iOS developer"
    }()

懒加载存储属性只会在首次使用时才会计算初始值属性，且懒加载属性必须声明（var）为变量，因为常量属性（let）初始化之前会有值

8.Swift中的访问控制权限

• open：实例可被同一模块内所有实体访问，模块外可导入该模块即可访问，模块外可被继承和重写。
• public：实例可被同一模块内所有实体访问，模块外可导入该模块即可访问，模块外不能被继承和重写。
• internal：实例可被同一模块内所有实体访问，模块外无法访问。大部分实体默认是Internal级别。
• fileprivate：限制实例只能在它定义的文件内部（源文件）访问。
• private： 限制实体只能在它定义的作用域内及同一文件extension中访问。

9.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"
}

10.Swift存储属性与计算属性的区别

• 存储属性即成员变量，存储在实例对象的内存中
• 计算属性本质就是方法(函数)，不占用实例对象的内存
  枚举不可以定义存储属性

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

11.运算符重载

即类、结构体、枚举可以为现有的运算符提供自定义的实现

struct Point {
  var x: Int
  var y: Int
    
  // 重载运算符   
  static func + (p1: Point, p2: Point) -> Point   {       
    return Point(x: p1.x + p2.x, y: p1.y + p2.y)   
  }
}
var p1 = Point(x: 10, y: 10)
var p2 = Point(x: 20, y: 20)
var p3 = p1 + p2

12.关键字 guard 和 defer 的用法

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

guard let name = self.text else { 
  return 
}

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

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

13.Swift 中的下标是什么

subscript可以给任意类型(枚举、结构体、类)增加下标功能，语法类似于实例方法、计算属性，本质就是方法(函数)

class Point {
    var x = 0.0, y = 0.0
    subscript(index: Int) -> Double {
        set {
            if index == 0 {
                x = newValue
            } else if index == 1 {
                y = newValue }
        }
        get {
            if index == 0 {
                return x
            } else if index == 1 {
                return y
            }
            return 0
        }
    }
}

var p = Point()
// 下标赋值
p[0] = 11.1
p[1] = 22.2
// 下标访问
print(p.x) // 11.1
print(p.y) // 22.2

14.Swift 和OC中初始化方法 (init)的区别

swift初始化方法需要保证所有的非optional的成员变量都完成初始化, 同时新增了convenience和required
convenience必须通过一个指定初始化器来完成初始化
required是强制子类重写父类中所修饰的初始化方法

15.什么是属性观察

属性观察是指在当前类型内对特性属性进行监测,并作出响应

• willSet会传递新值，默认叫newValue
• didSet会传递旧值，默认叫oldValue

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

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

16.如何将Swift 中的协议(protocol)中的部分方法设计为可选(optional)

• 协议和方法前面添加 @objc,然后在方法前面添加 optional,实际上是将协议转为了OC的方式

@objc protocol someProtocol {
  @objc  optional func test()
}

• 使用扩展(extension),来规定可选方法,在 swift 中,协议扩展可以定义部分方法的默认实现

protocol someProtocol {
    func test()
}

extension someProtocol{
    func test() {
        print("test")
    }
}

17.函数重载的定义，以及 swift 支不支持函数重载

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

18.Swift 中闭包的结构，以及尾随闭包、逃逸闭包和自动闭包的定义

• 闭包结构

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

• 尾随闭包，是一个书写在函数圆括号之后的闭包表达式，函数支持将其作为最后一个参数调用

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

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

• 逃逸闭包在函数结束后调用，闭包调用逃离了函数的作用域，需要通过@escaping声明

// 定义一个数组用于存储闭包类型
var completionHandlers: [() -> Void] = []

//  在方法中将闭包当做实际参数,存储到外部变量中
func someFunctionWithEscapingClosure(completionHandler: @escaping () -> Void) {
    completionHandlers.append(completionHandler)
}

someFunctionWithEscapingClosure(_:) 函数接受一个闭包作为参数，该闭包被添加到一个函数外定义的数组中。如果你不将这个参数标记为 @escaping，就会得到一个编译错误。

• 自动闭包不接受任何参数，延迟求值，只有在被调用时才会返回被包装在其中的表达式的值，需要通过@autoclosure声明

func goodMooning(morning:Bool ,who:@autoclosure() -> String){
    if morning {
        print("Good morning, (who())")
    }
}

18.可选链的定义

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

19.OC和Swift中的扩展（Extension）区别

• OC中有分类和扩展
• Swift中只有扩展（更类似OC中的分类）
• Swif Extension中不可以直接添加属性，编译会报错
• 类、结构体、枚举类型或者协议类型都可以添加扩展

20.交换数组中的两个元素

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

func swap(a: inout Int,  b: inout Int)  {
    (a, b) = (b , a)
}

func swap<T, U>(x: T,  y: U) -> (T, U)  {
   return (y, x)
}

21.实现一个 min 函数，返回两个元素中较小的元素

func min<T : Comparable>(_ a : T , b : T) -> T {
    return a < b ? a : b
}

22.map、filter、reduce、flatmap 的作用

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

23.利用Swift 的 Currying(柯里化) 特性，输入任一整数，输出输入的整数+2

柯里化(Currying) 将原来接受两个参数的函数变成新的接受一个参数的函数的过程。新的函数返回一个以原有第二个参数为参数的函数

func addOne(count: Int) -> Int {
    return count + 2
}

func add(count: Int, addition: Int) -> Int {
    return count + addition
}

func add(_ addition: Int) -> (Int) -> Int {
    return {
        count in 
        return count + addition
    }
}

24.为什么数组索引越界会Crash,而字典用下标取值时 key 没有对应值的话返回的是 nil 不会Crash

• 数组是一段连续内存地址,越界访问也能访问到内存，但这段内存不一定可用，所以会引起Crash
• 字典的key并没有对应确定的内存地址,所以是安全的

25.associatedtype(关联类型) 的作用

• 给协议中用到的类型定义一个占位名称
• 协议中可以拥有多个关联类型

26.声明一个只有一个参数没有返回值闭包的别名

typealias SomeClosuerType = (String) -> (Void)
let someClosuer: SomeClosuerType = { (name: String) in
    print("hello,", name)
}
someClosuer("world")