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)
