ჩაანაცვლებს თუ არა Deno - Node.js-ს ?
Tags: deno, node, typescript, javascript
Published: 2020-05-12 00:13:11

როგორც მოგეხსენებათ გამოვიდა [Deno](https://deno.land/) 1.0.0, რომელიც არის JavaScript/TypeScript დაცული გამშვები. მასში გაერთიანებულია მრავალი არსებული ბიბლიოთეკები და წარმოდგენილია ერთი ფაილის სახით, რაც მომავალშიც ასე იქნება. დაწერილია [Rust](https://www.rust-lang.org/) პროგრამირების ენაზე. იყენებს ბიბლიოთეკა [Tokio](https://tokio.rs/)-ს ივენთებისა და ასინქრონული ოპერაციების სამართავად. 
აგრეთვე იყენებს [V8](https://v8.dev/)-ს ([rusty_v8](https://crates.io/crates/rusty_v8) ბიბლიოთეკა) js/ts ფაილების გასაშვებათ. 
როგორც იცით Deno-ს შემქნელი გახლავთ [Ryan Dahl](https://tinyclouds.org/)-ი იგივე Node.js-ის ავტორი. თუ რატომ გადაწყვიტა მან რომ Deno შეექმნა გადადით ამ ლინკზე: [10 Things I Regret About Node.js](https://www.youtube.com/watch?v=M3BM9TB-8yA). 



## რა თვისებებიაქ Deno-ს, Node-ისგან განსხვავებით?
Deno ცდილობს მაქსიმალურად გაამარტივოს სისტემის API–ების გადაბმა V8 "ენჯინზე" რაც გვაძლევს შემდეგ რეზულტატს:
- დაცული sandbox გარემო 
- გამარტივებული მოდულური სისტემა
- ბრაუზერთან თავსებადობა
- Promises / Async / Await
- Typescript
- ინტეგრირებული ყველა საჭირო tool-ი



### ინსტალაცია
ინსტალაციის დეტალებისათვის შეგიძლიათ ნახოთ [მთავარი გვერდი](https://deno.land/).
გაუშვით შემდეგი კოდი ტერმინალში:
```sh 
curl -fsSL https://deno.land/x/install/install.sh | sh
```
იმისთვის რომ, დარწმუნდეთ მუშაობს თუ არა Deno გაუშვით შემდეგი:
```sh
deno run https://deno.land/std/examples/welcome.ts
// Welcome to Deno 🦕
```
გაშვების თანავე მოხდება კოდის კომპილირება სისტემის cache-ში (`~/.deno` unix სისტემაზე) სადაც Deno ინახავს დაკომპილირებულ ბიბლიოთეკებს. იგივე იდაა რაც `node_modules` თუმცა ბევრად უფრო უკეთესი. შეგიძლიათ cache-ი მდებარეობა შეცვალოთ ნებისმიერ მისამართზე `$DENO_DIR` გარემო ცვლადის მეშვეობით.

### დაცული sandbox გარემო
მთავარი რითაც Deno განსხვავდება Node-ის გან ეს არის, დაცულობაზე ორიენტირებული არქიტექტურა. რაც ძალიან მნიშვნელოვანია დღეს დღეობით. როგორც მოგეხსენებათ Node-ში `npm` პაკეტის მოთხოვნისას ჩვენ გვიწევს ბრმად ვენდოთ პაკეტის შემქმნელს რომელსაც შეუძლია თავისუფლად დააზიანოს ჩვენი სისტემა. არაფერს ვამბობ იმ არასაჭირო ფაილებზე რომელიც ამ პაკეტს მოყვება.
Deno-ზე კოდის გაშვება ხდება დაცულ sandbox-ში რაც ნიშნავს რომ დეfაულტად - კოდს არააქვს წვდომა:
- ფაილურ სისტემასთან, ჩაწერა/წაშლა
- ქსელურ სისტემასთან
- გაშვება სხვა დამხმარე სკრიპტებისა, საბ-პროცესის გაშვება
- გარემო ცვლადებთან წვდომა (enviroment variables)

დეველოპერი თავად გადაწყვიტავს როგორი უფლებები მიანიჭოს ამა თუ იმ სკრიპტს. თუ დააკვირდებით `deno run --help`-ი გიჩვენებთ დეტალურ ინფორმაციას თუ რა კონტროლი გაქვთ სკრიპტის გშვებისას.


### მოდულური სისტემა
რა არის მოდული? მოდული არის ფაილი. Deno როგორც ბრაუზერი ისე ტვირთავს ამ ფაილებს/მოდულებს URL-იდან. ეს მოდულები აუცილებლად უნდა იყოს ECMAScript სტანდარტებზე აწყობილი, რაც იმას ნიშნავს რომ არსებული Node-ის მოდულები აქ ვერ გაეშვება. თუმცა რაღაც თავსებადი ლეიერები არსებობს რომელიც ძირითადი Node-ის ფუნქციონალი გაეშვება. იხილეთ [Deno Node compatibility](https://deno.land/std/node/README.md)

```ts
import {readFileStr} from 'http://deno.ge/x/fs/mod.ts';
```
რა დიდი მნიშვნელობააქ URL-იდან ჩაიტვირთება მოდულები თუ `require('module')`-ის დახმარებით?
ის მნიშვნელობააქ რომ Deno პაკეტების დრისტრიბუციას შევძლებთ ცენტრალური რეგისტრის გარეშე როგორიცაა npm, რომ არ ვისაუბროთ ამ უკანასკნელის პრობლემებზე, და ერთ კომპანიის ქვეშ მყოფ ყველა პაკეტზე რაც ყველა კვერცხის ერთ კალათაში მოთავსებას გავს.არავითარი `package.json` და `node_modules` აღარ იქნება საჭირო.
ისმის კითხვა: რა იქნება თუ ბევრი ესეთი მისამართი გვაქვ აპლიკაციაში? 
აქ უკვე ჩვენს კრეატიულობაზეა დამოკიდებული თუ როგრო გადავჭრით ამ საკითხს.საერთო კონვევციით ზოგი იყენებს  `deps.ts` ფაილს სადაც მოხდება ყველა საჭირო ბიბლიოთეკის ჩაწერა. მაგალითად:
```ts
import * as Log from "https://deno.ge/x/log/mod.ts";
import {readJson} from "https://deno.land/std/fs/read_json.ts";

export {
  Log,
  readJson
};

export {
  HTTPOptions,
  HTTPSOptions,
  Response,
  serve,
  Server,
  ServerRequest,
  serveTLS,
} from "https://deno.land/std@v1.0.0/http/server.ts";
```
აგრეთვე შეგიძლიათ გამოიყენოთ [`--importmap`](https://github.com/denoland/deno/blob/master/docs/linking_to_external_code/import_maps.md)
რას ვიტყვით ამა თუ იმ პაკეტის ვერსიებზე? აქ უკვე პაკეტის პროვაიდერზე და დეველოპერზეა დამოკიდებული. მაგალითად: `unpkg.com/:package@:version/:file`
ან შეგიძლიათ მოძებნოთ Deno-სთან თავსებადი არსებული ES მოდულები [Pika CDN](https://www.pika.dev/cdn)-ის საშუალებით. მაგალითად:
```ts
import * as pkg from 'https://cdn.pika.dev/lodash-es@^4.17.15';
```


### ბრაუზერთან თავსებადობა
Deno ცდილობს რაც შეიძლება ბრაუზერთან თავსებადი იყოს. როცა ვიყენებთ ES მოდულებს ამისათვის არ უნდა გვჭირდებოდეს webpack-ი და მისნაირი სისტემის გამოყენება რომ აპლიკაცია ბროუზერში გაეშვას. ის არასაპორტებს ყველა ბროუზერის API-ის რათქმაუნდა თუმცა მთავარი გლობალური ცვლადები რაც ჩაკერებულია Deno-ს ბირთვში ესენია: 
```js
[
  window,fetch,setTimeout,setInterval,
  location,onload,URL,TextEncoder,TextDecoder,
  Request,Response,Event,Worker,Blob,File,crypto,
  ... // და ასე შემდეგ
]
```
ყურადღება მიაქციეთ fetch-ს. დიახ, შეგიძლიათ ასეთი კოდი წეროთ:
```ts
 let response = await fetch("http://deno.ge/x/api/exampleFile.json")
```
ასევე ყურადღება მიაქციეთ `Top Level await`-ს, ამას მოგვიანებით შევეხებით. აგრეთვე მომავალში `fetch`-ით შეძლებთ ლოკალური ფაილების წამოღებას. იხილეთ [#2150](https://github.com/denoland/deno/issues/2150)


### Promises / Async / Await
ამით collback-ების პრობლემა გადაიჭრა, აგრეთვე Deno ასაპორტებს `Top Level await`-ს იხილეთ [#471](https://github.com/denoland/deno/issues/471). რას ნიშნავს ეს? როგორც ზემოთ კოდში იხილეთ, `await`-ის გამოყენებისას ჩვენ არ გამოგვიყენებია `async` ფუნქციაში კოდის შეხვევა რომ, `await fetch(...)`-ეს კოდი გაგვეშვა. რაც ჩემი აზრით ძალიან ელეგანტურია.


### Typescript-ი
Typescript კომპაილერი არის ინტეგრირებული Deno-ს ბირთვში დეფfაულტად, რომელიც იყენებს [v8 snapshot](https://v8.dev/blog/custom-startup-snapshots)-ებს , რათა TS კომპაილერი გაეშვას სწრაფად მეხსიერებიდან, ამიტომ არაა საჭირო რომ Typescript-ის კომპაილერი ყოველ ჯერზე გაეშვას.
რათქმაუნდა როგორც Typescript-ი, ასევე Javascript-იც შეგიძლიათ გამოიყენოთ თავისუფლად.
რატომ Typescript-ი. იმიტომ რომ, როცა პროექტი იზრდება, იზრდება მოთხოვნაც თუ როგორ მოვახერხოთ კოდის არქიტექტურა და მისი მენეჯმენტი. Typescript-ი კი შესანიშნავი ენაა ამისათვის. თან უამრავი კარგი თვისებით გამოირჩევა Javascript-ისგან განსხვავებით.


### ინტეგრირებულია ყველა საჭირო tool-ი
Deno-ში არის ინტეგრირებული:
- ტესტების გამშვები `Deno.test()`. თეგიძლიათ ყოველგვარი ტესტ framework-ების ინსტალაციის გარეშე წეროთ ტესტები. მაგალითად:
```ts
import { assertEquals } from "https://deno.land/std/testing/asserts.ts";

//file.spec.ts
Deno.test({
  name: "testing example",
  fn(): void {
    assertEquals("world", "world");
    assertEquals({ hello: "world" }, { hello: "world" });
    // available assertions
    //equal()
    //assert()
    //assertEquals()
    //assertNotEquals()
    //assertStrictEq()
    //assertStrContains()
    //assertMatch()
    //assertArrayContains()
    //assertThrows()
    //assertThrowsAsync()
    //unimplemented()
    //unreachable()
  },
});

// გაშვება ხდება შემდეგ ნაირად
deno test file.spec.ts
```
- JSDoc მხარდაჭერა და მასზე აწყობილი დოკუმენტაცია [`deno doc`](https://doc.deno.land/)
- კოდის ფორმატირება `deno fmt <files>`
იყენებს [dPrint](https://dprint.dev/) ბიბლიოთეკას რომელიც ასაპორტებს [Prettier](https://prettier.io/)-ის მსგავს კოდის ფორმატირებას.
- კომპილირება და პროექტის შეფუთვა `deno bundle`-ის მეშვეობით.
`deno bundle`-ი აპლიკაციას ოპტიმიზაციას უკეთებს და დააკომპილირებს.
- Debugger `deno run --inspect-brk=<HOST:PORT> FileToDebug.ts`
ეს არის ბრაუზერთან ინტეგრირებული Debugger-ი, რის მეშვეობითაც შეგიძლიათ გახსნათ ბრაუზერის ინსპექტორი დასვათ break point-ი და დაადებაგოთ კოდი.
- მოყვება სტანდარტული ბიბლიოთეკები რომელიც გარანტირებულად იმუშავებს Deno-ზე. იხილეთ https://deno.land/std/


### საინტერესო საკითხები
იგეგმება [HTTP3 spec](https://tools.ietf.org/html/draft-ietf-quic-http-17) / QUIC პროტოკოლის ინტეგრირება, რაც ააჩქარებს ზოგადად ყველაფერს ვებ სივრცეში. სიმართლე გითხრათ მაინცდამაინც მომხრე არ ვარ UDP-ში TCP პროტოკოლის სტრიმებად გაშვების, თუმცა გუგლის უმეტესი სერვერები ახალ პროტოკოლზეა აწყობილი. როგორც ჩანს წლების მანძილზე კარგად მუშაობს. 

აგრეთვე დაგეგმილია [WEBGL](https://get.webgl.org/) ინტეგრირება Deno-ს ბირთვში. რაც იმას ნიშნავს რომ Deno-ზე შეგვეძლება "cross-platform " თამაშების დაწერა და არამარტო თამაშების.



### შეჯამება
ყველა ამბობს რომ Deno არ ჩაანაცვლებს Node-ს, მაგრამ ყველამ კარგად ვიცით რომ ეს ასე არ იქნება. ის საკმაოდ დიდ კონკურენციას გაუწევს Node-ს იმიტომ რომ, ყველა პრობლემა რაც Node-ს აქვს გადაჭრილია თვითონ შემქნელისაგან. ეგ არამარტო Node-ის სამყაროს შეეხება არამედ PHP-საც. საბოლოო ჯამში ყველა ირჩევს ისეთ ტექნოლოგიას რომელიც დაცულია და კომფორტულია დეველოპერებისათვის. რათქმაუნდა ეს ერთ ღამეში არ მოხდება და დრო ყველაფერს გვიჩვენებს.

### კონტრიბუცია
ამჟამად Deno-ს არააქ კარგი ინტელისენსი [VSCode](https://marketplace.visualstudio.com/items?itemName=axetroy.vscode-deno)-ზე და საერთოდ არააქ WebStorm-ზე. თქვენ შეგიძლიათ წვილი შეიტანოთ და ხმა [მისცეთ Deno-ს ინტეგრაციას WebStorm-ში](https://youtrack.jetbrains.com/issue/WEB-41607).
თუ გაქვთ რაიმე კითხვა ან გსურთ დახმარება, გაწევრიანდით Discord-ზე: https://discord.gg/uKZpSRD
ან ეწვიეთ მთავარ გვერდს: [Deno.ge](http://deno.ge)