Sto cercando di creare un file server statico in nodejs più come esercizio per comprendere node che come server perfetto. Conosco bene progetti come Connect e node-static e intendo utilizzare queste librerie per un codice più pronto per la produzione, ma mi piace anche capire le basi di ciò con cui sto lavorando. Con questo in mente, ho programmato un piccolo server.js:

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);

La mia domanda è duplice

1. È questo il modo "giusto" per creare e trasmettere in streaming html di base ecc. In node o esiste un metodo migliore / più elegante / più robusto?

2. Il .pipe () nel nodo fondamentalmente sta solo facendo quanto segue?

.

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

Grazie a tutti!

• Il tuo server di base sembra buono, tranne:

  Manca una returndichiarazione.

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

  E:

  res.writeHead(200, mimeType);

  dovrebbe essere:

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

• Sì pipe(), fondamentalmente, mette in pausa / riprende il flusso di origine (nel caso in cui il ricevitore sia più lento). Ecco il codice sorgente della pipe()funzione: https://github.com/joyent/node/blob/master/lib/stream.js

Meno è meglio

Vai prima al prompt dei comandi sul tuo progetto e usa

$ npm install express

Quindi scrivi il tuo codice app.js in questo modo:

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

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

Dovresti quindi creare una cartella "pubblica" in cui posizionare i file. Ho provato prima nel modo più difficile, ma devi preoccuparti dei tipi MIME che devono solo mappare cose che richiedono tempo e poi preoccuparti dei tipi di risposta, ecc. Ecc. Ecc .... no grazie.

Mi piace anche capire cosa sta succedendo sotto il cofano.

Ho notato alcune cose nel tuo codice che probabilmente vorresti ripulire:

• Si blocca quando filename punta a una directory, perché esiste è vero e cerca di leggere un flusso di file. Ho usato fs.lstatSync per determinare l'esistenza della directory.

• Non utilizza correttamente i codici di risposta HTTP (200, 404, ecc.)

• Mentre MimeType viene determinato (dall'estensione del file), non viene impostato correttamente in res.writeHead (come ha sottolineato Stewe)

• Per gestire caratteri speciali, probabilmente vorrai annullare l'escape dell'uri

• Segue ciecamente i collegamenti simbolici (potrebbe essere un problema di sicurezza)

Detto questo, alcune delle opzioni di Apache (FollowSymLinks, ShowIndexes, ecc.) Iniziano ad avere più senso. Ho aggiornato il codice per il tuo semplice file server come segue:

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]))

Che ne dici di questo modello, che evita di controllare separatamente che il file esista

        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);

Ho creato una funzione httpServer con funzionalità extra per uso generale basata sulla risposta di @Jeff Ward

1. custtom dir
2. index.html restituisce se req === dir

Utilizzo:

httpServer(dir).listen(port);

https://github.com/kenokabe/ConciseStaticHttpServer

Grazie.

il modulo st semplifica la gestione dei file statici. Ecco un estratto di 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)

La risposta di @ JasonSebring mi ha indicato nella giusta direzione, tuttavia il suo codice è obsoleto. Ecco come lo fai con la connectversione più recente.

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);

In connect GitHub Repository ci sono altri middleware che puoi usare.