服务计算 - 修改、改进 RxGo 包

最新推荐文章于 2020-11-10 10:22:16 发布
最新推荐文章于 2020-11-10 10:22:16 发布
阅读量156 收藏
点赞数
分类专栏： 服务计算 文章标签： go
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/crd39/article/details/109581751
版权

ReactiveX

Reactive Extensions的缩写，一般简写为Rx，最初是LINQ的一个扩展，由微软的架构师Erik Meijer领导的团队开发，在2012年11月开源，Rx是一个编程模型，目标是提供一致的编程接口，帮助开发者更方便的处理异步数据流，Rx库支持.NET、JavaScript和C++，Rx近几年越来越流行了，现在已经支持几乎全部的流行编程语言了，Rx的大部分语言库由ReactiveX这个组织负责维护，比较流行的有RxJava/RxJS/Rx.NET

尝试使用pmlpml/RxGo

github链接
照着readme尝试进行使用

hello world

package main

import (
	"fmt"

	RxGo "github.com/pmlpml/rxgo"
)

func main() {
	RxGo.Just("Hello", "World", "!").Subscribe(func(x string) {
		fmt.Println(x)
	})
}

hello world结果如图
在这里插入图片描述

链式

package main

import (
	"fmt"
	RxGo "github.com/pmlpml/rxgo"
)

func fibonacci(max int) func() (int, bool) {
	a, b := 0, 1
	return func() (r int, end bool) {
		r = a
		a, b = b, a+b
		if r > max {
			end = true
		}
		return
	}
}

func main() {
	RxGo.Start(fibonacci(10)).Map(func(x int) int {
		return 2*x
	}).Subscribe(func(x int) {
		fmt.Print(x)
	})
}

链式测试，此次测试先用start定了个0112358的源observable，随后用Map对对象内的数全进行了修改，最后用Subscribe打印出
在这里插入图片描述

连接

package main

import (
	"fmt"

	RxGo "github.com/pmlpml/rxgo"
)

func main() {
	//define pipeline
	source := RxGo.Just("Hello", "World", "!")
	next := source.Map(func(s string) string {
		return s + " "
	})
	//run pipeline
	next.Subscribe(func(x string) {
		fmt.Print(x)
	})
	fmt.Println()
	source.Subscribe(func(x string) {
		fmt.Print(x)
	})
}

这个主要测试是否是深修改，结果如下
在这里插入图片描述

实验部份，实现Filtering

实验过程

首先要知道实现方法，参照老师已经实现了的filter，观察他的调用函数顺序
Start()只是创建了个observable，并赋予了它的基础属性，直到Subscribe()上才是最终启动
Subscribe()中又动用到了connect()， connect()又动用到了op，这个op接口才是自己需要实现的

新开了个filterings.go之后就开始实现以下函数，
首先把op跟transOperator直接搬过来，改下名字跟类型

type filteringsOperater struct {
	opFunc func(ctx context.Context, o *Observable, item reflect.Value, out chan interface{}) (end bool)
}

func (tsop filteringsOperater) op(ctx context.Context, o *Observable) {
	// must hold defintion of flow resourcs here, such as chan etc., that is allocated when connected
	// this resurces may be changed when operation routine is running.
	in := o.pred.outflow
	out := o.outflow
	//fmt.Println(o.name, "operator in/out chan ", in, out)
	var wg sync.WaitGroup

	go func() {
		end := false
		for x := range in {
			if end {
				continue
			}
			// can not pass a interface as parameter (pointer) to gorountion for it may change its value outside!
			xv := reflect.ValueOf(x)
			// send an error to stream if the flip not accept error
			if e, ok := x.(error); ok && !o.flip_accept_error {
				o.sendToFlow(ctx, e, out)
				continue
			}
			// scheduler
			switch threading := o.threading; threading {
			case ThreadingDefault:
				if tsop.opFunc(ctx, o, xv, out) {
					end = true
				}
			case ThreadingIO:
				fallthrough
			case ThreadingComputing:
				wg.Add(1)
				go func() {
					defer wg.Done()
					if tsop.opFunc(ctx, o, xv, out) {
						end = true
					}
				}()
			default:
			}
		}

		wg.Wait() //waiting all go-routines completed
		o.closeFlow(out)
	}()
}

之后开始尝试实现下面的功能，出现问题了在对上面做改动
先装上 “github.com/stretchr/testify/assert”，“github.com/davecgh/go-spew/spew”，“github.com/pmezard/go-difflib/difflib”
再写这十二个功能的测试

package rxgo_test

import (
	"testing"
	"time"

	"github.com/pmlpml/rxgo"
	"github.com/stretchr/testify/assert"
)

func TestDebounce(t *testing.T) {
	res := []int{}
	ob := rxgo.Just(1, 2, 3, 4, 5, 6, 7, 8, 9).Map(func(x int) int {
		if x == 2 || x == 5 {
			time.Sleep(3 * time.Millisecond)
		} else {
			time.Sleep(1 * time.Millisecond)
		}
		return x
	}).Debounce(2 * time.Millisecond)

	ob.Subscribe(func(x int) {
		res = append(res, x)
	})

	assert.Equal(t, []int{1, 4, 9}, res, "debounce error")
}

func TestDistinct(t *testing.T) {
	res := []int{}
	ob := rxgo.Just(1, 2, 3, 3, 4, 5, 6, 7, 8, 9).Map(func(x int) int {
		time.Sleep(1 * time.Millisecond)
		return x
	}).Distinct()

	ob.Subscribe(func(x int) {
		res = append(res, x)
	})

	assert.Equal(t, []int{1, 2, 3, 4, 5, 6, 7, 8, 9}, res, "distinct error")
}

func TestElementAt(t *testing.T) {
	res := []int{}
	ob := rxgo.Just(1, 2, 3, 4, 5, 6, 7, 8, 9).Map(func(x int) int {
		time.Sleep(1 * time.Millisecond)
		return x
	}).ElementAt(1)

	ob.Subscribe(func(x int) {
		res = append(res, x)
	})

	assert.Equal(t, []int{2}, res, "elementAt error")
}

func TestFirst(t *testing.T) {
	res := []int{}
	ob := rxgo.Just(1, 2, 3, 4, 5, 6, 7, 8, 9).Map(func(x int) int {
		time.Sleep(1 * time.Millisecond)
		return x
	}).First()

	ob.Subscribe(func(x int) {
		res = append(res, x)
	})

	assert.Equal(t, []int{1}, res, "first error")
}

func TestIgnoreElements(t *testing.T) {
	res := []int{}
	ob := rxgo.Just(1, 2, 3, 4, 5, 6, 7, 8, 9).IgnoreElements()

	ob.Subscribe(func(x int) {
		res = append(res, x)
	})

	assert.Equal(t, []int{}, res, "ignore element error")
}

func TestLast(t *testing.T) {
	res := []int{}
	ob := rxgo.Just(1, 2, 3, 4, 5, 6, 7, 8, 9).Last()

	ob.Subscribe(func(x int) {
		res = append(res, x)
	})

	assert.Equal(t, []int{9}, res, "last error")
}

func TestSkip(t *testing.T) {
	res := []int{}
	ob := rxgo.Just(1, 2, 3, 4, 5, 6, 7, 8, 9).Map(func(x int) int {
		time.Sleep(1 * time.Millisecond)
		return x
	}).Skip(3)

	ob.Subscribe(func(x int) {
		res = append(res, x)
	})

	assert.Equal(t, []int{4, 5, 6, 7, 8, 9}, res, "skip error")
}

func TestSkiplast(t *testing.T) {
	res := []int{}
	ob := rxgo.Just(1, 2, 3, 4, 5, 6, 7, 8, 9).Map(func(x int) int {
		time.Sleep(1 * time.Millisecond)
		return x
	}).Skiplast(6)

	ob.Subscribe(func(x int) {
		res = append(res, x)
	})

	assert.Equal(t, []int{1, 2, 3}, res, "skiplast error")
}

func TestTake(t *testing.T) {
	res := []int{}
	ob := rxgo.Just(1, 2, 3, 4, 5, 6, 7, 8, 9).Map(func(x int) int {
		time.Sleep(1 * time.Millisecond)
		return x
	}).Take(3)

	ob.Subscribe(func(x int) {
		res = append(res, x)
	})

	assert.Equal(t, []int{1, 2, 3}, res, "take error")
}

func TestTakelast(t *testing.T) {
	res := []int{}
	ob := rxgo.Just(1, 2, 3, 4, 5, 6, 7, 8, 9).Map(func(x int) int {
		time.Sleep(1 * time.Millisecond)
		return x
	}).Takelast(3)

	ob.Subscribe(func(x int) {
		res = append(res, x)
	})

	assert.Equal(t, []int{7, 8, 9}, res, "takelast error")
}

写完测试后就是单元实现，实现就不放具体代码了，简要说明一下每个函数在干啥就是了

  1. Debounce
    Debounce的参数代表从后往前数间隔时间需大于参数才会被筛选出来，主要作用是过滤发射数据过快的项
    单元测试结果
    在这里插入图片描述

  2. Distinct
    去掉重复的项
    在这里插入图片描述
    这里着重讲一下，本来在测试的时后是没有加map(给每个项延迟避免并发)，可能是我实现的时后没有加互斥锁，导致每次测试顺序都不对，避免麻烦就在测试的时后加了延迟。(码力不足见量)

  3. ElementAt
    返回在该下标的项
    在这里插入图片描述

  4. Filter
    filter老师已经实现了就不重复做了

  5. First
    返回第一项
    在这里插入图片描述

  6. IgnoreElements
    啥都不返回
    在这里插入图片描述

  7. Last
    返回最后一个，由于不知道输入流什么时候结束，所以每输入进一个就存一个，直到没东西为止才输出。
    由于使用了filter做判断，所以对op做了简单修改

    加了这个

    	if o.flip != nil {
		buffer, ok := reflect.ValueOf(o.flip).Interface().([]reflect.Value)
		if !ok {
			panic("filter.go(op): buffer is not a slice")
		}
		for _, v := range buffer{
			o.sendToFlow(ctx, v.Interface(), out)
		}
	}

    在这里插入图片描述

  8. Skip
    跳过前n项
    在这里插入图片描述

  9. SkipLast
    跳过后n项，由于不知道尽头在哪，所以弄了个n大小的队列，即可简单实现
    在这里插入图片描述

  10. Take
    拿前n项
    在这里插入图片描述

  11. TakeLast
    拿后n项
    在这里插入图片描述

项目代码

crd39
关注
专栏目录
服务计算(6)——修改、改进 RxGo 包
qq_43278234的博客
11-06 435
文章目录1、简介2、课程任务filtering操作的实现测试作业提交我的完整代码 1、简介 ReactiveX是Reactive Extensions的缩写，一般简写为Rx，最初是LINQ的一个扩展，由微软的架构师Erik Meijer领导的团队开发，在2012年11月开源，Rx是一个编程模型，目标是提供一致的编程接口，帮助开发者更方便的处理异步数据流，Rx库支持.NET、JavaScript和C++，Rx近几年越来越流行了，现在已经支持几乎全部的流行编程语言了，Rx的大部分语言库由ReactiveX这个组
修改、改进 RxGo 包
Edith的博客
11-09 738
服务计算Homework06 项目地址 使用说明： 课程任务 阅读 ReactiveX 文档。请在pmlpml/RxGo基础上， 修改、改进它的实现 或添加一组新的操作，如filtering 该库的基本组成： rxgo.go 给出了基础类型、抽象定义、框架实现、Debug工具等 generators.go 给出了 sourceOperater 的通用实现和具体函数实现 transforms.go 给出了 transOperater 的通用实现和具体函数实现 RxGo的简单使用
服务计算第六次作业-修改、改进 RxGo 包
qq_43996906的博客
11-08 271
服务计算第六次作业-修改、改进 RxGo 包 1、简介 ReactiveX是Reactive Extensions的缩写，一般简写为Rx，最初是LINQ的一个扩展，由微软的架构师Erik Meijer领导的团队开发，在2012年11月开源，Rx是一个编程模型，目标是提供一致的编程接口，帮助开发者更方便的处理异步数据流，Rx库支持.NET、JavaScript和C++，Rx近几年越来越流行了，现在已经支持几乎全部的流行编程语言了，Rx的大部分语言库由ReactiveX这个组织负责维护，比较流行的有RxJava
RxGo：Go语言的React性扩展
02-25
RxGo Go语言的React式扩展 React性X 或简称Rx，是用于使用Observable流进行编程的API。 这是Go语言的官方ReactiveX API。 ReactiveX是一种新的异步编程方法，可以替代回调，promise和deferd。 它与处理事件或项目流有关，事件是系统中的任何发生或更改。 事件流称为 。 运算符是一个函数，它定义一个Observable，如何以及何时发出数据。 涵盖了运营商列表。 RxGo RxGo实现基于的概念。 管道是通过通道连接的一系列阶段，其中每个阶段是一组运行相同功能的goroutine。 让我们看一个具体的示例，每个框都是一个运算符： 我们使用Just运算符基于固定的项目列表创建静态Observable。 我们使用Map运算符定义一个转换函数（将一个圆转换为一个正方形）。 我们使用Filter运算符过滤每个黄色方块。 在
显示/光电技术中的半导体照明的特点
11-05
半导体照明与一般光伏电源配用的节能灯泡相比具有节能、长寿、安全、环保、色彩丰富、体积小、耐闪烁、可靠性高、调控方便等诸多优点。发光二极管作为一种新型照明光源正在获得越来越广泛的应用。 　　半导体照明特点 　　电子元件二极管中半导体发光二极管是常用的一种类型。发光二极管又称为光发射二极管(lightemittingdiode,简写为led)，是一种可将电能变为光能的一种器件，属于固态光源。led是半导体器件通过pn结实现电光转换，它有如下的特点： 　　(一)寿命长，响应快 　　一般来说，普通白炽灯的寿命约为1000h,荧光灯寿命约10000h,而led的寿命可达2--10万h,可见寿命长
服务计算之修改、改进 RxGo 包
weixin_43980838的博客
11-09 222
服务计算之修改、改进 RxGo 包简介课程任务filtering操作的实现简单说明包文件结构代码实现程序设计filteringOperator数据结构newFilterObservable函数op函数Debounce函数Distinct函数ElementAt函数First函数IgnoreElements函数Last函数Sample函数Skip函数SkipLast函数Take函数TakeLast函数单元测试功能测试源码 简介 ReactiveX是Reactive Extensions的缩写，一般简写为Rx，最
服务计算 作业六 修改、改进RxGo包
weixin_46092070的博客
11-10 210
修改、改进RxGo包简介课程任务项目实现阅读文档，知道要做什么实现思路基础部分（结构体定义、op函数、初始化函数）功能部分测试功能测试单元测试API文档 简介 ReactiveX是Reactive Extensions的缩写，一般简写为Rx，最初是LINQ的一个扩展，由微软的架构师Erik Meijer领导的团队开发，在2012年11月开源，Rx是一个编程模型，目标是提供一致的编程接口，帮助开发者更方便的处理异步数据流，Rx库支持.NET、JavaScript和C++，Rx近几年越来越流行了，现在已经支持几
服务计算作业六——修改、改进 RxGo 包
Floating__dust的博客
11-10 137
阅读 ReactiveX 文档。请在 pmlpml/RxGo 基础上， 修改、改进它的实现 或添加一组新的操作，如 filtering
开源项目-jochasinga-RxGo.zip
09-05
《RxGo：Go语言中的反应式编程实践》 在当今的软件开发领域，反应式编程已经成为一种备受关注的编程范式，它强调数据流和变化的传播，使得开发者能够更优雅地处理异步操作和并发问题。开源项目-jochasinga-RxGo.zip...
go语言之修改、改进RxGo包
weixin_43953962的博客
11-09 582
RxGo1、修改、改进RxGo包1.1 简介1.2 课程任务2、改进版RxGo2.1 设计说明2.2 程序主要函数2.3 单元测试2.4 功能测试 1、修改、改进RxGo包 1.1 简介 ReactiveX是Reactive Extensions的缩写，一般简写为Rx，最初是LINQ的一个扩展，由微软的架构师Erik Meijer领导的团队开发，在2012年11月开源，Rx是一个编程模型，目标是提供一致的编程接口，帮助开发者更方便的处理异步数据流，Rx库支持.NET、JavaScript和C++，Rx近几
Go 每日一库之 rxgo
darjun的博客
10-15 1811
简介 ReactiveX，简称为 Rx，是一个异步编程的 API。与 callback（回调）、promise（JS 提供这种方式）和 deferred（Python 的 twisted 网络编程库就是使用这种方式）这些异步编程方式有所不同，Rx 是基于事件流的。这里的事件可以是系统中产生或变化的任何东西，在代码中我们一般用对象表示。在 Rx 中，事件流被称为 Observable（可观察的）。事件流需要被 Observer（观察者）处理才有意义。想象一下，我们日常作为一个 Observer，一个重要的工作
Tobit与Probit模型Stata实现代码-最新发布.zip
最新发布
11-14
Tobit与Probit模型Stata实现代码-最新发布.zip
供AI训练的中文数据集持续更新与AI公司图谱目前的数据集餐饮行业8000问百度知道Alpaca中文数据集计算机领域数据.zip
11-14
Jupyter-Notebook
红警单机版（单机游戏）
11-14
红警单机版（单机游戏）
SwiftUI编写的贪吃蛇小游戏讲解
11-14
SwiftUI编写的贪吃蛇小游戏讲解
1996-2020年中国文化旅游统计年鉴-最新数据发布.zip
11-14
1996-2020年中国文化旅游统计年鉴-最新数据发布.zip
Jupyter_自动驾驶规划控制python代码实现.zip
11-14
Jupyter-Notebook
omwfa1hxz_1.apk
11-14
omwfa1hxz_1.apk
2001-2023年上市公司大数据应用指数数据集（6.1万样本，5600家企业，含原始数据、代码及结果，最新）.zip
11-14
2001-2023年上市公司大数据应用指数数据集（6.1万样本，5600家企业，含原始数据、代码及结果，最新）.zip
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值