Hochleistungs-Webanwendungspraktiken
einführen
fibjs ist ein leistungsstarkes Anwendungsserver-Framework, das hauptsächlich für die Web-Backend-Entwicklung entwickelt wurde. Es basiert auf der JavaScript-Engine Google v8 und wählt eine andere Parallelitätslösung als herkömmliche Rückrufe. fibjs verwendet Fasern, um die durch asynchrone Aufrufe verursachte Geschäftskomplexität auf der Framework-Ebene zu isolieren, wodurch die Entwicklungsschwierigkeiten erheblich verringert und Leistungsprobleme durch häufige asynchrone Verarbeitung im Benutzerbereich verringert werden.
Beim Design von fibjs wird großer Wert auf die Leistung gelegt. Die integrierten Netzwerk-IO- und HTTP-Module verwenden ein ereignisgesteuertes, nicht blockierendes I/O-Modell, sodass Entwickler problemlos hochzuverlässige Serveranwendungen implementieren können. Und da die unterste Ebene in C++ implementiert ist, verfügt fibjs über eine sehr überlegene Leistung, kann problemlos mit hohem gleichzeitigem Zugriff umgehen und äußerst stabile und zuverlässige Dienste bereitstellen.
Gleichzeitig unterstützt fibjs auch WebSocket, ein Vollduplex-Kommunikationsprotokoll, das auf dem TCP-Protokoll basiert. Es stellt eine unterbrechungsfreie Verbindung zwischen dem Browser und dem Server her, ermöglicht eine bidirektionale Datenübertragung in Echtzeit und kann Daten unterstützen in jedem Format. Übertragung. Mit WebSocket können auf einfache Weise Echtzeit-Kommunikationsanwendungen mit besseren Kommunikationseffekten implementiert werden.
Kurz gesagt, fibjs legt nicht nur Wert auf hohe Leistung und hohe Zuverlässigkeit, sondern bietet auch Echtzeit-Kommunikationsfunktionen wie WebSocket. Es handelt sich um ein Framework, das sich sehr gut für die Entwicklung von Hochgeschwindigkeits-Webanwendungen eignet.
Einrichtung der Entwicklungsumgebung
Bevor wir mit der Entwicklung von fibjs beginnen, müssen wir die Entwicklungsumgebung vorbereiten. In diesem Kapitel wird erläutert, wie Sie fibjs installieren, wie Sie das Projekt mit dem fibjs-Tool initialisieren und wie Sie die integrierte IDE-Entwicklungsumgebung verwenden.
Installieren Sie fibjs
Bei verschiedenen Betriebssystemen unterscheiden sich die Methoden zur Installation von fibjs geringfügig.
Für Linux- und macOS-Benutzer können fibjs mit dem folgenden Befehl installiert werden:
1curl -s https://fibjs.org/download/installer.sh | sh
Wenn Sie macOS verwenden und den Homebrew-Paketmanager verwenden, können Sie ihn auch mit dem folgenden Befehl installieren:
1brew install fibjs
Für Windows-Benutzer müssen Sie das Installationsprogramm von der offiziellen fibjs-Website herunterladen und dann den Anweisungen zur Installation folgen.
Erstellen Sie ein neues Projekt mit fibjs –init
Nach der Installation von fibjs können Sie mit dem fibjs-Tool schnell neue Projekte erstellen. Verwenden Sie den folgenden Befehl, um eine grundlegende Projektvorlage zu erstellen:
1fibjs --init
Dieser Befehl erstellt eine neue Projektstruktur im aktuellen Verzeichnis, einschließlich package.json, die zum Speichern grundlegender Projektinformationen und Abhängigkeitsinformationen verwendet wird.
Webanwendungen schreiben
Die Entwicklung von Webanwendungen ist derzeit das am häufigsten verwendete Anwendungsszenario von fibjs. fibjs bietet eine Reihe von Tools und Modulen, mit denen wir Webanwendungen schneller erstellen können.
Schreiben eines HTTP-Servers
- Importieren Sie zunächst das http-Modul.
- Instanziieren Sie http.Server und warten Sie auf Anfragen.
- Der Server wird über die Startfunktion gestartet.
1
2
3
4
5
6const http = require('http');
const server = new http.Server(8080, (req) => {
req.response.write('Hello World!');
});
server.start();
Analysieren Sie URL-Parameter und Anforderungstext
Das Parsen von URL-Parametern und Anforderungstexten ist sehr wichtig und wird in verschiedenen serverseitigen Anwendungen verwendet. In fibjs können die eingehenden URL-Parameter direkt über req.query analysiert werden, und der Anforderungstext wird über req.body gelesen.
1
2
3
4
5
6
7
8const http = require('http');
const server = new http.Server(8080, (req) => {
var name = req.query.get('name');
var msg = name ? `Hello ${name}!` : 'Hello world!';
req.response.write(msg);
});
server.start();
Implementieren Sie eine Schnittstellenzugriffskontrolle
Die Einschränkung des Benutzerzugriffs über Schnittstellen ist ein sehr häufiges Szenario. Unten finden Sie ein einfaches Beispiel.
1
2
3
4
5
6
7
8
9
10const http = require('http');
const server = new http.Server(8080, (req) => {
if (req.headers.get('auth') === 'ok') {
req.response.write('Hello World!');
} else {
req.response.write('Access Denied!');
}
});
server.start();
Routing-Verarbeitung hinzufügen
Routing ist eines der wichtigsten Konzepte in einer Webanwendung. Unter Routing versteht man die Verteilung empfangener Anfragen an Prozessoren nach bestimmten Regeln. In fibjs können Sie Ihr eigenes Routing-Modul schreiben und es an den http-Server binden und dann den URL-Abgleich und die entsprechende Verarbeitung durch benutzerdefinierte Routenanalyse durchführen.
1
2
3
4
5
6
7
8
9const http = require('http');
const { Router } = require('mq');
var router = new Router();
router.get('/hello/:name', function (req, name) {
req.response.write('hello, ' + name);
});
var svr = new http.Server(8080, router);
svr.start();
Das obige Beispiel lässt sich auch mit einfacherer Syntax umsetzen:
1
2
3
4
5
6
7
8const http = require('http');
var svr = new http.Server(8080, {
'/hello/:name': function (req, name) {
req.response.write('hello, ' + name);
}
});
svr.start();
Fehlerbehandlung und Protokollierung
In fibjs können Sie logische Ausnahmen über Try-Catch-Blöcke erfassen und zum Debuggen und Aufzeichnen in Protokolldateien ausgeben. Wenn es sich um schwerwiegende Ausnahmen handelt, können sie zur Verarbeitung direkt an das obere Framework geworfen werden.
1
2
3
4
5
6
7
8
9
10const console = require('console');
const http = require('http');
const server = new http.Server(8080, (req) => {
try {
// ...
} catch (e) {
console.log(e.message, e.stack);
}
});
domänenübergreifende Anfrage
In fibjs können wir die Methode „enableCrossOrigin“ verwenden, um domänenübergreifende Anforderungen zuzulassen. Hier ist ein Beispielcode, wie man einen http-Server erstellt und domänenübergreifende Anfragen zulässt:
1
2
3
4
5
6
7
8const http = require('http');
const server = new http.Server(8080, (req) => {
req.response.write('Hello World!');
});
server.enableCrossOrigin(); // enable cross domain request
server.start();
Im obigen Beispiel haben wir einen http-Server mit Port 8080 erstellt. Die Methode enableCrossOrigin() ermöglicht Cross-Origin-Anfragen.
Wenn Sie „enableCrossOrigin“ verwenden, um domänenübergreifende Anforderungen zuzulassen, können Sie die domänenübergreifenden Header angeben, die empfangen werden dürfen, indem Sie einen Parameter „allowHeaders“ übergeben. Standardmäßig ist der AllowHeaders-Wert Content-Type.
Der Beispielcode lautet wie folgt:
1
2// enable "Content-Type" and "Authorization" headers in cross domain request
server.enableCrossOrigin("Content-Type, Authorization");
Im obigen Code lautet der Wert vonallowHeaders „Content-Type, Authorization“, was bedeutet, dass der Server die beiden domänenübergreifenden Header „Content-Type“ und „Authorization“ empfangen darf. Wenn die Anfrage andere Header enthält, wird sie vom Server abgelehnt.
Es ist zu beachten, dass wir, wenn wir enableCrossOrigin verwenden, um die Fähigkeit zum Empfang domänenübergreifender Header einzurichten, beim Senden domänenübergreifender Anforderungen auch den entsprechenden Anforderungsheader festlegen müssen, da dieser sonst ebenfalls vom Server abgelehnt wird.
WebSockets
Das WebSocket-Protokoll ist ein Vollduplex-Kommunikationsprotokoll, das auf dem TCP-Protokoll basiert. Es stellt eine unterbrechungsfreie Verbindung zwischen dem Browser und dem Server her, kann eine bidirektionale Datenübertragung in Echtzeit realisieren und die Datenübertragung in jedem Format unterstützen. In fibjs stellt das WebSocket-Unterstützungsmodul entsprechende API-Schnittstellen bereit, mit denen die Entwicklung von WebSocket-Servern und -Clients realisiert werden kann.
Verwenden Sie das native WebSocket-Modul von fibjs, um die WebSocket-Serverseite zu implementieren
Serverseitig können HTTP-Anfragen durch die Upgrade-Funktion in WebSocket-Verbindungen umgewandelt werden. Beim Erstellen eines http-Serverobjekts können Sie ws.upgrade(callback) verwenden und es an die Methode http.start() übergeben, um die http-Anfrage in WebSocket zu konvertieren.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27var ws = require('ws');
var http = require('http');
var server = new http.Server(8080, {
'/ws': ws.upgrade(function(conn, req) {
console.log('a client connected.');
// listening for message events
conn.onmessage = function(evt) {
console.log('received message: ', evt.data);
// echo the message back to client
conn.send('Server: ' + evt.data);
};
// listening for close events
conn.onclose = function(code, reason) {
console.log('closed.');
};
// listening for error events
conn.onerror = function(err) {
console.log(err);
};
})
});
server.start();
Im obigen Beispiel können wir das vom Client gesendete Nachrichtenereignis und das Verbindungsschließungsereignis zwischen dem Server und dem Client überwachen. Wenn der Server die Client-Nachricht empfängt, sendet er dieselbe Nachricht an den Client zurück. An dieser Stelle wird eine einfache WebSocket-Punkt-zu-Punkt-Kommunikation implementiert.
Implementieren Sie die Interaktion mit der Datenspeicherung
Wenn Sie WebSocket für die Kommunikation verwenden, müssen Sie neben dem einfachen Senden und Empfangen von Nachrichten auch Vorgänge wie die dauerhafte Speicherung und Abfrage von Daten berücksichtigen. Zu diesem Zeitpunkt müssen Sie die Datenbank verwenden. Sie können das in fibjs integrierte Datenbankmodul verwenden, um mit der Datenbank zu interagieren.
Der Beispielcode lautet wie folgt:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33var ws = require("ws");
var http = require("http");
var db = require("db");
// open a mysql connection
var mysql = db.openMySQL("mysql://root:password@localhost/dbname");
var server = new http.Server(8080, {
"/ws": ws.upgrade(function(conn, req) {
console.log("a client connected.");
// listening for message events
conn.onmessage = function(evt) {
console.log("received message: ", evt.data);
// use execute to query the data
var rs = mysql.execute("SELECT * FROM user WHERE name=?", evt.data.toString());
conn.send(JSON.stringify(rs));
};
// listening for close events
conn.onclose = function(code, reason) {
console.log("closed.");
};
// listening for error events
conn.onerror = function(err) {
console.log(err);
};
})
});
server.start();
Im obigen Beispiel haben wir zuerst die openMySQL-Methode des DB-Moduls verwendet, um ein MySQL-Datenbankverbindungsobjekt mysql zu erstellen, und nachdem wir die Nachricht vom Client abgehört haben, haben wir die Execute-Methode verwendet, um die SQL-Abfrage direkt auszuführen und Datensätze abzurufen die Bedingungen erfüllen. Abschließend werden die Abfrageergebnisse über das WebSocket-Protokoll an den Client zurückgesendet.
Es ist zu beachten, dass in der tatsächlichen Entwicklung die Ausnahmebehandlung und die Datensicherheit gut durchgeführt werden müssen.
Zusammenfassend lässt sich sagen, dass wir über das DB-Modul einfach und unkompliziert mit der Datenbank in Kombination mit dem WebSocket-Protokoll interagieren können, um leistungsstarke Webanwendungen in Echtzeit zu implementieren.
Implementieren Sie die WebSocket-Client-Server-Kommunikation
Auf der Clientseite können Sie eine Verbindung zu einem WebSocket-Server herstellen, indem Sie eine WebSocket-Instanz erstellen und eine URL angeben und dann Nachrichten an den Server senden.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24var ws = require('ws');
// create a WebSocket object and connect to ws://localhost:8080/ws
var conn = new ws.Socket('ws://localhost:8080/ws');
// listening for open events
conn.onopen = function() {
conn.send('hello');
}
// listening for message events
conn.onmessage = function(evt) {
console.log('received message:', evt.data);
}
// listening for close events
conn.onclose = function(code, reason) {
console.log('closed.');
}
// listening for error events
conn.onerror = function(err) {
console.log(err);
}
Im obigen Client-Code erstellen wir eine WebSocket-Instanz und geben deren URL an. Nachdem die Verbindung erfolgreich hergestellt wurde, können wir Nachrichten an den Server senden. Wenn der Server die Client-Nachricht empfängt, sendet er dieselbe Nachricht an den Client zurück. Zu diesem Zeitpunkt wird eine einfache WebSocket-Punkt-zu-Punkt-Kommunikation implementiert.
Vorteile und Einsatzszenarien von WebSocket
Das WebSocket-Protokoll verfügt über ein typisches bidirektionales Kommunikationsmodell, das es dem Server ermöglicht, Daten aktiv an den Client zu übertragen. Es wird häufig zur Implementierung von Chats, Online-Spielen und anderen Anlässen verwendet, die Echtzeit und hohe Unmittelbarkeit erfordern. Im Vergleich zu anderen Übertragungsprotokollen bietet das WebSocket-Protokoll folgende Vorteile:
• Hohe Echtzeitleistung, unterstützt bidirektionale Kommunikation. • Einfache Protokollspezifikation, benutzerfreundlich. • Kann eine große Anzahl gleichzeitiger Verbindungen verarbeiten. • Unterstützt lange Verbindungen, wodurch die Netzwerkübertragungszeit verkürzt wird
Zu den häufigsten Nutzungsszenarien von WebSocket gehören Web-Chat, Spielschlachten, Online-Wiedergabe und Instant Messaging.
Zusammenfassend lässt sich sagen, dass die Implementierung über das WebSocket-Unterstützungsmodul sehr einfach ist und Entwickler schnell ihre eigenen Webanwendungen erstellen können.
Gerätetest
Test-Frameworks und Testmethoden
Im Softwareentwicklungsprozess ist das Testen ein sehr wichtiges Bindeglied, und Unit-Tests sind ein wichtiger Teil davon. Unit-Tests können effektiv überprüfen, ob der Code dem Design und den Anforderungen entspricht, und Fehler vermeiden, die bei der Änderung des Codes entstehen. Im Allgemeinen besteht das Prinzip des Unit-Tests darin, jede Funktion und Methode zu testen, um sicherzustellen, dass die Eingabe und Ausgabe jeder Funktion und Methode korrekt sind.
Ein Testframework ist eine Codebasis, die zum Schreiben, Ausführen und Überprüfen von Testfällen verwendet wird. Es bietet Testfallverwaltungs-, Ausführungs- und Berichtsfunktionen. Zu den beliebten Unit-Testing-Frameworks in JavaScript und Node.js gehören Mocha, Jest und Jasmine. In fibjs haben wir auch unser eigenes Testframework, das Testmodul.
Zu den im Unit-Testing-Prozess häufig verwendeten Testmethoden gehören Black-Box-Tests und White-Box-Tests.
Black-Box-Tests sind eine Testmethode, die nur die Eingabe und Ausgabe einer Funktion berücksichtigt, ohne die Implementierungsdetails innerhalb der Funktion zu berücksichtigen. Black-Box-Tests basieren auf Anforderungsanalysen und Designspezifikationen. Durch Testfallanalyse und -ausführung wird festgestellt, ob das Programm Logikfehler, Grenzfehler, Sicherheitsprobleme usw. aufweist. Der Vorteil besteht darin, dass der Testprozess einfach ist und die Testergebnisse zuverlässig sind. Der Nachteil besteht darin, dass der Test nicht alle Programmpfade abdecken kann.
White-Box-Tests sind eine Testmethode, die die internen Implementierungsdetails einer Funktion berücksichtigt, einschließlich bedingter Anweisungen, Schleifenanweisungen, Rekursion und Codeabdeckung. Diese Tests können mögliche Probleme in der Interaktion zwischen gemeinsam genutzten Daten und Code identifizieren. Der Vorteil von White-Box-Tests besteht darin, dass alle Programmpfade abgedeckt werden können. Der Nachteil besteht darin, dass der Testprozess komplizierter ist und die Testergebnisse von der Umgebung und den Implementierungsmethoden beeinflusst werden.
Schreiben Sie Testfälle mit dem Testmodul
In fibjs können wir das Testmodul verwenden, um Testfälle für den Webserver zu schreiben. Hier ist ein einfaches Beispiel:
1
2
3
4
5
6
7
8
9
10
11
12
13
14var test = require('test');
test.setup();
var http = require('http');
describe('Web server test', () => {
it('should return hello world', () => {
var r = http.get('http://localhost:8080/hello');
assert.equal(r.statusCode, 200);
assert.equal(r.data.toString(), 'Hello World');
});
});
test.run();
In diesem Beispiel verwenden wir die Funktionen „describe“ und „it“, um das Testmodul bzw. den Testfall zu definieren, und verwenden die Funktion „assertion“ zur Überprüfung der Behauptung.
In der Beschreibungsfunktion können wir mehrere It-Funktionen definieren, um jeweils verschiedene Szenarien zu testen. In jeder it-Funktion können wir die Funktion http.get verwenden, um eine HTTP-GET-Anfrage zu simulieren, die Antwort auf die Anfrage abzurufen und eine Assertionsüberprüfung wie „assertTrue“ und „assuredEqual“ durchzuführen.
Durch das Schreiben von Testfällen können Sie die Korrektheit von Funktionen und Modulen effektiv testen, die Produktqualität sicherstellen und außerdem die Wartbarkeit des Codes verbessern.
Heißes Update
Unter Hot Update versteht man die Aktualisierung des Servercodes, ohne den Dienst zu stoppen. Während des Programmentwicklungsprozesses sind für eine schnelle Iteration häufig Codeanpassungen und neue Funktionen erforderlich. Mithilfe von Hot-Updates können Sie neuen Code verwenden, um die Iterationsarbeit effizienter abzuschließen, ohne den Dienst anzuhalten.
In fibjs können wir das SandBox-Modul verwenden, um reibungslose Hot-Updates zu erreichen. Das SandBox-Modul kann eine sichere Ausführungsumgebung bereitstellen und globale Variablen und andere Funktionen simulieren. Für die spezifische Implementierung beachten Sie bitte die folgenden Schritte:
- Laden Sie die Codedateien, die aktualisiert werden müssen (z. B. web.js).
- Erstellen Sie über SandBox ein neues Sicherheitsmodul, laden Sie web.js in das Modul und generieren Sie das Sicherheitsmodul. Mounten Sie den Handler des laufenden Dienstes über das generierte Sicherheitsmodul erneut.
- Der Server verarbeitet weiterhin frühere Anforderungen und neue Anforderungen werden auf dem neuen Handler bereitgestellt.
Das Folgende ist ein Beispielcode, der das SandBox-Modul verwendet, um reibungslose Hot-Updates zu implementieren:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16const fs = require('fs');
const http = require('http');
const { SandBox } = require('vm');
let FILE_PATH = './web.js';
let handler = new SandBox().require(FILE_PATH).handler;
const server = new http.Server(8080, handler);
server.start();
fs.watch(FILE_PATH, (event, filename) => {
handler = new SandBox().require(FILE_PATH).handler;
server.handler = handler;
console.log(`[${new Date().toLocaleString()}] server reloaded.`);
});
In diesem Code laden wir beim Start des Programms zunächst den Code in web.js, erstellen dann eine SandBox-Instanz und laden den Code in die Instanz. Danach haben wir einen neuen HTTP-Server erstellt und die Methoden im Handler verwendet, um die Anfrage zu verarbeiten.
Im Code verwenden wir fs.watch, um Änderungen in der Datei web.js zu überwachen. Sobald sich die Datei ändert, laden wir den Code neu und aktualisieren die Implementierung im Handler.
Leistungsoptimierung
Während des Entwicklungsprozesses müssen wir uns häufig mit Leistungsproblemen auseinandersetzen. Die Optimierung von Code und die Verbesserung der Leistung gehören zu den wesentlichen Fähigkeiten von Entwicklern. In fibjs können wir CPU Profiler verwenden, um den Laufstatus des Programms zu analysieren und den Code zu optimieren.
In fibjs müssen Sie zum Starten von fibjs nur den Befehlszeilenparameter --prof verwenden, um den CPU-Profiler zu starten (das Standardintervall beträgt 1000 ms). Wenn Sie eine Protokollanalyse mit höherer Genauigkeit benötigen, können Sie den Parameter --prof-interval verwenden, um das Protokollintervall festzulegen. Zum Beispiel:
1
2$ fibjs --prof test.js # 启动 CPU Profiler，默认以 1000ms 为间隔
$ fibjs --prof --prof-interval=10ms test.js # 启动 CPU Profiler，以 10000us（即 10ms）为间隔
Wenn die Ausführung von fibjs abgeschlossen ist, wird im aktuellen Verzeichnis ein Quelldateinamenverzeichnis generiert. Dieses Verzeichnis enthält eine Protokolldatei und einige Hilfsdateien. Der Standardname der Protokolldatei lautet fibjs-xxxx.log, wobei xxxx ein Zeitstempel ist. Mit der Option --log können Sie den Namen der Protokolldatei angeben. An diesem Punkt können Sie --prof-processdie generierten Protokolle wie folgt verarbeiten:
1fibjs --prof-process fibjs-xxxx.log prof.svg
Nachdem der Vorgang abgeschlossen ist, öffnen Sie prof.svg mit dem Browser, um das Flammendiagramm dieses Protokolls anzuzeigen:
Sie können darauf klicken, um das Bild in voller Größe anzuzeigen. Im Bild in voller Größe können Sie die Maus bedienen, um detailliertere Informationen anzuzeigen Informationen: Prof. SVG .
Im generierten Flammendiagramm stellt jeder Farbblock einen Aufzeichnungspunkt dar. Je länger der Farbblock ist, desto öfter wird er aufgezeichnet. Jede Zeile stellt eine Ebene des Aufrufstapels dar. Je mehr Ebenen, desto mehr Ebenen werden aufgerufen. Der Stapel wird aufgerufen wird auf den Kopf gestellt. Je niedriger der Farbblock, desto origineller die Funktion.
Es gibt zwei Arten von Farbblöcken: einer ist rot und der andere blau. Im fibjs-Profiler steht Rot für JavaScript-Operationen und Blau für IO-Operationen oder native Operationen. Abhängig von dem Problem, das Sie lösen müssen, variieren die Bereiche, auf die Sie sich konzentrieren müssen. Wenn Sie beispielsweise das Problem einer hohen CPU-Auslastung lösen müssen, müssen Sie auf die roten Farbblöcke achten. Wenn Ihre Anwendung eine geringe CPU-Auslastung, aber eine langsame Reaktion aufweist, müssen Sie auf die blauen Farbblöcke achten. Je größer der Farbblock im oberen Bereich ist, desto mehr Aufmerksamkeit und Optimierung erfordert er.
Wir können versuchen, Funktionen anzupassen, die mehr CPU-Ressourcen beanspruchen, IO usw. asynchron zu implementieren oder den Code beim Schreiben zu optimieren.
Bereitstellung und online
Damit unser Projekt in einer Produktionsumgebung ausgeführt werden kann, müssen wir es kompilieren und bereitstellen. Hier stellen wir vor, wie Sie die Datei package.json zum Konfigurieren der Kompilierung und Bereitstellung verwenden.
Im Projekt können wir package.json verwenden, um Projektabhängigkeiten zu verwalten und die Kompilierung und Bereitstellung zu konfigurieren. Nehmen Sie als Beispiel ein einfaches Beispielpaket.json:
1
2
3
4
5
6
7{
"name": "my-project",
"version": "1.0.0",
"dependencies": {
"fib-pool": "^1.0.0"
}
}
Wenn wir das Projekt kompilieren und bereitstellen müssen, müssen wir nur das Projektverzeichnis im Terminal eingeben und den folgenden Befehl ausführen:
1fibjs --install
Dieser Befehl installiert automatisch die Module, von denen das Projekt abhängt. Anschließend können wir das Projekt mit folgendem Befehl starten:
1fibjs app.js