JavaScript runtime-ի ընտրությունը 2023 թվականին. Node, Bun թե Deno։
Node.js-ը կարող է լինել սերվերային JavaScript-ի դե ֆակտո ստանդարտը, բայց այն բոլորին չէ, որ գոհացնում է։ Այս հոդվածում դիտարկում ենք JavaScript-ի երկու այլընտրանքային runtime՝ Deno-ն և Bun-ը։ Արդյոք դրանք մի օր կփոխարինեն Node.js-ին։ Արժե՞ արդյոք փորձել դրանք ձեր հաջորդ նախագծում։ Կարդացեք և իմացեք։
Ըստ Աթվուդի օրենքի՝ ցանկացած հավելված, որը կարելի է գրել JavaScript-ով, ի վերջո կգրվի JavaScript-ով։ Օրենքը ձևակերպվել է Node.js-ի ի հայտ գալուց երկու տարի առաջ և պարզվեց, որ ճիշտ է եղել։ Երբ հայտնվեցին JavaScript-ը բրաուզերից դուրս կատարելու միջավայրեր, մարդիկ սկսեցին սովորական JS-ով ստեղծել սերվերներ, CLI-ներ և նույնիսկ մեքենայական ուսուցման ալգորիթմների մոդելներ։
Node.js-ը կարող է լինել սերվերային JavaScript-ի դե ֆակտո ստանդարտը, բայց այն բոլորին չէ, որ գոհացնում է, ամենաքիչը՝ իր սեփական հեղինակին։
Node
Node-ը՝ առաջին JS backend runtime-ը, ստեղծել է Ռայան Դալը 2009 թվականին։ Այն զգալիորեն ավելի հին է, քան իր մրցակիցները, և շատ ավելի լայն կիրառություն ունի։ Այն այնքան հայտնի է, որ դրա մասին երկար գրելու իմաստ քիչ կա։ Ուստի անցնենք անմիջապես ամփոփմանը՝
Առավելություններ.
- Չափազանց տարածված → առկա են բազմաթիվ համայնքային նախագծեր, ուսումնական նյութեր, աշխատանքային առաջարկներ և այլն
- Ընդհանուր առմամբ հաճելի և պարզ է աշխատելու համար
Թերություններ.
- Կատարում է միայն JavaScript. TypeScript նախագծերին պետք են լրացուցիչ գործիքներ, ինչպես ts-node-ը կամ swc-node-ը
node_modules-ը, որը լռելյայն պահվում է նախագծի ներսում, շատ սկավառակային տարածք է զբաղեցնում և չի մասշտաբավորվում նախագծերի քանակի աճին զուգընթաց- Դրա API-ն անհամատեղելի է բրաուզերի API-ի հետ։
Deno
Deno-ն JavaScript-ի և TypeScript-ի runtime է, որը նույնպես ստեղծել է Ռայան Դալը, թեև համարյա 10 տարի անց։ Այն նախատեսված էր Node.js-ի մի շարք թույլ կողմերը շտկելու համար, այդ թվում՝ նրա անվտանգության մոդելը, build համակարգը և ներկառուցված գործիքների բացակայությունը։
Նրա կարևորագույն հատկությունների թվում են առաջին կարգի TypeScript աջակցությունը, linter-ը, formatter-ը և թեստերի runner-ը՝ ներառված արկղից դուրս, ինչպես նաև սկրիպտները մեկ JavaScript ֆայլի կամ գործարկվող ֆայլի մեջ փաթեթավորելու հնարավորությունը։ Deno-ն դառնում է ավելի ու ավելի տարածված՝ որպես Node.js-ի ավելի անվտանգ և պակաս բարդ այլընտրանք։
Առավելություններ.
- TypeScript-ն աջակցվում է որպես առաջին կարգի քաղաքացի
- Ներառված են linter, formatter և թեստերի runner
- Նախագծված է անվտանգությունը որպես առաջնահերթություն ունենալով
- Աշխատում է Node-ի և npm-ի բազմաթիվ մոդուլների հետ
- Հետևում է վեբ պլատֆորմի ստանդարտներին՝ ավելի լավ DX-ի համար, օրինակ՝
fetch,WebSocketկամ նույնիսկlocalStorage։
Թերություններ.
- Շատ ավելի քիչ տարածված է, քան Node-ը
- Դեռ լիովին հասուն չէ. որոշ API-ներ և մեթոդներ անկայուն են կամ անավարտ
- Այս պահին Node նախագիծը Deno-ի վրա տեղափոխելը կարող է իսկապես դժվար լինել։
Թույլ տվեք ձեզ ներկայացնել մի քանի հատկություն, որոնք ինձ առանձնապես հետաքրքիր թվացին։
Տեղադրում
Նախ և առաջ՝ Deno-ն տեղադրում ենք՝ գործարկելով՝
curl -fsSL https://deno.land/x/install/install.sh | sh
Տեղադրման այլ մեթոդները նկարագրված են Deno-ի տեղադրման էջում։
Deno-ն ընդամենը մեկ գործարկվող երկուական ֆայլ է՝ առանց արտաքին կախվածությունների։ Երբ վերը նշված սկրիպտը կատարվի և Deno-ն ավելացվի PATH փոփոխականին, պատրաստ ենք սկսել։
Հաջորդը պետք է պատրաստենք մշակման միջավայրը IDE-ում։ Ինձ համար դա նշանակում էր պարզապես տեղադրել VS Code-ի Deno-ի պաշտոնական ընդլայնումը և միացնել այն իմ աշխատանքային տարածքի համար։
Deno-ն տրամադրում է LSP ինտեգրացիաներ խմբագրիչների/IDE-ների լայն շրջանակի համար, ինչպես նաև CLI ինքնալրացում տարածված shell-երի համար։ Ինտեգրացիաների ամբողջական ցանկը հասանելի է այս էջում։
Առաջին ծրագիրը
Ժամանակն է գրելու մեր առաջին Deno ծրագիրը։ Հետևյալ օրինակը վերցված է պաշտոնական փաստաթղթերից՝
// main.ts
const url = Deno.args[0];
const res = await fetch(url);
const body = new Uint8Array(await res.arrayBuffer());
await Deno.stdout.write(body);
Ծրագիրը հրամանի տողի արգումենտներից վերցնում է URL, ներբեռնում տվյալ կայքը, վերածում այն Uint8Array-ի և գրում ստանդարտ ելքի մեջ։
Deno-ն ձգտում է հնարավորության դեպքում հենվել ժամանակակից հատկությունների և վեբ ստանդարտների վրա, ուստի զարմանալի չէ, որ top-level await-ն աշխատում է, իսկ fetch-ը հասանելի է առանց որևէ բան import անելու։ Հիշատակման արժանի է նաև Deno գլոբալ փոփոխականը, որը բացահայտում է սերվերային կամ Deno-ին հատուկ API-ների լայն շրջանակ։
Անվտանգություն
Գործարկենք այս կոդը deno run main.ts-ով՝
Սա մեզ բերում է Deno-ի մեկ այլ հարմար հատկության։ Սկրիպտները ոչ մի հասանելիություն չունեն ֆայլերին, ցանցին կամ նույնիսկ միջավայրի փոփոխականներին, քանի դեռ այն բացահայտորեն չի տրվել։ Տրամաբանությունն այն է, որ ձեր linter-ը գործ չունի տվյալներ ցանցով ուղարկելու կամ ձեր մեքենայի վրա որևէ տեղ գրելու հետ։ Deno-ն լռելյայն sandbox-ում է պահում սկրիպտները, և երբ սկրիպտին ինչ-որ հասանելիություն է պետք, ձեզ թույլտվություն են հարցնում։
Բնականաբար, պետք չէ ամեն անգամ հարցնեն։ deno run-ն ընդունում է տարբեր flag-եր, որոնք սկրիպտներին տալիս են մանրամասն թույլտվություններ։ Օրինակ՝ deno run --allow-net=example.com main.ts https://example.com կատարելը main.ts սկրիպտին թույլ է տալիս մուտք գործել ցանց, բայց միայն example.com ծիրը։
TypeScript
Նկատեցի՞ք, որ պարզապես կատարեցինք TypeScript ֆայլ՝ առանց որևէ աղմուկի։ TypeScript մշակման առաջին կարգի փորձ տրամադրելը Deno-ի նպատակներից մեկն էր։ Փոխարենը, որ ինքներս կարգավորենք տրանսպիլյացիայի քայլը, ինչպես կանեինք Node.js նախագծում, ամեն ինչ թողնում ենք Deno-ին։ Եվ այն դա անում է խելացիորեն՝ պահելով քեշ, որպեսզի հետագա գործարկումները ստուգեն և տրանսպիլյացնեն միայն իսկապես անհրաժեշտ մասը։
Ես մեծ երկրպագու եմ տիպերի ստուգումը կատարումից լռելյայն առանձնացնելու ընտրության։ Սկրիպտը deno run script.ts-ով գործարկելը այն տրանսպիլյացնում է swc-ով և կատարում առանց որևէ տիպերի ստուգման։ Մոդուլի տիպերը ստուգելու համար գործարկում ենք deno check script.ts։ Վերջապես, երկու քայլերը կարելի է համատեղել deno run --check script.ts-ով։
Երկուսը բաժանելը լիովին խելամիտ է, որովհետև՝
- Տիպերի ստուգումը կարող է երկար տևել
- Մշակման ընթացքում հաճախ ուզում եք նախատիպավորել և կատարել կոդ, որը դեռ պատշաճ կերպով չի անոտացված։
Կոնֆիգուրացիոն ֆայլ, tasks և watch ռեժիմ
Deno-ն թույլ է տալիս նախագծի արմատում դնել deno.json անունով կոնֆիգուրացիոն ֆայլ։ Այն թույլ է տալիս կարգավորել ներկառուցված TypeScript կոմպիլյատորը, formatter-ը և linter-ը։ Օրինակ՝
{
"compilerOptions": {
"lib": ["deno.window"],
"strict": true
},
"imports": {
"std/": "https://deno.land/std@0.174.0/"
},
"tasks": {
"dev": "deno run --watch src/hello.ts"
},
"lint": {
"files": {
"include": ["src/"],
"exclude": ["src/testdata/"]
},
"rules": {
"tags": ["recommended"],
"include": ["ban-untagged-todo"],
"exclude": ["no-unused-vars"]
}
},
"fmt": {
"files": {
"include": ["src/"],
"exclude": ["src/testdata/"]
},
"options": {
"useTabs": true,
"lineWidth": 80,
"indentWidth": 4,
"singleQuote": true,
"proseWrap": "preserve"
}
}
}
compilerOptions դաշտը կարգավորում է TypeScript-ը նախագծի համար։ TS կոմպիլյատորի ընտրանքների մեծ մասն աջակցվում է Deno-ի կողմից։
imports դաշտը թույլ է տալիս սահմանել հատուկ import-ների համապատասխանեցումներ։ Վերը նշված կոնֆիգուրացիայի դեպքում, օրինակ, կարող ենք գրել՝
import { assertEquals } from "std/testing/assert.ts";
assertEquals(1, 2);
այս ձևի փոխարեն՝
import { assertEquals } from "https://deno.land/std@0.174.0/testing/assert.ts";
assertEquals(1, 2);
lint-ը և fmt-ը կարգավորում են ներկառուցված linter-ը և formatter-ը, իսկ tasks-ն աշխատում է ինչպես package.json-ի scripts-ը։ Դրանք կատարվում են deno task <task_name>-ով։
Հաճելի է, որ ամբողջ կոնֆիգուրացիան գտնվում է մեկ ֆայլում։ Որքան կարող եմ դատել, լռելյայն արժեքները խելամիտ են, ինչը օգնում է այդ ֆայլը կարճ պահել։
Deno-ում մեկ այլ հարմար բան է deno run-ի, deno test-ի, deno bundle-ի և deno fmt-ի համար հասանելի ներկառուցված --watch flag-ը։ Deno-ի օգտատերերը կարող են անել առանց nodemon-ի։
Մոդուլներ
Deno-ն մոդուլներին վերաբերվում է Node-ից տարբեր կերպ։
- Պահանջվում են ֆայլերի լրիվ անուններ. ֆայլի ընդլայնումը չի կարելի բաց թողնել
- index.js-ը հատուկ վերաբերմունք չի ստանում
- Երրորդ կողմի կախվածությունները import են արվում import հրահանգում URL դնելով։
// local, filesystem import
import { add } from "./arithmetic.ts"
// remote import
import { multiply } from "https://x.nest.land/ramda@0.27.0/source/index.js";
Իմ կարծիքով, սա Deno-ով աշխատանք սկսելիս մտածելակերպի ամենամեծ փոփոխություններից մեկն է։ Եթե import հրահանգներում այդ բոլոր հղումները ձեզ տարօրինակ են թվում, դուք լավ ընկերակցության մեջ եք։ Ահա թե ինչպես է Deno թիմը դա լուծում՝
Ճիշտ ճանապարհն այն է, որ ձեր արտաքին գրադարանները import անեք մեկ կենտրոնական
deps.tsֆայլում և այնտեղից նորից export անեք (այն նույն դերն է խաղում, ինչpackage.jsonֆայլը Node-ում)։ Ասենք, որ վերը նշված assertion գրադարանը օգտագործվում է մեծ նախագծի ամբողջ ընթացքում։ Ամեն տեղ"https://deno.land/std@0.177.0/testing/asserts.ts"import անելու փոխարեն կարող եք ստեղծելdeps.tsֆայլ, որը export է անում երրորդ կողմի կոդը։
Թեստավորում
Ինչպես կարող էիք արդեն սպասել, Deno-ն գալիս է սեփական ներկառուցված թեստերի runner-ով։ Jest-ի նման բանի համեմատ այն բավական մինիմալ է՝ առաջարկելով հիմնականում թեստեր և թեստի քայլեր հայտարարելու API։ Assertion-ները, թեստերի պատրաստումն ու մաքրումը նախատեսված է գրել սովորական JS-ով, այլ ոչ թե it.is.not.equal շղթայական ոճով, որին մեզ վարժեցրել են այլ ֆրեյմվորքները։
Որոշ առումներով այն հիշեցնում է Rust-ի թեստավորումը։ Սակայն ի տարբերություն Rust-ի, թեստային դեպքերը չեն կարող գտնվել իրականացման հետ նույն ֆայլում։ Որքան կարողացա տեսնել, Deno-ն թեստեր է փնտրում *.test.{ts,js,tsx,jsx}-ում և մի քանի այլ glob-երում, և անտեսում է Deno.test-ի ցանկացած այլ հանդիպում։
Սա ինձ համար փոքր հիասթափություն է, քանի որ ինձ դուր է գալիս unit թեստերը իրականացման կողքին պահելու DX-ը։ Ես լավ եմ օգտվում դրանից Node-ի վրա հիմնված նախագծերում Vitest-ով և, բնականաբար, Rust-ում։ Հաշվի առնելով, թե Deno-ի գործիքակազմի որքան մասն է կարծես հենվում Rust էկոհամակարգի վրա, ես սպասում էի, որ այդ հատկությունն էլ կլինի։
Փոխգործակցություն Node.js-ի և npm-ի հետ
1.28 տարբերակից սկսած՝ npm փաթեթները կարելի է օգտագործել Deno նախագծերում npm: specifier-ների միջոցով, այսպես՝
import lodash from "npm:lodash@^4.17";
console.log(lodash.map([1, 2, 3], (n) => n * 2));
Երբ փաթեթը գրված է TypeScript-ով կամ իր հետ բերում է սեփական տիպերը, ամեն ինչ աշխատում է ինչպես սպասվում է։ Սակայն երբ տիպեր չի բերում, կարող ենք խնդիրների հանդիպել՝
import lodash from "npm:lodash@^4.17";
console.log(lodash.map([1, 2, 3], (n) => n * 2));
// ^ error here:
// Parameter 'n' implicitly has an 'any' type.deno-ts(7006
Բարեբախտաբար, @deno-types դիրեկտիվը սա լուծում է, ինչպես Node-ում լրացուցիչ տիպերը որպես dev կախվածություններ տեղադրելը՝
// @deno-types="npm:@types/lodash"
import lodash from "npm:lodash@^4.17";
console.log(lodash.map([1, 2, 3], (n) => n * 2));
// ^ n is inferred as a number, Nice!
Deno-ն կարող է հիանալի թվալ, բայց հիշեք, որ npm փաթեթների աջակցությունը դեռ մշակվում է։ Որոշ փաթեթներ կարող են չաշխատել Deno-ի տակ, և այնպիսի գործիքներ, ինչպես deno bundle-ը և deno compile-ը, նույնպես ձախողվում են npm: specifier-ների վրա հենվող նախագծերում։
Այդուհանդերձ, ուրախ եմ, որ Node–Deno համատեղելիության շերտի վրա աշխատանքը ընթանում է, քանի որ տեղափոխությունը դիտարկող շատ մշակողների համար դա վճռորոշ գործոն է։
Bun
Bun-ը ամենանոր նորեկն է։ Թեև այն դեռ թխվում է, շատերն արդեն հուզված են դրանով։ Թխելու մասին խոսելով՝ Oven-ը Bun-ի հեղինակ Ջարեդ Սամների հիմնած ընկերության անունն է։ Այն ապահովել է 7 միլիոն դոլարի ֆինանսավորում՝ «Bun-ի զարգացումը առաջ մղելու, hosting տրամադրելու և Bun-ը վերջից վերջ JavaScript լուծման վերածելու համար», ինչպես նշված է նրա կայքում։
Bun-ը երեք հիմնական նպատակ է հետապնդում՝
- JavaScript-ը կատարել հնարավորինս արագ
- Տրամադրել գերազանց, համապարփակ և արագ գործիքակազմ (bundler, փաթեթների կառավարիչ և այլն)
- Աշխատել որպես յուրաքանչյուր գոյություն ունեցող Node նախագծի drop-in փոխարինող։
Ակնհայտ է, որ նրա մոտեցումը շատ տարբեր է Deno-ի մոտեցումից։ Փոխանակ վերաիմաստավորելու, թե որքան տարբեր կարող է լինել սերվերային JavaScript-ի իդեալական փորձը, Ջարեդ Սամները կենտրոնանում է այն բանի վրա, թե որքան արագ (և նաև հաճելի) կարող է դառնալ այդ փորձը։
Արտադրողականություն
Deno-ն հենվում է V8-ի վրա, JavaScript-ի այն նույն կատարող շարժիչի, որն օգտագործում է Node-ը, բայց Ջարեդը նկատել է, որ WebKit-ի (Safari) շարժիչը՝ JavaScriptCore-ը, սովորաբար մի փոքր ավելի արագ է և հիշողությունն ավելի արդյունավետ է օգտագործում։ Սակայն JSC-ն runtime-ում ներդնելն ավելի դժվար է, ինչի պատճառով սովորաբար ընտրում են V8-ը։ Սակայն Ջարեդը այն մարդը չէ, որ խուսափի ջանքից, և նրա հիմնական նպատակը ակնհայտ է՝ JavaScript-ի արտադրողականությունը նոր մակարդակի հասցնելը։
Բայց դա վերաբերում է միայն կատարող շարժիչին։ Ի՞նչն է runtime-ի մնացած մասերն այդքան արագ դարձնում։ Ամեն ինչի չափագրումը (benchmarking) և օպտիմալացումը, ինչը միայն հնարավոր է օպտիմալացնել։ Bun-ը իրականացված է Zig-ով՝ ցածր մակարդակի լեզվով՝ հիշողության ձեռքով կառավարմամբ, որը հնարավորություն է տալիս գրել չափազանց արագ կոդ, բայց նաև… ներմուծել սխալներ, որոնք ծրագրին segfault են պատճառում։ Իսկ հիմա այդպիսիք շատ կան։
Բարեբախտաբար, յուրաքանչյուր թողարկում շտկում է բազմաթիվ սխալներ և Bun-ն էլ ավելի արագ է դարձնում։
Գործիքակազմ և մշակողի փորձ
Չնայած վաղ փուլում լինելուն՝ Bun-ն արդեն առաջարկում է տպավորիչ գործիքակազմ։
Սկզբից՝ Bun-ը կարող է ծառայել որպես npm-ի հետ համատեղելի փաթեթների կառավարիչ։ Փորձեցի այն բավական մեծ repository-ի վրա, որը պահանջում է ավելի քան 3000 փաթեթի տեղադրում, և ահա արդյունքները՝
- yarn (առանց yarn.lock) → 236 վրկ
- yarn (yarn.lock-ով) → 63 վրկ
- bun install (առանց bun.lockb) → 21 վրկ
- bun install (bun.lockb-ով) → 6.77 վրկ
Տպավորիչ է. սա 10 անգամ արագացում է։
Bun-ը աշխատում է նաև որպես task runner։ Պարզապես bun run start կատարելը npm run start-ի փոխարեն խնայում է npm-ի ներմուծած ավելի քան 150 ms ծախսը։
Բացի այդ, Bun-ն առաջարկում է թեստերի runner, որը շարժվում է դեպի Jest-ի հետ լիարժեք համատեղելիություն։
Մշակումը արագացնելու համար կարող եք օգտագործել վերը նշված գործիքները, Bun-ի սեփական bundler-ի և transpiler-ի հետ միասին, առանց Bun-ը որպես ձեր runtime օգտագործելու անհրաժեշտության։
Ամփոփում
Ամփոփելով՝ Node.js-ը այսօր սերվերում JavaScript կատարելու ամենատարածված տարբերակն է՝ աջակցված հսկայական համայնքով և ռեսուրսների առատությամբ։
Deno-ն, սակայն, խոստումնալից նորեկ է, որը բերում է ավելի լավ անվտանգություն և ավելի լավ մշակման փորձ, հատկապես TypeScript նախագծերի համար։
Bun-ը դեռ իր զարգացման վաղ փուլում է, բայց ձգտում է ապահովել JavaScript-ի հնարավորինս արագ կատարումը՝ լիարժեք գործիքակազմի հետ միասին, ինչը այն դարձնում է գրավիչ ընտրություն արտադրողականության վրա կենտրոնացած ցանկացածի համար։