Node Learning Chat-Modulsystem

In diesem Artikel geht es um das Modulsystem in Node.js, einschließlich des Ereignismoduls, des Util-Moduls, des FS-Moduls, des Betriebssystemmoduls, des Pfadmoduls usw. Ich hoffe, es wird Ihnen hilfreich sein!

Modulsystem

Referenz: Node.js-Modulsystem

Damit Node.js-Dateien sich gegenseitig aufrufen können, stellt Node.js ein einfaches Modulsystem bereit.
Module sind die Grundkomponenten von Node.js-Anwendungen, und Dateien und Module haben eine Eins-zu-Eins-Entsprechung.
Mit anderen Worten, eine Node.js-Datei ist ein Modul, bei dem es sich um JavaScript-Code, JSON oder eine kompilierte C/C++-Erweiterung handeln kann.

Es gibt 4 Arten von Modulen (native Module und 3 Arten von Dateimodulen) in Node.js
Beispiel: var http = require("http");var http = require("http");

Node.js 中自带了一个叫做 http 的模块，我们在我们的代码中请求它并把返回值赋给一个本地变量。
这把我们的本地变量变成了一个拥有所有 http 模块所提供的公共方法的对象。【相关教程推荐：nodejs视频教程】

加载模块：

• 从文件模块缓存中加载
• 从原生模块加载
• 从文件加载
  • require方法接受以下几种参数的传递：
    • http、fs、path、events、util等，原生模块。
    • ./mod或…/mod，相对路径的文件模块。
    • /pathtomodule/mod，绝对路径的文件模块。
    • mod，非原生模块的文件模块。

模块接口

• exports 对象是模块公开的接口
• require 对象用于从外部获取一个模块的接口，即所获取模块的 exports 对象。

//例子
//hello.js
exports.world = function() {       //相当于给function()函数取了个别名world()
    console.log('Hello World');
  }

//main.js
var hello = require('./hello');
hello.world();  //访问 hello.js 的 world 函数

//结果
PS E:\learn> node main.js
Hello World

• 只是想把一个对象封装到模块中：module.exports = function() {...}
  模块接口的唯一变化是使用 module.exports = Hello 代替了exports.world = function(){}。 在外部引用该模块时，其接口对象就是要输出的 Hello 对象本身，而不是原先的 exports。

exports 和 module.exports 的使用
如果要对外暴露属性或方法，就用 exports 就行，要暴露对象(类似class，包含了很多属性和方法)，就用 module.exports。

//hello.js 
function Hello() { 
    var name; 
    this.setName = function(thyName) { 
        name = thyName; 
    }; 
    this.sayHello = function() { 
        console.log('Hello ' + name); 
    }; 
}; 
module.exports = Hello;   

//main.js 
var Hello = require('./hello'); 
hello = new Hello(); 
hello.setName('BYVoid'); 
hello.sayHello();

//结果
PS E:\learn> node main.js
Hello BYVoid

events模块

参考资料：Node.js EventEmitter

events 模块只提供了一个对象： events.EventEmitter。EventEmitter 的核心就是事件触发与事件监听器功能的封装。

• events 为一个模块，用 require("events"); 访问该模块。
• EventEmitter 相当于events模块里面的唯一的一个类，该类下有多个属性
  • addListener(event, listener) 为指定事件添加一个监听器到监听器数组的尾部。
  • on(event, listener) on函数为指定事件注册一个监听器，接受一个字符串 event 和一个回调函数。
  • once(event, listener) 为指定事件注册一个单次监听器，即 监听器最多只会触发一次，触发后立刻解除该监听器
  • removeListener(event, listener)移除指定事件的某个监听器，监听器必须是该事件已经注册过的监听器。它接受两个参数，第一个是事件名称，第二个是回调函数名称
  • removeAllListeners([event]) 移除所有事件的所有监听器， 如果指定事件，则移除指定事件的所有监听器。
  • setMaxListeners(n) 默认情况下， EventEmitters 如果你添加的监听器超过 10 个就会输出警告信息。 setMaxListeners 函数用于改变监听器的默认限制的数量。
  • listeners(event) 返回指定事件的监听器数组。
  • emit(event, [arg1], [arg2], [...]) 按监听器的顺序执行执行每个监听器，如果事件有注册监听返回 true，否则返回 false。
  • listenerCount(emitter, event)
  Node.js kommt Mit einem Modul namens http fordern wir es von unserem Code an und weisen den Rückgabewert einer lokalen Variablen zu.
Dadurch wird unsere lokale Variable in ein Objekt mit allen vom http-Modul bereitgestellten öffentlichen Methoden umgewandelt. [Empfohlene verwandte Tutorials: nodejs-Video-Tutorial

]

Lademodul:

Aus dem Dateimodul-Cache laden
• Aus dem nativen Modul laden
• Aus der Datei laden
  • Die require-Methode akzeptiert die folgenden Parameter:
    • http, fs, path , Events, Util usw., native Module.

./mod oder…/mod, Dateimodul mit relativem Pfad.

/pathtomodule/mod, Dateimodul mit absolutem Pfad.

mod, Dateimodul eines nicht nativen Moduls.

🎜🎜🎜Modulschnittstelle🎜🎜🎜

• exports-Objekt ist die vom Modul bereitgestellte Schnittstelle🎜
• Das require-Objekt wird verwendet, um die Schnittstelle eines Moduls von außen abzurufen, dh das Exportobjekt des erhaltenen Moduls. 🎜🎜

  //例子
  //event.js 文件
  var events = require('events');            // 引入 events 模块
  var emitter = new events.EventEmitter();   // 创建 eventEmitter 对象
  //为事件someEvent注册两个监视器
  emitter.on('someEvent', function(arg1, arg2) { 
      console.log('listener1', arg1, arg2); 
  }); 
  emitter.on('someEvent', function(arg1, arg2) { 
      console.log('listener2', arg1, arg2); 
  }); 
  //按顺序执行someEvent的每个监视器
  emitter.emit('someEvent', 'arg1 参数', 'arg2 参数');  // 'arg1 参数', 'arg2 参数'为参数arg1，arg2的值

  • Ich möchte nur ein Objekt in ein Modul kapseln: module.exports = function() {...}🎜 Die einzige Änderung an der Modulschnittstelle ist die Verwendung von module .exports = Hallo ersetzt exports.world = function(){}. Wenn das Modul extern referenziert wird, ist sein Schnittstellenobjekt das auszugebende Hello-Objekt selbst, nicht die ursprünglichen Exporte. 🎜🎜🎜🎜🎜Verwendung von exports und module.exports🎜🎜 Wenn Sie Eigenschaften oder Methoden der Außenwelt zugänglich machen möchten, verwenden Sie einfach exports. Wenn Sie Objekte (ähnlich wie Klassen, einschließlich vieler Eigenschaften und Methoden) verfügbar machen möchten, verwenden Sie module.exports. 🎜🎜

    //结果
    $ node event.js 
    listener1 arg1 参数 arg2 参数
    listener2 arg1 参数 arg2 参数

    🎜🎜🎜🎜events-Modul🎜🎜🎜🎜Referenz: Node.js. EventEmit ter🎜 🎜 🎜 🎜Das Ereignismodul stellt nur ein Objekt bereit: events.EventEmitter. Der Kern von EventEmitter ist die Kapselung von Ereignisauslöse- und Ereignis-Listener-Funktionen. 🎜🎜
    • events ist ein Modul. Verwenden Sie require("events");, um auf das Modul zuzugreifen. 🎜
    • EventEmitter entspricht der einzigen Klasse im Modul events. Diese Klasse hat mehrere Attribute
      • addListener(event, listener). Fügt einen Listener für das angegebene Ereignis am Ende des Listener-Arrays hinzu. 🎜
      • on(event, listener) Die on-Funktion registriert einen Listener für das angegebene Ereignis und akzeptiert ein String-Ereignis und eine Callback-Funktion. 🎜
      • once(event, listener) Registrieren Sie einen einmaligen Listener für das angegebene Ereignis, d. h. der Listener wird höchstens einmal ausgelöst und der Listener wird sofort nach dem Auslösen freigegeben 🎜
      • removeListener(event, listener)Entfernt einen Listener für das angegebene Ereignis. Der Listener muss ein registrierter Listener für das Ereignis sein. Es akzeptiert zwei Parameter, der erste ist der Ereignisname, der zweite ist der Name der Rückruffunktion🎜
      • removeAllListeners([event]) entfernt alle Listener für alle Ereignisse, wenn das Ereignis angegeben ist, Entfernt Alle Listener für das angegebene Ereignis. 🎜
      • setMaxListeners(n) Standardmäßig gibt EventEmitters eine Warnmeldung aus, wenn Sie mehr als 10 Listener hinzufügen. Die Funktion setMaxListeners wird verwendet, um die standardmäßige maximale Anzahl von Listenern zu ändern. 🎜
      • listeners(event) Gibt das Listener-Array für das angegebene Ereignis zurück. 🎜
      • emit(event, [arg1], [arg2], [...]) Führen Sie jeden Listener in der Reihenfolge des Listeners aus. Wenn das Ereignis einen registrierten Listener hat, gibt es true zurück , andernfalls Rückgabe von false. 🎜
      • listenerCount(emitter, event) Gibt die Anzahl der Listener für das angegebene Ereignis zurück. 🎜🎜🎜🎜

        //例子
        const util = require('util');
        
        async function fn() {
          return 'hello world';
        }
        const callbackFunction = util.callbackify(fn);
        
        callbackFunction((err, ret) => {
          if (err) throw err;
          console.log(ret);
        });
        
        //结果
        hello world

        //例子
        var util = require('util'); 
        //Base构造函数内三个属性
        function Base() {    
            this.name = 'base'; 
            this.base = 1991; 
            this.sayHello = function() { 
            console.log('Hello ' + this.name); 
            }; 
        } 
        
        //原型中定义的一个函数
        Base.prototype.showName = function() { 
            console.log(this.name);
        }; 
        
        //Sub构造函数内一个属性
        function Sub() { 
            this.name = 'sub'; 
        } 
        
        util.inherits(Sub, Base);  //Sub从Base继承
        var objBase = new Base(); 
        objBase.showName(); 
        objBase.sayHello(); 
        console.log(objBase); 
        
        var objSub = new Sub(); 
        objSub.showName(); 
        //objSub.sayHello(); 
        console.log(objSub); 
        
        //结果
        base 
        Hello base 
        { name: 'base', base: 1991, sayHello: [Function] } 
        sub 
        { name: 'sub' }
        //Base 有 name , base , sayHello() , showName()
        //Sub  有 name(自己定义的，不是继承的) , showName() 从Base继承的

        🎜🎜🎜🎜🎜util-Modul🎜🎜🎜🎜Referenz: 🎜🎜Offizielle Website des Utility-Dienstprogramms🎜🎜🎜Gemeinsame Node.js-Tools🎜🎜

        util 是一个Node.js 核心模块，提供常用函数的集合，用于弥补核心 JavaScript 的功能 过于精简的不足。

        util.callbackify(original)
        将 async 异步函数（或者一个返回值为 Promise 的函数）转换成遵循异常优先的回调风格的函数

        • 参数：original 为 async 异步函数。
        • 返回值：返回传统回调函数（或者一个返回值为 Promise 的函数）
          • 在返回的回调函数中，第一个参数为拒绝的原因（如果 Promise 解决，则为 null），第二个参数则是解决的值。

        //例子
        const util = require('util');
        
        async function fn() {
          return 'hello world';
        }
        const callbackFunction = util.callbackify(fn);
        
        callbackFunction((err, ret) => {
          if (err) throw err;
          console.log(ret);
        });
        
        //结果
        hello world

        util.inherits(constructor, superConstructor) 是一个实现对象间原型继承的函数。

        //例子
        var util = require('util'); 
        //Base构造函数内三个属性
        function Base() {    
            this.name = 'base'; 
            this.base = 1991; 
            this.sayHello = function() { 
            console.log('Hello ' + this.name); 
            }; 
        } 
        
        //原型中定义的一个函数
        Base.prototype.showName = function() { 
            console.log(this.name);
        }; 
        
        //Sub构造函数内一个属性
        function Sub() { 
            this.name = 'sub'; 
        } 
        
        util.inherits(Sub, Base);  //Sub从Base继承
        var objBase = new Base(); 
        objBase.showName(); 
        objBase.sayHello(); 
        console.log(objBase); 
        
        var objSub = new Sub(); 
        objSub.showName(); 
        //objSub.sayHello(); 
        console.log(objSub); 
        
        //结果
        base 
        Hello base 
        { name: 'base', base: 1991, sayHello: [Function] } 
        sub 
        { name: 'sub' }
        //Base 有 name , base , sayHello() , showName()
        //Sub  有 name(自己定义的，不是继承的) , showName() 从Base继承的

        • util.inspect(object,[showHidden],[depth],[colors]) 是一个将任意对象转换 为字符串的方法，通常用于调试和错误输出。它至少接受一个参数 object，即要转换的对象。
          • 它至少接受一个参数 object，即要转换的对象。
          • showHidden 是一个可选参数，如果值为 true，将会输出更多隐藏信息。
          • depth 表示最大递归的层数，如果对象很复杂，你可以指定层数以控制输出信息的多 少。如果不指定depth，默认会递归 2 层，指定为 null 表示将不限递归层数完整遍历对象。
          • 如果 colors 值为 true，输出格式将会以 ANSI 颜色编码，通常用于在终端显示更漂亮 的效果。

        var util = require('util'); 
        function Person() { 
            this.name = 'byvoid'; 
            this.toString = function() { 
            return this.name; 
            }; 
        } 
        var obj = new Person(); 
        console.log(obj);
        console.log(util.inspect(obj)); 
        console.log(util.inspect(obj, true));

        

        fs 模块

        参考资料：Node.js 文件系统
        Node.js 文件系统模块 官网
        fs.open(path, flags[, mode], callback) 在异步模式下打开文件

        • 参数：

          • path - 文件的路径。
          • flags - 文件打开的行为。具体值详见下文。
          • mode - 设置文件模式(权限)，文件创建默认权限为 0666(可读，可写)。
          • callback - 回调函数，带有两个参数如：callback(err, fd)

          r 以读取模式打开文件。如果文件不存在抛出异常。
          r+ 以读写模式打开文件。如果文件不存在抛出异常。
          rs 以同步的方式读取文件。
          rs+ 以同步的方式读取和写入文件。
          w 以写入模式打开文件，如果文件不存在则创建。
          wx 类似 ‘w’，但是如果文件路径存在，则文件写入失败。
          w+ 以读写模式打开文件，如果文件不存在则创建。
          wx+ 类似 ‘w+’， 但是如果文件路径存在，则文件读写失败。
          a 以追加模式打开文件，如果文件不存在则创建。
          ax 类似 ‘a’， 但是如果文件路径存在，则文件追加失败。
          a+ 以读取追加模式打开文件，如果文件不存在则创建。
          ax+ 类似 ‘a+’， 但是如果文件路径存在，则文件读取追加失败。

        fs.stat(path, callback) 通过异步模式获取文件信息

        • 参数：
          • path - 文件路径。
          • callback - 回调函数，带有两个参数如：callback(err, stats), stats 是 fs.Stats 对象。

        fs.stat(path)执行后，会将stats类的实例返回给其回调函数。可以通过stats类中的提供方法判断文件的相关属性

        stats.isFile() 如果是文件返回 true，否则返回 false。
        stats.isDirectory() 如果是目录返回 true，否则返回 false。
        stats.isBlockDevice() 如果是块设备返回 true，否则返回 false。
        stats.isCharacterDevice() 如果是字符设备返回 true，否则返回 false。
        stats.isSymbolicLink() 如果是软链接返回 true，否则返回 false。
        stats.isFIFO() 如果是FIFO，返回true，否则返回 false。FIFO是UNIX中的一种特殊类型的命令管道。
        stats.isSocket() 如果是 Socket 返回 true，否则返回 false。

        fs.writeFile(file, data[, options], callback) 异步模式下写入文件
        writeFile 直接打开文件默认是 w 模式，所以如果文件存在，该方法写入的内容会覆盖旧的文件内容。

        • Parameter:
          • Datei – Dateiname oder Dateideskriptor.
          • Daten – Die in die Datei zu schreibenden Daten, die ein String- oder Buffer-Objekt sein können.
          • options – Dieser Parameter ist ein Objekt, das {encoding, mode, flag} enthält. Die Standardkodierung ist utf8, der Modus ist 0666, das Flag ist 'w'
          • Callback – Callback-Funktion, die Callback-Funktion enthält nur Fehlerinformationsparameter (err), kehrt zurück, wenn das Schreiben fehlschlägt

        fs. read( fd, buffer, offset, length, position, callback) Liest die Datei im asynchronen Modus. Diese Methode verwendet den Dateideskriptor, um die Datei zu lesen. fs.read(fd, buffer, offset, length, position, callback) 异步模式下读取文件，该方法使用了文件描述符来读取文件。

        • 参数：
          • fd - 通过 fs.open() 方法返回的文件描述符。
          • buffer - 数据写入的缓冲区。
          • offset - 缓冲区写入的写入偏移量。
          • length - 要从文件中读取的字节数。
          • position - 文件读取的起始位置，如果 position 的值为 null，则会从当前文件指针的位置读取。
          • callback - 回调函数，有三个参数err, bytesRead, buffer，err 为错误信息， bytesRead 表示读取的字节数，buffer 为缓冲区对象。

        fs.close(fd, callback) 异步模式下关闭文件，该方法使用了文件描述符来读取文件。

        • 参数：
          • fd - 通过 fs.open() 方法返回的文件描述符。
          • callback - 回调函数，没有参数。

        fs.ftruncate(fd, len, callback) 异步模式下截取文件，该方法使用了文件描述符来读取文件。

        • 参数：
          • fd - 通过 fs.open() 方法返回的文件描述符。
          • len - 文件内容截取的长度。
          • callback - 回调函数，没有参数。

        fs.unlink(path, callback) 删除文件的语法格式：

        • 参数：
          • path - 文件路径。
          • callback - 回调函数，没有参数。

        fs.mkdir(path[, options], callback) 创建目录

        • 参数：
          • path - 文件路径
          • options 参数可以是
            • recursive - 是否以递归的方式创建目录，默认为 false。
            • mode - 设置目录权限，默认为 0777。
          • callback - 回调函数，没有参数。

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

        • 参数：
          • path - 文件路径
          • callback - 回调函数，回调函数带有两个参数err, files，err 为错误信息，files 为 目录下的文件数组列表

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

        • 参数：
          • path - 文件路径
          • callback - 回调函数，没有参数。

        OS 模块

        参考资料：Node.js OS 模块
        属性：os.EOL 定义了操作系统的行尾符的常量。
        方法：
        os.tmpdir() 返回操作系统的默认临时文件夹
        os.endianness() 返回 CPU 的字节序，可能的是 “BE” 或 “LE”。
        os.hostname() 返回操作系统的主机名。
        os.type() 返回操作系统名
        os.platform() 返回编译时的操作系统名
        os.arch() 返回操作系统 CPU 架构，可能的值有 “x64”、“arm” 和 “ia32”。
        os.release() 返回操作系统的发行版本。
        os.uptime() 返回操作系统运行的时间，以秒为单位。
        os.loadavg() 返回一个包含 1、5、15 分钟平均负载的数组。
        os.totalmem() 返回系统内存总量，单位为字节。
        os.freemem() 返回操作系统空闲内存量，单位是字节。
        os.cpus() 返回一个对象数组，包含所安装的每个 CPU/内核的信息：型号、速度（单位 MHz）、时间（一个包含 user、nice、sys、idle 和 irq 所使用 CPU/内核毫秒数的对象）。
        os.networkInterfaces()

        Parameter: fd – der von der fs.open()-Methode zurückgegebene Dateideskriptor. Puffer – Der Puffer, in den Daten geschrieben werden.

        offset – Der Schreiboffset für Pufferschreibvorgänge. length – Anzahl der Bytes, die aus der Datei gelesen werden sollen.

        position – die Startposition des Dateilesens. Wenn der Wert von position null ist, wird er von der Position des aktuellen Dateizeigers aus gelesen. callback – Rückruffunktion mit drei Parametern err, bytesRead und buffer. err ist die Fehlermeldung, bytesRead stellt die Anzahl der gelesenen Bytes dar und buffer ist das Pufferobjekt.

        fs.close(fd, callback) Schließen Sie die Datei im asynchronen Modus. Diese Methode verwendet den Dateideskriptor, um die Datei zu lesen.

        Parameter: fd – der von der fs.open()-Methode zurückgegebene Dateideskriptor. callback – Callback-Funktion, keine Parameter.

        fs.ftruncate(fd, len, callback) Dateien im asynchronen Modus abfangen Diese Methode verwendet Dateideskriptoren, um Dateien zu lesen.

        Parameter: fd – der von der fs.open()-Methode zurückgegebene Dateideskriptor.

        len – Die Länge des abgefangenen Dateiinhalts. callback – Callback-Funktion, keine Parameter.

        🎜🎜🎜🎜fs.unlink(path, callback) Syntaxformat zum Löschen von Dateien: 🎜🎜🎜Parameter: 🎜🎜Pfad – Dateipfad. 🎜🎜callback – Callback-Funktion, keine Parameter. 🎜🎜🎜🎜🎜fs.mkdir(path[, options], callback) Verzeichnis erstellen 🎜🎜🎜Parameter: 🎜🎜path – Dateipfad 🎜🎜optionsparameter können sein 🎜🎜recursive – ob rekursiv Erstellen Sie ein Verzeichnis auf folgende Weise. Der Standardwert ist false. 🎜🎜Modus – Verzeichnisberechtigungen festlegen, Standard ist 0777. 🎜🎜🎜🎜callback – Callback-Funktion, keine Parameter. 🎜🎜🎜🎜🎜fs.readdir(path, callback) Verzeichnis lesen 🎜🎜🎜Parameter: 🎜🎜path – Dateipfad 🎜🎜callback – Rückruffunktion, die Rückruffunktion benötigt zwei Parameter, err, Dateien , err ist die Fehlermeldung, files ist die Datei-Array-Liste im Verzeichnis 🎜🎜🎜🎜🎜fs.rmdir(path, callback) Löschen Sie das Verzeichnis 🎜🎜🎜Parameter: 🎜🎜Pfad – Dateipfad 🎜🎜 Rückruf – Rückruffunktion, keine Parameter. 🎜🎜🎜🎜🎜🎜🎜OS-Modul 🎜🎜🎜Referenz: Node.js OS-Modul 🎜<. br> Attribut: os.EOL Konstante, die das Zeilenendezeichen des Betriebssystems definiert.
        Methode:
        os.tmpdir() Gibt den temporären Standardordner des Betriebssystems zurück
        os.endianness() Gibt die CPU zurück Wortfolge, möglicherweise „BE“ oder „LE“.
        os.hostname() Gibt den Hostnamen des Betriebssystems zurück.
        os.type() Gibt den Namen des Betriebssystems zurück
        os.platform() Gibt den Namen des kompilierten Betriebssystems zurück
        os.arch() Gibt die CPU-Architektur des Betriebssystems zurück, mögliche Werte sind „x64“, „arm“ und „ia32“.
        os.release() Gibt die Release-Version des Betriebssystems zurück.
        os.uptime() Gibt die Zeit zurück, die das Betriebssystem ausgeführt wurde, in Sekunden.
        os.loadavg() Gibt ein Array zurück, das 1-, 5- und 15-Minuten-Lastdurchschnitte enthält.
        os.totalmem() Gibt die Gesamtmenge des Systemspeichers in Bytes zurück.
        os.freemem() Gibt die Menge des freien Speichers im Betriebssystem in Bytes zurück.
        os.cpus() Gibt ein Objektarray zurück, das Informationen über jede installierte CPU/jeden installierten Kern enthält: Modell, Geschwindigkeit (Einheit MHz), Zeit (eine davon enthält Benutzer, nice, sys, empty und irq Objekt der verwendeten CPU/Kern-Millisekunden).
        os.networkInterfaces() Rufen Sie die Liste der Netzwerkschnittstellen ab. 🎜🎜🎜🎜🎜Pfadmodul 🎜🎜🎜🎜Node.js-Pfadmodul 🎜🎜🎜🎜🎜🎜Netzmodul 🎜🎜🎜🎜Node.js-Netzmodul 🎜🎜🎜🎜🎜 🎜DNS-Modul🎜🎜🎜🎜Node.js DNS-Modul 🎜🎜🎜🎜🎜🎜Domänenmodul🎜🎜🎜🎜Node.js-Domänenmodul🎜🎜

        http-Modul

        Referenzen: Node, js-Webmodul

        url-Modul

        gulp-Modul Umgebungskonstruktion

        Webpack-Modul

        Webpack Erste Schritte-Tutorial

        Weitere Informationen zu Knoten finden Sie unter: nodejs-Tutorial!

Das obige ist der detaillierte Inhalt vonNode Learning Chat-Modulsystem. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!