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)

  • Scala学习之旅－对Option友好的flatMap 喝冰咖啡 scala学习
    聊点什么OptionflatMapvs.OptionOption的作用在Java/Scala中,Optional/Option(本文还是以scala代码为例)是用来表示某个对象存在或者不存在，也就是说,Option是某个类型T的Wrapper,如果T!=null,Option(T).isDefined==true如果T==null,Option(T).isEmpty==true有了Option这层
  • 编程学习笔记秘籍：开启高效学习之旅 青云交 java学习教学学习笔记传统纸质笔记本笔记工具选择笔记结构设计实践与复习策略掌握了高效记录并整理笔记的方法
    目录引言：正文：方向一：笔记工具选择传统纸质笔记本电子文档类工具（如MicrosoftWord、WPS等）专业编程笔记软件（如Notion、Evernote等）在线代码托管平台（如GitHub、GitLab等）方向二：笔记结构设计分类标签化建立知识关联方向三：实践与复习策略实践复习策略结束语：引言：“计算机科学教育不能使人成为程序员，就像学画笔和颜料不能使人成为画家一样。”——埃里克·雷蒙德。在当
  • flink---window 搞数据的小杰 flink大数据
    Window介绍DataStream:https://nightlies.apache.org/flink/flink-docs-release-1.17/zh/docs/dev/datastream/operators/windows/SQL:https://nightlies.apache.org/flink/flink-docs-release-1.17/zh/docs/dev/table/
  • Rust 操作符及示例 gqkmiss rustrust开发语言后端rust操作符操作符
    Rust操作符Rust提供了一系列操作符（operators），每种操作符都有特定的功能和应用场景。1.算术操作符这些操作符用于基本的数学运算：+:加法，用于两个数相加。示例:letsum=5+10;-:减法，用于两个数相减。示例:letdifference=10-5;*:乘法，用于两个数相乘。示例:letproduct=4*3;/:除法，用于两个数相除。示例:letquotient=10/2;%
  • 【Kafka专栏 11】深入理解Kafka的网络线程模型：是谁在幕后“操纵”数据流？ 夏之以寒 夏之以寒-kafka专栏kafka网络分布式网络模型
    作者名称：夏之以寒作者简介：专注于Java和大数据领域，致力于探索技术的边界，分享前沿的实践和洞见文章专栏：夏之以寒-kafka专栏专栏介绍：本专栏旨在以浅显易懂的方式介绍Kafka的基本概念、核心组件和使用场景，一步步构建起消息队列和流处理的知识体系，无论是对分布式系统感兴趣，还是准备在大数据领域迈出第一步，本专栏都提供所需的一切资源、指导，以及相关面试题，立刻免费订阅，开启Kafka学习之旅！
  • rh124第九章知识点问答----白熊的Linux学习之旅12 白白白白熊爱打APEX linux学习服务器
    第9章控制服务和守护进程1.守护进程(Daemon)是什么？列举一些常见的守护进程。答：守护进程是执行各种任务的后台等待或运行的进程。一般情况下，守护进程在系统引导时自动启动并持续运行至关机但可手动停止。且守护进程多以d结尾。常见的守护进程有Systemd2.怎么理解systemd.unit？列举一些常用的单元类型。答：systemd.unit是一个抽象的概念，用于定义一类对象，这类对象是系统知道
  • 【PHP小课堂】PHP中的数组函数学习（三） 码农老张Zy php学习android开发语言
    PHP中的数组函数学习（三）继续我们关于PHP中数组函数的学习之旅。之前就说过，数组相关的操作函数非常多，功能也非常的丰富，所以大家不要着急，还是跟着我一步一步地学习了解。毕竟有些函数确实是不太常用，但在许多业务场景下，却又会无比的方便。在这其中，最主要的是你在这个业务场景下，会不会想到系统已经默认提供的这些函数。所以，不要求全部掌握，但心里有个印象就可以了。数组搜索首先是数组搜索的功能，其实就是
  • 我的影刀RPA学习之旅：从好奇到成就 搬砖小蜗牛 影刀加油站rpa学习
    在数字化浪潮的推动下，我踏上了探索影刀RPA的旅程。这不仅是一次技能的学习，更是一场心灵的成长。以下是我学习影刀RPA的心里路程，充满了新奇的想法和最终成功的喜悦。启程：好奇心驱动的探索一切始于对自动化的好奇。在繁琐的日常任务中，我总是在想，是否有更高效的方法来处理这些重复性的工作。当我听说影刀RPA能够模拟人工操作，自动化执行任务时，我的内心充满了好奇和期待。挑战：跨越未知的障碍刚开始学习时，我
  • 开源模型应用落地-LlamaIndex学习之旅-LLMs-集成vLLM（二） 开源技术探险家 开源模型-实际应用落地#深度学习语言模型自然语言处理
    一、前言在这个充满创新与挑战的时代，人工智能正以前所未有的速度改变着我们的学习和生活方式。LlamaIndex作为一款先进的人工智能技术，它以其卓越的性能和创新的功能，为学习者带来前所未有的机遇。我们将带你逐步探索LlamaIndex的强大功能，从快速整合海量知识资源，到智能生成个性化的学习路径；从精准分析复杂的文本内容，到与用户进行深度互动交流。通过丰富的实例展示和详细的操作指南，无论你是初涉人
  • 凸优化学习之旅 还有你Y 最优化学习
    目录标题专业名词MM算法CCP算法：代码说明SCA算法：连续松弛梯度投影算法分支定界搜索法凸问题辨别OA算法λ-representationADMM算法代码说明BCD算法BCD（BlockCoordinateDescent）代码示例与ADMM的区别总结2024年5月6日15:15:26专业名词DC问题：DifferenceofConvex。Difference理解为差，convex是凸，DC问题就
  • 宋健｜Day33感恩日记 song_d807
    1.今天是高阶331练习的最后一天，没想到我也坚持到了终点。从第一天就迟交作业想退出，到中途想放弃，再到后面的习惯成自然，心态和状态都发生了变化，感恩这一次的学习之旅，看到了很多努力的同学，找到了又一个榜样。2.本来打算放弃继续331的，可是在胡老师的建议下，我又鼓起勇气再次参与。感慨我自己这种犹豫不决的性格，始终还没有变。也感恩胡老师对我的鼓舞，要改变的，是我自己，重要的是决定改变的那一刻。3.
  • Docker学习系列（七）：使用Kubernetes Operators进行应用的自动化运维管理 黄宝良 Docker运维docker学习
    使用KubernetesOperators进行应用的自动化运维管理KubernetesOperators是扩展Kubernetes功能的强大工具，可以自动化复杂的应用运维任务。本篇文章将详细介绍KubernetesOperators的概念、工作原理，并通过实际案例演示如何创建和使用Operators进行应用的自动化运维管理。一、什么是KubernetesOperators？KubernetesOp
  • RxSwift 使用踩坑 rxFatalError 走一朝
    fatalError(lastMessage)报错：PrintingdescriptionoflastMessage:"FailureconvertingfromOptional()toUIScrollViewDelegate"代码一直没有改过就集成了一个百度的bug分析第三方BaiduMobStatCodeless目前不清楚两者内部有什么冲突。
  • Java Operator SDK 快乐骑行^_^ 日常分享专栏java开发语言OperatorSDK
    JavaOperatorSDK生成项目骨架快速入门模式和最佳实践使用示例Operators实现示例OperatorQuarkusSpringBootOperators代表Kubernetes管理集群和非集群资源。这个JavaOperatorSDK(JOSDK)旨在通过使用一个对Java开发人员来说应该感觉自然的API，使编写Kubernetes操作员变得尽可能容易，并且不必担心许多低级细节，因为S
  • 路，在前方 - 草稿 84a2cad8c720
    带着憧憬和梦想走进河师大，带着期许和追求走进名师工作室，带着敬仰和神往走近余映潮老师，走进中原名师联盟课堂，开启我的学习之旅，踏上学习成长之路。一周的学习活动，带给我的不仅是精神的洗礼，更多的是发自内心的赞叹，为那些优秀的做课教师，更为我们所敬仰的语文巨匠_余映潮。作课的教师，风格各异，教学设计各具特色，或沉稳老练，自然展现；或慷慨激昂，深情演绎；或风趣幽默，引人遐思；或积淀深厚，高屋建瓴；或高雅
  • 2018.7.9北京学第一场 咋咋咋了
    经过爬山涉水来到了北京，迎接我们第一场学习之旅是何桂香老师的优化半日教学活动。图片发自App在几个小时的讲座，何老师的每个主题讲座都提出了老师们最常出现的问题，这是平时老师们易忽略但又很重要的问题，建议大家在开展活动前期一定要注意避免这些问题，同时活动后反思自己是都出现了这样的问题，一定要及时的改正。如下图1环境与材料问题；图2生活活动主要问题；图3游戏活动主要，图4户外活动主要问题；图5半日活动
  • rh124第五章知识点问答----白熊的Linux学习之旅8 白白白白熊爱打APEX linux学习运维
    1.怎么理解I/O重定向？答：I/O重定向可以更改进程获取其输入或输出的方式。可以从执行文件读取或写入而不是键盘，可以将输出或错误保存到文件而不是终端。2./dev/null是什么，有什么用途？答：它是一个空的特殊文件，但系统会持续清除其内容，可以理解为Linux中的垃圾箱但不可回收；可以用来清除不需要显示或保存的输出或错误。3.解释下列命令的结果：&>/dev/null、2>>file答：：将输
  • 那一刻我长大了 盈月Danny
    那个弯曲的背影，是我永远都忘不掉的。2020年初，一场突如其来的新冠疫情打破了我们的幸福生活，每天新闻里都会播放感染新冠的人数，数量越来越多，疫情也越来越严重，无论是工人还是学生都被迫在家工作、学习，我也开始了网课的学习之旅，在家的这段时间，是我记事以来和爸爸妈妈相处最长的一段时间了，这也让我悟透了一个道理。爸爸永远那么忙碌，我其实很想和爸爸一起吃顿饭，但他总是加班，即使在疫情期间，爸爸还在忙碌的
  • Unity学习要点 伊H 想到什么写什么学习unity游戏引擎
    前言学习Unity作为游戏开发的强大工具，对于初学者来说，掌握一些基础而实用的技巧是非常重要的。这不仅能帮助你更快地上手，还能在项目开发过程中提高效率。以下是一些Unity初学者的使用技巧，希望能为你的学习之旅提供帮助。###1.熟悉Unity界面与工作流程**开始前先浏览**：初次打开Unity，花时间熟悉编辑器的各个部分，如Hierarchy（层次结构）、Scene（场景）、Inspector
  • 奇妙的云端之旅 静待花开1975
    这一场遇见，新鲜而又奇妙，未曾相约，也不曾预告。我和我新一届的学生就这样相聚云端，踏上了长达三年的语文学习之旅。在这之前，我认真做了开学第一课的规划设计，设想了种种和学生相见的画面，甚至连我的每一个微笑，每一句话语，都做了精心的预设，但现在，这些显然都没有用了。大病初愈的新疆比以前更加谨慎，城市解封后第一时间就下达了延迟开学，网络授课的命令。于是，省去繁琐的入学手续，网络报名，建班级群，开视频会，
  • Chapter 06 axios使用指南 Heaven645 vue.js前端Vueaxios
    欢迎大家订阅【Vue2+Vue3】入门到实践专栏，开启你的Vue学习之旅！文章目录前言一、导入二、发送GET请求三、发送POST请求四、处理响应前言在现代前端开发中，与后端API进行数据交互是至关重要的。Axios是一个基于Promise的HTTP客户端，用于浏览器和Node.js。本文详细介绍了Axios的基本用法。一、导入导入官网提供的axios在线地址：二、发送GET请求axios.get(
  • 考研备考是选择电子学习工具无纸化学习？还是纸质版训练考感？ zhanger0807 考研考研数学考研数学二考研
    作为一名成功上岸的考研学子，回顾备考的艰辛历程，深感学习工具的选择至关重要。在当今数字化时代，我们面临着一个关键的抉择：是延续传统的纸质版资料学习，还是投身于电子学习工具的怀抱，开启无纸化学习之旅呢？一、电子学习工具的独特魅力选择一款适合自己的电子学习工具尤为重要，在这里我以我自己在备战考研时使用的一款免费的自学考研学习工具——"考研数学欧几里得”APP为例子，谈谈我使用电子学习工具的一些体验和感
  • 闭关一个月，找到真正的自己！ 简自强
    就我目前来看有几个问题需要解决，虽然坚持日更却没有达到精益求精的效果，反而水平开始下降，开始敷衍了事。这是在骗自己，再有太过于杂乱没有具体的细分领域进行，还是没搞清楚自己想要什么！是应该读书写笔记呢？还是记录自己职业技能资料，或者是喜欢游离在编程世界的代码行中，有时又兴趣使然做几首小诗！多则乱，乱则散，散则心不达！精力有限，爱好太多这造成我内心焦虑不安，给自己减负重新开始学习之旅！
  • 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年时间没有写文章了，所以当要写复盘文字的时候我就犯难，虽然我脑子里有好多话想说。正应了简言老师说的那句话——人生最大的悲哀是：有嘴不会说，有手不会写。吐槽完自己，我该进入正题了。这一次学习玛雅应该算是我第二次接触玛雅吧。第一次是在去年，也是简言老师
  • 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其他