it-swarm.com.de

Node.js schneller Dateiserver (statische Dateien über HTTP)

Gibt es Node.js einsatzbereites Tool (installiert mit npm), mit dessen Hilfe ich Ordnerinhalte als Dateiserver über HTTP verfügbar machen kann?.

Beispiel, wenn ich habe

D:\Folder\file.Zip
D:\Folder\file2.html
D:\Folder\folder\file-in-folder.jpg

Dann beginnend mit D:\Folder\node node-file-server.js konnte ich über auf die Datei zugreifen

http://hostname/file.Zip
http://hostname/file2.html
http://hostname/folder/file-in-folder.jpg

Warum löscht mein Node Static File Server Anfragen? Verweis auf etwas Mystisches

statischer Standarddateiserver für node.js

Welches Framework sollte ich verwenden, wenn es kein solches Tool gibt?

Verwandte: Grundlegender statischer Dateiserver in NodeJS

555
Paul Verest

Eine gute "gebrauchsfertige Tool" -Option könnte http-server sein:

npm install http-server -g

Um es zu benutzen:

cd D:\Folder
http-server

Oder so:

http-server D:\Folder

Probieren Sie es aus: https://github.com/nodeapps/http-server

947
Matt Self

Wenn Sie das fertige Tool nicht verwenden möchten, können Sie den folgenden Code verwenden, der von mir unter https://developer.mozilla.org/en-US/docs/Node_server_without_framework demonstriert wurde:

var http = require('http');
var fs = require('fs');
var path = require('path');

http.createServer(function (request, response) {
    console.log('request starting...');

    var filePath = '.' + request.url;
    if (filePath == './')
        filePath = './index.html';

    var extname = path.extname(filePath);
    var contentType = 'text/html';
    switch (extname) {
        case '.js':
            contentType = 'text/javascript';
            break;
        case '.css':
            contentType = 'text/css';
            break;
        case '.json':
            contentType = 'application/json';
            break;
        case '.png':
            contentType = 'image/png';
            break;      
        case '.jpg':
            contentType = 'image/jpg';
            break;
        case '.wav':
            contentType = 'audio/wav';
            break;
    }

    fs.readFile(filePath, function(error, content) {
        if (error) {
            if(error.code == 'ENOENT'){
                fs.readFile('./404.html', function(error, content) {
                    response.writeHead(200, { 'Content-Type': contentType });
                    response.end(content, 'utf-8');
                });
            }
            else {
                response.writeHead(500);
                response.end('Sorry, check with the site admin for error: '+error.code+' ..\n');
                response.end(); 
            }
        }
        else {
            response.writeHead(200, { 'Content-Type': contentType });
            response.end(content, 'utf-8');
        }
    });

}).listen(8125);
console.log('Server running at http://127.0.0.1:8125/');

UPDATE Wenn Sie von einer externen Anforderung/Datei auf Ihren Server zugreifen müssen, müssen Sie das CORS in Ihrer node.js-Datei überwinden, indem Sie das schreiben unten, wie ich in einer vorherigen Antwort erwähnt habe hier

// Website you wish to allow to connect
response.setHeader('Access-Control-Allow-Origin', '*');

// Request methods you wish to allow
response.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS, PUT, PATCH, DELETE');

// Request headers you wish to allow
response.setHeader('Access-Control-Allow-Headers', 'X-Requested-With,content-type');

// Set to true if you need the website to include cookies in the requests sent
// to the API (e.g. in case you use sessions)
response.setHeader('Access-Control-Allow-Credentials', true);

UPDATE

Wie Adrian in den Kommentaren erwähnte, schrieb er einen ES6-Code mit vollständiger Erklärung hier , ich poste nur seinen Code weiter unten, falls der Code aus irgendeinem Grund von der ursprünglichen Site verschwunden ist:

const http = require('http');
const url = require('url');
const fs = require('fs');
const path = require('path');
const port = process.argv[2] || 9000;

http.createServer(function (req, res) {
  console.log(`${req.method} ${req.url}`);

  // parse URL
  const parsedUrl = url.parse(req.url);
  // extract URL path
  let pathname = `.${parsedUrl.pathname}`;
  // based on the URL path, extract the file extention. e.g. .js, .doc, ...
  const ext = path.parse(pathname).ext;
  // maps file extention to MIME typere
  const map = {
    '.ico': 'image/x-icon',
    '.html': 'text/html',
    '.js': 'text/javascript',
    '.json': 'application/json',
    '.css': 'text/css',
    '.png': 'image/png',
    '.jpg': 'image/jpeg',
    '.wav': 'audio/wav',
    '.mp3': 'audio/mpeg',
    '.svg': 'image/svg+xml',
    '.pdf': 'application/pdf',
    '.doc': 'application/msword'
  };

  fs.exists(pathname, function (exist) {
    if(!exist) {
      // if the file is not found, return 404
      res.statusCode = 404;
      res.end(`File ${pathname} not found!`);
      return;
    }

    // if is a directory search for index file matching the extention
    if (fs.statSync(pathname).isDirectory()) pathname += '/index' + ext;

    // read file from file system
    fs.readFile(pathname, function(err, data){
      if(err){
        res.statusCode = 500;
        res.end(`Error getting the file: ${err}.`);
      } else {
        // if the file is found, set Content-type and send data
        res.setHeader('Content-type', map[ext] || 'text/plain' );
        res.end(data);
      }
    });
  });


}).listen(parseInt(port));

console.log(`Server listening on port ${port}`);
167
Hasan A Yousef

Für Benutzer, die einen Server benötigen, der über das NodeJS-Skript ausgeführt werden kann:

Sie können expressjs/serve-static verwenden, das connect.static ersetzt (das ab connect 3 nicht mehr verfügbar ist):

myapp.js:

var http = require('http');

var finalhandler = require('finalhandler');
var serveStatic = require('serve-static');

var serve = serveStatic("./");

var server = http.createServer(function(req, res) {
  var done = finalhandler(req, res);
  serve(req, res, done);
});

server.listen(8000);

und dann von der Kommandozeile:

  • $ npm install finalhandler serve-static
  • $ node myapp.js
74
jakub.g

Ich weiß, dass es kein Knoten ist, aber ich habe Pythons SimpleHTTPServer verwendet:

python -m SimpleHTTPServer [port]

Es funktioniert gut und kommt mit Python.

54
Matt Sergeant

connect könnte das sein, wonach Sie suchen.

Einfach zu installieren mit:

npm install connect

Dann könnte der einfachste statische Dateiserver wie folgt geschrieben werden:

var connect = require('connect'),
    directory = '/path/to/Folder';

connect()
    .use(connect.static(directory))
    .listen(80);

console.log('Listening on port 80.');
33
Oleg

Installieren Sie Express mit npm: https://expressjs.com/en/starter/installing.html

Erstellen Sie eine Datei mit dem Namen server.js auf derselben Ebene wie Ihre index.html mit folgendem Inhalt:

var express = require('express');
var server = express();
server.use('/', express.static(__dirname + '/'));
server.listen(8080);

Wenn Sie es an einem anderen Ort ablegen möchten, setzen Sie den Pfad in die dritte Zeile:

server.use('/', express.static(__dirname + '/public'));

CD in den Ordner, der Ihre Datei enthält, und führen Sie den Knoten von der Konsole aus mit dem folgenden Befehl aus:

node server.js

Suchen Sie nach localhost: 8080

15
pasx

NUR DEMO/PROTO-SERVER

Wenn das alles ist, was Sie brauchen, versuchen Sie Folgendes:

const http = require('http');
const fs = require('fs');
const port = 3000;
const app = http.createServer((req,res) => {
    res.writeHead(200);
    if (req.url === '/') req.url = '/index.html'; // courtesy of @JosephCho
    res.end(fs.readFileSync(__dirname + req.url));
});

app.listen(port);

Hinweis: Sie müssen "/index.html" als Teil Ihrer Adresse verwenden, z. B. " http: // localhost: 3000/index.html "

13
Jacksonkr

One-Line ™ Proofs statt Versprechen

enter image description here

Der erste ist http-server, hs - link

npm i -g http-server   // install
hs C:\repos            // run with one line?? FTW!!

Der zweite ist serve von ZEIT.co - link

npm i -g serve         // install
serve C:\repos         // run with one line?? FTW!!

Die folgenden Optionen stehen zur Verfügung, wenn dies Ihre Entscheidung erleichtert.

 C:\Users\Qwerty> http-server --hilfe 
 Verwendung: http-server [pfad] [optionen] 
 
 Optionen: 
 -p Zu verwendender Port [8080] 
 -a Zu verwendende Adresse [0.0.0.0] 
 -d Verzeichnislisten anzeigen [true] 
 -i AutoIndex anzeigen [true] 
 -g --gzip Gzip-Dateien nach Möglichkeit bereitstellen [false] 
 -e --ext Standarddateierweiterung, wenn keine angegeben [none] 
 -s --silent Protokollnachrichten unterdrücken von output 
 --cors [= headers] CORS über den "Access-Control-Allow-Origin" -Header aktivieren 
 Optional die durch Kommas getrennte CORS-Header-Liste bereitstellen 
 -o [path] Öffnen Sie das Browserfenster nach dem Start des Servers 
 -C Cache-Zeit (maximales Alter) in Sekunden [3600], z -c10 für 10 Sekunden. 
 Zum Deaktivieren der Zwischenspeicherung verwenden Sie -c-1. 
 -U --utc UTC-Zeitformat in Protokollnachrichten verwenden. 
 
 - P --proxy Fallback-Proxy, wenn die Anforderung nicht aufgelöst werden kann. Beispiel: http://someurl.com 
 
 -S - ssl Aktiviert https. 
 -C - zertifizierter Pfad zur SSL-Zertifikatsdatei (Standard: cert.pem). 
 -K --key Pfad zur SSL-Schlüsseldatei (Standard: key.pem). 
 
 -R --robots Reagiert auf /robots.txt [User-agent: *\nDisallow: /
 -h --help Diese Liste drucken und beenden. 
 C:\Users\Qwerty> serve --help 
 
 Verwendung: serve.js [options] [command] 
 
 Befehle: 
 
 Hilfe Hilfe anzeigen 
 
 Optionen: 
 
 -a, --auth Serve behind basic auth 
 - c, --cache Zeit in Millisekunden für das Zwischenspeichern von Dateien im Browser 
 -n, --clipless Adresse nicht in die Zwischenablage kopieren (standardmäßig deaktiviert) 
 -C, --cors Setup * CORS-Header zum Zulassen von Anforderungen aus beliebigen Quellen (standardmäßig deaktiviert) 
 -H, --help Verwendungsinformationen ausgeben 
 -I, --ignore Dateien und Verzeichnisse zum Ignorieren von 
 -O , --open Lokale Adresse im Browser öffnen (standardmäßig deaktiviert) 
 -p, --port Port zum Abhören (standardmäßig 5000) 
 -S, --silent Keine Protokollierung an die Konsole 
 -s, --single Diene Anwendungen für einzelne Seiten (setzt "-c" auf 1 Tag) 
 -t, --treeless Statikbaum nicht anzeigen (standardmäßig deaktiviert) 
 -u, --unzipped GZIP-Komprimierung deaktivieren 
 -V, --version Versionsnummer ausgeben 

Wenn Sie auf Änderungen achten müssen, lesen Sie hostr , credit Henry Tsengs Antwort

10
Qwerty

Es gibt einen anderen statischen Webserver, der ganz nett ist: Browser-Sync.

Es kann mit dem Node Package Manager heruntergeladen werden:

npm install -g browser-sync

Navigieren Sie nach der Installation zum Projektordner in der cmd-Eingabeaufforderung und führen Sie einfach Folgendes aus:

browser-sync start --server --port 3001 --files="./*"

Es werden alle Dateien im aktuellen Ordner im Browser bereitgestellt.

Weitere Informationen finden Sie unter BrowserSync

Vielen Dank.

8
Samrat Debroy

Here ist mein Web-Server-Pet-Projekt mit einer Datei/Lightweight-Node.js statischer Datei und ohne Abhängigkeit, von dem ich glaube, dass es ein schnelles und umfangreiches Tool ist, dessen Verwendung so einfach ist, wie die Ausgabe dieses Befehls auf Ihrem Linux/Unix/macOS-Terminal (oder termux unter Android), wenn node.js (oder nodejs-legacy unter Debian/Ubuntu) installiert ist:

curl pad.js.org | node 

(Für Windows-Benutzer gibt es in der Dokumentation unterschiedliche Befehle)

Es unterstützt verschiedene Dinge, von denen ich glaube, dass sie nützlich sind.

  • Hierarchische Verzeichnisindexerstellung/-bereitstellung
    • Mit Sortiermöglichkeit nach den verschiedenen Kriterien
    • Hochladen aus dem Browser per [Mehrfachdatei] per Drag & Drop und Kopieren/Einfügen von Dateien/Texten sowie Einfügen von Screenshots in die Zwischenablage des Systems unter Chrome, Firefox und anderen Browsern kann mit einigen Einschränkungen verbunden sein (die über die Befehlszeile deaktiviert werden können) Optionen, die es bietet)
    • Schaltfläche zum Erstellen/Hochladen von Ordnern/Notizen
  • Bereitstellung korrekter MIMEs für bekannte Dateitypen (mit der Möglichkeit, diese zu deaktivieren)
  • Möglichkeit der Installation als npm-Paket und lokales Tool oder als einlineare Installation als permanenter Service mit Docker
  • HTTP 206 File Serving (mehrteilige Dateiübertragung) für schnellere Übertragungen
  • Uploads von der Terminal- und Browser-Konsole (ursprünglich als Dateisystem-Proxy für die JS-Konsole von Browsern auf anderen Seiten/Domänen gedacht)
  • CORS Download/Upload (auch abschaltbar)
  • Einfache HTTPS-Integration
  • Leichte Befehlszeilenoptionen für eine bessere sichere Bedienung:
    • Mit meinem Patch auf node.js 8 können Sie ohne Erstinstallation auf die Optionen zugreifen: curl pad.js.org | node - -h
    • Oder installieren Sie es zuerst als systemweites npm-Paket mit [Sudo] npm install -g pad.js und greifen Sie dann mit der installierten Version auf die Optionen zu: pad -h
    • Oder verwenden Sie das mitgelieferte Docker-Image, das standardmäßig relativ sichere Optionen verwendet. [Sudo] docker run --restart=always -v /files:/files --name pad.js -d -p 9090:9090 quay.io/ebraminio/pad.js

Screenshot of a folder index using the tool

Die oben beschriebenen Funktionen sind größtenteils auf der Hauptseite des Tools dokumentiert http://pad.js.org . Mit einem von mir verwendeten netten Trick ist dies auch der Ort, von dem aus die Tool-Quelle selbst auch bedient wird!

Die Tool-Quelle ist auf GitHub , was Ihr Feedback, Ihre Feature-Wünsche und Ihre Wünsche begrüßt!

6
Ebrahim Byagowi

Ich hatte mit keiner der Antworten auf dieser Seite viel Glück, aber die folgenden Antworten schienen den Trick zu tun.

Fügen Sie eine server.js -Datei mit folgendem Inhalt hinzu:

const express = require('express')
const path = require('path')
const port = process.env.PORT || 3000
const app = express()

// serve static assets normally
app.use(express.static(__dirname + '/dist'))

// handle every other route with index.html, which will contain
// a script tag to your application's JavaScript file(s).
app.get('*', function (request, response){
  response.sendFile(path.resolve(__dirname, 'dist', 'index.html'))
})

app.listen(port)
console.log("server started on port " + port)

Stellen Sie außerdem sicher, dass Sie express benötigen. Führen Sie yarn add express --save oder npm install express --save aus (ich kann yarn empfehlen, es ist ziemlich schnell).

Sie können dist in den Ordner ändern, in dem sich Ihre Inhalte befinden. Für mein einfaches Projekt habe ich kein Serving aus einem Ordner ausgeführt, daher habe ich einfach den Dateinamen dist entfernt.

Dann können Sie node server.js ausführen. Da ich mein Projekt auf einen Heroku-Server hochladen musste, musste ich meiner package.json -Datei Folgendes hinzufügen:

  "scripts": {
    "start": "node server.js"
  }
6
FooBar

Wenn Sie das Express-Framework verwenden, ist diese Funktionalität sofort einsatzbereit.

Gehen Sie wie folgt vor, um eine einfache Dateiserving-App einzurichten:

mkdir yourapp
cd yourapp
npm install express
node_modules/express/bin/express
6
Daniel

Für eine gesunde Leistungssteigerung mit Node zur Bereitstellung statischer Ressourcen empfehle ich Buffet . Es funktioniert ähnlich wie ein Webanwendungsbeschleuniger, der auch als Caching-HTTP-Reverse-Proxy bezeichnet wird, lädt jedoch nur das ausgewählte Verzeichnis in den Speicher.

Buffet verwendet einen vollständig gepufferten Ansatz - alle Dateien werden beim Start der App vollständig in den Speicher geladen, sodass Sie das Brennen des Dateisystems nie spüren werden. In der Praxis ist dies immens effizient. So sehr, dass es möglicherweise sogar langsamer wird, wenn Sie Varnish vor Ihre App stellen!

Wir verwenden es auf der CodePile-Site und haben einen Anstieg von ~ 700 Anfragen/Sek. Auf> 4.000 Anfragen/Sek. Auf einer Seite festgestellt, auf der 25 Ressourcen bei einer gleichzeitigen Belastung von 1.000 Benutzerverbindungen heruntergeladen werden.

Beispiel:

var server = require('http').createServer();

var buffet = require('buffet')(root: './file'); 

 

server.on('request', function (req, res) {

  buffet(req, res, function () {

    buffet.notFound(req, res);

  });

});

 

server.listen(3000, function () {

  console.log('test server running on port 3000');

});
4
user742030

Schauen Sie sich das an link .

Sie müssen nur das Express-Modul von node js installieren.

var express = require('express');
var app = express();

app.use('/Folder', express.static(__dirname + '/Folder'));

Sie können auf Ihre Datei wie folgt zugreifen: http: //hostname/Folder/file.Zip

4
Syed Ali hassan

Hier ist ein weiterer einfacher Webserver.

https://www.npmjs.com/package/hostr

Installieren

npm install -g hostr

Arbeitsdirektor wechseln

cd myprojectfolder/

Und Start

hostr
3
Henry Tseng

Du kannst versuchen diene mir

So einfach geht's:

ServeMe = require('serve-me')();
ServeMe.start(3000);

Das ist alles.

PD: Der standardmäßig bereitgestellte Ordner ist "öffentlich".

3
muit

Installieren Sie zuerst den Node-Static Server über npm install node-static -g -g, um ihn global auf Ihrem System zu installieren. Navigieren Sie dann zu dem Verzeichnis, in dem sich Ihre Dateien befinden, und starten Sie den Server mit static zum Browser und tippe localhost: 8080/yourhtmlfilename.

2
samba

Zum Wohle der Suchenden mochte ich die Antwort von Jakub g, wollte aber eine kleine Fehlerbehandlung. Offensichtlich ist es am besten, Fehler zu behandeln richtig , aber dies sollte dazu beitragen, zu verhindern, dass eine Site beim Auftreten eines Fehlers angehalten wird. Code unten:

var http = require('http');
var express = require('express');

process.on('uncaughtException', function(err) {
  console.log(err);
});

var server = express();

server.use(express.static(__dirname));

var port = 10001;
server.listen(port, function() { 
    console.log('listening on port ' + port);     
    //var err = new Error('This error won't break the application...')
    //throw err
});
2
HockeyJ
const http = require('http');
const fs = require('fs');
const url = require('url');
const path = require('path');


let mimeTypes = {
  '.html': 'text/html',
  '.css': 'text/css',
  '.js': 'text/javascript',
  '.jpg': 'image/jpeg',
  '.png': 'image/png',
  '.ico': 'image/x-icon',
  '.svg': 'image/svg+xml',
  '.eot': 'appliaction/vnd.ms-fontobject',
  '.ttf': 'aplication/font-sfnt'
};



http.createServer(function (request, response) {
  let pathName = url.parse(request.url).path;
  if(pathName === '/'){
    pathName = '/index.html';
  }
  pathName = pathName.substring(1, pathName.length);
  let extName = path.extName(pathName);
  let staticFiles = `${__dirname}/template/${pathName}`;

      if(extName =='.jpg' || extName == '.png' || extName == '.ico' || extName == '.eot' || extName == '.ttf' || extName == '.svg')
      {
          let file = fr.readFileSync(staticFiles);
          res.writeHead(200, {'Content-Type': mimeTypes[extname]});
          res.write(file, 'binary');
          res.end();
      }else {
        fs.readFile(staticFiles, 'utf8', function (err, data) {
          if(!err){
            res.writeHead(200, {'Content-Type': mimeTypes[extname]});
            res.end(data);
          }else {
            res.writeHead(404, {'Content-Type': 'text/html;charset=utf8'});
            res.write(`<strong>${staticFiles}</strong>File is not found.`);
          }
          res.end();
        });
      }
}).listen(8081);
2
Slava Nazaryan

Es ist noch kein NPM-Server, aber ich habe auf Express einen einfachen statischen Server erstellt, mit dem Sie auch Formularübermittlungen akzeptieren und über einen Transaktions-E-Mail-Dienst per E-Mail versenden können (Sendgrid für jetzt, Mandrill kommt).

https://github.com/jdr0dn3y/nodejs-StatServe

2
jdr0dn3y

Wenn Sie sich für ultraleichten HTTP-Server ohne jegliche Voraussetzungen interessieren, sollten Sie sich Folgendes ansehen: Mungo

1
yossico

Für Entwicklerarbeiten können Sie (express 4) https://github.com/appsmatics/simple-httpserver.git verwenden

1
appsmatics

Sie können dafür das NPM serve -Paket verwenden. Wenn Sie das NodeJS-Zeug nicht benötigen, ist es ein schnelles und einfach zu verwendendes Tool:

1 - Installieren Sie das Paket auf Ihrem PC:

npm install -g serve

2 - Serviere deinen statischen Ordner mit serve <path>:

d:> serve d:\StaticSite

Es wird Ihnen angezeigt, welcher Port Ihres statischen Ordners bedient wird. Navigieren Sie einfach zum Host wie folgt:

http://localhost:3000
1
Diego Mendes

Bei der Suche in der NPM-Registrierung https://npmjs.org/search?q=server habe ich static-server https://github.com/maelstrom/static-server gefunden =

Mussten Sie schon einmal einem Kollegen eine Datei schicken, können sich aber nicht darum kümmern, dem 100-MB-Biest eine E-Mail zu schicken? Sie wollten eine einfache JavaScript-Beispielanwendung ausführen, hatten jedoch Probleme, sie über das Protokoll file: /// auszuführen? Wollten Sie Ihr Medienverzeichnis in einem LAN freigeben, ohne Samba oder FTP einzurichten, oder etwas anderes, bei dem Sie Konfigurationsdateien bearbeiten müssen? Dann wird Ihnen dieser Dateiserver das Leben ein wenig erleichtern.

Verwenden Sie npm, um den einfachen statischen Zeug-Server zu installieren:

npm install -g static-server

Führen Sie dann einfach Folgendes aus, um eine Datei oder ein Verzeichnis bereitzustellen

$ serve path/to/stuff
Serving path/to/stuff on port 8001

Das könnte sogar Ordnerinhalte auflisten.

Leider Dateien konnten nicht bereitgestellt werden :)

1
Paul Verest

Ein einfacher Static-Server mit connect

var connect = require('connect'),
  directory = __dirname,
  port = 3000;

connect()
  .use(connect.logger('dev'))
  .use(connect.static(directory))
  .listen(port);

console.log('Listening on port ' + port);

Siehe auch Verwenden von node.js als einfachen Webserver

1
dreampulse

Sie haben auch gefragt, warum Anfragen fallengelassen werden - nicht sicher, aus welchem ​​Grund Ihr Fall vorliegt, aber insgesamt sind Sie besser in der Lage, statische Inhalte von Servern mit dedizierter Middleware (nginx, S3, CDN) zu verarbeiten, da Node wirklich nicht dafür optimiert ist Netzwerkmuster. Weitere Erklärungen finden Sie hier (Punkt 13): http://goldbergyoni.com/checklist-best-practice-of-node-js-in-production/

0
Yonatan

Unten hat für mich gearbeitet:

Erstellen Sie eine Datei app.js mit folgendem Inhalt:

// app.js

var fs = require('fs'),
    http = require('http');

http.createServer(function (req, res) {
  fs.readFile(__dirname + req.url, function (err,data) {
    if (err) {
      res.writeHead(404);
      res.end(JSON.stringify(err));
      return;
    }
    res.writeHead(200);
    res.end(data);
  });
}).listen(8080);

Starten Sie eine Befehlszeile:

cmd

Führen Sie unten in cmd:

node app.js

Erstellen Sie einen index.html mit dem folgenden Inhalt

Hi

Gehe zu URL unten, in Chrom:

http://localhost:8080/index.html

Quelle: https://nodejs.org/en/knowledge/HTTP/servers/how-to-serve-static-files/

Ich hoffe, das hilft.

Ich benutze Houston bei der Arbeit und für persönliche Projekte funktioniert es gut für mich.

https://github.com/alejandro/Houston

0
matthewtole