Inout

一般的函数传参：

func normalFunc(param:Int) {
       let newParam = param + 10
    }

  var num = 10
  normalFunc(param:(num))

param是一个Let的类型，也就是不能改变的，所以是不能直接改变传入的num的值,
使用inout可以处理这个问题

 func inOutFunc(param: inout Int) {
        param = param + 10
    }

 inOutFunc(param: &num)
 print("inout传参：",num)

能看到传参的时候多加了与一个&，在源码分析中，这种传值方式其实是传递了内存地址，使得后面函数的param和num指向同一个内存，所以能修改到num。

@discardableResult

这个修饰可以去除一个返回值无指向情况下的警告

@discardableResult
    public func setConfig(_ block:(_ m:Self)->Void) ->Self {
        block(self)
        return self
    }

在调用setConfig的时候前面没有写let xx = setConfig( 在一般情况下是会报警告，加上discardableResult便能消除

final

final显示，是限制了一个访问权限，注意的是，final是用在Class中
Only classes and class members may be marked with 'final' 因为final限制了class的一个继承覆写权限

class finalClass {
    final func funcFinal()  {
    }
    func funcFinal02()  {
    }
}

class finalSubClass: finalClass {
    override func funcFinal02() {
        
    }
}

上面的函数funcFinal是不允许在finalSubClass中覆写的

dynamic

dynamic是Swift想达到OC一样的动态派发，而使用的一个修饰词，Swift本身为了效率是默认禁用了动态派发，注意这是默认，意思是Swift其实是可以动态派发
dynamic是只针对class的，被dynamic修饰的变量和函数，会使用到动态分发，当然这样也会出现一定的效率损耗，意味着如果不是对某变量或者函数动态改变，是不应该添加dynamic的，但是涉及到kvc、kvo和Method-Swizzle那就必须使用，因为这已经使用到OC的runtime机制

方法交换

定义一个类方法，把SixViewController中的dynamicFunc方法与DynamicClass的swizzleDynamicFunc调换

extension SixViewController {
    class func initWithMethodSwizzle() {
        let originalSelector = #selector(dynamicFunc)
        let swizzledSelector = #selector(DynamicClass.swizzleDynamicFunc)
        
        let originalMethod = class_getInstanceMethod(SixViewController.self, originalSelector)
        let swizzledMethod = class_getInstanceMethod(DynamicClass.self, swizzledSelector)
        
        //在进行 Swizzling 的时候,需要用 class_addMethod 先进行判断一下原有类中是否有要替换方法的实现
        let didAddMethod: Bool = class_addMethod(SixViewController.self, originalSelector, method_getImplementation(swizzledMethod!), method_getTypeEncoding(swizzledMethod!))
        //如果 class_addMethod 返回 yes,说明当前类中没有要替换方法的实现,所以需要在父类中查找,这时候就用到 method_getImplemetation 去获取 class_getInstanceMethod 里面的方法实现,然后再进行 class_replaceMethod 来实现 Swizzing
        if didAddMethod {
            class_replaceMethod(SixViewController.self, swizzledSelector, method_getImplementation(originalMethod!), method_getTypeEncoding(originalMethod!))
        } else {
            method_exchangeImplementations(originalMethod!, swizzledMethod!)
        }
    }
}

//SixViewController
 @objc dynamic func dynamicFunc() {
        print("原方法")
    }
    

class  DynamicClass  {
    @objc func swizzleDynamicFunc() {
        print("交换后方法")
    }
}

在SixViewController调用dynamicFunc后，会跳转到swizzleDynamicFunc中，实现一个方法交换，但是原函数是需要添加 dynamic的，否则无法动态交换

KVO dynamic属性

class  DynamicClass: NSObject  {
    @objc dynamic var dynamicStr = "这是一个动态分发变量"
    
    }

   var dynamicObj = DynamicClass()
   dynamicObj.addObserver(self, forKeyPath:"dynamicStr", options:[.new, .old], context: nil)
   DispatchQueue.main.asyncAfter(deadline: .now() + 2.0, execute: {
            self.dynamicObj.dynamicStr = "修改了值"
        })
        
  override func observeValue(forKeyPath keyPath: String?, of object: Any?, change: [NSKeyValueChangeKey : Any]?, context: UnsafeMutableRawPointer?) {
        
        if (keyPath == "dynamicStr") {
            print(keyPath!,"---",change![.newKey]!)
        }
    }

注意这里的几个细节， dynamic 前要添加@objc，DynamicClass是继承与NSObject，同时addObserver中的self也是继承与NSObject

dynamicCallable与dynamicMemberLookup

动态入参操作

@dynamicMemberLookup
@dynamicCallable
class MathClass {
    
    var params = [String: Any]()
    subscript(dynamicMember member: String) -> (Double, Double) -> (Double) {
        get {
            params[member] as! ((Double, Double)->(Double))
        }
        set {
            params[member] = newValue
        }
    }
    
    func dynamicallyCall(withArguments nums: [Int]) -> [Int]{
        var newNums: [Int] = []
        for n in nums {
            newNums.append(n * 2)
        }
        return newNums
    }
    
    func dynamicallyCall<T>(withArguments dicts:[[T]]) -> [T] {
       return dicts.flatMap{$0}
    }
}

添加dynamicCallable，是要求实现 dynamicallyCall方法，且要带上withArguments命名方式。dynamicMemberLookup，是要求实现subscript，且要带上dynamicMember命名方式。

调用

  let math = MathClass()
  math.addition = { $0 + $1 }
  math.subtraction = { $0 - $1 }
  print("加法：",math.addition(10,5))
  print("减法：",math.subtraction(10,5))
        
  let math02 = MathClass()
  let nums = math02(1,2,3,4,5)
  let TArray = math02(["新"],["年"],["快"],["乐"])
  print(nums)
  print(TArray)

输出

加法： 15.0
减法： 5.0
[2, 4, 6, 8, 10]
["新", "年", "快", "乐"]

断言 assert

要注意的是assert其实是适合调试用，其判断条件为false的时候会触发后面信息，注意不是true

  func escapingBlockFunc2(_ block:((_ str:NSString)->Void)?) {
        assert(block != nil, "block不为空")
        print("断言后")
    }
    

        escapingBlockFunc2(nil)

输出：
SwiftStudy/FireViewController.swift:77: Assertion failed: block不为空

函数重载

函数重载并不是重写，并不会对原函数造成影响，重载是对同一个方法名的函数进行不一样的入参，如何理解：

   func funcLoad() {
        
    }
    
    func funcLoad(_ param:Int) {
        
    }
    
    func funcLoad(_ param:Any...) {
        
    }
    
    func funcLoad(_ param:Int, params:String) {
        
    }

在Swift中，这几个函数是可以共存
虽然名字不一样，但是入参的类型，和入参的个数不一样，他们是认为是不一样的函数

运算符重载与自定义运算符

运算符重载

函数可以重载，在Swift中运算符也可以重载
怎么说：

struct SumStruct {
    var sum1:Int
    var sum2:Int
    
    static func +(s1:SumStruct,s2:SumStruct) -> SumStruct {
        return SumStruct(sum1: s1.sum1+s2.sum1, sum2: s1.sum2+s2.sum2)
    }
}

重新对+号运算重载

   let sum = SumStruct(sum1: 10, sum2: 20) + SumStruct(sum1: 5, sum2: 5)
   print(sum)

输出：

SumStruct(sum1: 15, sum2: 25)

运算符自定义

运算符定义，首先要先了解运算符的位置：

postfix operator //后缀 如 a++

infix operator // 中缀 a + b

prefix operator // 前缀 ++a

除此之外，还需确定一个运算符的优先组 precedencegroup

precedencegroup PointMultiplicationPrecedence {
    associativity: left//左结合  --- 从左往右运算
    higherThan: AdditionPrecedence//优先级：比加法高
    lowerThan: MultiplicationPrecedence//优先级：比乘法低
}

infix operator %+ : PointMultiplicationPrecedence//定义一个%+运算符，从左往右运算

然后要对这个运算的运算方式进行实现

struct CustomOperator {
    var sum1:Int64
    var sum2:Int64
}

extension CustomOperator {
    
    static func %+(operator1:CustomOperator,operator2:CustomOperator) -> CustomOperator {
        return CustomOperator(sum1:operator1.sum1  + operator2.sum1, sum2: operator1.sum2+operator2.sum2)
    }
}

    let customOperator1 = CustomOperator(sum1: 20, sum2: 30)
    let customOperator2 = CustomOperator(sum1: 10, sum2: 20)
    let customOperator  = customOperator1 %+ customOperator2 %+ customOperator1
    
    print("自定义运算符",customOperator)