---
# System prepended metadata

title: NodeJs
tags: [npm, gobelins, NodeJs]

---

# NodeJs

###### tags: `NodeJs` `npm` `gobelins`

## Streams
[Trello](https://trello.com/b/d4NoXctD/node-js)

upload = petit a petit
serveur stream = fur et a mesure

Liaison serveur - client

Stream = concept : Evenements et fonctions

## Streams types
### Récupérer des données : Readable
Données qui peuvent être lues
Source de données pas forcément disponibles au même moment
Géré par les pipe : Emet des données en continue : mode Flowing (il faut toujours les écouter) => mode par défaut

### Ecrire des données : Writable
Destination où je peux ecrire des données petit a petit

### Les deux : Duplex
A la fois readable et writable (côte à côte sans se parler)
exemple : socket TCP serveur client => chacun envoyer et recevroi des données au travers du socket

### Les deux + autre chose : Transform
A la fois readable et writable (ils sont liés)
Equivalent d'une fonction

## Opérateur Pipe
Permet de connecter deux streams entre eux
ReadableSource.pipe(writableSource)
Préférer pipeline()

## Code
### Créer un writable dans un fichier
```
//Créer un writable
const {Writable,Readable,Duplex,Transform} = require("stream");
const fs = require("fs");

//file contient un writable stream
const file = fs.createWriteStream("./big.txt");

//Ecrire dans le writable (écrase toute les données précédentes)
file.write("test\n");

//Terminer
file.end();
```
### Créer des Readables
#### Méthode 1
```
//Créer un writable
const {pipeline,Writable,Readable,Duplex,Transform} = require("stream");

//Créer un stream readable (structure de données en mémoire)
const inStream = new Readable({
    //Implémenter la méthode read
    read(){}
});

//Pousser dans le readable (en interne)
inStream.push("ABC");
inStream.push("DEF");

//Envoyer dans la console, lire les données
pipeline(inStream,process.stdout,(error) => {
    console.error(error);
})
```
#### Méthode 2 (meilleure)
```
//Créer un writable
const {pipeline,Writable,Readable,Duplex,Transform} = require("stream");

//Créer un stream readable (structure de données en mémoire)
const inStream = new Readable({
    //Implémenter la méthode read
    read(size){
        this.push(String.fromCharCode(this.currentCharCode++))
    }
});

inStream.currentCharCode = 65;

//Envoyer dans la console, lire les données
pipeline(inStream,process.stdout,(error) => {
    console.error(error);
})
```
### Créer des Writables
```
//Créer un writable
const {pipeline,Writable,Readable,Duplex,Transform} = require("stream");

//Créer un stream writable (structure de données en mémoire)
const outStream = new Writable({
    //Implémenter la méthode write
    write(chunk,encoding,callback){
        console.log("///\n"+chunk.toString()+"\n");
        callback();
    }
});

//Envoyer dans la console après action dans la console
pipeline(
    process.stdin,
    outStream,
    (error) => {
    console.error(error);
})
```
### Les deux
```
//Créer un writable
const {pipeline,Writable,Readable,Duplex,Transform} = require("stream");

//Créer un stream readable (structure de données en mémoire)
const inStream = new Readable({
    //Implémenter la méthode read
    read(size){
        this.push(String.fromCharCode(this.currentCharCode++))
    }
});

inStream.currentCharCode = 65;

//Créer un stream writable (structure de données en mémoire)
const outStream = new Writable({
    //Implémenter la méthode write
    write(chunk,encoding,callback){
        console.log("///\n"+chunk+"\n");
        
        //Dire qu'on a fini de faire qqchose
        callback();
    }
});

//Envoyer dans la console
pipeline(
    inStream,
    outStream,
    (error) => {
    console.error(error);
})
```
### Créer un Duplex
Intéressant pour stocker des choses dans un objet et les modifier
Exemple : web socket (données dans les deux sens)
```
//Créer un writable
const {pipeline,Writable,Readable,Duplex,Transform} = require("stream");


const duplexStream = new Duplex({
    //Implémenter la méthode read
    read(size){
        this.push(String.fromCharCode(this.currentCode++));
        if(this.currenCharCode > 80){
            this.push(null)
        }
    },
    
    //Implémenter la méthode write
    write(chunk,encoding,callback){
        console.log("///\n"+chunk+"\n");
        
        //Dire qu'on a fini de faire qqchose
        callback();
    }
});

duplexStream.currentCharCode = 65;


//Utiliser comme Readable
pipeline(
    duplexStream,
    process.stdout,
    (error) => {
        console.error(error);
    }
);
//Utiliser comme Writable
pipeline(
    process.stdin,
    duplexStream,
    (error) => {
        console.error(error);
    }
);
//Utiliser les deux
pipeline(
    duplexStream,
    duplexStream,
    (error) => {
        console.error(error);
    }
);
```
### créer un transform
```
const {pipeline,Writable,Readable,Duplex,Transform} = require("stream");

const transform = new Transform({
    //Implémenter la méthode write
    transform(chunk,encoding,callback){
        const data = "///\n"+chunk+"\n";
        this.push(data);
        
        //Dire qu'on a fini de faire qqchose
        callback();
    }
});

//Utiliser comme Readable
pipeline(
    process.stdin,
    transform,
    process.stdout
    (error) => {
        console.error(error);
    }
);
```

## NPM
- Installer npm et nodejs
- installer npm pour le projet 
```
    npm init
    npm install
    npm i request
```
