Գնահատել նախագիծը
← Բոլոր հրապարակումները

onClick, onDoubleClick և onHold հոսքերի կառուցումը RxJS-ով

Գործնական օրինակ այն մասին, թե ինչպես օգտագործել RxJS-ը՝ onClick, onDoubleClick և onHold իրադարձությունների վրա հարմար աբստրակցիա կառուցելու համար։

9 րոպե
RxJSՎիճակի մեքենաներԻրադարձությունների հոսքերԱսինքրոն

Այս գրառման մեջ մենք քայլ առ քայլ դիտարկում ենք գործնական օրինակ, թե ինչպես օգտագործել RxJS-ը՝ onClick, onDoubleClick և onHold իրադարձությունների վրա հարմար աբստրակցիա կառուցելու համար։ Դուք կտեսնեք, թե որքան պարզ է RxJS-ի պրիմիտիվները համադրել դեկլարատիվ լուծման մեջ, որը և՛ ընթեռնելի է, և՛ ընդհանրական, և որը հետագայում կարելի է ընդլայնել՝ առանց դժվարության ստանալով նոր հոսքեր, օրինակ՝ onTripleClick և այլն։

Երեք ժեստերն էլ բավականին տարածված են սարքային UI-ներում, օրինակ՝ ժամացույցներում, բայց ոչինչ չի խանգարում դրանք օգտագործել նաև ավելի ժամանակակից, թվային դիզայններում։

Սահմանենք մեր համակարգը

Սկսենք նրանից, թե ինչ իրադարձություններ կան մեր «համակարգում»։ Յուրաքանչյուր click և hold առաջանում է այն բանից, որ օգտատերը սեղմում է կոճակը կամ էկրանը, ապա բարձրացնում մատը։ Սա նշանակում է, որ «դրսից» մեզ հասնող միակ երկու իրադարձություններն են down և up իրադարձությունները։ Նկատի ունեցեք, որ կարևոր չէ՝ օգտատերը հպում է էկրանին, սեղմում է ստեղնաշարի ստեղնը, թե click է անում մկնիկով. տրամաբանությունը նույնն է մնում։ Եկեք սա արտահայտենք RxJS-ով.

import { Subject } from "rxjs";

export const downSubject = new Subject<"down">();
export const upSubject = new Subject<"up">();

const down$ = downSubject.asObservable();
const up$ = upSubject.asObservable();

Հետագայում մենք կհենվենք subject-ների վրա՝ կոնկրետ իրադարձությունները, օրինակ՝ React-ի MouseDown և MouseUp-ը, մեր հարթակից անկախ տրամաբանության մեջ թարգմանելու համար։

Այս հոսքերի արտանետած իրական արժեքները կարևոր չեն, քանի դեռ կարող ենք դրանք իրարից տարբերել։ Պարզ տողերը բավական կլինեն, բայց եթե երբևէ ցանկանանք իրադարձություններին կցել տվյալներ՝ ասենք, մկնիկի x և y կոորդինատները իրադարձության պահին, կարող ենք գրել մոտավորապես այսպես.

type Event<T extends string> = {
  type: T;
    // add payload here if needed
};

export const downSubject = new Subject<Event<"down">>(); // changed
export const upSubject = new Subject<Event<"up">>(); // changed

Լավ, ի՞նչ է հաջորդը։ Դիտարկենք, թե ցածր մակարդակում իրականում ինչ է click-ը։ Երբ մենք՝ որպես օգտատերեր, ուզում ենք ինչ-որ բանի վրա click անել, մենք.

  • պարզապես սեղմում ենք այն և անմիջապես բաց ենք թողնում
  • չենք ուզում զգալ, թե մրցավազքի մեջ ենք և պետք է ուշադիր հետևենք, որ մատը բավականաչափ արագ բարձրացնենք, որպեսզի պատահաբար որևէ այլ գործողություն չգործարկենք

Միայն click-երն իրականացնելը աննշան կլիներ.

const click$ = down$.pipe(
  switchMap(() =>
    up$.pipe(map(() => ({ type: "click" } as Event<"click">)))
  )
);

click$.subscribe(console.log);

Ամեն անգամ, երբ down իրադարձություն է տեղի ունենում, մենք բաժանորդագրվում ենք up իրադարձությունների հոսքին, և երբ up իրադարձությունը տեղի է ունենում, այն արտապատկերում ենք click իրադարձության։

click հոսքի ճշգրտում

Ի դեպ, մենք այստեղ ենթադրում ենք, որ down և up իրադարձությունների համակցված հոսքն այսպիսի տեսք ունի::

D--U-----D-U-----DU--DU---->

Այլ կերպ ասած, երկու down իրադարձություն երբեք իրար հետևից չեն գալիս, և նույնը վերաբերում է up իրադարձություններին։ Արդյո՞ք այս ենթադրությունը հիմնավոր է։

Անկեղծ ասած, ես չեմ կարողանում պատկերացնել ինտերֆեյս, որը թույլ կտար ինչ-որ բան երկու անգամ սեղմել (երկրորդ մատո՞վ) և բաց թողնել միայն մեկ անգամ։ Բայց պատկերացրեք իրավիճակ, երբ աշխատում ենք անվստահելի ցանցային կապի հետ, որը երբեմն պատահականորեն կրկնօրինակում է իրադարձությունները։

Եթե, ասենք, up իրադարձությունը կրկնօրինակվի, մեր ներկա իրականացումը մեկի փոխարեն կստեղծի երկու click։

Բարեբախտաբար, մենք կարող ենք պարզապես չեղարկել բաժանորդագրությունը up$-ից, երբ մեկ իրադարձություն հասել է.

const click$ = down$.pipe(
  switchMap(() =>
    up$.pipe(
            take(1) // new
        ).pipe(map(() => ({ type: "click" } as Event<"click">)))
  )
);

click$.subscribe(console.log);

Այժմ, անկախ նրանից, թե քանի up և down են հասնում, մենք կստեղծենք մեկ click յուրաքանչյուր առանձին զույգի համար, որը բաղկացած է down իրադարձությունից և դրան հաջորդող up իրադարձությունից։ Հիանալի է։

Այս օրինակը ցույց է տալիս, որ հոսքերի վարքի լավ ըմբռնմամբ մենք հաճախ կարող ենք բավարարել տարբեր պահանջներ շատ քիչ ջանքով՝ օգտագործելով ընդամենը մեկ RxJS օպերատոր։

Hold իրադարձությունների հոսք

Հաջորդը՝ սահմանենք իրադարձությունները, որոնք ուզում ենք արտադրել, մի քանի իրադարձություն ստեղծող ֆունկցիաների հետ միասին.

type Click = Event<"click">;
type DoubleClick = Event<"doubleClick">;
type Hold = Event<"hold">;

const createClick = () => ({ type: "click" } as Click);
const createDoubleClick = () => ({ type: "doubleClick" } as DoubleClick);
const createHold = () => ({ type: "hold" } as Hold);

Երբ down իրադարձությունը տեղի է ունենում, կա ընդամենը երկու հնարավորություն՝ արտապատկերել այն click-ի կամ արտապատկերել hold-ի։ hold-ը կարտանետվի ավտոմատ կերպով, եթե որոշակի ժամանակ անցնի առանց up իրադարձության։ Այսպիսով, մենք ունենք մրցավազք այն թայմերի միջև, որը գործարկում է hold իրադարձությունը, և up իրադարձության, որը գործարկում է click և չեղարկում է թայմերը։ Հենց դա էլ կիրականացնենք.

const HOLD_INTERVAL = 500;

const clickOrHold$ = down$.pipe(
  switchMap(() =>
    up$.pipe(
      map(createClick),
      raceWith(timer(HOLD_INTERVAL).pipe(map(createHold)))
    )
  )
);

clickOrHold$.subscribe(console.log);

Ավելի հարմարության համար կարող ենք նաև յուրաքանչյուր ժեստի համար առանձին հոսք ստեղծել.

const click$ = clickOrHold$.pipe(
    filter((event) => event.type === "click")
);

const hold$ = clickOrHold$.pipe(
    filter((event) => event.type === "hold")
);

Կրկնակի click-եր

Հիանալի է. մնացած միակ ժեստը doubleClick-ն է։ Քանի որ արդեն ունենք հոսք, որն արտադրում է click կամ hold իրադարձություններ, կկիրառենք filter օպերատորը՝ թողնելու միայն click-երը, ապա կչափենք հաջորդական click-երի միջև անցած ժամանակը, և եթե դրանք բավականաչափ մոտ են, կարտապատկերենք doubleClick-ի.

const DOUBLE_CLICK_INTERVAL = 300;

const doubleClick$ = click$.pipe(
  timeInterval(),
  filter(({ interval }) => interval < DOUBLE_CLICK_INTERVAL),
  map(createDoubleClick)
);

doubleClick$.subscribe(console.log);

Այստեղ մենք հենվեցինք timeInterval օպերատորի վրա, որը կցում է interval դաշտ՝ հաջորդական արտանետումների միջև անցած ժամանակով։

Ամեն ինչ միավորենք

Կարող եք մտածել, որ merge ֆունկցիան այն ամենն է, ինչ պետք է ամեն ժեստն արտանետող հոսք կառուցելու համար.

// won't work as we would expect
export const gestures$ = merge(click$, hold$, doubleClick$);

Սակայն երբ օգտատերը արագ երկու անգամ իրար հետևից click է անում, այդ հոսքը կստեղծի 3 իրադարձություն՝ click, click և doubleClick։ Շատ հավանական է՝ մենք կնախընտրեինք, որ այն արտանետի միայն մեկ doubleClick։

Առաջին միտքը, որ գալիս է գլխում, գուցե դա նույն կերպ իրականացնելն է, ինչպես կառուցեցինք clickOrHold$-ը.

// won't work!
const clickOrDoubleClick$ = click$.pipe(
  switchMap(() =>
    click$.pipe(
      map(createDoubleClick),
      raceWith(timer(HOLD_INTERVAL).pipe(map(createClick)))
    )
  )
);

Ցավոք, սա չի աշխատում, քանի որ switchMap-ում արտաքին և ներքին observable-ները նույնն են, ուստի հենց որ երկրորդ click-ը հասնում է, մենք անմիջապես չեղարկում ենք ներքին observable-ի բաժանորդագրությունը և երբեք չենք արտանետում doubleClick իրադարձությունը։

Այսպիսով, փոխարենը կդիմենք մեկ այլ, լայնորեն օգտագործվող տեխնիկայի։ Մուտք եկող click-երը կհավաքենք զանգվածի մեջ և կարտանետենք իրադարձություն՝ կախված այդ զանգվածի երկարությունից.

const DOUBLE_CLICK_INTERVAL = 200;

const clickOrDoubleClick$ = click$.pipe(
  buffer(click$.pipe(switchMap(() => timer(DOUBLE_CLICK_INTERVAL)))),
  map((clicksArr) =>
    clicksArr.length > 1 ? createDoubleClick() : createClick()
  )
);

Buffer օպերատորը հավաքում է արժեքներ, մինչև նրան պարամետրով տրված observable-ը արտանետի։ Ամբողջ հնարքը, ուրեմն, ճիշտ պարամետր տրամադրելու մեջ է։ Այս դեպքում ես տրամադրեցի observable, որն արտանետում է 0 (timer-ն արտանետում է 0, արժեքն ինքնին այստեղ կարևոր չէ) յուրաքանչյուր click իրադարձությունից 200 ms հետո։ Եթե օգտատերը այդ պատուհանի ընթացքում 2 (կամ ավելի) անգամ click անի, զանգվածը կպարունակի 1-ից ավելի տարր, և մենք այն կարտապատկերենք doubleClick-ի։

Վերջապես կարող ենք կառուցել ճիշտ վարվող ժեստերի հոսք.

export const gestures$ = merge(clickOrDoubleClick$, hold$);

Ամբողջական կոդը և օգտագործման օրինակ

Ստորև բերված է այն ամբողջ կոդը, որ մենք գրել ենք.

import {
  buffer,
  filter,
  map,
  merge,
  raceWith,
  Subject,
  switchMap,
  timer,
} from "rxjs";

type Event<T extends string> = {
  type: T;
};

export const downSubject = new Subject<Event<"down">>();
export const upSubject = new Subject<Event<"up">>();

const down$ = downSubject.asObservable();
const up$ = upSubject.asObservable();

export type Click = Event<"click">;
export type DoubleClick = Event<"doubleClick">;
export type Hold = Event<"hold">;

const createClick = () => ({ type: "click" } as Click);
const createDoubleClick = () => ({ type: "doubleClick" } as DoubleClick);
const createHold = () => ({ type: "hold" } as Hold);

const HOLD_INTERVAL = 500;

const clickOrHold$ = down$.pipe(
  switchMap(() =>
    up$.pipe(
      map(createClick),
      raceWith(timer(HOLD_INTERVAL).pipe(map(createHold)))
    )
  )
);

const click$ = clickOrHold$.pipe(filter((event) => event.type === "click"));

const hold$ = clickOrHold$.pipe(filter((event) => event.type === "hold"));

const DOUBLE_CLICK_INTERVAL = 200;

const clickOrDoubleClick$ = click$.pipe(
  buffer(click$.pipe(switchMap(() => timer(DOUBLE_CLICK_INTERVAL)))),
  map((clicksArr) =>
    clicksArr.length > 1 ? createDoubleClick() : createClick()
  )
);

const doubleClick$ = clickOrDoubleClick$.pipe(
  filter(({ type }) => type === "doubleClick")
);

export const gestures$ = merge(hold$, clickOrDoubleClick$);

Այժմ տեսնենք, թե ինչպես կարող են այս հոսքերը օգտագործվել հավելվածի ներսում։ Ես ստեղծեցի նոր Vite նախագիծ React և Typescript կաղապարից և App.tsx-ը փոխեցի հետևյալ կերպ.

import "./App.css";
import { downSubject, gestures$, upSubject } from "./gestures";

gestures$.subscribe((gesture) => {
  console.log(gesture);
});

function App() {
  return (
    <div className="App">
      <button
        onMouseDown={() => {
          downSubject.next({ type: "down" });
        }}
        onMouseUp={() => {
          upSubject.next({ type: "up" });
        }}
      >
        Button
      </button>
    </div>
  );
}

export default App;

Վարժություն ընթերցողի համար

Ահա մի մարտահրավեր, որը կօգնի կիրառել այսօր դիտարկածը։

Կառուցեք ClickStreak$՝ հոսք, որն արտանետում է թվեր (պարզության համար) և վարվում է այսպես.

  • Երբ օգտատերը կոճակի վրա n անգամ click է անում, ընդ որում՝ յուրաքանչյուր click գալիս է նախորդից 200 ms-ի ընթացքում, հոսքը արտանետում է n։

Այսպիսով, եթե որևէ մեկը կոճակի վրա մեկ անգամ click անի, ապա 0.2 վրկ դադար տա, կարտանետվի 1։ Եթե այն 17 անգամ արագ հաջորդականությամբ սեղմի, կարտանետվի միայն 17 թիվը, և այլն։

Բոնուս. վիճակի մեքենաներ

Թեև մեր հոսքերի վրա հիմնված իրականացումը շատ ավելի լավ է, քան if-երով, փոփոխականներով և setTimeout-ներով լի տիպային իմպերատիվ սպագետի կոդը, կա ևս մեկ մոտեցում, որը գուցե նույնիսկ ավելի լավն է՝ վիճակի մեքենաները (state machines)։

Եթե դեռ չեք հանդիպել վիճակի մեքենաներին, ես խորը չեմ մտնի դրանց մեջ, բայց հակիրճ՝ մենք նկարագրում ենք մեր համակարգը որպես բոլոր վիճակների բազմություն, որոնցում այն կարող է լինել, և այդ վիճակների միջև բոլոր հնարավոր անցումների, որոնք սովորաբար գործարկվում են իրադարձություններով։

Ստորև դիագրամ է, որը ցույց է տալիս, թե ինչպես կարող է մեր համակարգը մոդելավորվել որպես վիճակի մեքենա.
համակարգի մոդելավորումը վիճակի մեքենաներով

  • Մենք սկսում ենք default անունով վիճակից, որտեղից միակ հնարավոր անցումը afterDown-ն է՝ գործարկված down իրադարձությամբ։
  • afterDown մտնելիս մենք սկսում ենք 500 ms ներքին թայմեր, որը մեզ վերադարձնում է default և արտանետում է hold իրադարձություն։ Թայմերը սակայն դեն է նետվում, եթե այդ վիճակից դուրս գանք։
  • Հետևաբար, եթե up իրադարձությունը հասնի այն ժամանակ, երբ մենք afterDown վիճակում ենք, անցնում ենք afterClick-ի։
  • afterClick մտնելիս սկսում ենք երկրորդ թայմերը, այս անգամ 200 ms-ի, որը մեզ վերադարձնում է default և արտանետում է click։
  • Եթե, սակայն, down իրադարձությունը հասնի այդ թայմերի ավարտից առաջ, մենք փոխարենը անցնում ենք default՝ doubleClick իրադարձությամբ։

Ահա, թե ինչպես կարելի է սա իրականացնել xstate-ով՝ JavaScript-ի և Typescript-ի համար լայնորեն օգտագործվող վիճակի մեքենաների գրադարանով.

import { createMachine } from "xstate";

const timer = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));

export const gesturesMachine = createMachine({
  schema: {
    events: {} as { type: "UP" } | { type: "DOWN" },
  },
  initial: "default",
  states: {
    default: {
      on: {
        DOWN: "afterDown",
      },
    },
    afterDown: {
      on: {
        UP: "afterClick",
      },
      invoke: {
        src: () => timer(500),
        onDone: {
          target: "default",
          actions: () => console.log("hold"),
        },
      },
    },
    afterClick: {
      on: {
        UP: {
          target: "default",
          actions: () => console.log("doubleClick"),
        },
      },
      invoke: {
        src: () => timer(200),
        onDone: {
          target: "default",
          actions: () => console.log("click"),
        },
      },
    },
  },
});

Եվ ահա թե ինչպես կարելի է այն օգտագործել React-ում.

import "./App.css";
import { useMachine } from "@xstate/react";
import { gesturesMachine } from "./stateMachine";

function App() {
  const [_current, send] = useMachine(gesturesMachine);

  return (
    <div className="App">
      <button
        onMouseDown={() => {
          send("DOWN");
        }}
        onMouseUp={() => {
          send("UP");
        }}
      >
        State Machine Button
      </button>
    </div>
  );
}

export default App;

Կեցցե՛ք, հասաք վերջին։ Հուսով եմ՝ այս կարճ ուղեցույցը ձեզ մի փոքր ոգեշնչեց։ Եթե ունեք գաղափարներ կամ RxJS-ով հարմար հոսքեր կառուցելու սեփական փորձ, մի՛ վարանեք այդ մասին պատմել մեզ մեկնաբանությամբ 🙏🏻