美文网首页
swift开发日志(一){命名空间,泛型,闭包}

swift开发日志(一){命名空间,泛型,闭包}

作者: cyhai | 来源:发表于2022-01-24 18:09 被阅读0次

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

相关文章

  • swift开发日志(一){命名空间,泛型,闭包}

    swift 的命名空间 涉及到NSClassFromString,在Swift中的使用方式与OC是有区别,并不像O...

  • Swift入门二(对象函数)

    函数 闭包 GCD 尾随闭包 闭包循环引用解决(OC) 闭包循环引用解决(swift推荐) 面向对象 命名空间: ...

  • Swift三剑客

    Swift三剑客:闭包、泛型和协议 一、闭包 如何看闭包,晕 参考文章:谈一谈闭包 1、闭包定义: 在计算机科学中...

  • iOS开发 - 「Swift 学习」Swift泛型

    Swift泛型 泛型函数 以上是交换两个任意相同类型值的泛型函数,T是一个占位命名类型,swift不会查找命名为T...

  • Swift中泛型的使用

    在使用Swift开发的过程中,我们可能经常会碰到泛型。那么究竟什么是泛型?泛型作为Swift最为强大的特性之一,该...

  • swift4 泛型(一)

    swift 泛型 OC 是没有泛型也不支持命命空间的,但是swift中这两者都有,本章主要介绍 泛型 对于iOS开...

  • 2019-08-13jquery组件的写法

    闭包限定命名空间 (function($) { //默认参数 vardefaluts= { foreground:...

  • Swift中Array的map flatMap filter r

    map 1.map方法的定义 map函数接收一个闭包做参数,闭包本身参数是原数组的元素,闭包返回值是一个泛型,由泛...

  • 11.命名空间,对象枚举

    命名空间的作用:管理变量,防止全局污染,适用于模块化开发,闭包的变量私有化就是一个很好的处理命名空间的问题. 小技...

  • JavaScript学习之路-闭包

    一、闭包? 闭包一词想必iOS开发的童鞋指定很熟悉,Objective-C上的闭包叫Block,Swift上就叫闭...

网友评论

      本文标题:swift开发日志(一){命名空间,泛型,闭包}

      本文链接:https://www.haomeiwen.com/subject/prowhrtx.html