10 Node.js Best Practices: Erleuchtung aus dem Knotengurus

Key Takeaways

• Verwenden Sie NPM -Skripte zum Organisieren von Aufgaben wie Builds, Tests und Starten der App. Dies bietet eine einzige Quelle der Wahrheit, wenn Entwickler ein neues Projekt betrachten.
• Umgebungsvariablen wie process.env.node_env aus den frühen Stadien eines Projekts einsetzen. Dadurch wird kein Leck sensibler Informationen gewährleistet und den Code von Anfang an ordnungsgemäß erstellt.
• Verstehen Sie die Ereignisschleife und die Verwendung von SetImmediate () oder setTimeout (), um CPU-intensive Aufgaben in den nächsten Ereignisschleifzyklus zu laden.
• Verwenden Sie die funktionale Vererbung zur Einfachheit und vermeiden Sie die Komplexität der prototypischen Vererbung oder Klassen. Dies ist eine bevorzugte Methode unter vielen produktiven Knotenzusammenführern.
• Betrachten Sie Alternativen zu JavaScript, wie Typenkripten, Fluss, ELM, ClojureScript oder Coffeescript, abhängig von der Fachkenntnis und der Art der App. Dies kann dem Team möglicherweise mit sehr wenig Setup zugute kommen.

10 Node.js Best Practices: Aufklärung aus dem Knotengurus stammt vom Gastautor Azat Mardan. SitePoint -Gastbeiträge zielen darauf ab, Ihnen inhaltliche Inhalte von prominenten Schriftstellern und Sprechern der Web -Community zu bringen.

In meinen vorherigen Artikel 10 Tipps, um 2017 ein besserer Knotenentwickler zu werden, habe ich 10 Node.JS -Tipps, Tricks und Techniken eingeführt, die Sie heute auf Ihren Code anwenden können. Dieser Beitrag wird in diesem Sinne mit weiteren 10 Best Practices fortgesetzt, damit Sie Ihre Knotenfähigkeiten auf die nächste Ebene bringen können. Das werden wir abdecken:

1. Verwenden Sie NPM -Skripte - Hören Sie auf, Bash -Skripte zu schreiben, wenn Sie sie mit NPM -Skripten und Knoten besser organisieren können. Z. B. NPM Run Build, Start und Test. NPM -Skripte sind wie die einzelne Quelle der Wahrheit, wenn Knotenentwickler ein neues Projekt betrachten.
2. Verwenden Sie Env VARs - Verwenden Sie process.env.node_env, indem Sie es auf Entwicklung oder Produktion setzen. Einige Frameworks verwenden diese Variable ebenfalls, also spielen Sie nach der Konvention.
3. Verstehen Sie die Ereignisschleife - SetImmediate () ist nicht unmittelbar, während NextTick () nicht als nächstes ist. Verwenden Sie setImmediate () oder setTimeout (), um CPU-intensive Aufgaben in den nächsten Ereignisschleifzyklus zu laden.
4. Verwenden Sie die funktionale Vererbung-vermeiden
Nennen Sie die Dinge angemessen - geben Sie aussagekräftige Namen, die als Dokumentation dienen. Bitte, bitte keine Großbuchstaben, verwenden Sie bei Bedarf einen Armaturenbrett. Großbuchstaben in Dateinamen sehen nicht nur seltsam aus, sondern kann zu plattformübergreifenden Problemen führen.
Erwägen Sie, JavaScript nicht zu verwenden - ES6/7 ist eine erbärmliche Ergänzung, die aus 6 Jahren Sitzungen geboren wurde, als wir bereits ein besseres JavaScript namens Coffeescript hatten. Verwenden Sie es, wenn Sie den Versandcode schneller möchten und die Zeitverschwendung von Zeitverschwendung var/const/let, Halbkolons, Klasse und andere Argumente.
Native Code bereitstellen - Bei Verwendung von Transpilern native JS -Code (Ergebnis der Builds) begehen, damit Ihre Projekte ohne die Builds
7. ausgeführt werden können
Verwenden Sie GZIP - duh! NPM I Compression -s und vernünftige Protokollierung -nicht zu viel bis zu wenig Abhängig von der Umgebung. npm i Morgan -s
skalieren Sie - Überlegen Sie sich über das Clustering und die von Tag nach staatenlosen Dienste von Tag zu Ihrer Knotenentwicklung. Verwenden Sie PM2 oder Strongloops Cluster -Steuerung
Cache -Anforderungen - Machen Sie maximale Saft aus Ihren Knotenservern heraus, indem Sie sie hinter einem statischen Dateiserver wie Nginx und/oder Cache -Cache wie Lackcache und CDN -Caching anfordern.
10. .

Lassen Sie uns also jeden von ihnen einzeln halben und einen Blick darauf werfen. Sollen wir?

Verwenden Sie NPM -Skripte

Es ist jetzt fast ein Standard, NPM -Skripte für Builds, Tests und vor allem die App zu erstellen. Dies ist der erste Platz, wenn Knotenentwickler sich ansehen, wenn sie auf ein neues Knotenprojekt stoßen. Einige Leute (1, 2, 3, 4) haben sogar Grunzen, Gulp und die dergleichen für das niedrigere, aber zuverlässigere NPM-Skript geworfen. Ich kann ihre Argumentation total verstehen. In Anbetracht der Tatsache, dass NPM -Skripte vor und nach Haken haben, können Sie ein sehr ausgeklügeltes Automatisierungsgrad erreichen:

<span>"scripts": {
</span>  <span>"preinstall": "node prepare.js",
</span>  <span>"postintall": "node clean.js",
</span>  <span>"build": "webpack",
</span>  <span>"postbuild": "node index.js",
</span>  <span>"postversion": "npm publish"
</span><span>}
</span>

Wenn Sie sich für das Front-End entwickeln, möchten Sie zwei oder mehr Uhrenprozesse ausführen, um Ihren Code erneut zu erstellen. Zum Beispiel eine für Webpack und eine für Nodemon. Sie können dies mit && tun, da der erste Befehl die Eingabeaufforderung nicht veröffentlicht. Es gibt jedoch ein praktisches Modul, das gleichzeitig aufgerufen wird, das mehrere Prozesse hervorrufen und gleichzeitig ausführen kann.

Installieren Sie auch Dev -Befehlszeilen -Tools wie Webpack, Nodemon, Gulp, Mokka usw. lokal , um Konflikte zu vermeiden. Sie können auf ./node_modules/.bin/mocha z.

<span>export <span>PATH</span>="./node_modules/.bin:<span>$PATH"</span>
</span>

Verwenden Sie Env Vars

Verwenden Sie Umgebungsvariablen auch für die frühen Stadien eines Projekts, um sicherzustellen, dass sensible Informationen nicht ausgelöst werden, und um den Code von Anfang an ordnungsgemäß zu erstellen. Darüber hinaus werden einige Bibliotheken und Frameworks (ich weiß, dass Express es mit Sicherheit tut) Informationen wie node_env ein, um ihr Verhalten zu ändern. Stellen Sie es auf die Produktion ein. Setzen Sie auch Ihre Werte für mongo_uri und api_key. Sie können eine Shell -Datei (z. B. start.sh) erstellen und zu .Gitignore:

hinzufügen

<span>NODE_ENV=production MONGO_URL=mongo://localhost:27017/accounts API_KEY=lolz nodemon index.js
</span>

Nodemon hat auch eine Konfigurationsdatei, in der Sie Ihre Env -Vars (Beispiel) einstellen können:

<span>{
</span>  <span>"env": {
</span>    <span>"NODE_ENV": "production",
</span>    <span>"MONGO_URL": "mongo://localhost:27017/accounts"
</span>  <span>}
</span><span>}
</span>

Verstehen Sie die Ereignisschleife

Die mächtige und clevere Ereignisschleife macht den Knoten so schnell und brillant, indem er die ganze Zeit nutzt, die auf Eingabe- und Ausgabeaufgaben gewartet worden wäre. Somit ist der Knoten hervorragend darin, I/O-gebundene Systeme zu optimieren.

Wenn Sie etwas CPUintensives ausführen müssen (z. B. Berechnung, Hashing von Kennwörtern oder Komprimieren), möchten Sie zusätzlich zu neuen Prozessen für diese CPU-Tasks die Aufhebung der Aufgabe mit Setimmediat untersuchen () oder setTimeout () - Der Code in ihren Rückernständen wird im nächsten Ereignisschleifenzyklus fortgesetzt. NextTick () arbeitet im selben Zyklus, der dem Namen entspricht. Argh!

Hier ist ein Diagramm von Bert Belder, der an der Veranstaltungsschleife gearbeitet hat. Er weiß klar, wie die Eventschleife funktioniert!

Verwenden Sie die funktionale Vererbung

JavaScript unterstützen die prototypische Vererbung, wenn Objekte von anderen Objekten erben. Der Klassenoperator wurde auch der Sprache mit ES6 hinzugefügt. Es ist jedoch im Vergleich zum funktionellen Vererbung offen komplex. Die meisten Knotengurus bevorzugen die Einfachheit des letzteren. Es wird durch ein einfaches Funktionsfabrikmuster implementiert und erfordert nicht die Verwendung von Prototypen, neu oder dieser. Es gibt keine impliziten Auswirkungen, wenn Sie den Prototyp aktualisieren (wodurch sich auch alle Instanzen ändern), da in der funktionalen Vererbung jedes Objekt seine eigene Kopie von Methoden verwendet.

Betrachten Sie den Code von TJ Holowaychuk, dem produktiven Genie hinter Express-, Mokka-, Verbindungs-, Superagent- und Dutzenden anderer Knotenmodule. Express verwendet die funktionale Vererbung (Voller Quellcode):

<span>"scripts": {
</span>  <span>"preinstall": "node prepare.js",
</span>  <span>"postintall": "node clean.js",
</span>  <span>"build": "webpack",
</span>  <span>"postbuild": "node index.js",
</span>  <span>"postversion": "npm publish"
</span><span>}
</span>

Um objektiv zu sein, verwenden Kernknotenmodule viel prototypische Vererbung. Wenn Sie diesem Muster folgen, stellen Sie sicher, dass Sie wissen, wie es funktioniert. Weitere Informationen zu JavaScript -Vererbungsmustern finden Sie hier.

Nennen Sie die Dinge angemessen

Dieser ist offensichtlich. Gute Namen dienen als Dokumentation. Welches würdest du vorziehen?

<span>export <span>PATH</span>="./node_modules/.bin:<span>$PATH"</span>
</span>

Ich habe keine Ahnung, was Dexter tut, wenn ich App.Use () nur anschaue. Wie wäre es mit einem anderen sinnvolleren Namen:

<span>NODE_ENV=production MONGO_URL=mongo://localhost:27017/accounts API_KEY=lolz nodemon index.js
</span>

In der gleichen Weise müssen Dateinamen korrekt widerspiegeln, was der Zweck des Code im Inneren ist. Wenn Sie sich den Lib -Ordner des Knotens (GitHub Link) ansehen, der alle mit der Plattform gebündelten Kernmodule enthält, sehen Sie die klare Benennung der Dateien/Module (auch wenn Sie nicht sehr mit vertraut sind die Kernmodule):

<span>{
</span>  <span>"env": {
</span>    <span>"NODE_ENV": "production",
</span>    <span>"MONGO_URL": "mongo://localhost:27017/accounts"
</span>  <span>}
</span><span>}
</span>

Die internen Module sind mit einem Unterstrich (_debugger.js, _http_agent.js, _http_client.js) markiert, genau wie Methoden und Variable im Code. Dies hilft Entwicklern zu warnen, dass dies eine interne Schnittstelle ist. Wenn Sie sie verwenden, sind Sie alleine - beschweren Sie sich nicht, wenn sie neu gestaltet oder sogar entfernt wird.

Überlegen Sie, ob Sie JavaScript nicht verwenden

Huh? Hast du es gerade richtig gelesen? Aber was zum Teufel? Ja. Das ist richtig. Selbst mit ES6 und den beiden von ES2016/ES7 hinzugefügten Funktionen hat JavaScript noch seine Macken. Neben JavaScript gibt es andere Optionen, von denen Sie oder Ihr Team mit sehr wenig Setup profitieren können. Abhängig vom Fachwissen und der Art der App sind Sie möglicherweise besser mit TypeScript oder Flow, die eine starke Typisierung bieten. Am anderen Ende des Spektrums gibt es ELM oder ClojureScript, die rein funktionsfähig sind. Coffeescript ist eine weitere großartige und kattgetestete Option. Sie können sich auch Dart 2.0 ansehen.

Wenn Sie nur ein paar Makros benötigen (Makros ermöglichen es Ihnen, genau die gewünschte Sprache zu erstellen), nicht eine ganze neue Sprache, dann betrachten Sie Sweet.js, die genau das tun - erlauben Sie Ihnen - erlauben Sie Ihnen Code schreiben, der Code generiert.

Wenn Sie die Nicht-JavaScript-Route gehen, geben Sie bitte immer noch Ihren kompilierten Code an, da einige Entwickler Ihre Sprache möglicherweise nicht gut genug verstehen, um ihn ordnungsgemäß zu erstellen. Zum Beispiel ist VS -Code eines der größten Typenkriptprojekte, möglicherweise nach Angular 2, und Code verwendet das Kernmodul von TypeScript zum Patchknoten mit Typen. Im VSCODE/SRC/VS/BASE/NODE/OF VS CODE REPO (Link) können Sie bekannte Modulnamen wie Crypto, Process usw. sehen, jedoch mit der TS -Erweiterung. Es gibt andere TS -Dateien im Repo. Sie enthielten jedoch auch VSCODE/Build mit nativem JavaScript -Code.

Know Express Middleware

Express ist ein großartiger und sehr ausgereifter Rahmen. Die Brillanz besteht darin, unzählige andere Module zu ermöglichen, sein Verhalten zu konfigurieren. Daher müssen Sie die am häufigsten verwendete Middleware kennen und Sie wissen, wie Sie es verwenden. Warum also nicht mein Express -Cheat -Blatt schnappen. Ich habe dort die Hauptmodule aufgeführt. Zum Beispiel wird die NPM I -Komprimierung -S -S durch Deflation der Antworten die Download -Geschwindigkeit reduzieren. Logger ('Tiny') oder Logger ('Common') liefert weniger (dev) bzw. mehr (prod) Protokolle.

skalieren Sie

Knoten ist aufgrund seiner nicht blockierenden I/O großartig in Async und hält diese asynchronisierte Art der Codierung einfach, da es nur einen Thread gibt. Dies ist eine Gelegenheit, frühzeitig zu skalieren, vielleicht sogar mit den ersten Codezeilen. Es gibt das Core -Cluster -Modul, mit dem Sie ohne zu viele Probleme vertikal skalieren können. Ein noch besserer Weg wäre es jedoch, ein Tool wie PM2 oder Strongloops Cluster -Steuerung zu verwenden.

So können Sie zum Beispiel mit PM2:

beginnen

<span>"scripts": {
</span>  <span>"preinstall": "node prepare.js",
</span>  <span>"postintall": "node clean.js",
</span>  <span>"build": "webpack",
</span>  <span>"postbuild": "node index.js",
</span>  <span>"postversion": "npm publish"
</span><span>}
</span>

Dann können Sie vier Instanzen desselben Servers starten:

<span>export <span>PATH</span>="./node_modules/.bin:<span>$PATH"</span>
</span>

Für Docker hat PM2 Version 2 PM2-Docker. So kann Ihre Dockerfile so aussehen:

<span>NODE_ENV=production MONGO_URL=mongo://localhost:27017/accounts API_KEY=lolz nodemon index.js
</span>

Das offizielle Alpine Linux PM2 -Bild befindet sich im Docker -Hub.

Cache -Anforderungen

Dies ist ein DevOps -Best Practice, mit dem Sie mehr Saft aus Ihren Knoteninstanzen herausholen können (Sie erhalten mehr als eine mit PM2 oder dergleichen, siehe oben). Die Möglichkeit zu geben, Knotenserver zugelassen zu lassen, wie Apps wie Anfragen erstellen, Daten verarbeitet und die Geschäftslogik ausgeführt und den Datenverkehr auf statische Dateien auf einen anderen Webserver wie Apache HTTPD oder NGINX abgeladen werden. Auch hier sollten Sie Docker wahrscheinlich für die Einrichtung verwenden:

<span>{
</span>  <span>"env": {
</span>    <span>"NODE_ENV": "production",
</span>    <span>"MONGO_URL": "mongo://localhost:27017/accounts"
</span>  <span>}
</span><span>}
</span>

Ich benutze Docker Compose gerne, damit mehrere Container (Nginx, Knoten, Redis, MongoDB) miteinander arbeiten. Zum Beispiel:

exports <span>= module.exports = createApplication;
</span><span>// ...
</span><span>function createApplication() {
</span>  <span>var app = function(req<span>, res, next</span>) {
</span>    app<span>.handle(req, res, next);
</span>  <span>};
</span>
  <span>mixin(app, EventEmitter.prototype, false);
</span>  <span>mixin(app, proto, false);
</span>
  app<span>.request = { __proto__: req, app: app };
</span>  app<span>.response = { __proto__: res, app: app };
</span>  app<span>.init();
</span>  <span>return app;
</span><span>}
</span>

Zusammenfassung

In der heutigen Open-Source-Software gibt es keine Ausreden, die nicht aus dem vertrauenswürdigen und getesteten Code lernen können, der offen ist. Sie müssen nicht im inneren Kreis sein, um hineinzukommen. Das Lernen wird nie aufgehört und ich bin sicher, dass wir bald unterschiedliche Best Practices haben werden, basierend auf den Misserfolgen und Erfolgen, die wir erleben werden. Sie sind garantiert.

Schließlich wollte ich schreiben, wie Software die Welt frisst und wie JavaScript die Software isst. Es gibt großartige Dinge wie jährliche Standardveröffentlichungen, viele, viele NPM -Module, Werkzeuge und Konferenzen ... aber stattdessen werde ich fertig werden mit einem Wort der Vorsicht.

Ich sehe, wie immer mehr Menschen den nächsten neuen Framework oder die nächste Sprache jagen. Es ist das glänzende Objektsyndrom. Sie lernen jede Woche eine neue Bibliothek und jeden Monat einen neuen Rahmen. Sie überprüfen zwanghaft Twitter, Reddit, Hacker News und JS Weekly. Sie verwenden das überwältigende Aktivitätsniveau in der JavaScript -Welt, um zu zögern. Sie haben leere öffentliche Github -Geschichten.

neue Dinge lernen ist gut, aber verwirren Sie es nicht, wenn Sie tatsächlich Sachen aufgebaut haben. Was zählt und was Ihr Gehalt bezahlt, ist, Dinge tatsächlich aufzubauen. Halten Sie über Ingenieurwesen an. Sie erstellen nicht das nächste Facebook. Versprechen vs. Generatoren gegen Async warten ein Streit für mich, denn als jemand in einer Diskussion auf einen Thread antwortete, habe ich bereits meinen Rückruf geschrieben (und Coffeescript verwendet, um ihn schneller zu machen als in einfacher ES5/6/7! ).

Die endgültige Best Practice besteht darin, Best Practices zu verwenden, und das Beste der Besten besteht darin, die Grundlagen zu beherrschen. Lesen Sie den Quellcode, probieren Sie neue Dinge im Code aus und schreiben Sie vor allem selbst eine Menge Code. Hören Sie zu diesem Zeitpunkt auf zu lesen und schicken Sie den Versandcode, der zählt!

Und für den Fall, dass dieser Beitrag hier nicht ausreicht

https://blog.risingstack.com/nodejs-at-scale-npm-best-practices
https://devcenter.heroku.com/articles/node-best-practices
https://blog.risingstack.com/node-js-best-practices
https://expressjs.com/en/advanced/best-practice-performance.html
https://www.codementor.io/nodejs/tutorial/nodejs-best-practices

häufig gestellte Fragen (FAQs) auf Node.js Best Practices

Was sind einige der wichtigsten Best Practices für die Entwicklung von Node.js? Dazu gehören die Verwendung der asynchronen Programmierung, die nicht blockierende Operationen ermöglicht und die Leistung verbessert. Es ist auch wichtig, Fehler ordnungsgemäß zu behandeln, um Anwendungsabstürze zu verhindern. Weitere Best Practices sind die Verwendung eines Linters zur Durchsetzung der Codequalität, die Verwendung von Umgebungsvariablen für die Konfiguration und das Schreiben kleiner Module, um Ihre Codebasis überschaubar und verständlich zu halten. 🎜>

Es gibt verschiedene Möglichkeiten, die Leistung Ihrer Node.js -Anwendung zu verbessern. Eine der effektivsten Methoden ist die Verwendung des Cluster -Moduls, mit dem Sie untergeordnete Prozesse erstellen können, die alle Serverports teilen. Dies kann die Leistung Ihrer Anwendung erheblich verbessern, indem Sie mehr Anfragen gleichzeitig bearbeiten. Darüber hinaus können Sie Tools wie PM2 verwenden, um Ihre Node.js -Anwendungen zu verwalten und zu überwachen, mit denen Sie Leistungsprobleme identifizieren und angehen können. >

Einige häufige Fehler, die Sie bei der Entwicklung mit Node.js vermeiden sollten, umfassen das Blockieren der Ereignisschleife, die Nichtbearbeitung von Fehlern und die Verwendung von Tools wie Lintern, um die Codequalität durchzusetzen. Das Blockieren der Ereignisschleife kann zu Leistungsproblemen führen, da sie verhindert, dass andere Vorgänge ausgeführt werden. Nicht ordnungsgemäß zu behandeln können zu Anwendungsabstürzen führen, während keine Linter zu inkonsistenten Codequalität und potenziellen Fehler führen können.

Wie kann ich sicherstellen, dass meine Anwendung von node.js sicher ist? Dazu gehören die Verwendung von HTTPS zur sicheren Kommunikation, die Validierung und Bereinigung von Benutzereingaben, um Injektionsangriffe zu verhindern, und die Verwendung von Sicherheitskopfzeilen zum Schutz vor gemeinsamen Webanfälligkeiten. Es ist auch wichtig, Ihre Abhängigkeiten auf dem neuesten Stand zu halten, da veraltete Abhängigkeiten bekannte Sicherheitslücken enthalten können. Node.js -Entwicklung, und es gibt mehrere Best Practices, die folgen müssen. Dazu gehört das Schreiben von Unit-Tests zum Testen einzelner Komponenten Ihrer Anwendung, Integrationstests, um zu testen, wie diese Komponenten interagieren, und End-to-End-Tests, um Ihre Anwendung als Ganzes zu testen. Es ist auch wichtig, ein Continuous Integration (CI) -System (Continuous Integration) zu verwenden, um Ihre Tests automatisch auszuführen, wenn Änderungen an Ihrer Codebasis vorgenommen werden. Node.js wird normalerweise mit NPM, dem Standardpaket -Manager für node.js., durchgeführt. Es ist wichtig, genaue Versionen Ihrer Abhängigkeiten in Ihrem Paket.json -Datei anzugeben, um sicherzustellen, dass Ihre Anwendung wie erwartet funktioniert. Sie sollten auch Ihre Abhängigkeiten regelmäßig aktualisieren, um von Fehlerbehebungen und Sicherheitspatches zu profitieren. JS -Entwicklung. Zu den Best Practices gehört die Verwendung von Try/Catch-Blöcken, um synchrone Fehler zu fangen, Fehler mit fehlerhaften Rückrufen zur Behandlung asynchroner Fehler und die Verwendung eines zentralisierten Fehlerbehandlungsmechanismus, um alle Fehler an einem Ort zu behandeln. Es ist auch wichtig, Fehler für Debugging -Zwecke zu protokollieren und auf den Client mit entsprechenden Fehlermeldungen zu reagieren. beinhaltet mehrere Best Practices. Dazu gehört die Verwendung eines Linters zur Durchsetzung der Codequalität, nach einem konsistenten Codierungsstil und das Schreiben von Tests, um Fehler frühzeitig zu erfassen. Es ist auch wichtig, die Versionskontrolle (wie GIT) zu verwenden, um Änderungen an Ihrer Codebasis zu verfolgen und Codeüberprüfungen durchzuführen, um potenzielle Probleme zu fangen. Eine Node.js -Anwendung kann auf verschiedene Weise erreicht werden. Eine gängige Methode besteht darin, das Cluster -Modul zum Erstellen von untergeordneten Prozessen zu verwenden, die Server -Ports freigeben, sodass Ihre Anwendung gleichzeitig weitere Anfragen bearbeiten kann. Sie können auch Lastausgleich verwenden, um eingehenden Netzwerkverkehr über mehrere Server zu verteilen, und horizontale Skalierung (Hinzufügen von mehr Maschinen) oder vertikale Skalierung (hinzuzufügen mehr Ressourcen zu einer einzigen Maschine) je nach Ihren Anforderungen.

Was sind einige Best Practices für die Bereitstellung von Node.js -Anwendungen? Dazu gehören die Verwendung von Umgebungsvariablen für die Konfiguration, die Verwendung eines Prozessmanagers wie PM2 zur Verwaltung Ihrer Anwendung sowie die Verwendung eines Continuous Integration (CI) -Systems zur automatischen Bereitstellung Ihrer Anwendung, wenn Änderungen an Ihrer Codebasis vorgenommen werden. Es ist auch wichtig, Ihre Anwendung zu überwachen, um Leistungsprobleme zu identifizieren und zu beheben.

Das obige ist der detaillierte Inhalt von10 Node.js Best Practices: Erleuchtung aus dem Knotengurus. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!