Mon parcours d'apprentissage Node.js (3) - fonctions node.js, rappels, code et événement synchrones et asynchrones loop_node.js

1. Le rôle de node.js,

La signification d'E/S, (E/S est l'abréviation d'entrée/sortie, telle que : taper du texte sur le clavier, saisir, voir la sortie d'affichage du texte à l'écran. Déplacez la souris et voyez le mouvement de la souris sur l'écran. Entrée du terminal, et la sortie vue, etc.)

Les problèmes que node.js veut résoudre (traitement des entrées, entrées, concurrence élevée. Par exemple, il peut y avoir des millions de joueurs dans un jeu en ligne, il y a des millions d'entrées, etc.) (Catégories pour lesquelles node.js convient : quand Node.js est le mieux adapté lorsque l'application doit envoyer et recevoir des données sur le réseau. Il peut s'agir d'une API tierce, d'un appareil en réseau ou d'une communication en temps réel entre le navigateur et le serveur)
.
La signification de la concurrence (le terme concurrence décrit des choses qui se produisent en même temps et peuvent interagir les unes avec les autres. Le modèle d'E/S événementielles de Node nous permet de ne pas nous soucier de l'imbrication et de la concurrence, qui sont courantes dans les E/S asynchrones multithread. Ô question)

E/S réseau de démonstration

Code Js

var http = require('http'), 
  urls = ['www.baidu.com','www.10jqka.com.cn','www.duokan.com']; 
function fetchPage(url){ 
  var start = new Date(); 
  http.get({host:url},function(res){ 
    console.log("Got response from:" + url); 
    console.log("Request took:",new Date() - start, "ms"); 
  }); 
} 
for(var i=0; i<urls.length; i++){ 
  fetchPage(urls[i]); 
} 

Nommé, node.js
Nous exécutons node node.js
dans le terminal Sortie :

Nous demandons à node.js d'accéder à trois URL et de signaler la réponse reçue et le temps qu'elle a pris.
On voit que les deux temps de sortie sont différents. Affecté par divers facteurs, le temps de résolution des requêtes DNS, les procédures d'occupation du serveur, etc.

Pourquoi JavaScript est un langage événementiel
JavaScript est architecturé autour d'événements initialement associés au modèle d'objet de document (DOM). Les développeurs peuvent agir lorsque des événements se produisent. Ces événements incluent le clic de l'utilisateur sur un élément, la fin du chargement de la page, etc. À l'aide d'événements, les développeurs peuvent écrire des écouteurs d'événements qui sont déclenchés lorsqu'un événement se produit.

2. Rappel
1. Qu'est-ce qu'un rappel
2. Analyser les rappels

Un rappel fait référence au passage d'une fonction comme argument à une autre fonction et est généralement appelé une fois la première fonction terminée.

Exemple : comme la méthode hide() dans jquery,
Code Js

1,$("p").hide('slow'); 
2,$("p").hide('slow',function(){alert("The paragraph is now hidden")}); 

Les rappels sont facultatifs,
1 pas besoin de rappel
2. Il y a un rappel Lorsque le paragraphe est masqué, il sera appelé et une invite d'alerte s'affichera.

Vous pouvez donc voir la différence entre le code avec et sans rappels
Code Js

$("p").hide('slow'); 
alert("The paragraph is now hidden");//1 
 
$("p").hide('slow',function(){alert("The paragraph is now hidden")});//2 

1, il n'y a pas de rappel, et l'ordre d'exécution est le même. Cependant, on voit que le paragraphe p n'est pas complètement caché, et l'alerte sort
. 2. Il y a un rappel et l'exécution est en alerte
une fois le masquage terminé.
Analyser les rappels
Code Js

function haveBreakfast(food,drink,callback){ 
  console.log('Having barakfast of' + food + ', '+ drink); 
  if(callback && typeof(callback) === "function"){ 
    callback(); 
  } 
} 
 
haveBreakfast('foast','coffee',function(){ 
  console.log('Finished breakfast. Time to go to work!'); 
}); 

Sortie :

Having barakfast of foast，coffee
Finished breakfast. Time to go to work!

Voici une fonction créée avec trois paramètres. Le troisième paramètre est le rappel. Ce paramètre doit être une fonction.
La fonction haveBreakfast enregistre ce qui est mangé sur la console, puis appelle la fonction de rappel qui lui est transmise en paramètre.

Comment utiliser les rappels dans Node.js

Exemple d'utilisation du module de système de fichiers pour lire le contenu d'un fichier à partir du disque dans node.js

Code Js

var fs = require('fs'); 
 
fs.readFile('somefile.txt','utf8',function(err,data){ 
  if(err) throw err; 
  console.log(data); 
});

Le résultat est : le contenu dans somefile.txt.
1. Le module fs (système de fichiers) est demandé pour être utilisé dans les scripts
2. Fournissez le chemin du fichier sur le système de fichiers comme premier paramètre de la méthode fs.readFile
3. Le deuxième paramètre est utf8, qui représente l'encodage du fichier
4. Fournissez la fonction de rappel comme troisième paramètre de la méthode fs.readFile
5. Le premier paramètre de la fonction de rappel est err, qui sert à enregistrer l'erreur renvoyée lors de la lecture du fichier
6. Le deuxième paramètre de la fonction de rappel est de sauvegarder les données renvoyées par la lecture du fichier.
7. Une fois le fichier lu, le rappel sera appelé
8. Si l'erreur est vraie, une erreur sera générée
9. Si l'erreur est fausse, alors les données du fichier peuvent être utilisées
10. Dans cet exemple, les données seront enregistrées sur la console.

Un autre, le module http, le module http permet aux développeurs de créer des clients et des serveurs http.

Code Js

var http = require('http'); 
 
http.get({host:'shapeshed.com'},function(res){ 
  console.log("Got response:" + res.statusCode); 
}).on('error',function(e){ 
  console.log("Got error:" + e.message); 
 
}); 

Résultat : Réponse obtenue : 200
1. Demandez le module http à utiliser dans les scripts
2. Fournissez deux paramètres à la méthode http.get()
3. Le premier paramètre est l'objet options. Dans cet exemple, demander la page d'accueil de shapeshed.com
4. Le deuxième paramètre est une fonction de rappel qui prend la réponse comme paramètre
5. Lorsque le serveur distant renvoie la réponse, la fonction de rappel sera déclenchée.
6. Enregistrez le code d'état de la réponse dans la fonction de rappel. S'il y a une erreur, vous pouvez l'enregistrer.

Examinons ensuite 4 opérations d'E/S différentes, et elles utilisent toutes des rappels

Code Js

var fs = require('fs'), 
  http = require('http'); 
 
http.get({host:'www.baidu.com'},function(res){ 
  console.log("baidu.com"); 
}).on('error',function(e){ 
  console.log("Got error:" + e.message); 
 
}); 
 
fs.readFile('somefile.txt','utf8',function(err,data){ 
  if(err) throw err; 
  console.log("somefile"); 
}); 
 
http.get({host:'www.duokan.com'},function(res){ 
  console.log("duokan.com"); 
}).on('error',function(e){ 
  console.log("Got error:" + e.message); 
 
}); 
 
fs.readFile('somefile2.txt','utf8',function(err,data){ 
  if(err) throw err; 
  console.log("somefile2"); 
}); 

 我们能知道哪个操作先返回吗？
猜测就是从磁盘上读取的两个文件先返回，因为无需进入网络，但是我们很难说哪个文件先返回，因为我们不知道文件的大小。对于两个主页的获取，脚本要进入网络，而响应时间则依赖于许多难以预测的事情，Node.js进程在还有已经注册的回调尚未触发之前将不会退出。回调首先解决不可预测性的方法，他也是处理并发（或者说一次做超过一件事情）的高效方法。
下面是我执行的结果

  
 同步和异步代码 

先看代码，同步（或者阻塞）代码

Js代码 

function sleep(milliseconds){ 
  var start = new Date().getTime(); 
  while((new Date().getTime() -start) < milliseconds){ 
 
  } 
} 
function fetchPage(){ 
  console.log('fetching page'); 
  sleep(2000); 
  console.log('data returned from requesting page'); 
} 
function fetchApi(){ 
  console.log('fetching api'); 
  sleep(2000); 
  console.log('data returned from the api'); 
} 
fetchPage(); 
fetchApi(); 

 
当脚本运行时，fetchPage()函数会被调用，直到它返回之前，脚本的运行是被阻塞的，在fetchPage()函数返回之前，程序是不能移到fetchApi()函数中的。这称为阻塞操作。
Node.js几乎从不使用这种编码风格，而是异步地调用回调。
看下下面编码，，

Js代码 

var http = require('http'); 
 
function fetchPage(){ 
  console.log('fetching page'); 
  http.get({host:'www.baidu.com',path:'/?delay=2000'}, 
    function(res){ 
      console.log('data returned from requesting page'); 
    }).on('error',function(e){ 
      console.log("There was an error" + e); 
    }); 
} 
function fetchApi(){ 
  console.log('fetching api'); 
  http.get({host:'www.baidu.com',path:'/?delay=2000'}, 
    function(res){ 
      console.log('data returned from requesting api'); 
    }).on('error',function(e){ 
      console.log("There was an error" + e); 
    }); 
} 
fetchPage(); 
fetchApi(); 

 允许这段代码的时候，就不再等待fetchPage()函数返回了，fetchApi()函数随之立刻被调用。代码通过使用回调，是非阻塞的了。一旦调用了，两个函数都会侦听远程服务器的返回，并以此触发回调函数。
注意这些函数的返回顺序是无法保证的，而是和网络有关。
 
事件循环

Node.js使用javascript的事件循环来支持它所推崇的异步编程风格。基本上，事件循环使得系统可以将回调函数先保存起来，而后当事件在将来发生时再运行。这可以是数据库返回数据，也可以是HTTP请求返回数据。因为回调函数的执行被推迟到事件反生之后，于是就无需停止执行，控制流可以返回到Node运行时的环境，从而让其他事情发生。

Node.js经常被当作是一个网络编程框架，因为它的设计旨在处理网络中数据流的不确定性。促成这样的设计的是事件循环和对回调的使用，他们似的程序员可以编写对网络或I/O事件进行响应的异步代码。

需要遵循的规则有：函数必须快速返回，函数不得阻塞，长时间运行的操作必须移到另一个进程中。
Node.js所不适合的地方包括处理大量数据或者长时间运行计算等。Node.js旨在网络中推送数据并瞬间完成。