Ich versuche, einen statischen Dateiserver in nodejs eher als Übung zum Verständnis von node als als perfekten Server zu erstellen. Ich kenne Projekte wie Connect und Node-Static sehr gut und beabsichtige, diese Bibliotheken für produktionsfähigeren Code zu verwenden, aber ich verstehe auch gerne die Grundlagen meiner Arbeit. In diesem Sinne habe ich eine kleine server.js codiert:

var http = require('http'),
    url = require('url'),
    path = require('path'),
    fs = require('fs');
var mimeTypes = {
    "html": "text/html",
    "jpeg": "image/jpeg",
    "jpg": "image/jpeg",
    "png": "image/png",
    "js": "text/javascript",
    "css": "text/css"};

http.createServer(function(req, res) {
    var uri = url.parse(req.url).pathname;
    var filename = path.join(process.cwd(), uri);
    path.exists(filename, function(exists) {
        if(!exists) {
            console.log("not exists: " + filename);
            res.writeHead(200, {'Content-Type': 'text/plain'});
            res.write('404 Not Found\n');
            res.end();
        }
        var mimeType = mimeTypes[path.extname(filename).split(".")[1]];
        res.writeHead(200, mimeType);

        var fileStream = fs.createReadStream(filename);
        fileStream.pipe(res);

    }); //end path.exists
}).listen(1337);

Meine Frage ist zweifach

1. Ist dies der "richtige" Weg, um grundlegende HTML-Dateien usw. im Knoten zu erstellen und zu streamen, oder gibt es eine bessere / elegantere / robustere Methode?

2. Tut die .pipe () im Knoten im Grunde nur Folgendes?

.

var fileStream = fs.createReadStream(filename);
fileStream.on('data', function (data) {
    res.write(data);
});
fileStream.on('end', function() {
    res.end();
});

Vielen Dank an alle!

• Ihr Basisserver sieht gut aus, außer:

  Es returnfehlt eine Aussage.

  res.write('404 Not Found\n');
  res.end();
  return; // <- Don't forget to return here !!
  

  Und:

  res.writeHead(200, mimeType);

  sollte sein:

  res.writeHead(200, {'Content-Type':mimeType});

• Ja pipe()macht das im Grunde, es pausiert / setzt auch den Quellstrom fort (falls der Empfänger langsamer ist). Hier ist der Quellcode der pipe()Funktion: https://github.com/joyent/node/blob/master/lib/stream.js

Weniger ist mehr

Gehen Sie einfach zuerst zur Eingabeaufforderung Ihres Projekts und verwenden Sie

$ npm install express

Dann schreiben Sie Ihren app.js Code wie folgt:

var express = require('express'),
app = express(),
port = process.env.PORT || 4000;

app.use(express.static(__dirname + '/public'));
app.listen(port);

Sie würden dann einen "öffentlichen" Ordner erstellen, in dem Sie Ihre Dateien ablegen. Ich habe es zuerst auf die härtere Weise versucht, aber Sie müssen sich um MIME-Typen kümmern, die nur zeitaufwändige Dinge zuordnen müssen, und sich dann um Antworttypen usw. usw. usw. kümmern. Nein, danke.

Ich mag es auch zu verstehen, was unter der Haube vor sich geht.

Ich habe einige Dinge in Ihrem Code bemerkt, die Sie wahrscheinlich bereinigen möchten:

• Es stürzt ab, wenn der Dateiname auf ein Verzeichnis verweist, da exist wahr ist und versucht wird, einen Dateistream zu lesen. Ich habe fs.lstatSync verwendet, um die Existenz eines Verzeichnisses zu bestimmen.

• Die HTTP-Antwortcodes werden nicht korrekt verwendet (200, 404 usw.)

• Während MimeType ermittelt wird (aus der Dateierweiterung), wird es in res.writeHead nicht richtig eingestellt (wie von stewe hervorgehoben).

• Um mit Sonderzeichen umzugehen, möchten Sie wahrscheinlich den Uri verlassen

• Es folgt blind Symlinks (könnte ein Sicherheitsrisiko sein)

Vor diesem Hintergrund sind einige der Apache-Optionen (FollowSymLinks, ShowIndexes usw.) sinnvoller. Ich habe den Code für Ihren einfachen Dateiserver wie folgt aktualisiert:

var http = require('http'),
    url = require('url'),
    path = require('path'),
    fs = require('fs');
var mimeTypes = {
    "html": "text/html",
    "jpeg": "image/jpeg",
    "jpg": "image/jpeg",
    "png": "image/png",
    "js": "text/javascript",
    "css": "text/css"};

http.createServer(function(req, res) {
  var uri = url.parse(req.url).pathname;
  var filename = path.join(process.cwd(), unescape(uri));
  var stats;

  try {
    stats = fs.lstatSync(filename); // throws if path doesn't exist
  } catch (e) {
    res.writeHead(404, {'Content-Type': 'text/plain'});
    res.write('404 Not Found\n');
    res.end();
    return;
  }


  if (stats.isFile()) {
    // path exists, is a file
    var mimeType = mimeTypes[path.extname(filename).split(".").reverse()[0]];
    res.writeHead(200, {'Content-Type': mimeType} );

    var fileStream = fs.createReadStream(filename);
    fileStream.pipe(res);
  } else if (stats.isDirectory()) {
    // path exists, is a directory
    res.writeHead(200, {'Content-Type': 'text/plain'});
    res.write('Index of '+uri+'\n');
    res.write('TODO, show index?\n');
    res.end();
  } else {
    // Symbolic link, other?
    // TODO: follow symlinks?  security?
    res.writeHead(500, {'Content-Type': 'text/plain'});
    res.write('500 Internal server error\n');
    res.end();
  }

}).listen(1337);

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

var server = http.createServer(function (req, res) {
  res.writeHead(200, { 'content-type': 'text/plain' })

  fs.createReadStream(process.argv[3]).pipe(res)
})

server.listen(Number(process.argv[2]))

Wie wäre es mit diesem Muster, bei dem nicht separat überprüft wird, ob die Datei vorhanden ist

        var fileStream = fs.createReadStream(filename);
        fileStream.on('error', function (error) {
            response.writeHead(404, { "Content-Type": "text/plain"});
            response.end("file not found");
        });
        fileStream.on('open', function() {
            var mimeType = mimeTypes[path.extname(filename).split(".")[1]];
            response.writeHead(200, {'Content-Type': mimeType});
        });
        fileStream.on('end', function() {
            console.log('sent file ' + filename);
        });
        fileStream.pipe(response);

Ich habe eine httpServer-Funktion mit zusätzlichen Funktionen für den allgemeinen Gebrauch basierend auf der Antwort von @Jeff Ward erstellt

1. custtom dir
2. index.html gibt zurück, wenn req === dir

Verwendung:

httpServer(dir).listen(port);

https://github.com/kenokabe/ConciseStaticHttpServer

Vielen Dank.

Das st-Modul erleichtert das Bereitstellen statischer Dateien. Hier ist ein Auszug aus README.md:

var mount = st({ path: __dirname + '/static', url: '/static' })
http.createServer(function(req, res) {
  var stHandled = mount(req, res);
  if (stHandled)
    return
  else
    res.end('this is not a static file')
}).listen(1338)

@ JasonSebring Antwort zeigte mir in die richtige Richtung, aber sein Code ist veraltet. So machen Sie es mit der neuesten connectVersion.

var connect = require('connect'),
    serveStatic = require('serve-static'),
    serveIndex = require('serve-index');

var app = connect()
    .use(serveStatic('public'))
    .use(serveIndex('public', {'icons': true, 'view': 'details'}))
    .listen(3000);

Im connect GitHub Repository gibt es andere Middlewares, die Sie verwenden können.