swift开发日志（一）{命名空间，泛型，闭包}

swift 的命名空间

涉及到NSClassFromString，在Swift中的使用方式与OC是有区别，并不像OC可以直接往NSClassFromString()放入字符串类型的类名即可，Swift这样是找不到的

BundleName + . +Classname

列子：

   var name = Bundle.main.object(forInfoDictionaryKey: "CFBundleExecutable") as? String
    name = name?.replacingOccurrences(of: "-", with: "_")
    let fullClassName = name! + "." + className
    let classType = NSClassFromString(fullClassName) 

泛型

泛型，如同字面意思，没有固定的数据类型，而根据传入的类型决定是哪一种个类型，一般不是明确在< >里面传入明确类型，都是会根据传入的第一个参数或者指向者类型来决定

方法泛型

    func setFanTypeFun<T>( index: Int64) -> T where T:BaseIdViewObj

//调用
   let t1:BaseIdViewObj002 = (objT.swiftT?.setFanTypeFun(index: 24))!

其中的意思就是T代表着类型（泛型），T指向当前引用者的类型，而返回值也是引用者的类型而且有条件，这个类型继承BaseIdViewObj这个类或者遵从这个协议，t1是指向BaseIdViewObj002，而BaseIdViewObj002是继承BaseIdViewObj，所以可以通过并会返回，但是返回类型是BaseIdViewObj002类型。

类泛型

class FanTypeClass<T> {
    var fanObj: T?
    func fanTypeFunc(param:T) {
    }
}

    let fan = FanTypeClass<String>()
    fan.fanObj = "字符串"
    fan.fanTypeFunc(param: "字符串")

这个类规定了fanObj的类型是泛型，和fanTypeFunc方法入参是泛型，< >中标明是String类型，则，里面的就是String类型

再定义两个静态函数，相当于类函数

class FanTypeClass<T> {
   var fanObj: T?
   var objInt: Int64 = 0
   func fanTypeFunc(param:T) {
   
   }
   static func fanTypeClassFunc(param:T) -> T where T == TestStruct {
       return param
   }
   static func fanTypeClassFuncPro(param:T) ->T where T:FanTypeProtocol {
       return param
   }
   
}

创建一个结构体，一个协议和遵从协议的两个类

struct TestStruct  {
   var str:String?
   var num: Double?
}

protocol FanTypeProtocol {
   var str:String?{get}
   var num: Double?{get}
}

//extension FanTypeProtocol {
//    
//}

class TestProtocolClass: FanTypeProtocol {
   var str: String? {
       return "TestProtocolClass"
   }
   
   var num: Double? {
       return 100.0
   }
}

class TestProtocolClass02: FanTypeProtocol {
   var str: String? {
       return "TestProtocolClass02"
   }
   
   var num: Double? {
       return 99.0
   }
   
   
}

调用函数

       let structObj = TestStruct(str: "字符串", num: 1.002)
       let testS2 = FanTypeClass.fanTypeClassFunc(param: structObj)
       
       let obj01 = TestProtocolClass()
       let testS3 = FanTypeClass.fanTypeClassFuncPro(param: obj01)
       
       let obj02 = TestProtocolClass02()
       let testS4 = FanTypeClass.fanTypeClassFuncPro(param: obj02)
       
       print(testS2, "\n" ,testS3, "\n" ,testS4)

最终返回的对象的类型是

 TestStruct
 TestProtocolClass 
 TestProtocolClass02

枚举泛型

enum FanTypeEnum<T>{
    case FanTypeEnum001(param:T)
    case FanTypeEnum002
    case FanTypeEnum003

}

extension FanTypeEnum {
    func doSomeThingWithParam(p:T) {
        switch self {
        case .FanTypeEnum001(let param):
            print("可选项001:\n",param,p,"/n数据类型：",T.self)
        case .FanTypeEnum002:
            print("可选项002")
        case .FanTypeEnum003:
            print("可选项003")
        }
    }
}

调用

    let enumObj = FanTypeEnum.FanTypeEnum001(param: "传入类型为字符串\n")
    enumObj.doSomeThingWithParam(p:"函数入参也必须是字符串")

输出为

可选项001:
 传入类型为字符串
 函数入参也必须是字符串 /n数据类型： String

协议泛型

协议使用泛型和class、struct和enum有所区别，是不能直接用<>，而是使用associatedtype

///协议
protocol FanTypeTestProtocol {
    associatedtype Element:FTestClass
    var typeObj:Element?{get}
    var typeStr:String?{get}
    
    func fanTypeFunc(param:Element)->Void
    func fanTypeFuncReturn(param:Int64) -> Element
}

extension FanTypeTestProtocol {
    var typeObj:Element? {
        if (Element.self != FTestClass.self) {
            return Element()
        }
        return  FTestClass() as? Self.Element//给与默认类型
    }
    var typeStr:String?{
        return "处理改玩意实现为可选"
    }
    func fanTypeFunc(param: Element) {
        print("实际类型为：",param.self)
    }
    
    func fanTypeFuncReturn(param: Int64) -> Element {
        if param == 64 {
            return Element()
        }
        return self.typeObj!
    }
    
}

注意协议不是拿来实现的，是用来声明的，为保证协议的实现可选性，可以进行extension，extension中可以对协议声明的东西进行进一步实现

class FTestClass {
    required init() {
        print("初始化")
    }
}

class FTTestSubClass: FTestClass {
    
}


class FanTypeForProClass<MyType:FTestClass>: FanTypeTestProtocol {
    typealias Element = MyType
    
//    var typeObj: FTestClass? {
//        return FTestClass()//重写，覆盖协议扩展中的实现
//    }
//    var typeStr:String?{
//        return "注意这里类型指向"
//    }
//    func fanTypeFunc(param: FTestClass) {
//
//    }
    
//    func fanTypeFuncReturn(param: Int64) -> FTestClass {
//
//        return self.typeObj!
//    }
    
}

正如上面所说的，因为实现了extension，所以使用FanTypeTestProtocol协议的类可以选择不实现协议中的东西，而默认走extension里面的现实方式。
注意这里的typealias（类型别名，就是给类型起另一个名称），在你继承这个协议但是没有实现协议的东西的时候，但是有泛型存在，你需要使用typealias来明确Element是什么类型

调用

     let obj = FanTypeForProClass<FTTestSubClass>()
     let test = obj.fanTypeFuncReturn(param:64)
     obj.fanTypeFunc(param: test)
        
     let obj2 = FanTypeForProClass<FTestClass>()
     let test2 = obj2.fanTypeFuncReturn(param:63)
     obj2.fanTypeFunc(param: test2)

输出为

初始化
实际类型为： SwiftStudy.FTTestSubClass
初始化
实际类型为： SwiftStudy.FTTestSubClass

闭包

闭包大致是分四种：
普通闭包
自动闭包
尾随闭包
逃逸闭包

普通闭包

     ///普通闭包
      let noBlock = {
            return 1
     }
     
    let nBlock = { (make: Int64) in
       return make + 1
    }
    
    let m = nBlock(10)
    print("普通闭包：",m) //m=11

尾随闭包

可以逃离参数范围，追加在其后的一种闭包，可以看下面例子
普通方式：

///尾随闭包，Any...，可以传0个参数或者多个
    func paramBlockFunc(_ m:Any..., a:Int64, str:String,_ block:((_ make:String)->Void)?) {
        block?(str)
        print("入参：",m,a,str)
    }
    

调用

 paramBlockFunc(a: 30, str: "不实现尾随闭包", nil)
//普通闭包调用方式
paramBlockFunc(20,30,40, a: 40, str: "普通方式调用闭包", {
           print($0)
})
// 尾随闭包方式
 paramBlockFunc(20,30,40, a: 40, str: "尾随闭包") { make in
     print(make)
 }
//或者
 paramBlockFunc(20,30,40, a: 40, str: "尾随闭包") {
           print($0)
 }
        

输出结果：

入参： [] 30   不实现尾随闭包
入参： [20,30,40] 40    普通方式调用闭包
入参： [20,30,40] 40    尾随闭包

自动闭包

自动闭包是自动创建闭包，是以block做为参数传递，并且不接受任何参数，怎么理解呢
添加@autoclosure修饰的闭包，会自动形成闭包
这个闭包无法传入参数
自动闭包，可以做到延迟执行方式

以下的闭包，意思是，autoBlock是自动闭包，自动创建闭包，autoBlock可以理解为一个函数，返回一个String类型

   func autouBlockFunc(autoB autoBlock:@autoclosure () -> String) {
        let str = autoBlock()//如果不执行autoBlock(),是不执行闭包内容的，可以做到一种延迟执行
        print("自动闭包",str)
    }

调用

  var str = "哈哈哈哈哈哈"
  
  let autouBlockStringAdd = { () -> String in
  str = str.appending("\n笑个屁")
    return str
  }
  
  autouBlockFunc(autoB: autouBlockStringAdd())

定义一个block（autouBlockStringAdd），然后将block当做参数传给函数autouBlockFunc
当然也可以直接写入代码块注意后面加上()，因为@autoclosure ()后面呢跟随着一个类型， 而且@autoclosure 参数的参数类型必须是 '()'就是void

  autouBlockFunc(autoB:{str.appending("\n笑个屁")}())

逃逸闭包

逃逸闭包，可以脱离作用域的束缚，并被储存起来，和OC的block属性调用类似

看代码：

 var escapingBlock:((NSString)->Void)?

 func escapingblockFunc(_ block:@escaping (_ str:NSString)->Void) {
    escapingBlock = block
 }

 DispatchQueue.main.asyncAfter(deadline: .now() + 1.5, execute: {
            self.escapingBlock?("逃逸闭包")
        })
     
  escapingblockFunc { str in
            print(str)
  }

和OC的block一样，会存在一个相互持有问题，造成内存泄漏
比如：

  escapingblockFunc { str in
            print(str)
            self.blockFunc()
   }

在逃逸block中使用到self，就会造作一个内存泄漏，这时候和OC类似，需要进行self弱化，有两种写法
常用写法

 escapingblockFunc {[weak self]  str in
            print(str)
            self?.blockFunc()
  }

通用写法

  weak var weakSelf = self
  escapingblockFunc {  str in
            print(str)
            weakSelf?.blockFunc()
   }

除了使用escaping闭包会出现这种情况，其实以下写法也会

func escapingblockFunc(_ block:((_ str:NSString)->Void)?) {
 escapingBlock = block
}

因为这种写法也一样会把block保存起来，出了这个函数的作用域后仍然存在，
编译器也给出了答案Closure is already escaping in optional type argument,所以这时候这个闭包已经是逃逸了