【Développement Ethereum-04】Introduction à Node.js

1. Définir les variables

Utilisez const pour définir une constante, qui est une variable qui ne peut pas être modifiée ou réaffectée.

• Utilisez let pour définir une variable au lieu de var, car var présente de nombreux pièges ; vous pouvez considérer let comme var qui corrige le bogue. Par exemple, var autorise les déclarations de variables répétées sans signaler d'erreur ; la portée de var prête à confusion.
• Meilleure pratique : utilisez d'abord const, puis laissez si la variable doit être modifiée ; comprenez que de nombreux projets antérieurs utilisent encore var.

var i = 10;
console.log("var :", i);
var i = 100;
console.log("var :", i);

function test() {
    
    
    var m = 10;
    console.log("test m :", m);
}

test(); //console.log("test outside :", m); 
let j = "hello"
console.log("j :", j);
j = "HELLO"
console.log("j :", j);
const k = [1, 2, 3, 4];
console.log("k0 :", k);
k[0] = 100;
console.log("k1 :", k);

2. Mission de déstructuration

ES6 nous permet d'extraire des valeurs de tableaux et d'objets et d'attribuer des valeurs à des variables selon un certain modèle, appelé Destructuring

• Affectation de déstructuration de tableau

const arr = [1, 2, 3] //我们得到了⼀个数组 
let [a, b, c] = arr //可以这样同时定义变量和赋值 
console.log(a, b, c); // 1 2 3 

• Affectation de déstructuration d'objet (couramment utilisée)

const obj = {
    
     name: '俊哥',address:'深圳', age: '100'} //我们得到了⼀个对象 
let {
    
    name, age} = obj //可以这样定义变量并赋值 
console.log(name, age); //俊哥 100 

• Affectation déstructurante des paramètres de fonction (couramment utilisée)

const person = {
    
    name: '⼩明', age: 11}

function printPerson({
     
     name, age}) {
    
     // 函数参数可以解构⼀个对象 
    console.log(`姓名：${
      
      name} 年龄：${
      
      age}`);
}

printPerson(person) // 姓名：⼩明 年龄：11

3. Extension de fonction

ES6 ajoute de nombreuses extensions utiles aux fonctions.

• Valeurs par défaut des paramètres. À partir de ES6, nous pouvons définir des valeurs par défaut pour les paramètres d'une fonction. Le langage go a-t-il des valeurs par défaut ?

 function foo(name, address = '深圳') {
    
     
  console.log(name, address); 
  }
  foo("⼩明") // address将使⽤默认值 
  foo("⼩王", '上海') // address被赋值为'上海'` 

• Pour les fonctions fléchées, remplacez fonction par la fonction définie par =>, c'est-à-dire que les fonctions fléchées ne conviennent qu'aux fonctions ordinaires, pas aux constructeurs, aux fonctions membres ou aux fonctions prototypes

function add(x, y) {
    
    
    return x + y
}//演示⾃执⾏函数 
//函数也是变量，可以赋值 
// 这个箭头函数等同于上⾯的add函数 
(x, y) => x + y; // 如果函数体有多⾏，则需要⽤⼤括号包裹 
(x, y) => {
    
    
    if (x > 0) {
    
    
        return x + y
    } else {
    
    
        return x - y
    }
}

4. Héritage de classe

parce quejs a été initialement conçu comme un langage fonctionnel, tout est une fonction. Tous les objets sont hérités du prototype de fonction, et l'héritage d'objet est réalisé en héritant du prototype d'une fonction. Mais cette façon d'écrire confondra les nouveaux érudits, et elle est très différente des langues POO traditionnelles. ES6 encapsule la syntaxe de classe pour simplifier considérablement l'héritage d'objet.

class Person {
    
    
    constructor(name, age) {
    
    
        this.name = name
        this.age = age
    }// 注意：没有function关键字
    sayHello() {
    
    
        console.log(`⼤家好，我叫${
      
      this.name}`);
    }
}

class Man extends Person {
    
    
    constructor(name, age) {
    
    
        super(name, age)
    }

//重写⽗类的⽅法
    sayHello() {
    
    
        console.log('我重写了⽗类的⽅法！');
    }
}

let p = new Person("⼩明", 33) //创建对象
p.sayHello() // 调⽤对象p的⽅法，打印 ⼤家好，我叫⼩明
let m = new Man("⼩五", 33)
m.sayHello() // 我重写了⽗类的⽅法！

5. Comprendre les E/S asynchrones et pilotées par les événements NodeJS

NodeJS est au niveau du code utilisateur,Un seul thread est démarré pour exécuter le code de l'utilisateur==(aller langue ?)==. Chaque fois qu'une opération d'E/S chronophage (E/S de fichier, E/S réseau, E/S de base de données) est rencontrée, telle qu'une lecture et une écriture de fichier, une requête réseau, l'opération chronophage est lancée vers la boucle d'événement sous-jacente pour exécution, et la commande automatique Si elle n'attend pas, il continuera à exécuter le code suivant. Lorsque la boucle d'événements sous-jacente termine l'exécution d'E/S chronophages, notre fonction de rappel sera exécutée sous forme de notification. (Écrire une démo)

La synchronisation signifie que vous allez à la banque pour faire la queue pour les affaires, et rien ne peut être fait (bloqué) pendant la file d'attente ; asynchrone signifie que vous allez à la banque et utilisez la machine à numéros pour obtenir un numéro, et vous sont libres de faire autre chose à ce moment-là. Quand il s'agit de vous, vous serez averti de l'événement par un haut-parleur. Le système bancaire équivaut à la boucle d'événements sous-jacente, qui traite en continu les activités chronophages (IO).

6. Fonction de rappel

• L'incarnation directe de la programmation asynchrone Node.js est le rappel
• La fonction de rappel sera appelée une fois la tâche terminée. Node utilise un grand nombre de fonctions de rappel et toutes les API de Node prennent en charge les fonctions de rappel.
• La fonction de rappel apparaît généralement comme le dernier paramètre du paramètre.
• Nous pouvons exécuter d'autres commandes pendant la lecture du fichier. Une fois le fichier lu, nous renvoyons le contenu du fichier en tant que paramètre de la fonction de rappel. De cette façon, le code est exécuté sans bloquer ni attendre les opérations d'E/S de fichier. Cela améliore considérablement les performances de Node.js et peut gérer un grand nombre de requêtes simultanées.

 function foo1(name, age, callback) {
    
     } 
 function foo2(value, callback1, callback2) {
    
     }

Appel synchrone (bloquant)

Veuillez préparer à l'avance le fichier "input.txt" dans le répertoire actuel et écrire toutes les données.

 var fs = require("fs"); 
 data = fs.readFileSync('input.txt'); 
 console.log(data.toString()); 
 console.log("程序执⾏结束!"); 

Appel asynchrone (non bloquant)

var fs = require("fs");
fs.readFile('input.txt', function (err, data) {
    
    
    if (err) return console.error(err);
    console.log(data.toString());
});
console.log("程序执⾏结束!");

7. Système de modules

Afin de permettre aux fichiers Node.js de s'appeler, Node.js fournit un système de module simple. Un fichier est un module, utilisant le mot-clé export pour implémenter

//hello.js
let Hello = () => {
    
    
    console.log("hello world!")
}
module.exports = Hello;

//main.js var Hello = require('./hello'); 
Hello();

8. module de chemin

• Le module path fournit des fonctions utilitaires pour gérer les chemins des fichiers et des répertoires
• path.basename : renvoie la dernière partie d'un chemin
• path.dirname : renvoie le nom du répertoire d'un chemin
• path.extname : renvoie l'extension d'un chemin path.join : utilisé pour raccorder les segments de chemin donnés
• path.normalize : normalise un chemin
• path.resolve([de …], à)

var path = require("path");
// 格式化路径 
console.log('normalization : ' + path.normalize('/test/test1//2slashes/1slash/tab/. .'));
// 连接路径 
console.log('joint path : ' + path.join('/test', 'test1', '2slashes/1slash', 'tab', '..'));
// 转换为绝对路径 
console.log('resolve : ' + path.resolve('main.js'));
// 路径中⽂件的后缀名 
console.log('ext name : ' + path.extname('main.js'));

9. module fs

Modules liés aux opérations sur les fichiers

• fs.stat/fs.statSync : Accéder aux métadonnées du fichier, telles que la taille du fichier, l'heure de modification du fichier
• fs.readFile/fs.readFileSync : lire les fichiers de manière asynchrone/synchrone
• fs.writeFile/fs.writeFileSync : écrit des fichiers de manière asynchrone/synchrone
• fs.readdir/fs.readdirSync : lit le contenu du dossier
• fs.unlink/fs.unlinkSync : supprimer des fichiers
• fs.rmdir/fs.rmdirSync : seuls les dossiers vides peuvent être supprimés, en pensant : comment supprimer les dossiers non vides ?
  – Utilisez le module tiers fs-extra pour supprimer.
• fs.watchFile : surveille les modifications de fichiers

let fs = require('fs');
var filename = './testfile.txt';

//同步读取
var data = fs.readFileSync(filename);
console.log(data.toString());

//异步读取
fs.readFile(filename, function (err, data) {
    
    
    console.log("========= read done!");
    console.log(data.toString())
});
console.log("111111111111");

//打开⽂件
fs.open(filename, 'r+', function (err, fd) {
    
    
    if (err) {
    
    
        return console.err("open failed!");
    }
    console.log("open ok!");
})
fs.stat(filename, function (err, stat) {
    
    
    console.log("is file :" + stat.isFile());
    console.log("is dir :" + stat.isDirectory());
})

var output = './output.txt';
//同步写⽂件
var data = "你好"
var res = fs.writeFileSync(output, data)
console.log("res :", res); //undefine
//异步写文件
fs.writeFile(output, data, function (err) {
    
    
    if (err) {
    
    
        //console.log("")
    }
    console.log("writeFile write ok!!!")
})
fs.appendFile(output, data, function (err) {
    
    
    if (err) {
    
    
        //console.log("")
    }
    console.log("appendFile ok!!!")
})
}

10. Promesses et asnyc/wait

Bien que les méthodes de programmation asynchrone et callback puissent tirer pleinement parti du CPU, lorsque la logique du code devient de plus en plus complexe, de nouveaux problèmes surgissent. Veuillez essayer d'écrire le code logique suivant de manière asynchrone :
déterminez d'abord si un fichier est un fichier ou un répertoire, s'il s'agit d'un répertoire, lisez les fichiers de ce répertoire, recherchez le fichier se terminant par txt, puis récupérez son fichier taille.
Félicitations, lorsque vous avez terminé les tâches ci-dessus, vous êtes entré dans le niveau ultime : Callback hell callback hell !
Afin de résoudre le problème de Callback hell, Promise et async/wait sont nés.

• Le rôle de promise est d'encapsuler le code de rappel asynchrone et de diviser la fonction de rappel d'origine en deux fonctions de rappel , ce qui présente l'avantage d'une meilleure lisibilité. La syntaxe est la suivante :
  Remarque sur la syntaxe : les méthodes de résolution et de rejet à l'intérieur d'une promesse ne peuvent être appelées qu'une seule fois , une fois celle-ci appelée, l'autre ne peut pas être appelée ; si elle est appelée, elle est invalide.

 // 创建promise对象
let readFilePromise = new Promise(function (resolve, reject)=>{
    
    
    // 在异步操作成功的情况选调⽤resolve，失败的时候调⽤reject
    fs.readFile('xxx.txt', (err, data) => {
    
    
        if (err) {
    
    
            reject(err)
        } else {
    
    
            resolve(data.toString())
        }
    })
});
// 使⽤promise
readFilePromise.then((text) => {
    
    
    //then⾥⾯就是我们传给Promise的resolve
    // then⽅法是当Promise内部调⽤了resolve的时候执⾏
    //then有两个参数，then(onResolve, onReject)，⼀般写第⼀个即可，第⼆个通过catch来处理 //
}).catch((err) => {
    
    
    //catch⽅法是当Promise内部调⽤了reject的时候执⾏ 
    console.log(err);
})

• Le rôle de async/wait est de convertir directement le code asynchrone de Promise en écriture synchrone . Notez que le code est toujours asynchrone . Cette innovation a une signification révolutionnaire.
• Exigences grammaticales :
  –await ne peut être utilisé que dans les méthodes modifiées par async, mais async ne nécessite pas d'attente.
  –wait ne peut être suivi que d'une méthode async et d'une promesse. En supposant que vous ayez un objet de promesse, vous pouvez l'écrire comme ceci en utilisant async/wait :

async function asyncDemo() {
    
    
    try {
    
    
        // 当promise的then⽅法执⾏的时候 
        let text = await readFilePromise
        // 当你⽤promise包装了所有的异步回调代码后，就可以⼀直await，真正意义实现了以同步 的⽅式写异步代码 
        console.log('异步道明执⾏');
    } catch (e) {
    
    
        // 捕获到promise的catch⽅法的异常 
        console.log(e);
    }
}

asyncDemo()
console.log('我是同步代码');

Les petites tâches utilisent promise et async/wait pour réécrire le code logique ci-dessus, sentons la puissance puissante ! . La meilleure façon d'écrire du code asynchrone : 1. Utilisez d'abord promise pour encapsuler le code de rappel asynchrone, vous pouvez utiliser la méthode util.promisify fournie par node 2. Utilisez async/wait pour écrire du code asynchrone.