Swift知识点(五)

21. 面向协议编程、响应式编程

问:给出一个字符串,计算出里面数字的个数
var str = "1234test1234"

func numberCount(_ str: String) -> Int {
    var count = 0
    //方法一
    for c in str {
        if ("0"..."9").contains(c){
            count = count + 1
        }
    }
    return count
    
    //方法二
    for c in str where ("0"..."9").contains(c) {
        count = count + 1
    }
    return count
    
    //方法三
    let tempStr = str.filter { c in
        return ("0"..."9").contains(c)
    }
    return tempStr.count
}

let result = numberCount(str)
print(result)//8

以上几种方法,都是自定义函数方法,哪用去哪写

既然这个功能是全局性的,可以写到扩展里面:

ar str = "1234test1234"
let result = str.numberCount
print(result)

//扩展
extension String {
	//计算属性
    var numberCount: Int {
        var count = 0
        for c in str where ("0"..."9").contains(c) {
            count = count + 1
        }
        return count
    }
}

这种方法,属性名没有特殊标识,有可能String里面有一个numberCount,会造成覆盖
因此,最好命名为xx_numberCount,这种好改

如果可以str.xx.numberCount这样调用更好,看着像是私有库里面的方法

var str = "1234test1234"

struct YZ {
    var string: String
    init(_ string: String) {
        self.string = string
    }
    
    var numberCount: Int {
        var count = 0
        for c in str where ("0"..."9").contains(c) {
            count = count + 1
        }
        return count
    }
}

extension String {
    var yz: YZ {
        return YZ(self)
    }
}

let result = str.yz.numberCount
print(result)

这种做法好是好,但还有缺点,只有String的扩展,如果以后是数组或者其他类型求里面的数字个数,还要写其他的。因此,可以用泛型去做:

var str = "1234test1234"

//YZ类型,是一个Base泛型
struct YZ<Base> {
    var base: Base
    init(_ base: Base) {
        self.base = base
    }
}

extension String {
    var yz: YZ<String> {
        return YZ(self)
    }
    
    static var yz: YZ<String>.Type {
        //返回的是类类型
        return YZ<String>.self
    }
}

extension YZ where Base == String {
    var numberCount: Int {
        var count = 0
        for c in base where ("0"..."9").contains(c) {
            count = count + 1
        }
        return count
    }
    
    //类方法
    static func test() {
        print("test")
    }
}

class Person {}
extension Person {
    var yz: YZ<Person> {
        return YZ(self)
    }
}

extension YZ where Base: Person {
    //对象方法
    func run(){
        print("run")
    }
}

let result = str.yz.numberCount
print(result)//8

let person = Person()
person.yz.run()//run

//类型扩展
String.yz.test()//test

上述,使用泛型,做到不需要一个类型写一种样式

但,多个类型有公共特点,可以抽出来,但不适用抽父类,因为,有结构体、有类,Dog跟Person也没有关系。因此,这种情况下,可以使用协议,即:面向协议编程

var str = "1234test1234"
//步骤一:
//YZ类型,是一个Base泛型
struct YZ<Base> {
    var base: Base
    init(_ base: Base) {
        self.base = base
    }
}

//步骤二:
//利用协议扩展前缀属性
//协议定义
protocol YZCompatible {}
//协议的扩展(里面可以写实现)
extension YZCompatible {
    var yz: YZ<Self> {
    	set {}
    	get { YZ(self) }
    }
    static var yz: YZ<Self>.Type {
    	//写set,get是为了下面的函数可以加mutating
    	set {}
    	get { YZ<Self>.self }
    }
}

//步骤三:
//给字符串扩展功能,让String拥有前缀属性
extension String: YZCompatible {}
//给 String.yz 类对象 或 String().yz 实例对象 前缀扩展功能
extension YZ where Base == String {
    var numberCount: Int {
        var count = 0
        for c in base where ("0"..."9").contains(c) {
            count = count + 1
        }
        return count
    }
    
    //类方法
    static func test() {
        print("test")
    }
}

class Person {}
extension Person: YZCompatible {}

extension YZ where Base: Person {
    //对象方法
    func run(){
        print("run")
    }
}

class Dog {}
extension Dog: YZCompatible {}

let result = str.yz.numberCount
print(result)//8

let person = Person()
person.yz.run()//run

//类型扩展
String.yz.test()//test

响应式编程(Reactive Programing)

响应式编程简称LRP
一般与函数式融合在一起,所以也会叫做:函数响应式编程(Functional Reactive Programming,简称FRP)

比较著名、成熟的响应式框架:

  • ReactiveCocoa
    简称RAC,有OC、Swift版本

  • ReactiveX
    简称Rx,有众多编程语言的版本,比如:RxJava、RxKotlin、RxJS、RxPHP、RxGo、RxSwift

RxSwift

Observable:负责发送事件(Event)
Observer:负责订阅Observable,监听Observable发送的事件(Event)

Event有3种
next:携带具体数据
error:携带错误信息,表面Observable终止,不会再发出事件
completed:表明Observable终止,不会再发出事件

一个RxSwift的简单应用:
发送事件、订阅事件

import UIKit
//导入RxSwift
import RxSwift
import RxCocoa

class ViewController: UIViewController {
    override func viewDidLoad() {
        super.viewDidLoad()
        
        //Observable 负责发送事件
        //Observable创建的时候,Observable接收泛型,因此要具体指出类型,假设类型是Int
        //发送的是Int,到时候接收也是Int
        let observable = Observable<Int>.create { observer in
            
            //发送消息
            observer.onNext(11)
            observer.onCompleted()//到这,后面的22和33不再执行。换成error也一样
            observer.onNext(22)
            observer.onNext(33)
            observer.onCompleted()
            
            return Disposables.create()
        }
        
        //订阅Observer
        observable.subscribe { event in
            switch event {
            case .next(let element)://订阅的内容
                print("next", element)//element是Int类型,因为发送的是Int类型
            case .error(let error)://订阅发生错误
                print("eroor", error)
            case .completed://订阅完成
                print("completed")
            }
        }
    }
    
}
其他几种发送事件的方式:
//相当于next
let observable = Observable.just(1)//1

//可以多次打印,相当于next打印3次,每次打印其中一个
let observable = Observable.of(1, 2, 3)//1, 2, 3

//与上面的结果一样
let observable = Observable.from([1, 2, 3])

//如果使用just,里面放数组,相当于订阅一个数组,而不是订阅多次
let observable = Observable.just([1, 2, 3])

还可以发送定时器事件:

//dueTime x时间后开始
//period x时间执行一次
//scheduler 线程
let observable = Observable<Int>.timer(.seconds(1), period: .seconds(3), scheduler: MainScheduler.instance)
        
//因为订阅类型是Int,传给text是String,因此不行
//这里借助map,将Int值,转换为了String
observable.map { a in
	"text内容:\(a)"
}.bind(to: label.rx.text)

Disposable

每当Observable被订阅时,都会返回一个Disposable实例,当调用Disposable的dispose,就相当于取消订阅

//订阅Observer
let disposable = observable.subscribe { event in
    switch event {
    case .next(let element):
        print("next", element)
        
        label.text = String(element)
    case .error(let error):
        print("eroor", error)
    case .completed:
        print("completed")
    }
}

//某一个地方,调用dispose(),则后续不再订阅
disposable.dispose()

而下面这种,订阅后紧接着就调用dispose(),代码只订阅一次

//订阅Observer
let disposable = observable.subscribe { event in
    switch event {
    case .next(let element):
        print("next", element)
        
        label.text = String(element)
    case .error(let error):
        print("eroor", error)
    case .completed:
        print("completed")
    }
}.dispose()

利用Binder

let binder = Binder<String>(label) { label, value in
	label.text = value
}
        
Observable.just("2222").subscribe(binder).dispose()
//或者
Observable.just("2222").bind(to: binder).dispose()

22. 标准库源码分析、项目实战

Swift源码地址

下载过源码后,可以新建一个空的工程,然后将源码拉进项目中去

可以不做copy,因为只是查看

大部分源码有用信息在stdlib文件夹下,再具体下就是stdlib-public-core文件夹下

可以通过源码分析下:map、flatMap等高级函数的实现

==

var age1: Int? = nil
var age2: Int?? = nil
print(age1 == age2)//false

var age3: Int? = 10
var age4: Int?? = 10
print(age3 == age4)//true

当值为nil的时候,类型不一样,因此,不相等
当值不为nil,且值相等的时候,比较的是值,因此,相等

MetaData

MetaData是前八个字节的内容
每个类型有不同的MetaData

反射

对于任意一个类型,都能够动态获取这个类的所有属性和方法信息

Swift的反射机制目前比较弱,通过Mirror类型来提供简单的反射功能

  • 9
    点赞
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值