Junior React մշակո՞ղ եք։ 4 եղանակ՝ ձեր նախագծին ավելի պրոֆեսիոնալ և տպավորիչ տեսք տալու համար
Իմացեք, թե ինչպես բարելավել ձեր մշակողի փորձը և ձեր կոդը դարձնել ավելի հեշտ սպասարկվող ու ավելի պարզ՝ ուրիշների հետ աշխատելու համար։
Կարդացեք, եթե ցանկանում եք՝
- կտրուկ բարելավել ձեր մշակողի փորձը,
- ձեր կոդը դարձնել ավելի հեշտ սպասարկվող և ուրիշների հետ համատեղ աշխատելու համար ավելի պարզ,
- ձեր GitHub-ի նախագծերով զարմացնել աշխատանքի ընդունող ինժեներներին,
որովհետև այս գրառումը գրվել է հենց ձեզ համար։
1. Օգտագործեք Volta
Արդյո՞ք այս իրավիճակներից որևէ մեկը ծանոթ է ձեզ։
- Դուք կլոնավորում եք թարմ repo, գործարկում եք npm install կամ yarn, և ձեր տերմինալը լցվում է առեղծվածային սխալներով՝ միայն հետո readme-ից պարզելու համար, որ հավելվածն աշխատում է բացառապես Node 13.9.0-ից մինչև 14.4.0 տարբերակներով։
- Ձեր ինտեգրման ինչ-որ պահի գործընկերը անցողիկ նշում է «ի դեպ, այն հավաքելու համար Node 12 է պետք»։
- Երբ որևէ մեկը ասում է, որ չի կարողանում գործարկել ձեր նախագիծը, ձեր առաջին հարցը միշտ լինում է «Ի՞նչ Node և npm տարբերակներ ունես այս պահին»։
- Դուք աշխատում եք մի քանի նախագծի վրա զուգահեռ, և յուրաքանչյուրին պետք են որոշ գործիքների տարբեր տարբերակներ։
Volta-ն լուծում է այս բոլոր խնդիրները, և դա անում է զարմանալիորեն լավ։ Սկսելու համար ահա այն ամենը, ինչ ձեզ հարկավոր է։
- Տեղադրեք այն
curl https://get.volta.sh | bashհրամանով կամ Windows-ում՝ օգտվեք նրանց կայքի ցուցումներից։ - Ձեր նախագծի արմատային թղթապանակում գործարկեք
volta pinհրամանը՝ package.json-ում որոշակի գործիքների տարբերակներ ամրագրելու համար։ Օրինակ, այս հրամանները գործարկելուց հետո՝
volta pin node@12.20
volta pin yarn@1.19
ձեր package.json-ը կստանա հետևյալ տողերը՝
"volta": {
"node": "12.20.2",
"yarn": "1.19.2"
}
Արդյունքում ցանկացած մարդ, ով ունի Volta և գործարկում է Node-ից կամ Yarn-ից կախված հրաման, ավտոմատ կստանա ճիշտ նույն տարբերակները։ Եթե այդ տարբերակները բացակայում են, Volta-ն նախ դրանք տեղադրում է, ապա կատարում հրամանը։
Volta-ի առանձնահատկությունը նրա անհավանական հեշտ օգտագործումն է – երբ այն ընդունեք, կզարմանաք, թե ինչպես էիք առանց դրա գլուխ հանում։
2. Օգտագործեք Storybook
Ես չեմ պատկերացնում, թե ինչպես կարելի է արդյունավետ աշխատել Todo հավելվածից մեծ որևէ բանի վրա առանց Storybook-ի։
Լրջորեն։ Իհարկե, մեզանից շատերի նման ես նախկինում աշխատել եմ մեծ նախագծերի վրա առանց դրա, բայց այն օրվանից, ինչ սկսեցի Storybook-ներ ներառել իմ աշխատանքային հոսքերում, արտադրողականությունս մեծապես աճել է։ Օրինակ, հիշում եմ, որ ինչ-որ փոքր կոմպոնենտ կառուցելու համար ստիպված էի հավելվածում սեղմսեղմելով հասնել որոշակի էկրանի, որպեսզի այն հայտնվի։ Իսկ եթե իմ փոփոխությունները հավելվածի վերաբեռնում էին առաջացնում, ստիպված էի կոմպոնենտը նորից որոնել ամենուր։
Որոշ մշակողներ սա նկատում են նույնպես և վերջում ստեղծում են մի տեսակ /playground ենթաէջ, որը ցուցադրում է բոլոր մաքուր կոմպոնենտները՝ մշակումն ու տեսողական թեստավորումը հեշտացնելու համար։ Storybook-ը մոտավորապես դա է – պարզապես շատ ավելի քիչ հնարավորություններով։
Storybook-ի դեպքում դուք ձեր կոմպոնենտների կողքին գրում եք *.stories.tsx ֆայլեր և դրանցում այդ կոմպոնենտները ռենդերում եք տարբեր props-երով, որպեսզի նրանց տարբեր վիճակները ցուցադրվեն կողք կողքի։ Եվ քանի որ stories ֆայլերը ներմուծում են ձեր կոմպոնենտները, ձեր արած ամեն փոփոխություն իրական ժամանակում արտացոլվում է Storybook-ում։
Storybook-ը ձեր նախագծում ձեզ մղում է դեպի կոմպոնենտային մշակում – այսինքն՝ UI կառուցել՝ սկսելով հիմնական, մաքուր կոմպոնենտներից և դրանք համադրելով ավելի մեծ էկրանների մեջ։
Ինչպես մաքուր ֆունկցիաները, մաքուր կոմպոնենտներն ունեն երեք կարևոր հատկություն.
- Դրանք թեստավորելը ավելի հեշտ է։ Քանի որ մաքուր կոմպոնենտները կողմնակի ազդեցություններ չունեն, դրանք կարելի է դետերմինիստական կերպով թեստավորել՝ պարզապես տալով props-երի տարբեր հավաքածուներ և ստուգելով, որ դրանք ռենդերում են սպասվող արդյունքը։ Ցանցային հարցումները մոկ անելու կամ ընդհատելու կարիք չկա։
- Դրանք կրկին օգտագործելը ավելի հեշտ է։ Քանի որ մաքուր կոմպոնենտները կախված չեն թաքնված վիճակից, դուք պետք է կարողանաք դրանք տեղադրել ձեր հավելվածի տարբեր տեսքերում կամ նույնիսկ կրկին օգտագործել այլ նախագծերում, և դրանք պետք է պարզապես աշխատեն։
- Դրանք համադրելը ավելի հեշտ է։ Ամեն էկրան, տեսք կամ դասավորություն կառուցելու փոխարեն՝ ամեն անգամ զրոյից CSS գրելով յուրաքանչյուր տարրի համար, դուք կարող եք ձեր էկրանը հավաքել՝ պարզապես մաքուր կոմպոնենտները տեղադրելով կոնտեյների մեջ և դասավորությունը կարգավորելով տվյալ համադրությանը հատուկ ստիլային props-երով։ Ձեզ պետք չէ ստեղծել «միանգամյա» բազմաթիվ կոմպոնենտներ, ինչպիսին է
TrendingPostsBottomButton-ը, որոնք երբեք չեն կարող կրկին օգտագործվել իրենց խիստ կոնկրետ ներքին ոճավորման պատճառով։
Սա միայն վերևում նշված կոմպոնենտային մշակման ամբողջ պարադիգմայի մակերեսն է։ Եթե ցանկանում եք աճել որպես UI ինժեներ և խնայել ինքներդ ձեզ վատ նախագծված դիզայն համակարգերի առաջացրած հիասթափության մեծ մասից, խորհուրդ եմ տալիս ծանոթանալ այս կայքերին.
- https://www.componentdriven.org/
- atomic web design մեթոդաբանությունը
- https://storybook.js.org/tutorials/intro-to-storybook/
3. Բիզնես տրամաբանությունը դրեք custom hook-երում
Ենթադրենք, մենք կառուցում ենք էկրան, որը պետք է օգտատիրոջը ցուցադրի մեր բլոգի բոլոր հասանելի գրառումները։ Նախորդ բաժնի տնային առաջադրանքն արդեն կատարելով՝ մենք գրել ենք մեր մաքուր կոմպոնենտները՝ PostsStast և Post, և թեստավորել դրանք Storybook-ում։ Պակասում է միայն մի կոմպոնենտ, որը բերում է գրառումների տվյալները և փոխանցում դրանք իր զավակներին։
Ահա մի բան, որ կարող ենք մտածել.
export const AllPosts = () => {
const [posts, setPosts] = useState<null | PostData[]>(null);
const [postsCount, setPostsCount] = useState(-1);
const [viewedPostsIds, setViewedPostsIds] = useState<number[]>([]);
const [isError, setIsError] = useState(false);
useEffect(() => {
fetch("http://localhost:1337/posts")
.then((res) => res.json())
.then((data) => setPosts(data))
.catch(() => setIsError(true));
}, []);
useEffect(() => {
fetch("http://localhost:1337/posts/count")
.then((res) => res.json())
.then((data) => setPostsCount(data))
.catch(() => setIsError(true));
}, []);
if (isError) {
return <div>Error...</div>;
}
if (postsCount === -1 || !posts) {
return <div>Loading...</div>;
}
const transformedPosts = posts.map((post) => ({
...post,
isViewed: viewedPostsIds.includes(post.id),
}));
return (
<div>
<h1>All Posts</h1>
<PostsStats postsCount={postsCount} />
{transformedPosts.map((post) => (
<Post
key={post.id}
post={post}
isViewed={post.isViewed}
onClick={() =>
setViewedPostsIds((posts) => {
if (posts.includes(post.id)) {
return posts;
}
return [...posts, post.id];
})
}
/>
))}
</div>
);
};
Այս կոմպոնենտը… բավական շատ բան է անում։
Սկզբում այն ստեղծում է վիճակի 4 առանձին մաս, որոնցից մի քանիսը կախված են միմյանցից։
Հետո մենք բերում ենք տվյալները, և քանի որ պետք է կանչել երկու endpoint, մեզ պետք են երկու useEffects։
Դրանից հետո մենք կատարում ենք մի քանի ստուգում՝ որոշելու, թե սխալի, թե բեռնման վիճակ պետք է ցուցադրվի։
Իսկ երբ տվյալները հաջողությամբ բեռնվել են, մենք դեռ պետք է միավորենք արտաքին տվյալները մեր տեղական վիճակի հետ, որը հետևում է սեղմված հոդվածներին։
Միայն դրանից հետո կարող ենք էկրանը ռենդերել ճիշտ տվյալներով։
Արդար լինելու համար, այս օրինակը այդքան էլ վատ չէ։ Խնդիրն այն է, որ եթե շարունակեք այսպես կոդավորել, կունենաք 300+ տող կոդ ունեցող կոմպոնենտներ նախքան դրանք կհասնեն return հրամանին։ Այդպիսի կոմպոնենտները դժվար է կարդալ և սպասարկել, և դրանք հեշտությամբ կարող են թաքցնել race condition-ներ վիճակի տարբեր արժեքների և effect-ների միջև։
Ինչպե՞ս խուսափել դրանից։ Նայեք.
export const AllPosts = () => {
const { posts, postsCount, isLoading, isError, view } = usePosts();
if (isLoading) {
return <div>Loading...</div>;
}
if (isError) {
return <div>Error...</div>;
}
return (
<div>
<h1>All Posts</h1>
<PostsStats postsCount={postsCount} />
{posts.map((post) => (
<Post
key={post.id}
post={post}
isViewed={post.isViewed}
onClick={() => view(post.id)}
/>
))}
</div>
);
};
Այս մոտեցումն ունի մի քանի առավելություն.
- Յուրաքանչյուրը անմիջապես կարող է ասել, թե ինչի համար է նախատեսված կոմպոնենտը։
- Քանի դեռ նրա API-ն մնում է նույնը, մենք կարող ենք վերաձևակերպել, բարելավել և թեստավորել մեր
usePosts-ը՝ առանց այս կոմպոնենտին կամ այն օգտագործող որևէ այլ կոմպոնենտին դիպչելու։ isLoadingևisErrorդրոշները հեշտացնում են որոշել, թե որ UI-ը ռենդերել։- Նոր բիզնես պահանջ է՝ գրառումները ցուցադրել հավելվածի մեկ այլ տեղում։ Խնդիր չէ։ Ամբողջ տրամաբանությունը կարգին գտնվում է
usePostshook-ի ներսում։ - Custom hook-երը նաև շատ լավ են համադրվում։ Պե՞տք է ցուցադրել միայն դիտված գրառումները։ Պարզապես գրեք
useViewedPosts, որը ներսում կանչում էusePosts-ը և վերադարձնում զտված արդյունքները։
Custom hook-եր գրելու մանրամասն ուղեցույցի համար տե՛ս React-ի պաշտոնական (beta) փաստաթղթերը։
4. Գրեք պարզ կոդ
Այս վերջին խորհուրդը հավանաբար ամենակարևորն է, ինչպես նաև յուրացնելու համար ամենադժվարը։
Ենթադրենք, պետք է տվյալներ բերել և դրանք օգտատիրոջը ներկայացնել աղյուսակով։ Պետք չէ տվյալների բերման համար կառուցել boilerplate-ով ծանրաբեռնված, անհասկանալի, օբյեկտ-կողմնորոշված աբստրակցիա և հետո դրա վրա դնել ևս մեկ աբստրակցիայի շերտ՝ այն ֆունկցիոնալ React կոմպոնենտում օգտագործելու համար։ Կարող եք պարզապես օգտագործել react-query hook՝ տվյալները բերելու և դրանք ձեր կոմպոնենտի ներսում աղյուսակի մեջ արտապատկերելու համար։ Ամեն ինչ մնում է մեկ կոմպոնենտում՝ առանց անհասկանալի աբստրակցիաների կամ միջնորդավորումների։
Պարզ կոդը ծնվում է փոփոխականների ճշգրիտ անուններ ընտրելու, ֆունկցիաների համար խելամիտ API նախագծելու, մաքուր կոդ գրելու և առաջադրանքի համար ճիշտ գործիքներ ընտրելու համադրությունից։
Ինչպես ավելի լավ սովորել դա.
- Գրեք շատ կոդ։ Նույն բանը նորից իրականացրեք տարբեր գրադարաններով, պատերններով կամ ճարտարապետություններով։ Այդպես եք սովորում, թե որ մոտեցումներն են որ խնդիրներին ավելի լավ համապատասխանում։
- Ժամանակ հատկացրեք կոդ կարդալուն և մտածեք, թե արդյոք որևէ հատված, ֆունկցիա, կամ նույնիսկ մի ամբողջ ֆիչա կարող էր ավելի պարզ կերպով կառուցվել։
- Հետևեք (գոնե որոշ չափով) ծրագրավորողների համայնքներին, որտեղ մարդիկ կիսվում են իրենց գիտելիքներով, ինչպես նաև գրադարաններով և տեխնիկաներով, որոնց մասին գուցե չեք լսել։ Օրինակներ են ծրագրավորման subreddit-ները, ինչպիսիք են r/react-ը և r/typescript-ը, կամ հետևել այնպիսի մարդկանց, ինչպիսիք են Matt Pocock-ը, Josh W. Comeau-ն կամ ես :)
Շնորհակալություն ընթերցելու համար 😊։ Այս խորհուրդներից որևէ մեկը հատկապես օգտակար էր ձեզ համար։ Կամ գուցե ցանկանում եք ինչ-որ բան ավելացնել։ Մի հապաղեք մեկնաբանություն թողնել կամ մեզ էլ. նամակ ուղարկել։