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

JavaScript runtime-ի ընտրությունը 2023 թվականին. Node, Bun թե Deno։

Node.js-ը կարող է լինել սերվերային JavaScript-ի դե ֆակտո ստանդարտը, բայց այն բոլորին չէ, որ գոհացնում է։ Այս հոդվածում դիտարկում ենք JavaScript-ի երկու այլընտրանքային runtime՝ Deno-ն և Bun-ը։ Արդյոք դրանք մի օր կփոխարինեն Node.js-ին։ Արժե՞ արդյոք փորձել դրանք ձեր հաջորդ նախագծում։ Կարդացեք և իմացեք։

11 րոպե
JavaScriptFrontendBackendFull stackգործիքակազմ

Ըստ Աթվուդի օրենքի՝ ցանկացած հավելված, որը կարելի է գրել 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-ի հնարավորինս արագ կատարումը՝ լիարժեք գործիքակազմի հետ միասին, ինչը այն դարձնում է գրավիչ ընտրություն արտադրողականության վրա կենտրոնացած ցանկացածի համար։