Introduction détaillée aux modules et méthodes dans nodejs

Cet article vous apporte une introduction détaillée aux modules et méthodes de nodejs. Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer. J'espère qu'il vous sera utile.

1. Spécifications de chargement des modules

Il existait des solutions de chargement de modules js avant ES6, les plus importantes étant les spécifications CommonJS et AMD. commonjs est principalement utilisé sur les serveurs pour réaliser un chargement synchrone, comme nodejs. Les spécifications AMD s'appliquent aux navigateurs, tels que requirejs, pour le chargement asynchrone. Il existe également des spécifications CMD pour les solutions de chargement synchrone telles que seaJS.

Nodejs dispose d'un système de chargement de modules simple. Dans Nodejs, les fichiers et les modules ont une correspondance biunivoque (chaque fichier est considéré comme un module indépendant).

Le seul objet qui nécessite de voir est module.exports. Il ne peut pas voir l'objet exports, et l'objet exports que nous utilisons lors de l'écriture de modules n'est en fait qu'une référence à module.exports.

2, module.exports et exports

Chaque module de Nodejs créera automatiquement un objet module. En même temps, il existe un attribut appelé exports sous l'objet module, qui peut exporter des instances. d'une certaine classe. Attribuez à module.exports pour exporter une instance de cette classe.

Avant l'exécution du module, Nodejs attribuera la valeur de module.exports à la variable globale exports afin que module.exports.f = ... puisse être écrit de manière plus concise sous la forme exports.f = ... . Remarque : Comme toutes les variables, si exports est réaffecté, il ne sera plus lié à module.exports, et le module spécifié ne sera pas exporté

3. Le mécanisme de require

Supposons que Y est le chemin et X est le nom du fichier ou du répertoire. Lorsque Nodejs rencontre require(Y+X), il est traité dans l'ordre suivant :

1. Si X est un module principal) Chargement depuis la mémoire entre les modules intégrés 🎜> 2. Si Y commence par "./", "/" ou "../" (les chemins relatifs et les chemins absolus sont considérés comme des modules de fichiers)

a. Traitez X comme un fichier, à partir du chemin spécifié, recherchez les fichiers suivants dans l'ordre : X, X.js, X.json, à partir du chemin spécifié, recherchez les fichiers suivants dans séquence : X/package.json (champ principal), X/index.js, X/index.json, X/index.node Tant que l'un d'eux existe, le fichier sera renvoyé Continuer à exécuter

.

3. Le module tiers installé par npm, un package

Si X n'est pas un module core et ne commence pas par "./", "/" ou "../", Alors Nodejs démarrera à partir du répertoire parent du module actuel et tentera de charger le module depuis son répertoire /node_module S'il n'est toujours pas trouvé, il se déplacera vers le répertoire parent suivant jusqu'au répertoire racine du système de fichiers

<.> 4. Lancez « introuvable »

4 La différence entre importer et exiger

. ​​ Après la publication de la norme ES6, le module est devenu la norme. L'utilisation standard est d'exporter l'interface avec la commande export (sortir le module) et d'introduire le module avec import. Cependant, dans notre module de nœud habituel, nous adoptons la spécification CommonJS et. utilisez require pour introduire le module, utilisez module.exports pour exporter l'interface.

ES6 implémente les fonctions du module au niveau des spécifications du langage, et la mise en œuvre est assez simple. Il peut remplacer complètement les spécifications CommonJS et AMD existantes et devenir une solution de module universelle pour les navigateurs et les serveurs.

La syntaxe de l'importation est différente de celle de require, et l'importation doit être placée au début du fichier, et aucun autre code logique n'est autorisé devant

​​ L'utilisation de require est très simple. C'est l'équivalent du portail de module.exports. Quel est le contenu derrière module.exports ? Quel est le résultat de require ? de require à quelqu'un Les variables équivalent au chevauchement des positions de require et module.exports dans des espaces parallèles. Lorsque vous l'utilisez, vous pouvez ignorer complètement le concept de modularité et utiliser require. Il suffit de le traiter comme la fonction globale intégrée d'un nœud. Ses paramètres peuvent même être des expressions

5, programmation asynchrone de nœud I/. 0 Et boucle d'événements

La manifestation 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. Toutes les API Node prennent en charge les fonctions de rappel.

Nous pouvons lire le fichier tout en exécutant d'autres commandes. Une fois la lecture du fichier terminée, nous renvoyons le contenu du fichier en tant que paramètre de la fonction de rappel. De cette façon, il n’y a pas de blocage ou d’attente pour les opérations d’E/S de fichiers lors de l’exécution du code. Cela améliore considérablement les performances de Node.js et peut gérer un grand nombre de requêtes simultanées.

import $ from 'jquery';
import * as _ from '_';
import {a,b,c} from './a';
import {default as alias, a as a_a, b, c} from './a';

        Node.js 是单进程单线程应用程序，但是通过事件和回调支持并发，所以性能非常高。Node.js 的每一个 API 都是异步的，并作为一个独立线程运行，使用异步函数调用，并处理并发。

        Node.js 基本上所有的事件机制都是用设计模式中观察者模式实现。Node.js 单线程类似进入一个while(true)的事件循环，直到没有事件观察者退出，每个异步事件都生成一个事件观察者，如果有事件发生就调用该回调函数.

6，nodejs事件系统 Node.js EventEmitter

        Node.js 所有的异步 I/O 操作在完成时都会发送一个事件到事件队列。EventEmitter 对象如果在实例化时发生错误，会触发 error 事件。当添加新的监听器时，newListener 事件会触发，当监听器被移除时，removeListener 事件被触发。

// 引入 events 模块
var events = require('events');
// 创建 eventEmitter 对象
var eventEmitter = new events.EventEmitter();

方法：

       1，addListener(event, listener) 为指定事件添加一个监听器到监听器数组的尾部。

       2，on(event, listener) 为指定事件注册一个监听器，接受一个字符串 event 和一个回调函数。

       3，removeListener(event, listener) 移除指定事件的某个监听器，监听器必须是该事件已经注册过的监听器。它接受两个参数，第一个是事件名称，第二个是回调函数名称。

        4，removeAllListeners([event]) 移除所有事件的所有监听器， 如果指定事件，则移除指定事件的所有监听器

        5， listeners(event) 返回指定事件的监听器数组。

        6，emit(event, [arg1], [arg2], [...]) 按参数的顺序执行每个监听器，如果事件有注册监听返回 true，否则返回 false。

7，nodejs文件系统

        异步和同步：Node.js 文件系统（fs 模块）模块中的方法均有异步和同步版本，例如读取文件内容的函数有异步的 fs.readFile() 和同步的 fs.readFileSync()。异步的方法函数最后一个参数为回调函数，回调函数的第一个参数包含了错误信息(error)。

方法：

       1、打开文件 fs.open(path, flags[, mode], callback)

       2、获取文件信息 fs.stat(path, callback)

        3、写入文件 fs.writeFile(file, data[, options], callback)

        4、读取文件 fs.read(fd, buffer, offset, length, position, callback)

             参数使用说明如下：

                     fd - 通过 fs.open() 方法返回的文件描述符。

                     buffer - 数据写入的缓冲区。

                     offset - 缓冲区写入的写入偏移量。

                     length - 要从文件中读取的字节数。

                     position - 文件读取的起始位置，如果 position 的值为 null，则会从当前文件指针的位置读取。

                    callback - 回调函数，有三个参数err, bytesRead, buffer，err 为错误信息， bytesRead 表示读取的字节数，buffer 为缓冲区对象。

        5、关闭文件 fs.close(fd, callback)

        6、截取文件 fs.ftruncate(fd, len, callback)

        7、删除文件 fs.unlink(path, callback)

        8、创建目录 fs.mkdir(path[, mode], callback)

        9、读取目录 fs.readdir(path, callback)

        10、删除目录 fs.rmdir(path, callback)

8、Node.js Stream(流)

        Stream 是一个抽象接口，Node 中有很多对象实现了这个接口。例如，对http 服务器发起请求的request 对象就是一个 Stream，还有stdout（标准输出）。

        所有的 Stream 对象都是 EventEmitter 的实例。常用的事件有：

               data - 当有数据可读时触发。

               end - 没有更多的数据可读时触发。

               error - 在接收和写入过程中发生错误时触发。

finish - déclenché lorsque toutes les données ont été écrites sur le système sous-jacent.

1. Créez un flux lisible

var readerStream = fs.createReadStream('input.txt');

2. Créez un flux inscriptible et écrivez Accédez au fichier. output.txt

varwriterStream = fs.createWriteStream('output.txt');

3. Pipeline les opérations de lecture et d'écriture, lit le contenu du fichier input.txt et copie le contenu. Écrivez dans le fichier output.txt

                    readerStream.pipe(writerStream);

4. Le fichier input.txt compressé est input.txt.gz, chain stream

fs. .createReadStream('input.txt').pipe(zlib.createGzip()).pipe(fs.createWriteStream('input.txt.gz'));

5. Décompressez input.txt.gz. le fichier est input.txt

fs.createReadStream('input.txt.gz').pipe(zlib.createGunzip()).pipe(fs.createWriteStream('input.txt'));

9. Objet global Node.js

Il existe un objet spécial en JavaScript appelé objet global (Global Object). Il et toutes ses propriétés peuvent être utilisées n'importe où dans le programme. . Accès local, c'est-à-dire variables globales.

1. __filename __filename représente le nom de fichier du script en cours d'exécution. Il affichera le chemin absolu de l'emplacement du fichier et peut ne pas être le même que le nom de fichier spécifié par le paramètre de ligne de commande. S'il s'agit d'un module, la valeur renvoyée est le chemin d'accès au fichier du module.

2. __dirname __dirname représente le répertoire où se trouve le script actuellement exécuté.

3. setTimeout(cb, ms) setTimeout(cb, ms) La fonction globale exécute la fonction spécifiée (cb) après le nombre spécifié de millisecondes (ms). :setTimeout() n'exécute la fonction spécifiée qu'une seule fois. Renvoie une valeur de handle représentant le minuteur.

4. clearTimeout(t) clearTimeout(t) La fonction globale est utilisée pour arrêter un timer précédemment créé via setTimeout(). Le paramètre t est le timer créé via la fonction setTimeout().

5. setInterval(cb, ms) setInterval(cb, ms) La fonction globale exécute la fonction spécifiée (cb) après le nombre spécifié de millisecondes (ms).

Renvoie une valeur de handle représentant la minuterie. La minuterie peut être effacée à l'aide de la fonction clearInterval(t). La méthode setInterval() continuera à appeler la fonction jusqu'à ce que clearInterval() soit appelée ou que la fenêtre soit fermée.

6. La console console est utilisée pour fournir une sortie standard de la console. Il s'agit d'un outil de débogage fourni par le moteur JScript d'Internet Explorer, qui est ensuite progressivement devenu un standard d'implémentation pour les navigateurs.

7. processus processus est une variable globale, c'est-à-dire une propriété de l'objet global. Il s'agit d'un objet utilisé pour décrire l'état actuel du processus Node.js et fournit une interface simple avec le système d'exploitation. Les attributs importants incluent les flux d'entrée et de sortie standard stdin et stdout

Recommandations associées :

reacComment implémenter la fonction de changement de couleur de peau

js Code pour implémenter le transfert de données entre les pages

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!