Créer un backend en Javascript (partie 7) : Les Events et les Streams
Tags: javascript, node, express, beginners
Published: 2021-10-18 14:11:10

---
title: Créer un backend en Javascript (partie 7) : Les Events et les Streams
description: 
published: true
tags: javascript, nodejs, express, beginner
cover_image: https://dev-to-uploads.s3.amazonaws.com/uploads/articles/f1qn7uw1ymkntxsgx3tu.png
series: node101
---

Voici une série d'articles qui vous permettra créer des applications backend en Javascript.

Node.js est aujourd'hui un incontournable, il est donc essentiel pour un développeur de le maitriser.

Je vais donc publier un nouvel article environ au deux jours et petit à petit vous apprendrez tout ce qu'il y a à savoir sur Node.js

Pour ne rien manquer suivez moi sur twitter : https://twitter.com/EricLeCodeur
<hr>

## Les Events
Une grande partie du noyau Node.js est construite autour d'une architecture asynchrone idiomatique axée sur les événements dans laquelle certains types d'objets (appelés « emitters ») émettent des événements qui provoquent l'appel de fonction « listeners ».

L'exemple suivant montre un EventEmitter simple avec un seul "listener" qui se produit lorsque, par exemple, une vente est effectuée

```jsx
const EventEmitter = require('events');

const myEmitter = new EventEmitter()

myEmitter.on('newSale', () => {
  console.log('A new sale occur')
})

myEmitter.emit('newSale')
```

La méthode eventEmitter.on() est utilisée pour enregistrer les "listeners", tandis que la méthode eventEmitter.emit() est utilisée pour déclencher l'événement.

Lorsque l'événement est déclenché, le contenu de la callback fonction sera exécuté

```jsx
console.log('A new sale occur')
```

### Passer des arguments aux "listeners"

La méthode eventEmitter.emit() permet à un ensemble arbitraire d'arguments d'être transmis aux fonctions "listeners"

```jsx
const EventEmitter = require('events');

const myEmitter = new EventEmitter()

myEmitter.on('newSale', (total) => {
  console.log(`A new sale occur total of: ${price}`)
})

myEmitter.emit('newSale', 599.99)
```

### Node.js server travail avec un eventEmitter

Maintenant que nous connaissons les événements Node.js. Nous sommes en mesure de mieux comprendre la logique de l'objet serveur Node.js.

```jsx
const server = http.createServer()

// Crétion d'un événment appelé "request"
server.on('request', (req, res) => {
  // Exécuter ce code lorsque le event "request" sera déclenché
  res.end('Request received')
})

// this will loop and wait for events
server.listen(5000, '127.0.0.1', () => {
  console.log('Waiting for request')
})
```

## Les Streams
### Qu'est-ce que sont les Streams ?

Les Streams sont utilisés pour traiter (lire et écrire) des données morceau par morceau (chunks) sans terminer l'ensemble de l'opération de lecture et d'écriture et également sans conserver toutes les données en mémoire.

Youtube ou Netflix sont de bons exemples de Streams. Vous n'avez pas besoin d'attendre le chargement complet de la vidéo. Le processus se fait pièce par pièce (chunks). Vous pouvez donc commencer à regarder le média même si le fichier entier n'est pas encore téléchargé

Dans Node.js, il exisxte des Streams "readable" et des Streams "writable. Les Readable Streams peuvent par exemple être un fichier lu ou une requête http de données.

Writable Streams est l'opposé des Readable Streams donc par exemple une réponse http ou un fichier à envoyer

Voici un exemple de lecture d'un fichier de données volumineux. 

```jsx
const fs = require('fs')
const server = require('http').createServer()

server.on('request', () => {
    // No need to load the entire file to memory
    // fs.readFile('data.txt', (err, data) => {
    //    if (err) console.log(err)
    //    res.end(data);
    // })

    // Create a Readable Streams
    const readable = fs.createReadStream('data.txt')

    // Pipe the Stream chunk to a writable Stream
    readable.pipe(res);
})
```

La méthode readable.pipe() attache un Stream "writeable" au "readable", ce qui le fait basculer automatiquement en mode fluide et transfère toutes ses données vers le "writable" attaché. Le flux de données sera automatiquement géré afin que le Stream "writable" de destination ne soit pas submergé par un Stream "readable" plus rapide.

## Conclusion
C'est tout pour aujourd'hui, suivez moi sur twitter : https://twitter.com/EricLeCodeur afin d'être avisé de la parution du prochain article (d'ici deux jours).