“这里有”,有人说,然后您将获得此输入值流,您希望在...上执行以下操作
Input: '1-1----11---2--1122----1---2---2-2-1-2---|'
Output: '1-----------2--1-2-----1---2-------1-2---|'
到目前为止没有什么奇怪的,
但是现在,如果再次出现相同的值,则有人说“这很不错”,“但前提是不要很快!”。我希望在相同值之间至少有'----'
个刻度。您说“ Okey”,然后添加一个油门
const source = new Subject<number>();
// mysterious cave troll is randomly source.next(oneOrTwo)
const example = source.pipe(throttle(val => interval(4000)));
Input: '1-1----11---2--1122----1---2---2-2-1-2-----|'
Output: '1------1----2----2-----1-------2-----2-----|'
“那不是我想要的!查看您错过的所有值”,指的是您针对流式传输的所有值进行限制。
Input: '1-1----11---2--1122----1---2---2-2-1-2-----|'
Output: '1------1----2----2-----1-------2-----2-----|'
'-------------->1<--------->2<----->1<------|' <-- Missed values
“在这里,让我展示给你看。”那个神秘的人说,并给你这个
Input: '1-1----11---2--1112----1---2---2-2-1-2-----|'
Output: '1------1----2--1--2----1---2-----2-1-------|'
我对此的回答是,感觉好像没有一个组合的窗口。
从更有经验的人那里,
这是很难解决的问题吗?(或者我错过了一个明显的解决方案)
答案 0 :(得分:2)
这是我的第二次尝试,它按输出过滤流(而不是采用distinctUntil),然后进行限制并合并两个流。
当然,我们可能没有一组已知的值(1,2,... n)。
如果我能弄清楚皱纹,将再加上一个例子。
pos.prediction <- predict(NBA.SOM3, newdata = NBA.testing)
Error in FUN(X[[i]], ...) :
Data type not allowed: should be a matrix or a factor
这是我的支票(毫秒= 4000)
const output = merge(
source.pipe( filter(x => x === 1), throttle(val => interval(ms))),
source.pipe( filter(x => x === 2), throttle(val => interval(ms)))
)
我认为这在流中的值集事先未知(或范围较大,因此扩展上一个答案不切实际)的情况下会起作用。
只要源代码完整,它就应该起作用。
input 1-1----11---2--1112----1---2---2-2-1-2-----
expected 1------1----2--1--2----1---2-----2-1-------
filter(1) 1-1----11------111-----1-----------1-------
throttle(1) 1------1-------1-------1-----------1-------
filter(2) ------------2-----2--------2---2-2---2-----
throttle(2) ------------2-----2--------2-----2---------
merged 1------1----2--1--2----1---2-----2-1-------
expected 1------1----2--1--2----1---2-----2-1-------
我还没有证据,将在下一个发布。
答案 1 :(得分:1)
在我的头上,您想要按时间间隔进行缓冲,然后在每个缓冲中进行区分。
实际上,您希望每n毫秒重新启动/重新启动一次非重复运行。
String prodName[]={choice};
int Quantity[] = {};
int Total[]={};
String Price[]={choice} ;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
ArrayAdapter<CharSequence> badapter = ArrayAdapter.createFromResource(
this,
R.array.products,
android.R.layout.simple_spinner_dropdown_item);
listView = (ListView) findViewById(R.id.list1);
button = (Button) findViewById(R.id.button);
spinner = (Spinner)findViewById(R.id.spinner);
badapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
spinner.setAdapter(badapter);
final MyAdapter adapter = new MyAdapter(this, prodName, Price);
//set the adapter
listView.setAdapter(adapter);
button.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
String sample;
choice = spinner.getSelectedItem().toString();
prodName = choice.split(choice);
}
});
}
答案 2 :(得分:1)
首先我想到了将distinctUntilChanged()
和throttleTimte()
结合起来的想法,但是我无法提出解决方案,然后尝试了其他方法。
我想到的运算符是throttleDistinct()
,它可以按照您的意愿工作:StackBlit Editor Link
它有2个参数,分别是:
duration: number
,以毫秒为单位,类似于
throttleTime(duration: number)
equals: (a: T, b: T) => boolean
,用于比较上一项是否等于下一项(默认情况下是下一项)
(a, b) => a === b
import { of, fromEvent, interval, Observable } from 'rxjs';
import { map, scan, filter, } from 'rxjs/operators';
const source = fromEvent(document, 'keypress')
.pipe(map((x: any) => x.keyCode as number))
source
.pipe(
throttleDistinct(1000),
)
.subscribe((x) => console.log('__subscribe__', x));
export function throttleDistinct<T>(
duration: number,
equals: (a: T, b: T) => boolean = (a, b) => a === b
) {
return (source: Observable<T>) => {
return source
.pipe(
map((x) => {
const obj = { val: x, time: Date.now(), keep: true };
return obj;
}),
scan((acc, cur) => {
const diff = cur.time - acc.time;
const isSame = equals(acc.val, cur.val)
return diff > duration || (diff < duration && !isSame)
? { ...cur, keep: true }
: { ...acc, keep: false };
}),
filter((x) => x.keep),
map((x) => x.val),
)
}
}
答案 3 :(得分:0)
这是一个基于运算符理论的棘手的解决方案,但我不确定它是否确实有效,因为我需要首先模拟源发射。
因此,节流阀和非重复流始终会缓存最新的值,而zip确保它们总是成对发出,而当任何流发出时zip总是会发出,因为它是shareReplay(1)。
即使zip流是由节流阀触发的,我们也总是采用distinctStream的发射值,因为distinctStream始终具有最后一个缓存的值。
const throttleStream= source.pipe(throttle(val => interval(4000)),shareReplay(1))
const distinctStream= source.pipe(distinctUntilChanged(),shareReplay(1))
zip(throttleStream,distinctStream).pipe(
map((t,d)=>d)
)
答案 4 :(得分:0)
我找到了可行的解决方案,有人对此有任何看法吗?
source.pipe(
windowTime(4000),
concatMap(obs => obs.pipe(distinct()))
);
之前StackBlitz example中的示例
更新:这实际上不能100%起作用。它仅考虑当前窗口。例如,您可以拥有
`[1-12][2---]` which would give `1--22---|`
其中[----]
代表时间窗口。换句话说,如果首先在一个窗口中最后发出一个值,然后在下一个窗口中首先发出一个值,则相同的值将彼此紧接着通过。
感谢@ eric99让我意识到这一点。