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

Debouncing input handler-ները React-ում

Այս գրառումը debouncing-ի մասին է, այսինքն՝ օգտատիրոջ կողմից input-ների հետ փոխազդեցության արդյունքում տեղի ունեցող գործողության միտումնավոր հետաձգման։

4 րոպե
TypescriptReactԻրադարձությունների մշակումDebouncing

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

Իրադարձությունների մշակում

React-ում (և ընդհանրապես JavaScript-ում) input-ների փոփոխությունները սովորաբար մշակվում են event listener-ի որևէ տեսակով, օրինակ՝ onChange callback-ներով։ Վերցնենք սովորական տեքստային input. յուրաքանչյուր սեղմում կանչում է կցված handler-ը և նրան փոխանցում է event օբյեկտ, որը պարունակում է վերջին արժեքը։

const handler = (event: React.ChangeEvent<HTMLInputElement>) => {
 /*..*/
};
/*..*/
<input onChange={handler} />;

Սա լավ է աշխատում հավելվածի վիճակը համաժամեցված պահելու համար, բայց արդյոք դա է մեզ պետք ամեն անգամ։ Իսկապե՞ս յուրաքանչյուր աննշան փոփոխություն պետք է հետևանք առաջացնի՝ անկախ իրավիճակից։

Օգտագործման դեպք

Ենթադրենք՝ պետք է ձեր հավելվածի համար որոնման տեքստային բաղադրիչ կառուցել, որտեղ օգտատերը որոնման հարցումը մուտքագրում է պարզ input-ի մեջ։ UX-ը բարելավելու համար հանում եք «submit» կոճակը, և հարցումը API-ին փոխանցում եք դեռ տպելու ընթացքում։ Ժամանակակից UI-ները հաճախ հենց այդպես են աշխատում։

Ամեն ինչ լավ է, մինչև նկատում եք, որ յուրաքանչյուր սեղմում բրաուզերին ստիպում է XHR (HTTP) հարցում ուղարկել backend-ին։ Բազմապատկեք դա միևնույն պահին ձեր հավելվածից օգտվող մարդկանց թվով, և ահա՝ դուք չմտադրված ստեղծել եք մի բան, որ նման է DDoS (distributed denial of service) հարձակման։ Լավագույն դեպքում՝ երբ սերվերը համեմատաբար կարճ ժամանակում հարյուրավոր հարցումներով «հեղեղվի», IDS/IPS պաշտպանության մեխանիզմները որոշ կլիենտների IP-ները կմտցնեն սև ցուցակ։ Վատագույն դեպքում՝ ամբողջ backend ծառայությունը կկործանվի։

❗️ Դրա հետ մեկտեղ, կարճ ժամանակում այդքան շատ asynchronous հարցումներ ուղարկելը զգալիորեն մեծացնում է պատասխանների սխալ հերթականությամբ հասնելու հավանականությունը։

Օգտատիրոջ համար այս race condition-ը առաջացնում է խիստ դյուրագրգռող UI անհետևողականություններ, օրինակ՝ ավելի հին հարցումը լուծվում է վերջինը, և UI-ը ցույց է տալիս հարցման հնացած տարբերակի արդյունքները։

Debounce չարված էֆեկտներ

Ստորև բերված անիմացիան ցույց է տալիս debouncing-ից զուրկ input-ից եկող իրադարձությունների «հեղեղը»՝

Յուրաքանչյուր սեղմում մշակվում է առանձին։ «Debugger» պատուհանը գրանցում է յուրաքանչյուր «էֆեկտ»՝ նմանակելով backend սերվերին ուղարկվող հարցումները։ Սա ակնհայտորեն հեռու է օպտիմալ լինելուց։

Իրադարձությունների ճիշտ մշակում

Այստեղ ես օգտագործում եմ lodash.debounce (ըստ էության՝ առանձին ֆունկցիա, որը հանված է «մայր» lodash գրադարանից), որպեսզի կառուցեմ event handler-ի debounce արված տարբերակը՝

import debounce from "lodash.debounce";
const DEBOUNCE_TIME_MS = 300;
/*..*/
const onNameChange = useMemo(
 () =>
   debounce((event: React.ChangeEvent<HTMLInputElement>) => {
     setEffects(/*..*/);
   }, DEBOUNCE_TIME_MS),
 []
);

Այս կոդում debounce-ը ընդունում է երկու արգումենտ՝ function (handler) և wait ժամանակը։

ℹ️ Խիստ ասած, debounce-ը ընդունում է նաև երրորդ արգումենտ՝ options, որը թույլ է տալիս, օրինակ, սահմանել՝ handler-ը պետք է աշխատի timeout-ի սկզբո՞ւմ և/կամ վերջո՞ւմ։ Սակայն այն ընտրովի է և կարելի է բաց թողնել։

Դրա հետ մեկտեղ ամեն ինչ փաթաթված է React-ի useMemo hook-ի մեջ, որպեսզի ֆունկցիան ամեն render-ի ժամանակ կրկին առանց կարիքի չստեղծվի։

Ստորև բերված անիմացիան ցույց է տալիս debounce արված event handler-ի վարքը։

Տարբերությունը հեշտ է նկատել. քանի դեռ օգտատերը շարունակում էր տպել (սեղմումների միջև «դադարը» DEBOUNCE_TIME_MS-ից կարճ էր), էֆեկտը հետաձգվում էր։

Նկատեք՝ օգտատերը նախադասության վերջին մոտ տպելու ընթացքում երկու անգամ կարճ դադար է արել (և երրորդ անգամ՝ երբ ավարտել է)։ Հենց այդ պահերին են աշխատել debounce արված էֆեկտները։ Debugger-ը գրանցել է ընդամենը 3 էֆեկտ՝ հսկայական բարելավում՝ համեմատած debouncing-ից զուրկ տարբերակի մոտ 13 անգամ ավելի շատ իրադարձությունների հետ։

ℹ️ Հիշեք. debounce արված event handler-ը աշխատում է մոտավորապես այսպես՝

  • գրավում է օգտատիրոջ ստեղծած իրադարձությունները և «հավաքում» դրանք,
  • սպասում է, մինչև անցնի «լռության» շրջան (իրադարձություններ չկան), սովորաբար մոտ 300-500 միլիվայրկյան,
  • կատարում է էֆեկտը՝ օգտագործելով «ամենավերջին» տվյալները։

Մաքրում

Լավ գաղափար է նաև նախատեսել մաքրման տրամաբանություն այն դեպքի համար, երբ բաղադրիչը unmount է լինում (օրինակ՝ երբ օգտատերը լքում է route-ը)։ Այդ պատճառով պետք է ավելացնել useEffect, որը վերադարձնում է ֆունկցիա, որը կանչում է debounce արված event handler-ի .cancel() մեթոդը։

useEffect(() => {
 return () => {
   onNameChange.cancel();
 };
}, [onNameChange]);

💡 Պատճառը. ենթադրենք՝ DEBOUNCE_TIME_MS-ը բավական երկար է (օրինակ՝ 1000-2000ms), որպեսզի տեղի ունենա հետևյալը՝

  • օգտատերը սկսում է տպել,
  • օգտատերը անմիջապես լքում է ընթացիկ route-ը, ուստի որոնման բաղադրիչը unmount է լինում debounce արված էֆեկտի աշխատելուց առաջ

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

debounce(..)-ը կանչելով վերադարձվող յուրաքանչյուր ֆունկցիա ունի մի քանի լրացուցիչ հատկություն, այդ իսկ պատճառով նրա վրա կարելի է կանչել .cancel()։

Եզրակացություններ

Գերազանց օգտատիրական փորձ ապահովելու համար ժամանակակից ինտերֆեյսները պետք է հաշվի առնեն արտադրողականությունը։ Իրադարձությունների և էֆեկտների մշակման օպտիմալացումը ընդամենը մեկն է այն բազմաթիվ բաներից, որ ինժեներները պետք է հիշեն։

Դա չի նշանակում, որ պետք է «շտկել» ձեր յուրաքանչյուր հավելվածի յուրաքանչյուր input-ը. օրինակ՝ միանգամայն նորմալ է, որ սովորական տեքստային input-ը ամեն սեղմման ժամանակ թարմացնի ձևի հիշողության մեջ պահվող վիճակը։ Միշտ հաշվի առեք, թե ինչ կառաջացնի իրադարձությունների մշակումը տարբեր հաճախականություններով, և ընտրեք իրավիճակին համապատասխան ռազմավարությունը։

ℹ️ Եթե հետաքրքիր է, այստեղ կգտնեք debounce արված event handler-ի աշխատող օրինակ՝ ամբողջական կոդային բազայի հետ միասին։