M

MLOG

Ελληνικά

Κατακτήστε τη νέα Ρητή Διαχείριση Πόρων της JavaScript με `using` και `await using`. Μάθετε να αυτοματοποιείτε την εκκαθάριση, να αποτρέπετε διαρροές πόρων και να γράφετε πιο καθαρό και στιβαρό κώδικα.

Η Νέα Υπερδύναμη της JavaScript: Μια Βαθιά Βουτιά στη Ρητή Διαχείριση Πόρων

Στον δυναμικό κόσμο της ανάπτυξης λογισμικού, η αποτελεσματική διαχείριση των πόρων αποτελεί ακρογωνιαίο λίθο για τη δημιουργία στιβαρών, αξιόπιστων και αποδοτικών εφαρμογών. Για δεκαετίες, οι προγραμματιστές JavaScript βασίζονταν σε χειροκίνητα μοτίβα όπως το try...catch...finally για να διασφαλίσουν ότι οι κρίσιμοι πόροι—όπως οι χειριστές αρχείων, οι συνδέσεις δικτύου ή οι συνεδρίες βάσεων δεδομένων—απελευθερώνονται σωστά. Αν και λειτουργική, αυτή η προσέγγιση είναι συχνά dàiòngoς, επιρρεπής σε σφάλματα και μπορεί γρήγορα να γίνει δυσκίνητη, ένα μοτίβο που μερικές φορές αναφέρεται ως η «πυραμίδα της καταστροφής» σε πολύπλοκα σενάρια.

Εδώ έρχεται μια αλλαγή παραδείγματος για τη γλώσσα: η Ρητή Διαχείριση Πόρων (ERM). Οριστικοποιημένο στο πρότυπο ECMAScript 2024 (ES2024), αυτό το ισχυρό χαρακτηριστικό, εμπνευσμένο από παρόμοιες δομές σε γλώσσες όπως οι C#, Python και Java, εισάγει έναν δηλωτικό και αυτοματοποιημένο τρόπο για τον χειρισμό της εκκαθάρισης πόρων. Αξιοποιώντας τις νέες λέξεις-κλειδιά using και await using, η JavaScript παρέχει πλέον μια πολύ πιο κομψή και ασφαλή λύση σε μια διαχρονική πρόκληση του προγραμματισμού.

Αυτός ο περιεκτικός οδηγός θα σας ταξιδέψει στη Ρητή Διαχείριση Πόρων της JavaScript. Θα εξερευνήσουμε τα προβλήματα που λύνει, θα αναλύσουμε τις βασικές της έννοιες, θα δούμε πρακτικά παραδείγματα και θα αποκαλύψουμε προηγμένα μοτίβα που θα σας δώσουν τη δυνατότητα να γράφετε πιο καθαρό, πιο ανθεκτικό κώδικα, ανεξάρτητα από το πού στον κόσμο προγραμματίζετε.

Η Παλιά Φρουρά: Οι Προκλήσεις της Χειροκίνητης Εκκαθάρισης Πόρων

Πριν μπορέσουμε να εκτιμήσουμε την κομψότητα του νέου συστήματος, πρέπει πρώτα να κατανοήσουμε τα σημεία πόνου του παλιού. Το κλασικό μοτίβο για τη διαχείριση πόρων στη JavaScript είναι το μπλοκ try...finally.

Η λογική είναι απλή: αποκτάτε έναν πόρο στο μπλοκ try και τον απελευθερώνετε στο μπλοκ finally. Το μπλοκ finally εγγυάται την εκτέλεση, είτε ο κώδικας στο μπλοκ try επιτύχει, αποτύχει ή επιστρέψει πρόωρα.

Ας εξετάσουμε ένα συνηθισμένο σενάριο από την πλευρά του διακομιστή: το άνοιγμα ενός αρχείου, η εγγραφή δεδομένων σε αυτό και στη συνέχεια η διασφάλιση ότι το αρχείο θα κλείσει.

Παράδειγμα: Μια Απλή Λειτουργία Αρχείου με try...finally


const fs = require('fs/promises');

async function processFile(filePath, data) {
  let fileHandle;
  try {
    console.log('Άνοιγμα αρχείου...');
    fileHandle = await fs.open(filePath, 'w');
    console.log('Εγγραφή στο αρχείο...');
    await fileHandle.write(data);
    console.log('Τα δεδομένα γράφτηκαν επιτυχώς.');
  } catch (error) {
    console.error('Παρουσιάστηκε σφάλμα κατά την επεξεργασία του αρχείου:', error);
  } finally {
    if (fileHandle) {
      console.log('Κλείσιμο αρχείου...');
      await fileHandle.close();
    }
  }
}

Αυτός ο κώδικας λειτουργεί, αλλά αποκαλύπτει αρκετές αδυναμίες:

Τώρα, φανταστείτε τη διαχείριση πολλαπλών πόρων, όπως μια σύνδεση βάσης δεδομένων και ένας χειριστής αρχείου. Ο κώδικας γρήγορα γίνεται ένα ένθετο χάος:


async function logQueryResultToFile(query, filePath) {
  let dbConnection;
  try {
    dbConnection = await getDbConnection();
    const result = await dbConnection.query(query);

    let fileHandle;
    try {
      fileHandle = await fs.open(filePath, 'w');
      await fileHandle.write(JSON.stringify(result));
    } finally {
      if (fileHandle) {
        await fileHandle.close();
      }
    }
  } finally {
    if (dbConnection) {
      await dbConnection.release();
    }
  }
}

Αυτή η ένθεση είναι δύσκολη στη συντήρηση και την κλιμάκωση. Είναι ένα σαφές σημάδι ότι χρειάζεται μια καλύτερη αφαίρεση. Αυτό είναι ακριβώς το πρόβλημα που σχεδιάστηκε να λύσει η Ρητή Διαχείριση Πόρων.

Αλλαγή Παραδείγματος: Οι Αρχές της Ρητής Διαχείρισης Πόρων

Η Ρητή Διαχείριση Πόρων (ERM) εισάγει ένα συμβόλαιο μεταξύ ενός αντικειμένου-πόρου και του JavaScript runtime. Η κεντρική ιδέα είναι απλή: ένα αντικείμενο μπορεί να δηλώσει πώς πρέπει να εκκαθαριστεί, και η γλώσσα παρέχει σύνταξη για να εκτελέσει αυτόματα αυτήν την εκκαθάριση όταν το αντικείμενο βγει εκτός εμβέλειας.

Αυτό επιτυγχάνεται μέσω δύο κύριων συνιστωσών:

  1. Το Πρωτόκολλο Disposable: Ένας τυποποιημένος τρόπος για τα αντικείμενα να ορίζουν τη δική τους λογική εκκαθάρισης χρησιμοποιώντας ειδικά σύμβολα: Symbol.dispose για σύγχρονη εκκαθάριση και Symbol.asyncDispose για ασύγχρονη εκκαθάριση.
  2. Οι Δηλώσεις `using` και `await using`: Νέες λέξεις-κλειδιά που δεσμεύουν έναν πόρο σε μια εμβέλεια μπλοκ. Όταν το μπλοκ εξέλθει, η μέθοδος εκκαθάρισης του πόρου καλείται αυτόματα.

Οι Βασικές Έννοιες: `Symbol.dispose` και `Symbol.asyncDispose`

Στην καρδιά του ERM βρίσκονται δύο νέα γνωστά Σύμβολα. Ένα αντικείμενο που έχει μια μέθοδο με ένα από αυτά τα σύμβολα ως κλειδί του θεωρείται «απορρίψιμος πόρος» (disposable resource).

Σύγχρονη Απόρριψη με `Symbol.dispose`

Το σύμβολο Symbol.dispose προσδιορίζει μια σύγχρονη μέθοδο εκκαθάρισης. Αυτό είναι κατάλληλο για πόρους όπου η εκκαθάριση δεν απαιτεί ασύγχρονες λειτουργίες, όπως το σύγχρονο κλείσιμο ενός χειριστή αρχείου ή η απελευθέρωση ενός κλειδώματος στη μνήμη.

Ας δημιουργήσουμε ένα περιτύλιγμα (wrapper) για ένα προσωρινό αρχείο που αυτοκαθαρίζεται.


const fs = require('fs');
const path = require('path');

class TempFile {
  constructor(content) {
    this.path = path.join(__dirname, `temp_${Date.now()}.txt`);
    fs.writeFileSync(this.path, content);
    console.log(`Δημιουργήθηκε προσωρινό αρχείο: ${this.path}`);
  }

  // Αυτή είναι η σύγχρονη μέθοδος disposable
  [Symbol.dispose]() {
    console.log(`Απόρριψη προσωρινού αρχείου: ${this.path}`);
    try {
      fs.unlinkSync(this.path);
      console.log('Το αρχείο διαγράφηκε επιτυχώς.');
    } catch (error) {
      console.error(`Αποτυχία διαγραφής αρχείου: ${this.path}`, error);
      // Είναι σημαντικό να διαχειρίζεστε τα σφάλματα και μέσα στη dispose!
    }
  }
}

Κάθε αντικείμενο της κλάσης `TempFile` είναι πλέον ένας απορρίψιμος πόρος. Έχει μια μέθοδο με κλειδί `Symbol.dispose` που περιέχει τη λογική για τη διαγραφή του αρχείου από τον δίσκο.

Ασύγχρονη Απόρριψη με `Symbol.asyncDispose`

Πολλές σύγχρονες λειτουργίες εκκαθάρισης είναι ασύγχρονες. Το κλείσιμο μιας σύνδεσης βάσης δεδομένων μπορεί να περιλαμβάνει την αποστολή μιας εντολής `QUIT` μέσω του δικτύου, ή ένας πελάτης ουράς μηνυμάτων μπορεί να χρειαστεί να αδειάσει τον εξερχόμενο buffer του. Για αυτά τα σενάρια, χρησιμοποιούμε το `Symbol.asyncDispose`.

Η μέθοδος που σχετίζεται με το `Symbol.asyncDispose` πρέπει να επιστρέφει ένα `Promise` (ή να είναι μια `async` συνάρτηση).

Ας μοντελοποιήσουμε μια ψευδή σύνδεση βάσης δεδομένων που πρέπει να απελευθερωθεί πίσω σε ένα pool ασύγχρονα.


// Ένα mock pool βάσης δεδομένων
const mockDbPool = {
  getConnection: () => {
    console.log('Αποκτήθηκε σύνδεση ΒΔ.');
    return new MockDbConnection();
  }
};

class MockDbConnection {
  query(sql) {
    console.log(`Εκτέλεση ερωτήματος: ${sql}`);
    return Promise.resolve({ success: true, rows: [] });
  }

  // Αυτή είναι η ασύγχρονη μέθοδος disposable
  async [Symbol.asyncDispose]() {
    console.log('Απελευθέρωση σύνδεσης ΒΔ πίσω στο pool...');
    // Προσομοίωση καθυστέρησης δικτύου για την απελευθέρωση της σύνδεσης
    await new Promise(resolve => setTimeout(resolve, 50));
    console.log('Η σύνδεση ΒΔ απελευθερώθηκε.');
  }
}

Τώρα, κάθε αντικείμενο `MockDbConnection` είναι ένας ασύγχρονα απορρίψιμος πόρος. Γνωρίζει πώς να απελευθερώσει τον εαυτό του ασύγχρονα όταν δεν χρειάζεται πλέον.

Η Νέα Σύνταξη: `using` και `await using` σε Δράση

Έχοντας ορίσει τις disposable κλάσεις μας, μπορούμε τώρα να χρησιμοποιήσουμε τις νέες λέξεις-κλειδιά για να τις διαχειριστούμε αυτόματα. Αυτές οι λέξεις-κλειδιά δημιουργούν δηλώσεις με εμβέλεια μπλοκ, ακριβώς όπως οι `let` και `const`.

Σύγχρονη Εκκαθάριση με `using`

Η λέξη-κλειδί `using` χρησιμοποιείται για πόρους που υλοποιούν το `Symbol.dispose`. Όταν η εκτέλεση του κώδικα φύγει από το μπλοκ όπου έγινε η δήλωση `using`, η μέθοδος `[Symbol.dispose]()` καλείται αυτόματα.

Ας χρησιμοποιήσουμε την κλάση μας `TempFile`:


function processDataWithTempFile() {
  console.log('Είσοδος στο μπλοκ...');
  using tempFile = new TempFile('Αυτά είναι κάποια σημαντικά δεδομένα.');

  // Μπορείτε να δουλέψετε με το tempFile εδώ
  const content = fs.readFileSync(tempFile.path, 'utf8');
  console.log(`Διαβάστηκε από το προσωρινό αρχείο: "${content}"`);

  // Δεν χρειάζεται κώδικας εκκαθάρισης εδώ!
  console.log('...εκτελείται περισσότερη δουλειά...');
} // <-- το tempFile.[Symbol.dispose]() καλείται αυτόματα ακριβώς εδώ!

processDataWithTempFile();
console.log('Έξοδος από το μπλοκ.');

Η έξοδος θα ήταν:

Είσοδος στο μπλοκ...
Δημιουργήθηκε προσωρινό αρχείο: /path/to/temp_1678886400000.txt
Διαβάστηκε από το προσωρινό αρχείο: "Αυτά είναι κάποια σημαντικά δεδομένα."
...εκτελείται περισσότερη δουλειά...
Απόρριψη προσωρινού αρχείου: /path/to/temp_1678886400000.txt
Το αρχείο διαγράφηκε επιτυχώς.
Έξοδος από το μπλοκ.

Κοιτάξτε πόσο καθαρό είναι αυτό! Ολόκληρος ο κύκλος ζωής του πόρου περιέχεται μέσα στο μπλοκ. Το δηλώνουμε, το χρησιμοποιούμε και το ξεχνάμε. Η γλώσσα αναλαμβάνει την εκκαθάριση. Αυτή είναι μια τεράστια βελτίωση στην αναγνωσιμότητα και την ασφάλεια.

Διαχείριση Πολλαπλών Πόρων

Μπορείτε να έχετε πολλαπλές δηλώσεις `using` στο ίδιο μπλοκ. Θα απορριφθούν με την αντίστροφη σειρά της δημιουργίας τους (συμπεριφορά LIFO ή «σαν στοίβα»).


{
  using resourceA = new MyDisposable('A'); // Δημιουργήθηκε πρώτο
  using resourceB = new MyDisposable('B'); // Δημιουργήθηκε δεύτερο
  console.log('Μέσα στο μπλοκ, χρησιμοποιώντας πόρους...');
} // το resourceB απορρίπτεται πρώτο, μετά το resourceA

Ασύγχρονη Εκκαθάριση με `await using`

Η λέξη-κλειδί `await using` είναι το ασύγχρονο αντίστοιχο του `using`. Χρησιμοποιείται για πόρους που υλοποιούν το `Symbol.asyncDispose`. Δεδομένου ότι η εκκαθάριση είναι ασύγχρονη, αυτή η λέξη-κλειδί μπορεί να χρησιμοποιηθεί μόνο μέσα σε μια `async` συνάρτηση ή στο ανώτατο επίπεδο ενός module (αν υποστηρίζεται το top-level await).

Ας χρησιμοποιήσουμε την κλάση μας `MockDbConnection`:


async function performDatabaseOperation() {
  console.log('Είσοδος στην async συνάρτηση...');
  await using db = mockDbPool.getConnection();

  await db.query('SELECT * FROM users');

  console.log('Η λειτουργία της βάσης δεδομένων ολοκληρώθηκε.');
} // <-- το await db.[Symbol.asyncDispose]() καλείται αυτόματα εδώ!

(async () => {
  await performDatabaseOperation();
  console.log('Η async συνάρτηση ολοκληρώθηκε.');
})();

Η έξοδος αποδεικνύει την ασύγχρονη εκκαθάριση:

Είσοδος στην async συνάρτηση...
Αποκτήθηκε σύνδεση ΒΔ.
Εκτέλεση ερωτήματος: SELECT * FROM users
Η λειτουργία της βάσης δεδομένων ολοκληρώθηκε.
Απελευθέρωση σύνδεσης ΒΔ πίσω στο pool...
(αναμονή 50ms)
Η σύνδεση ΒΔ απελευθερώθηκε.
Η async συνάρτηση ολοκληρώθηκε.

Όπως και με το `using`, η σύνταξη `await using` χειρίζεται ολόκληρο τον κύκλο ζωής, αλλά `awaits` σωστά την ασύγχρονη διαδικασία εκκαθάρισης. Μπορεί ακόμη και να χειριστεί πόρους που είναι μόνο σύγχρονα απορρίψιμοι—απλώς δεν θα τους περιμένει.

Προηγμένα Μοτίβα: `DisposableStack` και `AsyncDisposableStack`

Μερικές φορές, η απλή εμβέλεια μπλοκ του `using` δεν είναι αρκετά ευέλικτη. Τι γίνεται αν χρειάζεται να διαχειριστείτε μια ομάδα πόρων με διάρκεια ζωής που δεν είναι συνδεδεμένη με ένα μόνο λεκτικό μπλοκ; Ή τι γίνεται αν ενσωματώνετε μια παλαιότερη βιβλιοθήκη που δεν παράγει αντικείμενα με `Symbol.dispose`;

Για αυτά τα σενάρια, η JavaScript παρέχει δύο βοηθητικές κλάσεις: `DisposableStack` και `AsyncDisposableStack`.

`DisposableStack`: Ο Ευέλικτος Διαχειριστής Εκκαθάρισης

Ένα `DisposableStack` είναι ένα αντικείμενο που διαχειρίζεται μια συλλογή λειτουργιών εκκαθάρισης. Είναι το ίδιο ένας απορρίψιμος πόρος, οπότε μπορείτε να διαχειριστείτε ολόκληρη τη διάρκεια ζωής του με ένα μπλοκ `using`.

Έχει αρκετές χρήσιμες μεθόδους:

Παράδειγμα: Διαχείριση Πόρων υπό Συνθήκη

Φανταστείτε μια συνάρτηση που ανοίγει ένα αρχείο καταγραφής μόνο αν πληρούται μια συγκεκριμένη συνθήκη, αλλά θέλετε όλη η εκκαθάριση να γίνει σε ένα μέρος στο τέλος.


function processWithConditionalLogging(shouldLog) {
  using stack = new DisposableStack();

  const db = stack.use(getDbConnection()); // Πάντα χρησιμοποιούμε τη ΒΔ

  if (shouldLog) {
    const logFileStream = fs.createWriteStream('app.log');
    // Αναβάλλουμε την εκκαθάριση για το stream
    stack.defer(() => {
      console.log('Κλείσιμο του stream του αρχείου καταγραφής...');
      logFileStream.end();
    });
    db.logTo(logFileStream);
  }

  db.doWork();

} // <-- Η στοίβα απορρίπτεται, καλώντας όλες τις καταχωρημένες συναρτήσεις εκκαθάρισης με σειρά LIFO.

`AsyncDisposableStack`: Για τον Ασύγχρονο Κόσμο

Όπως ίσως μαντέψατε, το `AsyncDisposableStack` είναι η ασύγχρονη έκδοση. Μπορεί να διαχειριστεί τόσο σύγχρονα όσο και ασύγχρονα disposables. Η κύρια μέθοδος εκκαθάρισής του είναι η `.disposeAsync()`, η οποία επιστρέφει ένα `Promise` που επιλύεται όταν ολοκληρωθούν όλες οι ασύγχρονες λειτουργίες εκκαθάρισης.

Παράδειγμα: Διαχείριση Μείγματος Πόρων

Ας δημιουργήσουμε έναν χειριστή αιτήσεων web server που χρειάζεται μια σύνδεση βάσης δεδομένων (ασύγχρονη εκκαθάριση) και ένα προσωρινό αρχείο (σύγχρονη εκκαθάριση).


async function handleRequest() {
  await using stack = new AsyncDisposableStack();

  // Διαχείριση ενός ασύγχρονου disposable πόρου
  const dbConnection = await stack.use(getAsyncDbConnection());

  // Διαχείριση ενός σύγχρονου disposable πόρου
  const tempFile = stack.use(new TempFile('request data'));

  // Υιοθέτηση ενός πόρου από ένα παλιό API
  const legacyResource = getLegacyResource();
  stack.adopt(legacyResource, () => legacyResource.shutdown());

  console.log('Επεξεργασία αιτήματος...');
  await doWork(dbConnection, tempFile.path);

} // <-- το stack.disposeAsync() καλείται. Θα αναμένει σωστά την ασύγχρονη εκκαθάριση.

Το `AsyncDisposableStack` είναι ένα ισχυρό εργαλείο για την ενορχήστρωση πολύπλοκης λογικής εγκατάστασης και κατάργησης με καθαρό, προβλέψιμο τρόπο.

Στιβαρός Χειρισμός Σφαλμάτων με το `SuppressedError`

Μία από τις πιο διακριτικές αλλά σημαντικές βελτιώσεις του ERM είναι ο τρόπος με τον οποίο χειρίζεται τα σφάλματα. Τι συμβαίνει αν προκύψει ένα σφάλμα μέσα στο μπλοκ `using`, και ένα *άλλο* σφάλμα προκύψει κατά την επακόλουθη αυτόματη απόρριψη;

Στον παλιό κόσμο του `try...finally`, το σφάλμα από το μπλοκ `finally` θα αντικαθιστούσε ή θα «κατέπνιγε» συνήθως το αρχικό, πιο σημαντικό σφάλμα από το μπλοκ `try`. Αυτό συχνά καθιστούσε τον εντοπισμό σφαλμάτων απίστευτα δύσκολο.

Το ERM λύνει αυτό το πρόβλημα με έναν νέο παγκόσμιο τύπο σφάλματος: το `SuppressedError`. Αν ένα σφάλμα συμβεί κατά την απόρριψη ενώ ένα άλλο σφάλμα ήδη διαδίδεται, το σφάλμα απόρριψης «καταπνίγεται». Το αρχικό σφάλμα προκαλείται, αλλά τώρα έχει μια ιδιότητα `suppressed` που περιέχει το σφάλμα απόρριψης.


class FaultyResource {
  [Symbol.dispose]() {
    throw new Error('Σφάλμα κατά την απόρριψη!');
  }
}

try {
  using resource = new FaultyResource();
  throw new Error('Σφάλμα κατά τη λειτουργία!');
} catch (e) {
  console.log(`Αναχαιτίστηκε σφάλμα: ${e.message}`); // Σφάλμα κατά τη λειτουργία!
  if (e.suppressed) {
    console.log(`Καταπιεσμένο σφάλμα: ${e.suppressed.message}`); // Σφάλμα κατά την απόρριψη!
    console.log(e instanceof SuppressedError); // false
    console.log(e.suppressed instanceof Error); // true
  }
}

Αυτή η συμπεριφορά διασφαλίζει ότι ποτέ δεν χάνετε το πλαίσιο της αρχικής αποτυχίας, οδηγώντας σε πολύ πιο στιβαρά και ευανάγνωστα συστήματα για εντοπισμό σφαλμάτων.

Πρακτικές Περιπτώσεις Χρήσης στο Οικοσύστημα της JavaScript

Οι εφαρμογές της Ρητής Διαχείρισης Πόρων είναι τεράστιες και σχετικές με προγραμματιστές σε όλο τον κόσμο, είτε εργάζονται στο back-end, στο front-end, είτε στον έλεγχο.

Υποστήριξη σε Περιηγητές και Runtimes

Ως ένα σύγχρονο χαρακτηριστικό, είναι σημαντικό να γνωρίζετε πού μπορείτε να χρησιμοποιήσετε τη Ρητή Διαχείριση Πόρων. Στα τέλη του 2023 / αρχές του 2024, η υποστήριξη είναι ευρεία στις τελευταίες εκδόσεις των κυριότερων περιβαλλόντων JavaScript:

Για παλαιότερα περιβάλλοντα, θα χρειαστεί να βασιστείτε σε transpilers όπως το Babel με τα κατάλληλα plugins για να μετασχηματίσετε τη σύνταξη `using` και να κάνετε polyfill τα απαραίτητα σύμβολα και τις κλάσεις stack.

Συμπέρασμα: Μια Νέα Εποχή Ασφάλειας και Σαφήνειας

Η Ρητή Διαχείριση Πόρων της JavaScript είναι κάτι περισσότερο από απλή συντακτική ζάχαρη· είναι μια θεμελιώδης βελτίωση της γλώσσας που προάγει την ασφάλεια, τη σαφήνεια και τη συντηρησιμότητα. Αυτοματοποιώντας την κουραστική και επιρρεπή σε σφάλματα διαδικασία εκκαθάρισης πόρων, απελευθερώνει τους προγραμματιστές να επικεντρωθούν στην κύρια επιχειρηματική τους λογική.

Τα βασικά συμπεράσματα είναι:

Καθώς ξεκινάτε νέα έργα ή αναδιαμορφώνετε υπάρχοντα κώδικα, σκεφτείτε να υιοθετήσετε αυτό το ισχυρό νέο μοτίβο. Θα κάνει τη JavaScript σας πιο καθαρή, τις εφαρμογές σας πιο αξιόπιστες και τη ζωή σας ως προγραμματιστή λίγο πιο εύκολη. Είναι ένα πραγματικά παγκόσμιο πρότυπο για τη συγγραφή σύγχρονης, επαγγελματικής JavaScript.