ripple_k
ripple_k

RxSwift学习之旅-Operators

Operators是RxSwift的基本组成部分，它的重要性就不言而喻了，前面只是提到在我们开发中，当收到observable发出.next的事件时，如果其携带的value并不是我们想要直接拿来使用的那个value，那我们就需要在我们拿到最终的value之前，对数据进行相应的处理

Filtering Operators

Ignoring operators

ignoreElements

ignoreElements能够忽略.next的事件，当我们只关心observable sequence是否结束时使用

example(of: "ignoreElements") {
    let strikes = PublishSubject()
    
    strikes.ignoreElements().subscribe({ (event) in
        print(event)
    }).disposed(by: dispose)
    
    strikes.onNext("X")
    strikes.onNext("X")
    strikes.onCompleted()
//    strikes.onError(MyError.myError)
}
--- Example of: ignoreElements ---
completed

上述事例中，我们使用ignoreElements忽略了两次.onNext("X")事件，只有当stries发出onCompleted或onError事件时，我们的订阅才能接收到响应，整个过程如下图所示


RxSwift学习之旅-Operators_第1张图片
Snip20170525_2.png
elementAt

有些时候你只关注第n个元素发出的事件，而忽略其它事件elementAt就派上用场了

example(of: "elementAt") { 
    let strikes = PublishSubject()
    
    strikes.elementAt(2).subscribe({ (event) in
        print(event)
    }).disposed(by: dispose)
    
    strikes.onNext("1")
    strikes.onNext("2")
    strikes.onNext("3")
    strikes.onNext("4")
}
--- Example of: elementAt ---
next(3)
completed

需要注意的是，上述事例中，我们并没有发出completed事件，但是当observable sequence响应到指定下下标元素的.onNext事件后，observable sequence会主动结束。提醒一下，这个下标是从0开始的哦~

那如果我们提前发送了completed事件会怎样呢

example(of: "elementAt") { 
    let strikes = PublishSubject()
    
    strikes.elementAt(2).subscribe({ (event) in
        print(event)
    }).disposed(by: dispose)
    
    strikes.onNext("1")
    strikes.onNext("2")
    strikes.onCompleted()
    strikes.onNext("3")
    strikes.onNext("4")
}
--- Example of: elementAt ---
error(Argument out of range.)

当订阅还没有响应到指定下标的事件而提前发出.onCompleted()的话，这时候响应的将是一个error。整个过程如下图所示


RxSwift学习之旅-Operators_第2张图片
Snip20170525_3.png
filter

filter只允许满足条件的value通过

example(of: "filter") { 
    Observable.of(1,2,3,4,5,6,7,8,9,10).filter({ (value) -> Bool in
        value % 2 == 0
    }).subscribe({ (event) in
        print(event)
    }).disposed(by: dispose)
}
--- Example of: filter ---
next(2)
next(4)
next(6)
next(8)
next(10)
completed

过程如下图


RxSwift学习之旅-Operators_第3张图片
Snip20170525_5.png

Skipping operators

skip

skip跳过前几个

example(of: "skip") { 
    Observable.of("A", "B", "C", "D", "E", "F", "G").skip(3).subscribe({ (event) in
        print(event)
    }).disposed(by: dispose)
}
--- Example of: skip ---
next(D)
next(E)
next(F)
next(G)
completed

如图


RxSwift学习之旅-Operators_第4张图片
Snip20170525_6.png
skipWhile

skipWhile一旦有元素让通过，后面的元素都被允许通过

example(of: "skipWhile") { 
    Observable.of(1,2,3,4,5,6,7,8,9,10,2,3,4).skipWhile({ (value) -> Bool in
        return value < 5
    }).subscribe({ (event) in
        print(event)
    }).disposed(by: dispose)
}
--- Example of: skipWhile ---
next(5)
next(6)
next(7)
next(8)
next(9)
next(10)
next(2)
next(3)
next(4)
completed

如图


RxSwift学习之旅-Operators_第5张图片
Snip20170525_8.png
skipUntil

skipUntil(Observable)直到Observable发出.next事件，才允许通过

example(of: "skipUntil") {
    let subject = PublishSubject()
    let trigger = PublishSubject()
    
    subject.skipUntil(trigger).subscribe({ (event) in
        print(event)
    }).disposed(by: dispose)
    
    subject.onNext("A")
    subject.onNext("B")
    trigger.onNext("aaa")
    subject.onNext("C")
    subject.onNext("D")
}
--- Example of: skipUntil ---
next(C)
next(D)

直到trigger发出.onNext("aaa")事件，subject才能响应事件，如图


RxSwift学习之旅-Operators_第6张图片
Snip20170525_9.png

Taking operators

take

take(n)只取前n个值。取完后自己completed

example(of: "take") { 
    Observable.of(1,2,3,4,5,6,7,8,9).take(3).subscribe({ (event) in
        print(event)
    }).disposed(by: dispose)
}
--- Example of: take ---
next(1)
next(2)
next(3)
completed

如果n>elememt的个数，则全部取完后结束，如图


RxSwift学习之旅-Operators_第7张图片
Snip20170525_10.png
takeWhileWithIndex

takeWhileWithIndex从第一个元素开始取，takeWhileWithIndex闭包的两个参数分别代表序列中的元素和下标，takeWhileWithIndex闭包中的条件只要不成立则终止取值

example(of: "takeWhileWithIndex") { 
    Observable.of(1,2,3,4,3,2,7,8,9).takeWhileWithIndex({ (element, index) -> Bool in
        return element < 5 && index < 3
    }).subscribe({ (event) in
        print(event)
    }).disposed(by: dispose)
}
--- Example of: takeWhileWithIndex ---
next(1)
next(2)
next(3)
completed
takeUntil

takeUntil(Observable)只要Observable发出.next事件，则序列终止

example(of: "takeUntil") {
    let subject = PublishSubject()
    let trigger = PublishSubject()
    
    subject.takeUntil(trigger).subscribe({ (event) in
        print(event)
    }).disposed(by: dispose)
    
    subject.onNext("1")
    subject.onNext("2")
    trigger.onNext("X")
    subject.onNext("3")
}
--- Example of: takeUntil ---
next(1)
next(2)
completed

trigger发出.onNext("X")事件，subject终止响应事件，如图


RxSwift学习之旅-Operators_第8张图片
Snip20170525_11.png

takeUntil在RxCocoa中有一个很好的应用场景

 someObservable.takeUntil(self.rx.deallocated) .subscribe(onNext: {
      print($0)
 })

Distinct operators

distinctUntilChanged

distinctUntilChanged如果连续的value相同，则被忽略，直到发生改变

example(of: "distinctUntilChanged") {
    Observable.of("A", "A", "B", "B", "A").distinctUntilChanged()
        .subscribe(onNext: {
        print($0)
    }).addDisposableTo(dispose)
}
--- Example of: distinctUntilChanged ---
A
B
A

如图


RxSwift学习之旅-Operators_第9张图片
Snip20170525_12.png
distinctUntilChanged(comparer: @escaping (Self.E, Self.E) throws -> Bool)

自定义一个比较器，只有符合比较器条件的值才能通过

example(of: "distinctUntilChanged(comparer: @escaping (Self.E, Self.E) throws -> Bool)") {
    Observable.of(1,2,3,10,10,5,6,70,8,9).distinctUntilChanged({ (element1, element2) -> Bool in
        print("element1:", element1, "element2:", element2)
        return element1 > element2
    }).subscribe({ (event) in
        print(event)
    }).disposed(by: dispose)
}
--- Example of: distinctUntilChanged(comparer: @escaping (Self.E, Self.E) throws -> Bool) ---
next(1)
element1: 1 element2: 2
next(2)
element1: 2 element2: 3
next(3)
element1: 3 element2: 10
next(10)
element1: 10 element2: 10
next(10)
element1: 10 element2: 5
element1: 10 element2: 6
element1: 10 element2: 70
next(70)
element1: 70 element2: 8
element1: 70 element2: 9
completed

上面例子中，自定义比较器element1 > element2，条件不成立，则element1取较大的值，并发射，element2依次往后取与element1进行比较。原理如图

RxSwift学习之旅-Operators_第10张图片
Paste_Image.png

Transforming Operators

toArray

将序列中的若干元素转换为一个数组元素

example(of: "toArray") { 
    let disposeBag = DisposeBag()
    
    Observable.of("A", "B", "C").toArray().subscribe({ (event) in
        print(event)
    }).disposed(by: disposeBag)
}
--- Example of: toArray ---
next(["A", "B", "C"])
completed
RxSwift学习之旅-Operators_第11张图片
Snip20170601_1.png
map

将sequence中的值进行自定义转换

example(of: "map") { 
    let disposeBag = DisposeBag()
    
    Observable.of(1,2,3).map({
        $0 * 2
    }).subscribe(onNext: { (value) in
        print(value)
    }).disposed(by: disposeBag)
}
--- Example of: map ---
2
4
6
RxSwift学习之旅-Operators_第12张图片
Snip20170601_2.png
mapWithIndex
example(of: "mapWithIndex") {
    let disposeBag = DisposeBag()
    
    Observable.of(1,2,3,4,5,6).mapWithIndex({ (integer, index) in
        index > 2 ? integer * 2 : integer
    }).subscribe({
        print($0)
    }).disposed(by: disposeBag)
}
--- Example of: mapWithIndex ---
next(1)
next(2)
next(3)
next(8)
next(10)
next(12)
completed
RxSwift学习之旅-Operators_第13张图片
Snip20170601_3.png
flatMap

将一个序列发射的值转换成序列，然后将他们压平到一个序列。这也类似于 SequenceType 中的 flatMap。比如说我想将Observable 的序列转换为 Observable 序列

example(of: "flatMap") { 
    struct Student {
        var score: Variable
    }
    
    let disposeBag = DisposeBag()
    
    let xiaoMing = Student(score: Variable(80))
    let xiaoHong = Student(score: Variable(95))
    
    let student = PublishSubject()
    
    student.asObservable().flatMap({
        $0.score.asObservable()
    }).subscribe({
        print($0)
    }).disposed(by: disposeBag)
    
    student.onNext(xiaoHong)
    student.onNext(xiaoMing)
    
    xiaoMing.score.value = 100
    
}
--- Example of: flatMap ---
next(95)
next(80)
next(100)
RxSwift学习之旅-Operators_第14张图片
Snip20170601_4.png
flatMapLatest

跟flatMap相比较，flatMapLatest只能响应最后一个元素值的变化

example(of: "flatMapLatest") {
    struct Student {
        var score: Variable
    }
    
    let disposeBag = DisposeBag()
    
    let xiaoMing = Student(score: Variable(80))
    let xiaoHong = Student(score: Variable(95))
    
    let student = PublishSubject()
    
    student.asObservable().flatMapLatest({
        $0.score.asObservable()
    }).subscribe({
        print($0)
    }).disposed(by: disposeBag)
    
    student.onNext(xiaoMing)
    xiaoMing.score.value = 65
    
    student.onNext(xiaoHong)
    xiaoMing.score.value = 88
    xiaoHong.score.value = 100
    
}
--- Example of: flatMapLatest ---
next(80)
next(65)
next(95)
next(100)
RxSwift学习之旅-Operators_第15张图片
Snip20170601_5.png

Combining Operators

startWith

指定队列起始元素

example(of: "startWith") { 
    let numbers = Observable.of(2,3,4)
    
    let observable = numbers.startWith(1)
    observable.subscribe(onNext: { (element) in
        print(element)
    }).dispose()
}
--- Example of: startWith ---
1
2
3
4
RxSwift学习之旅-Operators_第16张图片
Snip20170601_6.png
Observable.concat

合并两个队列，concat合并的两个sequence元素必须是相同类型

example(of: "Observable.concat") {
    let first = Observable.of(1,2,3)
    let second = Observable.of(4,5,6)
    
    let observable = Observable.concat([first, second])
    observable.subscribe(onNext: { (element) in
        print(element)
    }).dispose()
}
--- Example of: Observable.concat ---
1
2
3
4
5
6
concat
example(of: "concat") { 
    let germanCities = Observable.of("Berlin", "Münich", "Frankfurt")
    let spanishCities = Observable.of("Madrid", "Barcelona", "Valencia")
    let observable = germanCities.concat(spanishCities)
    observable.subscribe(onNext: { value in
        print(value)
    }).dispose()
}
--- Example of: concat ---
Berlin
Münich
Frankfurt
Madrid
Barcelona
Valencia
concat one element
example(of: "concat one element") {  
    let numbers = Observable.of(2,3,4)
    
    let observable = Observable.just(1).concat(numbers)
    observable.subscribe(onNext: { (element) in
        print(element)
    }).dispose()
}
--- Example of: concat one element ---
1
2
3
4
RxSwift学习之旅-Operators_第17张图片
Snip20170601_7.png
merge

把两个sequence合并成一个

example(of: "merge") { 
    let left = PublishSubject()
    let right = PublishSubject()
    
    let source = Observable.of(left.asObservable(), right.asObservable())
    let observable = source.merge()
    let disposable = observable.subscribe(onNext: { value in
        print(value)
    })
    
    var leftValues = ["Berlin", "Munich", "Frankfurt"]
    var rightValues = ["Madrid", "Barcelona", "Valencia"]
    repeat {
        if arc4random_uniform(2) == 0 {
            if !leftValues.isEmpty {
                left.onNext("Left:  " + leftValues.removeFirst())
            }
        } else if !rightValues.isEmpty {
            right.onNext("Right: " + rightValues.removeFirst())
        }
    } while !leftValues.isEmpty || !rightValues.isEmpty
    
    disposable.dispose()
}
--- Example of: merge ---
Right: Madrid
Right: Barcelona
Left:  Berlin
Right: Valencia
Left:  Munich
Left:  Frankfurt
RxSwift学习之旅-Operators_第18张图片
Snip20170601_8.png
combineLatest

将两个observable绑定，只有当它们都发出事件的时候才能subscribe到它们的最新发送的值

example(of: "combineLatest") { 
    let left = PublishSubject()
    let right = PublishSubject()
    
    let observable = Observable.combineLatest(left,right)
    let disposable = observable.subscribe(onNext: { (left,right) in
        print(left,right)
    })
    
    print("> Sending a value to Left")
    left.onNext("Hello,")
    print("> Sending a value to Right")
    right.onNext("world")
    print("> Sending another value to Right")
    right.onNext("RxSwift")
    print("> Sending another value to Left")
    left.onNext("Have a good day,")
    
    disposable.dispose()
}
--- Example of: combineLatest ---
> Sending a value to Left
> Sending a value to Right
Hello, world
> Sending another value to Right
Hello, RxSwift
> Sending another value to Left
Have a good day, RxSwift

example(of: "combine user choice and value") {
    let choice : Observable =
        Observable.of(.short, .long)
    let dates = Observable.of(Date())
    let observable = Observable.combineLatest(choice, dates) {
        (format, when) -> String in
        let formatter = DateFormatter()
        formatter.dateStyle = format
        return formatter.string(from: when)
    }
    observable.subscribe(onNext: { value in
        print(value)
    })
}
--- Example of: combine user choice and value ---
6/1/17
June 1, 2017
RxSwift学习之旅-Operators_第19张图片
Snip20170601_9.png
zip

把多个sequence合并为一个sequence，当所有的observable都产生element的时候，selector function会生成一个对应索引的element

example(of: "zip") {
    enum Weather {
        case cloudy
        case sunny
    }
    let bag = DisposeBag()
    
    let left = Observable.of(.sunny, .cloudy, .cloudy, .sunny)
    let right = Observable.of("Lisbon", "Copenhagen", "London", "Madrid", "Vienna")
    
    let observable = Observable.zip(left, right){ (weather, city) -> String in
        "it's \(weather) in \(city)"
    }
    observable.subscribe(onNext: { (result) in
        print(result)
    }).addDisposableTo(bag)
}
--- Example of: zip ---
it's sunny in Lisbon
it's cloudy in Copenhagen
it's cloudy in London
it's sunny in Madrid
RxSwift学习之旅-Operators_第20张图片
Snip20170602_10.png

Triggers

withLatestFrom

将两个 observable sequence 合并到一个 observable sequence ，每当self发出element将获取到第二个 observable sequence 的最新element

example(of: "withLatestFrom") {
    let bag = DisposeBag()
    
    let button = PublishSubject()
    let textField = PublishSubject()
    
    let observable = button.withLatestFrom(textField)
    observable.subscribe(onNext: { (text) in
        print(text)
    }).addDisposableTo(bag)
    
    textField.onNext("Par")
    textField.onNext("Pari")
    textField.onNext("Paris")
    
    button.onNext()
    button.onNext()
}
--- Example of: withLatestFrom ---
Paris
Paris
RxSwift学习之旅-Operators_第21张图片
Snip20170602_11.png
sample

每当sampler产生一个.next()事件，将从源sequence中获取最新element，如果在sampler两次事件间隔中源sequence没有新element产生，则获取不到element

example(of: "sample") {
    let bag = DisposeBag()
    
    let button = PublishSubject()
    let textField = PublishSubject()
    
    let observable = textField.sample(button)
    observable.subscribe(onNext: { (text) in
        print(text)
    }).addDisposableTo(bag)
    
    textField.onNext("Par")
    textField.onNext("Pari")
    textField.onNext("Paris")
    
    button.onNext()
    button.onNext()
}
--- Example of: sample ---
Paris
RxSwift学习之旅-Operators_第22张图片
Snip20170602_12.png

Switches

amb

两个observable sequence谁先发送element谁就是第一响应者。

example(of: "amb") {
    let left = PublishSubject()
    let right = PublishSubject()

    let observable = left.amb(right)
    let disposable = observable.subscribe(onNext: { value in
        print(value)
    })

    right.onNext("Copenhagen")
    left.onNext("Lisbon")
    left.onNext("London")
    left.onNext("Madrid")
    right.onNext("Vienna")
    disposable.dispose()
}
--- Example of: amb ---
Copenhagen
Vienna
RxSwift学习之旅-Operators_第23张图片
Snip20170602_13.png
switchLatest

响应最新的observable sequence中的element

example(of: "switchLatest") {
    let one = PublishSubject()
    let two = PublishSubject()
    let three = PublishSubject()
    
    let source = PublishSubject>()
    let observable = source.switchLatest()
    let dispose = observable.subscribe(onNext: { (value) in
        print(value)
    })
    
    source.onNext(one)
    one.onNext("one first")
    two.onNext("two first")
    
    source.onNext(two)
    one.onNext("one second")
    two.onNext("two second")
    
    source.onNext(three)
    three.onNext("three first")
    one.onNext("one third")
    three.onNext("three second")
    
    source.onNext(two)
    two.onNext("two third")
    three.onNext("three third")
}
--- Example of: switchLatest ---
one first
two second
three first
three second
two third
RxSwift学习之旅-Operators_第24张图片
Snip20170602_14.png
reduce

将一个observable sequence中的元素做一个累加，返回一个单一的结果。第一个参数为最初的累加值

example(of: "reduce") { 
    let source = Observable.of(1, 3, 5, 7, 9)
    
    let observable = source.reduce(0, accumulator: { summary, newValue in
        return summary + newValue
    })
   // 可简写为    
   // let observable = source.reduce(0, accumulator: +)
    
    observable.subscribe(onNext: { value in
        print(value)
    })
}
--- Example of: reduce ---
25
RxSwift学习之旅-Operators_第25张图片
Snip20170602_15.png
scan

将一个observable sequence中的元素做一个累加，返回每个累加结果。第一个参数为最初的累加值

example(of: "scan") { 
    let source = Observable.of(1,3,5,7,9)
    
    let observable = source.scan(0, accumulator: { (summary, newValue) -> Int in
        return summary + newValue
    }) 
    // 可简写为  
    // let observable = source.scan(0, accumulator: +)
    observable.subscribe(onNext: { (value) in
        print(value)
    })
}
--- Example of: scan ---
1
4
9
16
25
RxSwift学习之旅-Operators_第26张图片
Snip20170602_16.png
小结

最后提一下RxSwift所有的Operators都是定义在ObservableType的协议延展里面的，返回值都是 -> RxSwift.Observable，以满足开发者在日常开发中的链式调用，所以在日常开发中，你可以这样写代码

 input.skipWhile { $0 == 0 }
        .filter { $0 < 10 }
        .take(10)
        .toArray()
        .subscribe(onNext: {
            print($0)
        })
        .addDisposableTo(disposeBag)

你可能感兴趣的:(RxSwift学习之旅-Operators)

  • 闭关一个月，找到真正的自己！ 简自强
    就我目前来看有几个问题需要解决，虽然坚持日更却没有达到精益求精的效果，反而水平开始下降，开始敷衍了事。这是在骗自己，再有太过于杂乱没有具体的细分领域进行，还是没搞清楚自己想要什么！是应该读书写笔记呢？还是记录自己职业技能资料，或者是喜欢游离在编程世界的代码行中，有时又兴趣使然做几首小诗！多则乱，乱则散，散则心不达！精力有限，爱好太多这造成我内心焦虑不安，给自己减负重新开始学习之旅！
  • IOS 14 封装网络请求框架 sziitjin IOSios
    本文基于IOS13网络请求和Moya框架，对网络请求框架Moya的二次封装，并实现JSON对象解析等。添加依赖#网络请求框架#https://github.com/Moya/Moyapod'Moya/RxSwift'#避免每个界面定义disposeBag#https://github.com/RxSwiftCommunity/NSObject-Rxpod"NSObject+Rx"#JSON解析为对
  • 如何提高学习效率？ Hufy
    很多人渴望学习能速成，但更重要的是理解学习是什么。学习不只是储备大量的知识，更是要改变我们的思维和行动方式，改变我们看待世界的方式。学习并不是记忆大量的信息，而是指改变我们的思维和行为方式。学习来自经验，涉及不同范例的转换，这改变了我们看待世界的方式。学习的最佳状态是带动思想、身体和精神，当思想、身体和精神投入其中，就开启了一段平衡而连续的学习之旅。图片发自App1、抛弃提步向前的想法当开始真正学
  • 为什么学习Python 莫辜负自己的一世韶光
    我第一门学的语言是C语言,后来因为公司内部业务需要,要去快速的开发一个小型的网站.公司当时又招不到人.就尝试让公司的人做一哈,然后就开始了Python的学习之旅.当时因为有编程基础,所以就从框架开始看,哪里不懂,就百度查询.然后后来的一切学习都是基于热爱了,Python这门语言确实比较易学,并且优雅简洁.因为个人比较赶兴趣的点是网站全栈开发,自己最熟悉的模块是Django框架,文档基本读完,并且其
  • 编程路上的“迷宫逃脱”：从Bug堆到算法之巅的奇妙之旅 隐私无忧 万花筒#乱78糟bugAIGC
    编程路上的“迷宫逃脱”：从Bug堆到算法之巅的奇妙之旅嘿，各位编程界的勇士们，欢迎来到这场既刺激又充满挑战的编程学习之旅！在这条路上，我们不仅要与代码为伍，还要与那些让人头疼不已的Bug斗智斗勇。但请相信，每一次的跌倒和迷茫，都是通往高手之路的必经之路。今天，就让我这位IT领域的“老油条”，用专业又不失幽默的语气，和大家聊聊如何在Bug的迷宫中找到出口，以及在复杂的算法面前保持冷静的秘诀吧！一、B
  • Python速成指南：从零开始的编程之旅 gpt4简单就能用 python开发语言人工智能pandas算法哈希算法
    前言：为什么选择Python？在开始我们的Python学习之旅之前，让我们先思考一个问题：为什么要学习Python？为什么在众多编程语言中，Python如此受欢迎？简单易学：Python的语法简洁明了，非常接近自然语言，这使得初学者能够快速上手。应用广泛：从Web开发到数据分析，从人工智能到科学计算，Python几乎无所不能。丰富的生态系统：Python拥有海量的第三方库和框架，能够轻松实现各种复
  • #产品体系学习之旅# 日日日gungun
    以用户为中心的设计a）你自己是产品的深度用户b）不要为了1%的可能，去影响99%的用户c）质量比数量更重要，对活跃用户的关注要远大于新增用户d）关注产品的长期发展（一年以后），而非短期利益（产品、运营、销售、kpi）e）拼死维护用户的利益，有一个大不了不干了的精神I：以用户为中心，这里有三个关键点：①用户—作为产品经理，要清楚自己的产品主次要功能是什么，用户为何而来，用户的使用目的；②中心—这个主
  • 玛雅13月亮历法学习心路历程——第一天 再次接触玛雅，被惊讶到了 Amelia_0bf8
    昨天即7月26号，玛雅历法新年磁性白巫师年的第一天，同时在这一天里，我开启了我的玛雅历法学习之旅。今天我要写学习完第一节课的复盘文字。说真的，我已经有6年时间没有写文章了，所以当要写复盘文字的时候我就犯难，虽然我脑子里有好多话想说。正应了简言老师说的那句话——人生最大的悲哀是：有嘴不会说，有手不会写。吐槽完自己，我该进入正题了。这一次学习玛雅应该算是我第二次接触玛雅吧。第一次是在去年，也是简言老师
  • MATLAB 2023a：强化学习算法的实战演练与性能评估 zmjia111 机器学习matlabmatlab算法开发语言深度学习机器学习yolo
    在深度学习领域，MATLAB2023版深度学习工具箱以其完整的工具链和高效的运行环境，为研究人员和开发者提供了前所未有的便利。这一工具箱不仅集成了建模、训练和部署的全部功能，更以其简洁易用的语法和强大的算法库，为深度学习任务的快速实现铺平了道路。相较于Python等编程语言，MATLAB的语法更为直观，上手更为迅速。无需繁琐的环境配置和库安装，用户只需打开MATLAB界面，即可轻松开始深度学习之旅
  • [坚持＋努力]我的圆梦之旅/尖椒中学文科学习分享 安定区张虎
    参加尖椒中学文科学习一来，我每节课都没有落下，有些课程我反复听了好几遍，而且还做了笔记。我不仅被凉水井中学的课程所吸引，还被凉水井中学勇于探索的精神所打动，他们的老师感觉都是专家，都是充满能量的人。尖椒文科的学习已经结束了，期待下一期的课程，我现在对这次学习之旅的成果做个汇报总结。图片发自App一、思想的彻底转变以学生为中心的教学模式，刚接触时我也曾经为之痴迷过，也曾因此对自己的教学做过尝试性的改
  • RxSwift如何选择操作符? MMD_
    amb多个Observables中，取第一个发出元素的Observablebuffer缓存元素当元素达到某个数量，然后将元素集合发送出来catchError拦截一个error事件，将他替换成其他的元素或一组元素，使得正常结束catchErrorJustReturn将error事件替换成其他的一个元素，然后结束该序列combineLatest将多个Observables中最新的元素通过一个函数组合起
  • Vue路由模式 几何心凉 前端小常识vue.js前端javascript
    聚沙成塔·每天进步一点点本文内容⭐专栏简介路由模式1.Hash模式2.History模式选择路由模式的考虑因素⭐写在最后⭐专栏简介Vue学习之旅的奇妙世界欢迎大家来到Vue技能树参考资料专栏！创建这个专栏的初衷是为了帮助大家更好地应对Vue.js技能树的学习。每篇文章都致力于提供清晰、深入的参考资料，让你能够更轻松、更自信地理解和掌握Vue.js的核心概念和技术。订阅这个专栏，让我们一同踏上更深入
  • 牢记初心不忘誓言—我的青椒学习之旅 镇雄068钟婷
    我从未想过我会选择老师这个职业，当我从考场走出后我还在反问自己，为何报考老师？我自己给不出答案，也许是一时的心血来潮，也许是为了随大流，但最终，我考上了，成为了一名小学老师。一、校园第一堂课第一次走上属于我的讲台，讲台下几十个孩子整整齐齐的坐着，我感觉有点忐忑不安，全身都在冒汗，一声“老师好”让我更加的慌乱了，一双双充满着求知欲望的眼睛紧紧盯着我，我慌忙让孩子们赶紧坐下，颤抖着打开了课本，开始了我
  • Python初学之旅：探索、挑战与收获 琛哥的程序 python开发语言
    自从我决定踏入编程的大门，Python成为了我选择的第一把钥匙。这把钥匙不仅为我打开了一个全新的世界，还让我在其中找到了乐趣、挑战和不断的成长。在此，我想分享我作为初学者的Python学习之旅，记录那些摸索、尝试和突破的时刻。在开始学习之前，我对编程几乎一无所知，只知道它是一种让计算机执行任务的方式。选择Python作为起点，是因为听闻它的语法简洁、易于上手，而且应用领域广泛。但真正踏入学习之后，
  • Angular + rxjs 实现 某个方法防抖 clearlove_lwc Angularangular.js前端
    场景：监听输入变化从而触发搜索方法或某个方法的搜索框、输入框等//引入rxjs等包import{Subject}from'rxjs';import{distinctUntilChanged,debounceTime}from'rxjs/operators';举例：search()方法会调用getList()这个方法向后台查询数据//预置方法/*调用后台查询数据接口*/getList(){*****
  • Angular中如何实现防抖和节流 crary,记忆 前端知识总结angular.jsjavascript前端angular
    在Angular中实现防抖和节流的方法有多种，这篇博客主要是详细介绍两种常用的方法：使用RxJS操作符和使用Angular自带的工具。使用RxJS操作符实现防抖和节流：防抖（Debounce）：//简易版import{debounceTime}from'rxjs/operators';input.valueChanges.pipe(debounceTime(300)).subscribe(valu
  • 活动回顾｜RocketMQ 运维经验圆桌交流「第二期」 后端java
    2023年12月3日，AutoMQ举办了第二场线上交流会RocketMQ运维经验圆桌交流「第二期」，本次交流会汇聚了RocketMQ的作者以及来自腾讯云、网易、社区的技术专家。在这个充满交流热情的活动中，大家共同探讨了RocketMQ的运维经验，分享了宝贵的见解。接下来让我们一起回顾此次RocketMQ运维学习之旅！从用户堆积问题看RocketMQ可观测的实现腾讯云RocketMQ技术专家李伟老师
  • #产品体系学习之旅# 日日日gungun
    认识产品的正确姿势a）系列化：单点突破、延伸同类、以点带面；b）深度体验：多次重复认真的完成主流用户的任务；c）追踪式体验：跟踪任务效果、跟踪版本迭代过程；I：我觉得这就是一个广度和深度认识产品的过程，广度指的是：系列化—从点到面，深度就是多次重复完成任务（分为一般任务和会员任务）&追踪式体验（追踪这个事项的发展）A1：我目前的手里的需求分析和竞品分析是一个很好的锻炼机会，这两个事情是可以横纵向发
  • 看到孩子抑郁的真相，我不再折腾孩子，转而踏踏实实修理自己 郁金香抗抑郁
    本篇作者|阿星本篇编辑|董小姐插图来源|illustrator_225今日导读如果你还在认为孩子休学、厌学、抑郁、叛逆、仇亲....是因为孩子自身出了问题，那么，今天这位妈妈的故事，也许会转变的你的一些观念。作者阿星妈妈，是一位在郁金香成长起来的妈妈，2018年，因为自己和小女儿同时出现抑郁状况，她来到郁金香求助，随后跌跌撞撞地开始了自己的探索和学习之旅，本就有抑郁症状、阅读与思维能力大幅下降的她
  • 菜鸟的树莓派Raspberry Pi学习之旅（三）——更换软件源 King_Joker97 菜鸟的树莓派RaspberryPi学习之旅学习linux
    文章目录前言一、为什么要给树莓派更换软件源二、如何给树莓派更换软件源1.检查系统架构、版本2.修改配置文件2.1修改软件包镜像源2.2修改系统软件源2.3同步更新源2.4修改更新软件报包总结前言上一篇文章中，我们学习了如何安装树莓派操作系统RaspberryPiOS，这一次我们来讨论为什么以及如何给树莓派更换软件源。一、为什么要给树莓派更换软件源树莓派默认的软件源是外国的软件源，国内虽然可以连接使
  • C++ opencv之图像像素的算术操作 阿超没有蛀牙 OpenCVopencv
    这节课我们来学习图像像素的读写操作。文章目录一、像素的加减乘除操作1、加法操作：2、减法操作：3、除法操作：4、乘法操作一、像素的加减乘除操作1、加法操作：voidQuickDemo::operators_Demo(Mat&image){Matdst;dst=image+Scalar(50,50,50);imshow("加法操作",dst);}输出结果为：可以明显的感受到右边这幅图，亮度增强了。o
  • C++opencv图像算数操作-加减乘除 忙什么果 opencvc++opencv开发语言
    quick_opencv.h#includeusingnamespacecv;classQuickDemo{public:voidoperators_demo(Mat&image);//图像算数操作};QuickDemo.cpp#include//图像算数操作voidQuickDemo::operators_demo(Mat&image){Matdst1,dst2,dst3,dst4;//超出25
  • 【成长】遇见更好的自己――我的青椒学习之旅 陕县2270王爱霞
    时间过的真快参加青椒学习，不知不觉已经快一年啦！能参加这次青椒学习是我的荣幸。当第一次看到青椒规划时，我内心出现过波动，可是经过一段时间的学习，我开始转变自己的观念，学习是一种乐趣，更是一种成长！只要你用真心对待她，她所回报给你的远远超过你付出的。加油坚持到底就是胜利。图片发自App永远保持一颗童心。永远带着童心走进孩子的世界,那么你将是一个永远让孩子喜爱的老师。童心拉近我和孩子之间的距离用童心接
  • 早点睡觉，快乐出发！ 向阳花开_田英瑞
    图片发自App田英瑞焦点18期，持续分享1053天（20180817，周五）今晚凉快，出去散了会儿步，脱掉了鞋子，光着脚丫，坐在干净凉爽的台阶上，无比放松！看人、看树、看车水马龙，美美的心情！明天和几个伙伴出去学习，是没去过的地方，没见过的老师；那里有我期待的伙伴，期待的课程！今天做好了一切准备，只为了这次的快乐学习之旅！早点休息，明早快乐出发！
  • 【遇见青椒 遇见不断成长的自己】我的青椒学习之旅 陕县2104赵姗
    沪江CCtalk直播课给我们大家带来了全新的理念，全新的课堂，更有利于我们合作与交流、协作与共享。依托现代信息技术手段，开发和利用网上教育资源，建立开放、交互动态的网络直播平台，实现资源的交流与共享，以教育消息化推动教育现代化。从2017年9月开始学习至今，每一次的直播课都让我收获满满，坚持收看直播已经成为我生活学习中不可或缺的部分。一、观看直播，更新教育理念。在沪江CCtalk直播课上，我们有幸
  • 梦想实现——我的尖椒学习之旅 陕县1565李娜
    乡村教师青椒计划开播已有八个月之久，从最初接触这一网络培训，原以为跟以往的网络培训一样，讲一些高大上却没有什么实际意义的内容，因此学习也是流于形式。直到有一天真正坐下聆听课程时，才发现里面别有洞天：既有北京大学教授讲述的理论知识，更有来自一线的成功经验，两者相得益彰。于是变化在悄然中发生：由别人提醒着学习到自觉投入其中:由跟帖到发帖......被动向主动转变，还在别人的指导下下载了，我在拓展我的空
  • 520快乐 说吧演讲高级班候语者郭为
    城市花火今日总结：1、首先，今晚精彩的课程，大家精彩的演说，让我更加熟悉大家，看到每一位伙伴的勇敢和成长2、今日完成《拆掉思维里的墙》阅读打卡，有点仓促3、今日专业课打卡，新的一门课程开课，这是最认真的一次课了，喜欢老师4、今日去领了英语词典快递，OMYGOD!精彩学习之旅再次开始吧明日计划：1、早起锻炼，元气满满。2、专业课学习，又有新的课程开始啦啦啦3、《拆掉思维里的墙》阅读打卡；《沉重的翅膀
  • 《与青椒共成长》我的青椒学习之旅 陕县1200张建荣
    耳旁依然回想着专家们热爱教育事业、无私奉献、精益求精的敬业精神以及老师们那谦虚谨慎、友善宽容的态度。我时常在思考：为什么他们的课堂总是那么丰富多采？他们的见解总是那么的深邃？他们的角度总是那么恰到好处？透过近一年的青椒学，使我深受启发。图片发自App一、充分发挥教师的主导作用。在课堂教学中，教师的主导作用是不容忽视的。在先学后教，当堂训练的教学模式上，教师的主导作用就应体此刻精心的准备上，体此刻简
  • 勤勉至学–我的青椒学习之旅 灵宝0189陈沛
    时光匆匆，我的教学生活伴随着青椒学习成长着。一次次学习，一次次进步，虽然忙碌，即使匆匆，但这种成长中的充实让人欣喜、雀跃。眼瞅着学生们课堂上学得开心、学得到位，班级风貌焕然一新，我也看到了自己的成长，也由衷的感谢青椒变辣椒的蜕变之师–乡村青年教师的教授们。看看我的孩子们，我的班级管理成效就洋溢在孩子们自信的脸蛋上；从你走进班级、走近孩子，就可以看出班级各项活动的井然有序……不得不说，在青椒上我学到
  • 2022年11月24日 星期四 晴｜Day85 小白儿三十
    2022年11月24日星期四晴｜Day85#生命故事写作《美好大学·舍友7》01感恩日记请写下“我对今天心存感激的1件事”。今天，我最想感恩的是，自己。今日是感恩节，也许是自己最近开始写“感恩日记”并切身体会到它的好处。所以，这一天对我来说，还挺特别！（具体在成功日记中详述）感恩自己，2021年4月底，踏上了知识付费的学习之旅。这一路走来，收获满满~敬请期待我的年终复盘大戏吧！！！我计划未来1个月
  • JAVA基础 灵静志远 位运算加载Date字符串池覆盖
    一、类的初始化顺序 1 （静态变量，静态代码块）-->（变量，初始化块）--> 构造器 同一括号里的，根据它们在程序中的顺序来决定。上面所述是同一类中。如果是继承的情况，那就在父类到子类交替初始化。 二、String 1 String a = "abc"; JAVA虚拟机首先在字符串池中查找是否已经存在了值为"abc"的对象，根
  • keepalived实现redis主从高可用 bylijinnan redis
    方案说明 两台机器（称为A和B），以统一的VIP对外提供服务 1.正常情况下，A和B都启动，B会把A的数据同步过来（B is slave of A） 2.当A挂了后，VIP漂移到B；B的keepalived 通知redis 执行：slaveof no one，由B提供服务 3.当A起来后，VIP不切换，仍在B上面；而A的keepalived 通知redis 执行slaveof B，开始
  • java文件操作大全 0624chenhong java
    最近在博客园看到一篇比较全面的文件操作文章，转过来留着。 http://www.cnblogs.com/zhuocheng/archive/2011/12/12/2285290.html 转自http://blog.sina.com.cn/s/blog_4a9f789a0100ik3p.html 一.获得控制台用户输入的信息    &nbs
  • android学习任务 不懂事的小屁孩 工作
    任务 完成情况 搞清楚带箭头的pupupwindows和不带的使用 已完成 熟练使用pupupwindows和alertdialog，并搞清楚两者的区别 已完成 熟练使用android的线程handler,并敲示例代码 进行中 了解游戏2048的流程，并完成其代码工作 进行中-差几个actionbar 研究一下android的动画效果，写一个实例 已完成 复习fragem
  • zoom.js 换个号韩国红果果 oom
    它的基于bootstrap 的 https://raw.github.com/twbs/bootstrap/master/js/transition.js  transition.js模块引用顺序 <link rel="stylesheet" href="style/zoom.css"> <script src=&q
  • 详解Oracle云操作系统Solaris 11.2 蓝儿唯美 Solaris
    当Oracle发布Solaris 11时，它将自己的操作系统称为第一个面向云的操作系统。Oracle在发布Solaris 11.2时继续它以云为中心的基调。但是，这些说法没有告诉我们为什么Solaris是配得上云的。幸好，我们不需要等太久。Solaris11.2有4个重要的技术可以在一个有效的云实现中发挥重要作用：OpenStack、内核域、统一存档（UA）和弹性虚拟交换（EVS）。 
  • spring学习——springmvc（一） a-john springMVC
    Spring MVC基于模型-视图-控制器（Model-View-Controller，MVC）实现，能够帮助我们构建像Spring框架那样灵活和松耦合的Web应用程序。   1，跟踪Spring MVC的请求 请求的第一站是Spring的DispatcherServlet。与大多数基于Java的Web框架一样，Spring MVC所有的请求都会通过一个前端控制器Servlet。前
  • hdu4342 History repeat itself-------多校联合五 aijuans 数论
    水题就不多说什么了。 #include<iostream>#include<cstdlib>#include<stdio.h>#define ll __int64using namespace std;int main(){ int t; ll n; scanf("%d",&t); while(t--)
  • EJB和javabean的区别 asia007 beanejb
    EJB不是一般的JavaBean,EJB是企业级JavaBean,EJB一共分为3种,实体Bean,消息Bean,会话Bean,书写EJB是需要遵循一定的规范的,具体规范你可以参考相关的资料.另外,要运行EJB,你需要相应的EJB容器,比如Weblogic,Jboss等,而JavaBean不需要,只需要安装Tomcat就可以了   1.EJB用于服务端应用开发, 而JavaBeans
  • Struts的action和Result总结 百合不是茶 strutsAction配置Result配置
        一:Action的配置详解:      下面是一个Struts中一个空的Struts.xml的配置文件     <?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE struts PUBLIC &quo
  • 如何带好自已的团队 bijian1013 项目管理团队管理团队
    在网上看到博客" 怎么才能让团队成员好好干活"的评论，觉得写的比较好。 原文如下： 我做团队管理有几年了吧，我和你分享一下我认为带好团队的几点： 1.诚信         对团队内成员，无论是技术研究、交流、问题探讨，要尽可能的保持一种诚信的态度，用心去做好，你的团队会感觉得到。 2.努力提
  • Java代码混淆工具 sunjing ProGuard
    Open Source Obfuscators ProGuard http://java-source.net/open-source/obfuscators/proguardProGuard is a free Java class file shrinker and obfuscator. It can detect and remove unused classes, fields, m
  • 【Redis三】基于Redis sentinel的自动failover主从复制 bit1129 redis
    在第二篇中使用2.8.17搭建了主从复制，但是它存在Master单点问题，为了解决这个问题，Redis从2.6开始引入sentinel，用于监控和管理Redis的主从复制环境，进行自动failover，即Master挂了后，sentinel自动从从服务器选出一个Master使主从复制集群仍然可以工作，如果Master醒来再次加入集群，只能以从服务器的形式工作。   什么是Sentine
  • 使用代理实现Hibernate Dao层自动事务 白糖_ DAOspringAOP框架Hibernate
    都说spring利用AOP实现自动事务处理机制非常好，但在只有hibernate这个框架情况下，我们开启session、管理事务就往往很麻烦。 public void save(Object obj){ Session session = this.getSession(); Transaction tran = session.beginTransaction(); try
  • maven3实战读书笔记 braveCS maven3
    Maven简介 是什么？ Is a software project management and comprehension tool.项目管理工具 是基于POM概念(工程对象模型) [设计重复、编码重复、文档重复、构建重复，maven最大化消除了构建的重复] [与XP：简单、交流与反馈；测试驱动开发、十分钟构建、持续集成、富有信息的工作区]     功能：
  • 编程之美-子数组的最大乘积 bylijinnan 编程之美
    public class MaxProduct { /** * 编程之美 子数组的最大乘积 * 题目: 给定一个长度为N的整数数组，只允许使用乘法，不能用除法，计算任意N-1个数的组合中乘积中最大的一组，并写出算法的时间复杂度。 * 以下程序对应书上两种方法，求得“乘积中最大的一组”的乘积——都是有溢出的可能的。 * 但按题目的意思，是要求得这个子数组，而不
  • 读书笔记-2 chengxuyuancsdn 读书笔记
    1、反射 2、oracle年-月-日 时-分-秒 3、oracle创建有参、无参函数 4、oracle行转列 5、Struts2拦截器 6、Filter过滤器(web.xml) 1、反射 (1)检查类的结构 在java.lang.reflect包里有3个类Field,Method,Constructor分别用于描述类的域、方法和构造器。 2、oracle年月日时分秒 s
  • [求学与房地产]慎重选择IT培训学校 comsci it
          关于培训学校的教学和教师的问题,我们就不讨论了,我主要关心的是这个问题       培训学校的教学楼和宿舍的环境和稳定性问题       我们大家都知道，房子是一个比较昂贵的东西，特别是那种能够当教室的房子... &nb
  • RMAN配置中通道(CHANNEL)相关参数 PARALLELISM 、FILESPERSET的关系 daizj oraclermanfilespersetPARALLELISM
    RMAN配置中通道(CHANNEL)相关参数 PARALLELISM 、FILESPERSET的关系 转 PARALLELISM --- 我们还可以通过parallelism参数来指定同时"自动"创建多少个通道： RMAN > configure device type disk parallelism 3 ; 表示启动三个通道，可以加快备份恢复的速度。
  • 简单排序:冒泡排序 dieslrae 冒泡排序
    public void bubbleSort(int[] array){ for(int i=1;i<array.length;i++){ for(int k=0;k<array.length-i;k++){ if(array[k] > array[k+1]){
  • 初二上学期难记单词三 dcj3sjt126com sciet
    concert 音乐会 tonight 今晚 famous 有名的；著名的 song 歌曲 thousand 千 accident 事故；灾难 careless 粗心的，大意的 break 折断；断裂；破碎 heart 心（脏） happen  偶尔发生，碰巧 tourist 旅游者；观光者 science （自然）科学 marry 结婚 subject 题目；
  • I.安装Memcahce 1. 安装依赖包libevent Memcache需要安装libevent,所以安装前可能需要执行 Shell代码 收藏代码 dcj3sjt126com redis
    wget http://download.redis.io/redis-stable.tar.gz tar xvzf redis-stable.tar.gz cd redis-stable make   前面3步应该没有问题，主要的问题是执行make的时候，出现了异常。 异常一： make[2]: cc: Command not found 异常原因：没有安装g
  • 并发容器 shuizhaosi888 并发容器
       通过并发容器来改善同步容器的性能，同步容器将所有对容器状态的访问都串行化，来实现线程安全，这种方式严重降低并发性，当多个线程访问时，吞吐量严重降低。    并发容器ConcurrentHashMap       替代同步基于散列的Map，通过Lock控制。   &nb
  • Spring Security（12）——Remember-Me功能 234390216 Spring SecurityRemember Me记住我
    Remember-Me功能   目录   1.1     概述 1.2     基于简单加密token的方法 1.3     基于持久化token的方法 1.4     Remember-Me相关接口和实现
  • 位运算 焦志广 位运算
    一、位运算符Ｃ语言提供了六种位运算符： & 按位与 | 按位或 ^ 按位异或 ~ 取反 << 左移 >> 右移 1. 按位与运算 按位与运算符"&"是双目运算符。其功能是参与运算的两数各对应的二进位相与。只有对应的两个二进位均为1时，结果位才为1 ，否则为0。参与运算的数以补码方式出现。 例如：9&am
  • nodejs 数据库连接 mongodb mysql liguangsong mongodbmysqlnode数据库连接
    1.mysql 连接    package.json中dependencies加入     "mysql":"~2.7.0"    执行 npm install      在config 下创建文件 database.js    
  • java动态编译 olive6615 javaHotSpotjvm动态编译
        在HotSpot虚拟机中，有两个技术是至关重要的，即动态编译(Dynamic compilation)和Profiling。     HotSpot是如何动态编译Javad的bytecode呢？Java bytecode是以解释方式被load到虚拟机的。HotSpot里有一个运行监视器，即Profile Monitor,专门监视
  • Storm0.9.5的集群部署配置优化 roadrunners 优化storm.yaml
    nimbus结点配置（storm.yaml）信息： # Licensed to the Apache Software Foundation (ASF) under one # or more contributor license agreements. See the NOTICE file # distributed with this work for additional inf
  • 101个MySQL 的调节和优化的提示 tomcat_oracle mysql
    　1. 拥有足够的物理内存来把整个InnoDB文件加载到内存中——在内存中访问文件时的速度要比在硬盘中访问时快的多。 　　2. 不惜一切代价避免使用Swap交换分区 – 交换时是从硬盘读取的，它的速度很慢。 　　3. 使用电池供电的RAM（注：RAM即随机存储器）。 　　4. 使用高级的RAID（注：Redundant Arrays of Inexpensive Disks，即磁盘阵列
  • zoj 3829 Known Notation(贪心) 阿尔萨斯 ZOJ
    题目链接：zoj 3829 Known Notation 题目大意：给定一个不完整的后缀表达式，要求有2种不同操作，用尽量少的操作使得表达式完整。 解题思路：贪心，数字的个数要要保证比∗的个数多1，不够的话优先补在开头是最优的。然后遍历一遍字符串，碰到数字+1，碰到∗-1,保证数字的个数大于等1，如果不够减的话，可以和最后面的一个数字交换位置（用栈维护十分方便），因为添加和交换代价都是1
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他