NodeJs-ի ներածություն

Ներածություն

Երբ փորձում եք սովորել համացանցի մասին

զարգացում, մենք սովորաբար գտնում ենք, որ ճակատային մասը զգալիորեն ավելի հասանելի է, քան հետին մասը: Դրա համար շատ պատճառներ կան, մասնավորապես, ակնթարթային հետադարձ կապի զգացումը, որը գալիս է կոդի մեջ էջի որոշակի տարրը փոխելուց և կայքի վրա կիրառվող փոփոխությունը նկատելուց: Այս արձագանքը հաճախ օգտակար է սկսնակների համար, քանի որ այն հնարավորություն է տալիս նրանց հարմարեցնել իրենց ծածկագիրը և սովորել իրենց սխալներից: Ցավոք սրտի, դա այդպես չէ հետին պլանի դեպքում. հաճախ, զգալի աշխատանք է նվիրվում նախօրոք միջավայրը կարգավորելուն և այն կախվածությունները տեղադրելուն, որոնք անհրաժեշտ են պարզ «Բարև աշխարհ» հաղորդագրությունը տերմինալում հայտնվելու համար: Բարեբախտաբար:, բաց կոդով համայնքում անընդհատ մեծ առաջընթաց է գրանցվում շրջանակների մշակման գործընթացի հեշտացման ուղղությամբ, և NodeJs-ի ծրագրավորողների փորձի բարելավումը դրա լավ օրինակն է Javascript-ով հարմար է և առաջարկում է մի շարք ներկառուցված գործիքներ և առանձնահատկություններ, որոնք տարբերում են այն իր մրցակիցներից Այս հոդվածում մենք կուսումնասիրենք NodeJ-ը և դրա էկոհամակարգը գործնական մոտեցմամբ՝ կառուցելով լիովին ֆունկցիոնալ նախագիծ:

Ի՞նչ ենք կառուցելու։

ToDo հավելվածները կիրառական նախագիծ են սկսնակների համար, որոնք սովորում են առաջնահերթ զարգացում: Ահա թե ինչու մենք որոշեցինք ստեղծել Todo list API: Սա մեզ հնարավորություն կտա ավելացնել տվյալների կայունությունը մեր ինտերֆեյսին և մեզ հնարավորություն կտա մանիպուլյացիայի ենթարկել այս տվյալները (ավելացնելով, թարմացնելով, ջնջելով գործերը և այլն…):

Վերջնական կոդը կարելի է գտնել այստեղ:

Մեր գործիքները

Այս նախագծի համար մենք կօգտագործենք պարզեցված տեխնոլոգիական փաթեթ: Այն կարելի է համարել որպես բազմաթիվ գործիքների մինիմալ տարբերակ, որոնք դուք կգտնեք իրական կյանքի նախագծերում, պատճառն այն է, որ ավելի բարձր մակարդակի գաղափարները նույնն են: Գործարկման մանրամասները և կոնկրետ գործիքի ընտրությունը մյուսի փոխարեն կարևոր չեն սկսելու համար:

• NodeJs-ը, ինչպես նշեցինք, Javascript-ի ամենահայտնի շրջանակներից է սերվերի կողմից հավելվածներ ստեղծելու համար:

• ExpressJs-ը նվազագույն Javascript շրջանակ է, որն օգտագործվում է NodeJS-ի վերևում: Այն արագացնում է զարգացման գործընթացը՝ օգտագործելով բազմաթիվ ներկառուցված հնարավորություններ: Այն նաև օգտագործվում է որպես NodeJS նախագծերի զարգացման պրակտիկաների ստանդարտացման միջոց՝ ինժեներների համար դրա օգտագործումը հեշտացնելու համար:

• LowDB-ն պարզ հիշողության տվյալների բազա է: Դրա պարզությունը մեզ թույլ է տալիս ցուցադրել, թե ինչպես կարելի է համագործակցել տվյալների բազայի հետ NodeJs նախագծում՝ առանց ավելի առաջադեմ թեմաների, ինչպիսիք են տեղակայումները և կոնֆիգուրացիաները:

Այժմ, երբ մենք հայտնաբերեցինք բոլոր գործիքները, որոնք մենք կօգտագործենք, եկեք հասնենք մեր ստեղնաշարերին և սկսենք կոդավորումը:

Տեղադրում

Node-ը հասանելի է բոլոր հարթակներում: Տեղադրման բոլոր ուղեցույցները կարելի է գտնել պաշտոնական կայքում: Windows-ի օգտվողները պետք է համոզվեն, որ ավելացնեն հանգույց ուղիղ դեպի շրջակա միջավայրի փոփոխականներ, որպեսզի այն օգտագործվի հրամանի տողում:

Մեզ անհրաժեշտ կլինի նաև տեղադրել npm: Npm-ը NodeJs-ի ստանդարտ փաթեթների կառավարիչն է: Դա մեզ հնարավորություն կտա կառավարել մեր նախագծի կախվածությունը: Տեղադրման ուղեցույցը կարող եք գտնել այստեղ:

Ծրագրի սկզբնավորում

Անցեք հղմանը և կլոնավորեք մեկնարկային նախագիծը.

Սա պարզ մեկնարկային պահոց է մեր նախագծի համար: Այն պարունակում է բոլոր կախվածությունները, որոնք մենք կօգտագործենք նախագծի ֆայլի կառուցվածքի հետ միասին: Մենք կբացատրենք յուրաքանչյուր տարրը հասնելուց հետո: Բացեք ձեր տերմինալը, նավարկեք դեպի նախագծի ուղին և գործարկեք հրամանը.

npm install

Սա կտեղադրի ծրագրի բոլոր կախվածությունները, որոնք նշված են package.json ֆայլում: package.json-ը ցանկացած Javascript/NodeJs նախագծի հիմքում հայտնաբերված ֆայլն է, այն պարունակում է վերջինիս մասին մետատվյալներ և օգտագործվում է կառավարելու բոլոր նախագծի կախվածությունները, սցենարները և տարբերակները:

Բոլոր կախվածությունները տեղադրվելուց հետո մենք կարող ենք սկսել մեր հավելվածը.

npm run start

«Սկսել»-ը սկրիպտ է, որը մենք նշել ենք փաթեթում: json ֆայլ: Այն նշում է մեր հավելվածի մուտքի ֆայլը, որը մեր դեպքում app.js է:

Այժմ ձեր տերմինալում պետք է հայտնվի հետևյալ հաղորդագրությունը.

Սա նշանակում է, որ մեր սերվերը հաջողությամբ գործարկվել է և լսում է 3000 նավահանգիստ ուղարկված ցանկացած հարցում: Եկեք նայենք app.js-ին և բացատրենք, թե ինչ է կատարվում այստեղ.

App.js-ը մեր նախագծի մուտքագրման ֆայլն է (և միակն այս պահին): Մենք ներկայացնում ենք «app» անունով էքսպրես հավելվածը, նշում ենք, որ բոլոր հարցումները, որոնք ունեն «GET» մեթոդը և «/» ենթուղին, կկարգավորվեն այս երթուղով և կանցնեն մի ֆունկցիա, որը կոչվում է «Middleware», որը ընդունում է հարցումը և պատասխանի օբյեկտը որպես պարամետրեր. Սա շատ կարևոր է, քանի որ հարցումը պարունակում է իր մշակման համար անհրաժեշտ ողջ տեղեկատվությունը (պարամետրեր, հարցման մարմին, հարցման վերնագրեր և այլն), և պատասխանի օբյեկտն այն է, որը կվերադարձվի հաճախորդին: Մենք սկսում ենք պարզապես ուղարկելով «Բարև աշխարհ» հաղորդագրությունը: Դրանից հետո մենք ստիպում ենք մեր հավելվածը լսել ցանկացած մուտքային հարցումներ նշված պորտին (մեր դեպքում՝ 3000), և գրանցել «Լսում եմ 3000 նավահանգիստը» հաղորդագրությունը՝ նշելու, որ մեր հավելվածը գործարկված է և գործարկված և պատրաստ է հարցումներ ընդունելու:

Բացեք ձեր տերմինալը և հղման տողում մուտքագրեք «localhost:3000/» և սեղմեք Enter: Սա նշված ուղին է, որը մենք կարող ենք օգտագործել մեր սերվերին տեղայնորեն հասնելու համար: Դուք կստանաք հետևյալ հաղորդագրությունը.

Տվյալների բազայի կազմաձևում

Lowdb-ը բաց կոդով տվյալների բազա է, որը հեշտ է օգտագործել և հատուկ կարգավորում չի պահանջում: Դրա հիմքում ընկած ընդհանուր գաղափարը բոլոր տվյալները տեղական json ֆայլում պահելն է: LowDB-ի տեղադրումից հետո (ինչն արվել է, երբ մենք տեղադրեցինք բոլոր կախվածությունները), մենք կարող ենք ավելացնել հետևյալ կոդը db.js-ում.

Այս կոդը բավականին նման է LowDB-ի պաշտոնական փաստաթղթերում հայտնաբերվածին: Մենք այն մի փոքր շտկեցինք մեր սեփական օգտագործման դեպքում: Տող առ տող բացատրենք.

Առաջին մի քանի տողերը անհրաժեշտ կախվածությունները ներմուծելու համար են։ «միանալը» օգտակար գործառույթ է, որը հասանելի է «ուղի» մոդուլում: Այն NodeJs-ի հիմնական մոդուլներից մեկն է, որն առաջարկում է բազմաթիվ մեթոդներ՝ հետ վարվելու և ուղիների հետ վարվելու համար: «Low» և «JSONFile» երկու դասերն են, որոնք ենթարկվում են LowDB-ի կողմից: Առաջինը ստեղծում է json ֆայլի օրինակ, որը կպարունակի մեր տվյալները: Երկրորդը ստեղծում է տվյալների բազայի իրական օրինակը, որը կգործի դրա վրա: Վերջապես, «lodash»-ը ամենաշատ օգտագործվող javascript գրադարաններից մեկն է, որն առաջարկում է օգտակար գործառույթների լայն տեսականի ծրագրավորման ընդհանուր առաջադրանքների համար: Մենք այն ավելացնում ենք մեր տվյալների բազայի օրինակում, որպեսզի կարողանանք օգտագործել դրա առաջադեմ մեթոդները մեր տվյալների մշակման համար:

Նախ, մենք նշում ենք db.json ֆայլի ուղին: Դա այն ֆայլն է, որը կպարունակի մեր տվյալները և կփոխանցվի LowDB-ին: Եթե ​​ֆայլը չի ​​գտնվել նշված ուղու վրա, LowDB-ն կստեղծի այն:

Այնուհետև մենք փոխանցում ենք ֆայլի ուղին LowDB ադապտերին և փոխանցում այն ​​մեր նոր՝ LowDB տվյալների բազայի օրինակին: «db» փոփոխականն այնուհետև կարող է օգտագործվել մեր տվյալների բազայի հետ հաղորդակցվելու համար: Տվյալների բազայի օրինակը ստեղծելուց հետո մենք կարդում ենք json ֆայլից՝ օգտագործելով db.read(): Սա կսահմանի «տվյալների» դաշտը մեր տվյալների բազայի օրինակում, որպեսզի մենք կարողանանք մուտք գործել տվյալների բազայի բովանդակություն: Ուշադրություն դարձրեք, որ այս տողին նախորդել ենք «սպասել» բառով: Սա նշանակում է, որ այս հրահանգը կարող է անհայտ ժամանակ պահանջել լուծելու համար, և որ NodeJs գործընթացը պետք է սպասի իր կատարմանը, նախքան մնացած կոդը շարունակելը: Մենք դա անում ենք, քանի որ ընթերցման գործողությունը պահանջում է հիշողության հասանելիություն նշված ֆայլին, և այս տեսակի գործողության կատարման ժամանակը կախված է ձեր մեքենայի բնութագրերից:

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

Ի վերջո, մենք գործարկում ենք db.write()՝ տվյալների վրա մեր կատարած փոփոխությունները կիրառելու և տվյալների բազայի օրինակը արտահանելու համար, որպեսզի այն օգտագործվի մեր նախագծի այլ ֆայլերում:

Ընդհանուր խնդրանք/պատասխան աշխատանքի ընթացք

Դիտարկենք հետևյալ դիագրամը.

Այն ցույց է տալիս ընդհանուր ճարտարապետությունը, որը կիրառվում է NodeJs/Express-ով կառուցված բազմաթիվ backend հավելվածներում: Հասկանալով ընդհանուր աշխատանքային հոսքը, որը հետևում է հարցումների մշակմանը, ոչ միայն թույլ կտա ստեղծել և կառուցվածքավորել NodeJs հավելվածները, այլ նաև հնարավորություն կտա փոխանցել այս հասկացությունները ձեր ընտրած ցանկացած տեխնիկական փաթեթի մեջ: Մենք կուսումնասիրենք տարբեր շերտերը, որոնք խանգարում են այս գործընթացին և կբացատրենք դրանց դերերը.

## HTTP հարցումների շերտ

Սա մեր հավելվածի առաջին շերտն է, պատկերացրեք այն որպես դարպաս, որը ստանում է տարբեր հաճախորդներից ստացվող տարբեր հարցումների լայն շրջանակ, յուրաքանչյուր հարցում այնուհետև վերլուծվում և ուղարկվում է հավելվածի հատուկ մաս, որպեսզի այն մշակվի:

• Երթուղիչներ. այստեղ մենք ակնարկում ենք Էքսպրես երթուղիչները, բայց այս հայեցակարգը կարելի է գտնել բազմաթիվ հետին շրջանակներում: Ուղղորդիչները միջոց են մեր բիզնեսի տրամաբանության տրամաբանական բաշխումը մեր կոդի վրա կիրառելու համար, ինչը նշանակում է, որ տարրերի յուրաքանչյուր խումբ, որոնք ունեն նմանատիպ հատկանիշներ, մշակվում են նույն մուտքով և կարող են առանձնացվել մնացած հավաքածուներից: Սա ունի այն առավելությունը, որ կոդի յուրաքանչյուր բաղադրիչն անկախ է մյուսներից և ավելի հեշտ է պահպանել և ընդլայնել: Ավելի կոնկրետ, և որպես օրինակ, բոլոր հարցումները, որոնք համապատասխանում են «/posts» ընդհանուր url ուղու պայմաններին, կկարգավորվեն նույն երթուղիչով: Կախված իրենց http մեթոդից (GET, POST և այլն), կօգտագործվի այլ վերահսկիչ:

• Կարգավորիչներ. վերահսկիչը ստանում է ֆիլտրացված հարցումներ երթուղիչներից, կիրառում է լրացուցիչ մշակում և կանչում է սպասարկման համապատասխան մեթոդները:

Բիզնես տրամաբանական շերտ

Այս շերտը եզակի է՝ կախված հավելվածի օգտագործման կոնկրետ դեպքերից և դրա հետևում գտնվող բիզնես տրամաբանությունից:

• Ծառայություններ. Ծառայությունները մեթոդների մի շարք են, որոնք պարունակում են հավելվածի հիմնական տրամաբանությունը: Նրանք նաև փոխազդում են տվյալների բազայի հետ՝ օգտագործելով ORMs/ODMs:)

• Երրորդ կողմի ծառայություններ. շատ ժամանակակից հավելվածներ ընտրում են հավելվածի տրամաբանության մի մասը փոխանցել հատուկ ծառայություններին, որոնք հասանելի են API-ի միջոցով: Այս տեսակի ծառայությունները կարող են լինել վճարումների մշակման ծառայություններ, ստատիկ ֆայլերի պահպանում, ծանուցումներ և այլն:

• ODM/ORM. ORM-ները և ODM-ները հանդես են գալիս որպես միջնորդ ծառայությունների և տվյալների բազայի միջև: Նրանց դերը տվյալների բազայի վրա բարձր մակարդակի աբստրակցիա ապահովելն է, որը թույլ է տալիս ծրագրավորողին գրել կոդ իրենց ընտրած ծրագրավորման լեզվով` տվյալների բազայի հատուկ լեզուների փոխարեն, ինչպիսին է SQL-ը:

Տվյալների կայունության շերտ

• Տվյալների շտեմարաններ. ինչպես արդեն նշեցինք, գրեթե բոլոր հավելվածներին անհրաժեշտ է տվյալների կայունության որոշակի ձև: Այս մասով կառավարվում են տվյալների բազաները, և կախված տվյալների բնույթից, բիզնես տրամաբանությունից և շատ այլ նկատառումներից, որոշակի տվյալների բազայի ընտրությունը մյուսի փոխարեն կարևոր է համարվում հավելվածի արդյունավետության և մասշտաբայնության համար:

Օրինակ՝ Գրառման ավելացում

Այժմ, երբ մենք հասկանում ենք ճարտարապետության հիմքում ընկած ընդհանուր գաղափարը, եկեք այն կիրառենք մեր պարզ օրինակի վրա: Մենք կիրականացնենք մեր հավելվածում todo գրառում ավելացնելու գործառույթը։ Ենթադրենք, որ ցանկացած գրառում ունի եզակի id, որը թույլ կտա մեզ ավելի ուշ բացահայտել այն մեր տվյալների բազայում, վերնագիր, որը տող է, և կարգ, որը տիպի ամբողջ թիվ է: Հետևելով մեր դիագրամին՝ մենք կսկսենք իրականացնել երթուղիչը: index.js ֆայլին ավելացրեք հետևյալ կոդը.

Սա մեր երթուղիչի ֆայլն է: Մենք ներմուծում ենք էքսպրես և «addPost» մեթոդը մեր վերահսկիչից (մենք շուտով կիրականացնենք սա), ստեղծում ենք էքսպրես երթուղիչի օրինակ և կապում ենք addPost մեթոդը մեր երթուղիչին, ինչը նշանակում է, որ յուրաքանչյուր հարցման համար, որն ունի արմատային ուղի և http: «POST» մեթոդը, այն կարգավորելու համար կկանչվի «addPost» մեթոդը:

Նախքան վերահսկիչում մեր մեթոդը կիրառելը, մենք հղում ենք կատարում նոր երթուղիչին մեր հիմնական app.js ֆայլում և նշում դրա ուղին որպես «/posts». վերահսկիչի տարբեր մեթոդներով.

Մենք ներմուծում ենք երթուղիչը և այն անվանում «փոստեր»: app.use(«/posts»,...) նշանակում է, որ «/posts» ենթուղով բոլոր հարցումները, անկախ դրանց http մեթոդից, ուղղորդվելու են նշված երթուղիչին:

App.js-ի այլ փոփոխությունները ներառում են տվյալների բազայի կազմաձևման ֆայլի ներմուծումը, որպեսզի այն կատարվի, և express.json()-ի օգտագործումը որպես միջնակարգ ծրագիր, որը թույլ կտա մեզ մուտք գործել հարցումի մարմնի օբյեկտ:

Այժմ, երբ մեր երթուղիները սահմանված են, մենք կարող ենք ավելացնել «addPost» մեթոդը controller.js ֆայլում.

«addPost»-ը միջին ծրագրային ֆունկցիա է, որը որպես պարամետրեր է ընդունում հարցումը, պատասխանի օբյեկտները և հաջորդ գործառույթը: Երբ հաջորդ գործառույթը կանչվի, գործընթացը կտեղափոխվի շղթայի հաջորդ միջնակարգ ծրագիր կամ կավարտի հարցումը: Մեթոդի կոդում մենք վերնագիրն ու պատվերը հանում ենք հարցման մարմնից և դրանք որպես պարամետրեր փոխանցում «createPost» ծառայության ֆունկցիային։ Այս ֆունկցիան վերցնում է գրառման ատրիբուտները, ստեղծում է նոր գրառում և վերադարձնում այն: Նոր գրառումը ստեղծելուց հետո մենք այն վերադարձնում ենք հաճախորդին 200 կարգավիճակի կոդի հետ միասին, ինչը նշանակում է, որ հարցումը հաջողվել է: Դուք կարող եք նկատել, որ մեր կոդը դրված է try/catch բլոկի ներսում՝ ցանկացած անսպասելի սխալ հայտնաբերելու և այն հաջորդ միջին ծրագրին փոխանցելու համար: Լավագույն պրակտիկա է համարվում բոլոր երթուղիչներին կցել սխալների մշակման միջին ծրագիր, որը վերացնում է սխալը և վերադարձնում է բովանդակալից սխալի հաղորդագրություն հաճախորդին:

Այժմ մնում է միայն ներդնել «createPost» գործառույթը service.js-ում:

Ինչպես ավելի վաղ նշեցինք ճարտարապետության տարբեր շերտերը բացատրելիս, ծառայության շերտը փոխազդում է տվյալների պահպանման լուծման հետ ORM/ODM-ի օգտագործման միջոցով: Այնուամենայնիվ, մեր օրինակում մենք կարիք չենք ունենա օգտագործել առանձին ORM, քանի որ Lowdb-ն ունի Javascript-ի ներկառուցված աջակցություն: Նրա շարահյուսության մասին բոլոր մանրամասները կարելի է գտնել փաստաթղթերում:

«createPost» մեթոդը ստանում է վերնագիր և պատվեր որպես պարամետրեր և դրանք օգտագործում է գրառման օբյեկտ ստեղծելու համար: Եզակի id-ի համար մենք օգտագործում ենք հատուկ գրադարան, որը կոչվում է «nanoid», որը ստեղծում է նիշերի յուրահատուկ հաջորդականություն: Մենք ավելացնում ենք նոր գրառումը տվյալների բազայի գրառումների զանգվածում և գրում ենք այս փոփոխությունները. նոր գրառումն այնուհետև վերադարձվում է ֆունկցիայի կողմից:

Այժմ, երբ «createPost»-ը պատրաստ է, գրառումների ավելացման գործառույթն այժմ ավարտված է և գործարկված: Մենք փորձարկում ենք այն Փոստմենի միջոցով՝ API-ների փորձարկման հանրաճանաչ գործիք.

Մենք ընտրում ենք «POST»՝ որպես հարցման http մեթոդ՝ նշված url ուղու հետ միասին՝ «localhost:3000/posts»: Մենք վերնագիրը և պատվերը որպես json ձևաչափ ավելացնում ենք body բաժնում և ուղարկում հարցումը։ Ինչպես ցույց է տրված վերևում, մենք ստանում ենք 200 OK կարգավիճակը նորաստեղծ գրառման հետ միասին:

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

Շատ հասկացություններ և գաղափարներ են ուսումնասիրվել այս նախագծում. մենք լուսաբանեցինք, թե ինչպես տեղադրել և կարգավորել մեր նախագծային միջավայրը, սովորեցինք, թե ինչպես կարգավորել LowDB-ն տեղական տվյալների կայունության համար, ուսումնասիրեցինք NodeJS/Express backend հավելվածների ընդհանուր ճարտարապետությունը և տեսանք, թե ինչպես կիրառել այն պարզ օրինակով: Ի վերջո, մենք փորձարկեցինք մեր հավելվածը՝ օգտագործելով Postman-ը:

Այստեղ նպատակն էր բացահայտել այն ամենի պարզեցված տարբերակը, ինչը վերաբերում է ժամանակակից backend հավելվածների ստեղծմանը: Ինչպես տեսանք ավելի վաղ, NodeJs-ը հզոր գործիք է, որը մեզ հնարավորություն է տալիս ստեղծել պարզ և բարդ API-ներ: Համակցված շրջանակների իր հարուստ էկոհամակարգի հետ, ինչպիսիք են էքսպրեսը և գործիքների ու գրադարանների առատությունը գրեթե ցանկացած օգտագործման դեպքում, դա օրինական լուծում է ժամանակակից backend-ի զարգացման համար. լուծում, որը մենք խորհուրդ ենք տալիս սովորել և տիրապետել: