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
,所以这时候这个闭包已经是逃逸了
网友评论