Debouncing input handler-ները React-ում
Այս գրառումը debouncing-ի մասին է, այսինքն՝ օգտատիրոջ կողմից input-ների հետ փոխազդեցության արդյունքում տեղի ունեցող գործողության միտումնավոր հետաձգման։
Այս գրառման թեման 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-ի աշխատող օրինակ՝ ամբողջական կոդային բազայի հետ միասին։