Explication détaillée de 4 concepts JavaScript de Node.js

Explication détaillée de 4 concepts JavaScript dans Node.js

Ne serait-il pas étonnant si vous n'aviez besoin de connaître qu'un seul langage de programmation pour créer une application full-stack ? Pour concrétiser cette idée, Ryan Dahl a créé node.js. Node.js est un framework côté serveur construit sur le puissant moteur JavaScript V8 de Chrome. Bien qu’écrite à l’origine en C, l’application s’exécute via JavaScript.

De cette façon, le problème est résolu. Une seule langue peut les gouverner tous. De plus, vous n’avez besoin d’utiliser que cette seule langue dans toute l’application. Par conséquent, nous devons avoir une compréhension approfondie de node.js. C'est de cela que parle cet article.

Les quatre concepts de base suivants sont nécessaires si vous souhaitez maîtriser node.js. Je vais vous les présenter dans une histoire aussi courte que possible.

1. E/S non bloquantes ou asynchrones

Étant donné que Node.js est un framework côté serveur, l'une de ses tâches principales est de gérer requête du serveur de navigation. Dans un système d'E/S traditionnel, la requête actuelle n'est émise que lorsque la réponse (page HTML) de la requête précédente est arrivée. C'est pourquoi cela s'appelle bloquer les E/S. Le serveur bloque les autres requêtes afin de traiter la requête en cours, ce qui fait attendre le navigateur.

Node.js ne suit pas ce principe d'E/S. Si une requête prend beaucoup de temps, Node.js enverra la requête à la boucle d'événements et continuera à traiter la requête suivante dans la pile d'appels. Une fois le traitement de la requête en attente terminé, elle en informe Node.js et la réponse est rendue sur le navigateur.

Utilisez un exemple factice pour comprendre ceci :

Blocage des E/S

// take order for table 1 and wait...
var order1 = orderBlocking(['Coke', 'Iced Tea']);
// once order is ready, take order back to table.
serveOrder(order1);
// once order is delivered, move on to another table.
// take order for table 2 and wait...
var order2 = orderBlocking(['Coke', 'Water']);
// once order is ready, take order back to table.
serveOrder(order2);
// once order is delivered, move on to another table.
// take order for table 3 and wait...
var order3 = orderBlocking(['Iced Tea', 'Water']);
// once order is ready, take order back to table.
serveOrder(order3);
// once order is delivered, move on to another table.

Dans cet exemple de restaurant, le serveur donne le menu et attend que la commande soit terminé, puis retournez à table et servez à partir du menu. Pendant que le client actuel commande, le serveur attend à proximité et n'accepte pas les menus des autres clients.

E/S non bloquantes

// take order for table 1 and move on...
orderNonBlocking(['Coke', 'Iced Tea'], function(drinks){
  return serveOrder(drinks);
});
// take order for table 2 and move on...
orderNonBlocking(['Beer', 'Whiskey'], function(drinks){
  return serveOrder(drinks);
});
// take order for table 3 and move on...
orderNonBlocking(['Hamburger', 'Pizza'], function(food){
  return serveOrder(food);
});

Dans cet exemple, le serveur récupère le menu, l'informe au chef, puis revient chercher un autre menu. En train de compléter le premier menu, il sert non seulement les clients actuels dans l'ordre, mais accepte également les commandes d'autres clients. Les serveurs ne perdent pas de temps à bloquer les commandes d'autres clients.

2. Prototype

Le prototype est un concept complexe en JavaScript. Mais comme vous utilisez plusieurs fois des prototypes dans Node.js, chaque développeur JavaScript doit comprendre ce concept.

Dans un langage qui implémente l'héritage classique, tel que Java ou C, pour les langages soucieux de la réutilisation du code, vous devez d'abord écrire une classe, puis créer des objets à partir de cette classe ou étendre cette classe . Cependant, la notion de classes n'existe pas en JavaScript. Créez d'abord un objet en JavaScript, puis ajoutez vos propres objets à partir de cet objet ou créez de nouveaux objets. C'est ce qu'on appelle l'héritage archétypal et la réalisation à travers les archétypes.

Chaque objet JavaScript est lié à un objet prototype dont il peut hériter des propriétés. Les prototypes sont similaires aux classes d’autres langages OO, mais la différence est qu’ils sont également eux-mêmes des objets. Chaque objet est lié à Object.prototype et Object.prototype est livré avec JavaScript prédéfini.

Si vous recherchez une propriété via obj.propName ou obj['propName'] et que l'objet n'a pas de propriété pouvant être vérifiée via obj.hasOwnProperty('propName'), alors le moteur d'exécution JavaScript le fera Recherchez des propriétés dans des objets prototypes. Si l'objet prototype ne possède pas une telle propriété, alors ses prototypes sont vérifiés en séquence jusqu'à ce qu'une correspondance soit trouvée ou que Object.prototype soit atteint. Si aucune chaîne de prototypes n'existe pour la propriété, cela donne une valeur indéfinie.

Comprenez ce concept avec l'exemple de code suivant :

if (typeof Object.create !== 'function') {
    Object.create = function (o) {
        var F = function () {};
        F.prototype = o;
        return new F();
    };
var otherPerson = Object.create(person);

Lorsque vous créez un nouvel objet, vous devez choisir un objet qui doit être son prototype. Ici, nous ajoutons une méthode à la fonction Object. Cette méthode crée un nouvel objet en utilisant un autre objet comme prototype, qui lui est transmis en paramètre.

Lorsque l'on change un nouvel objet, son prototype n'est pas affecté. Cependant, lorsque nous apportons des modifications à un objet prototype, ces modifications sont visibles par tous les objets basés sur ce prototype.

Le prototype est un concept complexe. Je développerai cela dans un autre article.

3. Modules

Si vous avez déjà été exposé à des packages en Java, les modules de Node.js ne sont pas différents. Si ce n’est pas le cas, ne vous inquiétez pas. Les modules sont de simples fichiers JavaScript contenant du code dans un but spécifique. Le modèle de module est utilisé pour rendre votre code facile à naviguer et à utiliser. Pour utiliser un attribut de module, vous devez l'exiger dans un fichier JavaScript, un peu comme si vous importiez un package dans une classe Java.

Il existe deux types de modules dans node.js.

Modules de base - Ces modules sont pré-compilés avec la bibliothèque Node.js. Le but des modules de base est de fournir aux développeurs des extraits de code fréquents et répétitifs qui, s'ils ne sont pas disponibles, les mettraient dans une situation où ils devraient écrire le même code encore et encore. Certains modules de base communs sont HTTP, URL, EVENTS, FILE SYSTEM, etc.

用户定义模块——用户定义模块是开发人员在应用程序内创建用于特定目的的模块。当核心模块不能满足期望功能的时候就需要用户定义模块。

模块通过require函数提取。如果它是一个核心模块，那么参数仅仅是模块的名称。如果它是一个用户自定义模块，那么参数就是该模块在文件系统中的路径。例如：

// extract a core module like this
var http = require('http);
// extract a user defined module like this
var something = require('./folder1/folder2/folder3/something.js');

4.回调函数

在JavaScript中，函数被认为是第一类对象。这意味着你可以对这些函数做所有可对常规对象做的操作。你可以赋值函数给变量，作为参数传递函数给方法，作为对象属性声明函数，甚至从函数返回函数。

回调函数是JavaScript中的匿名函数，它可以作为参数传递给其他函数，要么被执行或返回自函数稍后执行。这是回调函数——这个使用最广的函数编程范式的基础。

当我们将回调函数作为参数传递给另一个函数的时候，我们只能传递函数定义……换言之就是，我们不知道这个回调函数什么时候会执行。这完全取决于调用函数的机制。它会在以后的某个时间点“回调”，因此而得名。这也是非阻塞或Node.js异步行为的唯一基础，如下例所示。

setTimeout(function() {
    console.log("world");
}, 2000)
console.log("hello");

这是回调函数最简单的例子之一。我们将一个匿名函数作为一个参数传递，这个参数只需在控制台上记录一些输出到setTimeout函数。它是唯一的函数定义，但是不知道何时执行。这需要经过2秒后，通过第二个参数，调用setTimeout函数来决定。

首先，第二个日志语句记录输出到控制台，然后，2秒钟后，回调函数中的日志语句记录输出。

// output
hello
world

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!