Erstellen eines Microblogs mit Node.js, Git und Markdown

Erstellen Sie ein Microblog basierend auf Node.js, Git und Markdown

In diesem Artikel wird untersucht, wie ein Microblog mit Node.js, Git und einigen Abhängigkeiten erstellt wird. Diese App soll statische Inhalte aus Dateien bereitstellen, die im Repository übermittelt wurden. Sie lernen, wie Sie Ihre Anwendung erstellen und testen und einen Einblick in den Prozess der Bereitstellung Ihrer Lösung erhalten. Letztendlich haben Sie eine minimalistische, runnable Blog -Anwendung, auf der Sie aufbauen können.

Schlüsselpunkte:

• node.js bietet einen ausgewogenen Satz von APIs, die ideal für den Aufbau von Mikroblog -Plattformen sind, die keine unnötige Komplexität erfordern.
• Git wird verwendet, um Blog -Beiträge als versionierte Textdokumente zu speichern, ohne herkömmliche Datenbanken zu verwenden.
• Markdown wird für die Formatierung von Blog -Posts verwendet, sodass leichte Inhalte ermöglicht werden können und schrittweise verbessert werden können.
• Braten.it wird für Unit -Tests verwendet, da es einfach ist und keine Abhängigkeiten aufweist, was ein schnelles Feedback und ein verbessertes Entwicklervertrauen ermöglicht.
• Die Microblog -Architektur ist auf Einfachheit und minimale Abhängigkeiten für die Bereitstellung von Blog -Inhalten ausgelegt, um eine schnelle Leistung zu gewährleisten.
• Die Anwendung verwendet einen benutzerdefinierten Markdown -Parser- und einfachen Vorlagenfunktionen, um Markdown in HTML umzuwandeln, um sicherzustellen, dass das Blog leicht und reaktionsschnell ist.

Hauptkomponenten von Microblogs

Um einen tollen Blog zu erstellen, benötigen Sie zunächst einige Komponenten:

• Bibliothek zum Senden von HTTP -Nachrichten
• Repository zum Speichern von Blog -Posts
• Unit -Testläufer oder Bibliothek
• Markdown -Parser

Um HTTP -Nachrichten zu senden, habe ich Node.js ausgewählt, da sie alles enthält, was Sie benötigen, um eine Hypertextnachricht aus dem Server zu senden. Die beiden Module von besonderem Interesse sind http und fs. Das http -Modul erstellt einen Knoten -HTTP -Server. Das fs -Modul liest die Datei. Node verfügt über eine Bibliothek zum Erstellen von Mikroblogs mit HTTP.

Um ein Blog -Post -Repository zu speichern, werde ich Git anstelle einer voll funktionsfähigen Datenbank auswählen. Der Grund dafür ist, dass Git selbst ein Versionsrepository für Versionsdokumente ist. Dies ist genau alles, was ich benötige, um Blog -Post -Daten zu speichern. Das Hinzufügen von Datenbanken als Abhängigkeiten hinderte mich daran, Code für viele Probleme schreiben zu müssen.

Ich habe mich für Blog -Posts im Markdown -Format entschieden und mit marked analysieren. Wenn ich mich später dazu entscheide, kann ich dadurch frei sein, den ursprünglichen Inhalt schrittweise zu verbessern. Markdown ist eine gute leichte Alternative zu regulärem HTML.

Für Unit -Tests habe ich den hervorragenden Testläuferbraten gewählt. Ich habe diese Alternative ausgewählt, weil sie keine Abhängigkeiten hat und meine Anforderungen an die Testtests erfüllt. Sie können einen anderen Testläufer wie Band auswählen, aber es hat ungefähr acht Abhängigkeiten. Der Grund, warum ich Braten mag. Es ist, dass es keine Abhängigkeiten hat.

Mit dieser Liste von Komponenten habe ich alle Abhängigkeiten, die ich für ein Microblog erstellen muss.

Abhängigkeiten auswählen ist nicht einfach. Ich denke, der Schlüssel ist, dass alles, was über den Umfang des aktuellen Problems hinausgeht, zu einer Abhängigkeit werden kann. Zum Beispiel erstelle ich keinen Testläufer oder ein Datenrepository, daher füge ich ihn der Liste hinzu. Keine gegebene Abhängigkeit kann die Lösung schlucken und den Code entführen. Daher ist es sinnvoll, nur leichte Komponenten auszuwählen.

In diesem Artikel geht davon aus, dass Sie bereits mit Knoten, NPM und Git sowie verschiedenen Testmethoden vertraut sind. Ich mache nicht jeden Schritt, wenn ich Schritt für Schritt einen Microblog -Aufbau aufbaue, sondern mich auf bestimmte Bereiche des Codes konzentriere. Wenn Sie die Aktion zu Hause befolgen und der Code in GitHub hochgeladen wurde, können Sie jeden Code -Snippet ausprobieren.

Test

Tests gibt Ihnen Vertrauen in Ihren Code und stärkt die Rückkopplungsschleife. Eine Feedback -Schleife in der Programmierung bezieht sich auf die Zeit, in der es dauert, dass ein neuer Code geschrieben wird und ihn ausgeführt wird. In jeder Weblösung bedeutet dies, viele Ebenen zu überspringen, um Feedback zu erhalten. Zum Beispiel Browser, Webserver und sogar Datenbanken. Mit zunehmender Komplexität kann dies bedeuten, dass es einige Minuten oder sogar eine Stunde dauert, um Feedback zu erhalten. Mit Unit -Tests können wir diese Schichten reduzieren und ein schnelles Feedback erhalten. Dies konzentriert sich auf das aktuelle Problem.

Ich starte gerne eine Lösung, indem ich schnelle Unit -Tests schreibe. Dies brachte mich dazu, Tests für jeden neuen Code zu schreiben. So rennen Sie mit Roast.it.

zur package.json Datei hinzufügen:

<code class="language-json">"scripts": {
  "test": "node test/test.js"
},
"devDependencies": {
  "roast.it": "1.0.4"
}</code>

In

test.js Dateien stellen Sie alle Unit -Tests ein und führen sie aus. Zum Beispiel können Sie Folgendes tun:

<code class="language-javascript">var roast = require('roast.it');

roast.it('Is array empty', function isArrayEmpty() {
  var mock = [];

  return mock.length === 0;
});

roast.run();
roast.exit();</code>

Um den Test auszuführen, führen Sie npm install && npm test aus. Zu meiner Freude muss ich nicht mehr hart arbeiten, um neuen Code zu testen. Darum geht es bei Tests: Happy Programmierer gewinnen Vertrauen und konzentrieren sich auf Lösungen.

Skelett

Mit dem Microblog reagieren Knoten auf Clientanfragen. Ein effektiver Weg ist durch die http.CreateServer() Knoten -API. Dies ist in den folgenden Auszügen in app.js:

zu sehen

<code class="language-javascript">/* app.js */
var http = require('http');
var port = process.env.port || 1337;

var app = http.createServer(function requestListener(req, res) {
  res.writeHead(200, { 'Content-Type': 'text/plain; charset=utf-8'});
  res.end('A simple micro blog website with no frills nor nonsense.');
});

app.listen(port);

console.log('Listening on http://localhost:' + port);</code>

Führen Sie dieses Skript durch das NPM -Skript in package.json:

aus

<code class="language-json">"scripts": {
  "start": "node app.js"
}</code>

Jetzt wird http://localhost:1337/ zur Standardroute und gibt eine Nachricht an den Client zurück. Die Idee ist, weitere Routen hinzuzufügen, um andere Antworten zurückzugeben, z. B. mit dem Inhalt des Blog -Beitrags.

Ordnerstruktur

Um die Struktur der Anwendung zu erstellen, habe ich beschlossen, die folgenden Hauptteile zu verwenden:

Ich werde diese Ordner verwenden, um den Code zu organisieren. Hier ist ein Überblick über den Zweck jedes Ordners:

• blog: Speichern Sie Original -Blog -Beiträge im reinen Markdown -Format
• message: Wiederverwendbares Modul zum Erstellen von Antwortnachrichten an Clients
• route: Andere Routen als Standardrouten
• test: Wo schreibe Unit -Tests
• view: Wo soll HTML -Vorlagen
platziert werden

Mehr Routing und Testen

Für den ersten Anwendungsfall werde ich einen weiteren Weg zum Blog -Beitrag einführen. Ich habe mich entschlossen, es in eine überprüfbare Komponente namens BlogRoute zu setzen. Was ich mag, ist, dass Sie Abhängigkeiten in sie injizieren können. Diese Trennung von Bedenken zwischen Einheiten und ihren Abhängigkeiten ermöglicht Unit -Tests. Jede Abhängigkeit erhält einen Schein im isolierten Test. Auf diese Weise können Sie unveränderliche, wiederholbare und schnelle Tests schreiben.

Zum Beispiel sieht der Konstruktor so aus:

<code class="language-json">"scripts": {
  "test": "node test/test.js"
},
"devDependencies": {
  "roast.it": "1.0.4"
}</code>

Effektive Einheiten -Tests sind:

<code class="language-javascript">var roast = require('roast.it');

roast.it('Is array empty', function isArrayEmpty() {
  var mock = [];

  return mock.length === 0;
});

roast.run();
roast.exit();</code>

derzeit erwartet BlogRoute ein req -Objekt, das aus der Knoten -API stammt. Um den Test abzuschließen, machen Sie einfach Folgendes:

<code class="language-javascript">/* app.js */
var http = require('http');
var port = process.env.port || 1337;

var app = http.createServer(function requestListener(req, res) {
  res.writeHead(200, { 'Content-Type': 'text/plain; charset=utf-8'});
  res.end('A simple micro blog website with no frills nor nonsense.');
});

app.listen(port);

console.log('Listening on http://localhost:' + port);</code>

damit können wir es mit der Anforderungspipeline verbinden. Sie können Folgendes in app.js:

machen

<code class="language-json">"scripts": {
  "start": "node app.js"
}</code>

Der Vorteil eines Tests besteht darin, dass ich mir keine Sorgen um Implementierungsdetails im Voraus machen muss. Ich werde bald message definieren. Die Objekte res und req stammen aus der http.createServer() Knoten -API.

repository

Das nächste Problem besteht darin, die ursprünglichen Blog -Postdaten in BlogRoute.route() zu lesen. Der Knoten bietet ein fs -Modul, mit dem Sie aus dem Dateisystem lesen können.

Beispiel:

<code class="language-javascript">/* route/blogRoute.js */
var BlogRoute = function BlogRoute(context) {
  this.req = context.req;
};</code>

Dieser Code -Snippet befindet sich in message/readTextFile.js. Im Zentrum der Lösung lesen Sie Textdateien im Repository. Bitte beachten Sie, dass fs.readFile() eine asynchrone Operation ist. Deshalb nimmt es den fn -Rückruf und ruft ihn mit Dateidaten auf. Diese asynchrone Lösung verwendet einfache Rückrufe.

Dies bietet die Anforderung für die Datei -IO. Was ich daran mag, ist, dass es nur ein Problem löst. Da es sich um ein Cross-Domain-Problem handelt, wie z. B. Lesen von Dateien, müssen keine Unit-Tests durchgeführt werden. Unit -Tests sollten nur die Isolation Ihres eigenen Codes und nicht die Code anderer testen.

theoretisch können Sie ein Dateisystem im Speicher simulieren und Unit -Tests auf diese Weise schreiben, aber die Lösung beginnt dann überall Bedenken und verwandelt sich in Verwirrung.

Cross-Domain-Probleme wie das Lesen von Dateien liegen außerhalb des Rahmens des Codes. Beispielsweise hängt das Lesen von Dateien von einem Subsystem ab, das Sie nicht direkt steuern können. Dies macht die Tests zerbrechlich und erhöht die Zeit und Komplexität der Rückkopplungsschleife. Dies ist ein Problem, das von Ihrer Lösung getrennt werden muss.

Markdown -Parser

Das nächste Problem besteht darin, die ursprünglichen Markdown -Daten aus dem Repository in HTML zu konvertieren. Dieser Prozess ist in zwei Schritte unterteilt:

• HTML -Vorlage aus view Ordner
abrufen
Markdown an HTML analysieren und Vorlagen ausfüllen

BlogRoute Bei der Soundprogrammierung ist es die Idee, ein großes Problem in kleine, einfach zu handhemische Teile aufzuteilen. Lassen Sie uns die erste Frage lösen: Wie kann man HTML -Vorlagen basierend auf dem, was ich in

basiert, bekommt?

Eine Methode könnte:

<code class="language-javascript">/* test/blogRouteTest.js */
roast.it('Is valid blog route', function isValidBlogRoute() {
  var req = {
    method: 'GET',
    url: 'http://localhost/blog/a-simple-test'
  };

  var route = new BlogRoute({ req: req });

  return route.isValidRoute();
});</code>

sein

dummyTest Denken Sie daran, dass dies den im vorherigen Abschnitt verwendeten virtuellen Rückruf ersetzt.

Um den Rückruf dummyTest zu ersetzen, machen Sie Folgendes:

<code class="language-json">"scripts": {
  "test": "node test/test.js"
},
"devDependencies": {
  "roast.it": "1.0.4"
}</code>

(Der nachfolgende Inhalt wird aufgrund von Platzbeschränkungen weggelassen. Fügen Sie ihn bitte nach Bedarf hinzu)

Das obige ist der detaillierte Inhalt vonErstellen eines Microblogs mit Node.js, Git und Markdown. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!