Detaillierte Einführung in Module und Methoden in NodeJS

Dieser Artikel bietet Ihnen eine detaillierte Einführung in die Module und Methoden in nodejs. Ich hoffe, dass er für Freunde hilfreich ist.

1. Modulladespezifikationen

Vor ES6 gab es js-Modulladelösungen, die wichtigsten waren CommonJS- und AMD-Spezifikationen. CommonJS wird hauptsächlich auf Servern verwendet, um synchrones Laden zu erreichen, z. B. NodeJS. Für Browser gelten AMD-Spezifikationen wie requirejs für asynchrones Laden. Es gibt auch CMD-Spezifikationen für synchrone Ladelösungen wie seaJS.

Nodejs verfügt über ein einfaches Modulladesystem. In Nodejs haben Dateien und Module eine Eins-zu-Eins-Entsprechung (jede Datei wird als unabhängiges Modul betrachtet).

Das einzige Objekt, das angezeigt werden muss, ist module.exports. Es kann das Exportobjekt nicht sehen, und das Exportobjekt, das wir beim Schreiben von Modulen verwenden, ist eigentlich nur eine Referenz auf module.exports.

2, module.exports und exports

Jedes Modul in Nodejs erstellt automatisch ein Modulobjekt. Gleichzeitig gibt es unter dem Modulobjekt ein Attribut namens exports, mit dem Instanzen exportiert werden können Weisen Sie module.exports zu, um eine Instanz dieser Klasse zu exportieren.

Bevor das Modul ausgeführt wird, weist Nodejs den Wert von module.exports der globalen Variablen exports zu, sodass module.exports.f = ... prägnanter geschrieben werden kann als exports.f = ... . Hinweis: Wenn Sie Exporte neu zuweisen, ist sie wie alle Variablen nicht mehr an module.exports gebunden und das angegebene Modul wird nicht exportiert

3. Der Mechanismus von require

Angenommen, Y ist der Pfad und X der Dateiname oder Verzeichnisname. Wenn Nodejs auf require(Y+X) trifft, wird es in der folgenden Reihenfolge verarbeitet:

1. Wenn

a. Behandeln Sie X als Datei. Suchen Sie ausgehend vom angegebenen Pfad nacheinander nach den folgenden Dateien: X, X.js, X.json. Suchen Sie ausgehend vom angegebenen Pfad nach den folgenden Dateien Sequenz: X/package.json (Hauptfeld), X/index.js,

3. Das von npm installierte Drittanbietermodul, ein Paket

Wenn X kein Kernmodul ist und nicht mit „./“, „/“ oder „../“ beginnt, dann Nodejs startet vom übergeordneten Verzeichnis des aktuellen Moduls und versucht, das Modul aus seinem /node_module-Verzeichnis zu laden. Wenn es immer noch nicht gefunden wird, wird es in das nächste übergeordnete Verzeichnis verschoben, bis das Stammverzeichnis des Dateisystems

4. Wirf „nicht gefunden“

4. Der Unterschied zwischen Import und Require

​​ Nach der Veröffentlichung des ES6-Standards wurde das Modul zum Standard. Die Standardverwendung besteht darin, die Schnittstelle mit dem Exportbefehl zu exportieren (dieses Modul nach außen zu exportieren) und das Modul mit dem Import einzuführen Die Spezifikation und Verwendung von CommonJS erfordert die Einführung des Moduls. Verwenden Sie module.exports, um die Schnittstelle zu exportieren.

ES6 implementiert Modulfunktionen auf der Ebene von Sprachspezifikationen und die Implementierung ist recht einfach. Es kann die vorhandenen CommonJS- und AMD-Spezifikationen vollständig ersetzen und zu einer universellen Modullösung für Browser und Server werden.

Die Syntax des Imports unterscheidet sich von der Syntax von „require“, und der Import muss am Anfang der Datei platziert werden. Vor

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

ist kein anderer logischer Code zulässig ​​ Die Verwendung von „require“ entspricht dem Portal „module.exports“. Was ist das Ergebnis von „require“? von require an jemanden. Variablen sind gleichbedeutend mit der Überlappung der Positionen von require und module.exports in parallelen Räumen. Wenn Sie es verwenden, können Sie das Konzept der Modularität vollständig ignorieren und es einfach als integrierte globale Funktion eines Knotens behandeln. Seine Parameter können sogar Ausdrücke sein:

require('./a')(); // a模块是一个函数，立即执行a模块函数
var data = require('./a').data; // a模块导出的是一个对象
var a = require('./a')[0]; // a模块导出的是一个数组

5, Knoten-asynchrone Programmierung I/0 Ereignisse. Schleife

Die direkte Manifestation der asynchronen Programmierung von Node.j ist der Rückruf. Die Rückruffunktion wird nach Abschluss der Aufgabe aufgerufen. Node verwendet eine große Anzahl von Rückruffunktionen.

Wir können die Datei lesen, während wir andere Befehle ausführen. Nachdem das Lesen der Datei abgeschlossen ist, geben wir den Dateiinhalt als Parameter der Rückruffunktion zurück. Auf diese Weise gibt es beim Ausführen von Code keine Blockierungen oder Wartezeiten für Datei-E/A-Vorgänge. Dies verbessert die Leistung von Node.js erheblich und kann eine große Anzahl gleichzeitiger Anforderungen verarbeiten.

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 – wird ausgelöst, wenn alle Daten in das zugrunde liegende System geschrieben wurden.

1. Erstellen Sie einen lesbaren Stream

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

2. Erstellen Sie einen beschreibbaren Stream und schreiben Sie „Gehe zu“ der Datei Output.txt

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

3. Pipeline-Lese- und Schreibvorgänge, Lesen des Inhalts der Datei input.txt und Kopieren des Inhalts Schreiben Sie in die Datei „output.txt“

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

5. Entpacken Sie input.txt.gz Datei ist input.txt

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

9. Node.js globales Objekt

Es gibt ein spezielles Objekt in JavaScript, das globale Objekt (Global Object) und alle seine Eigenschaften können überall im Programm verwendet werden . Lokaler Zugriff, also globale Variablen.

1. __filename __filename stellt den Dateinamen des Skripts dar, das gerade ausgeführt wird. Es wird der absolute Pfad des Dateispeicherorts ausgegeben, der möglicherweise nicht mit dem durch den Befehlszeilenparameter angegebenen Dateinamen übereinstimmt. In einem Modul ist der zurückgegebene Wert der Pfad zur Moduldatei.

2. __dirname __dirname stellt das Verzeichnis dar, in dem sich das aktuell ausgeführte Skript befindet.

3. setTimeout(cb, ms) setTimeout(cb, ms) Die globale Funktion führt die angegebene Funktion (cb) nach der angegebenen Anzahl von Millisekunden (ms) aus. :setTimeout() führt die angegebene Funktion nur einmal aus. Gibt einen Handle-Wert zurück, der den Timer darstellt.

4. clearTimeout(t) clearTimeout(t) Die globale Funktion wird verwendet, um einen zuvor über setTimeout() erstellten Timer zu stoppen. Der Parameter t ist der von der Funktion setTimeout() erstellte Timer.

5. setInterval(cb, ms) setInterval(cb, ms) Die globale Funktion führt die angegebene Funktion (cb) nach der angegebenen Anzahl von Millisekunden (ms) aus.

Gibt einen Handle-Wert zurück, der den Timer darstellt. Der Timer kann mit der Funktion „clearInterval(t)“ gelöscht werden. Die Methode setInterval() ruft die Funktion weiterhin auf, bis clearInterval() aufgerufen oder das Fenster geschlossen wird.

6. Konsolenkonsole wird zur Bereitstellung einer Konsolenstandardausgabe verwendet. Es handelt sich um ein Debugging-Tool, das von der JScript-Engine des Internet Explorers bereitgestellt wird und später nach und nach zum Implementierungsstandard für Browser wurde.

7. Prozess Prozess ist eine globale Variable, also eine Eigenschaft des globalen Objekts. Es handelt sich um ein Objekt, das zur Beschreibung des aktuellen Node.js-Prozessstatus verwendet wird und eine einfache Schnittstelle mit dem Betriebssystem bietet. Zu den wichtigen Attributen gehören die Standard-Eingabe- und Ausgabeströme stdin und stdout

Verwandte Empfehlungen:

reacSo implementieren Sie die Funktion zum Ändern der Hautfarbe

js-Code zur Implementierung der Datenübertragung zwischen Seiten

Das obige ist der detaillierte Inhalt vonDetaillierte Einführung in Module und Methoden in NodeJS. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!