File server rapido Node.js (file statici su HTTP)


642

Esiste uno strumento pronto per l'uso di Node.js (installato con npm), che mi aiuterebbe a esporre il contenuto delle cartelle come file server su HTTP.

Esempio, se ho

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

Quindi a partire da D:\Folder\ node node-file-server.js ho potuto accedere al file tramite

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

Perché il mio file server statico del nodo elimina le richieste? fare riferimento ad alcuni mistici

file server statico standard node.js

Se non esiste tale strumento, quale framework dovrei usare?

Correlati: file server statico di base in NodeJS


Ho scritto un modulo chiamato Cachemere che ti consente di farlo. Inoltre, memorizza automaticamente nella cache tutte le risorse. Dai
Jon

npmjs.com/package/local-web-server - server web statico leggero, configurazione zero
Victor

Risposte:


1092

Una buona opzione "strumento pronto per l'uso" potrebbe essere http-server:

npm install http-server -g

Per usarlo:

cd D:\Folder
http-server

Oppure, in questo modo:

http-server D:\Folder

Dai un'occhiata: https://github.com/nodeapps/http-server


10
Questo è bellissimo. Ho dovuto specificare un indirizzo bc per qualche motivo il valore predefinito 0.0.0.0 non cooperava con il mio ambiente di sviluppo. http-server -a localhostottenuto er dun.
Sam Berry,

41
io usohttp-server -a localhost -p 80
Muhammad Umer il

10
Vale la pena controllare anche la sincronizzazione del browser , che può fare più o meno la stessa cosa ma con l'aggiunta del bonus di aggiornamento live quando i file vengono modificati.
Nick F,

3
--corsper inviare Access-Control-Allow-Origin:*insieme alle intestazioni di risposta (ovvero quando si pubblica un file json)
Daniel F,

9
npx http-server- npx lo trasforma in un one-liner che scarica i file necessari e lo esegue.
Mike McKay,

186

Se non si desidera utilizzare lo strumento pronto, è possibile utilizzare il codice seguente, come dimostrato da me su https://developer.mozilla.org/en-US/docs/Node_server_without_framework :

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

AGGIORNAMENTO Se è necessario accedere al server da domanda / file esterni, è necessario superare CORS, nel file node.js scrivendo quanto segue, come ho menzionato in una risposta precedente qui

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

AGGIORNARE

Come Adrian ha menzionato, nei commenti, ha scritto un codice ES6 con una spiegazione completa qui , sto solo ripubblicando il suo codice di seguito, nel caso in cui il codice sia passato dal sito originale per qualsiasi motivo:

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

2
Sicuramente, response.writeHead(200dovrebbe essere response.writeHead(404;)
Thomas Hunter II,

14
Quel codice non consentirebbe di salire sull'albero dei file facendo qualcosa come 127.0.0.1/../../../etc/passwd ? Non vedo assegni contro quello.
Rolf

3
Se qualcuno fosse interessato alla versione ES6 +, ho creato un file server statico che gestisce i tipi MIME: gist.github.com/amejiarosario/53afae82e18db30dadc9bc39035778e5
Adrian

1
@Adrian Questo codice è fantastico, ma ho trovato un modo per ottenere l'accesso root con esso. La soluzione è limitare la quantità di periodi iniziali sul nome file a uno in modo da non poter fare ../../etc/passwordcose. gist.github.com/amejiarosario/53afae82e18db30dadc9bc39035778e5
Reed

1
pathname = pathname.replace(/^(\.)+/, '.');
Seph Reed,

79

Per le persone che desiderano eseguire un server eseguibile all'interno dello script NodeJS:

Puoi usare expressjs / serve-static che sostituisce connect.static(che non è più disponibile a partire da connect 3):

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

e quindi dalla riga di comando:

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

1
FYI Questo non ha funzionato per me. Ho installato il filehandler usando npm install filehandlere il pacchetto è elencato nella node_modulesdirectory. Ma quando eseguo il myapp.jsnodo genera un errore, dicendo Error: cannot find module filehandler. Se commento lo ststment richiesto per caricare il filehandler, l'app carica bene-statico, quindi sembra che ci sia qualcosa di sbagliato nel pacchetto filhandler. Oggi è il 12 dicembre 2014, quindi forse il pacchetto è cambiato da quando è stata pubblicata questa risposta?
Lee Jenkins,

7
Non è un finalgestorefile
jakub.g

un altro vantaggio di questa soluzione è che i file non sono memorizzati nella cache, quindi non è necessario riavviare un processo quando si apportano modifiche al codice.
klimat,

59

So che non è Node, ma ho usato SimpleHTTPServer di Python:

python -m SimpleHTTPServer [port]

Funziona bene e viene fornito con Python.


16
Python3 equivalente: python -m http.server [port](quello menzionato è per Python2)
jakub.g

Python fallisce per me quando si tratta di servire file di grandi dimensioni come le immagini del sistema operativo. Fedora 23
Zimy,

9
E su PHP:php -S localhost:8000
dennis l'

Lo uso per pubblicare rapidamente contenuti da una cartella in qualsiasi momento.
Adrian Lynch,

33

connect potrebbe essere quello che stai cercando.

Installato facilmente con:

npm install connect

Quindi il file server statico più semplice potrebbe essere scritto come:

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

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

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

4
Questo non funziona più a partire da connect 3 in quanto non espone connect.static; vedere la mia risposta di seguito per una sostituzione
jakub.g

4
Credo che sia ancora in bundle con express per impostazione predefinita, ma effettivamente esiste ora in un requiremodulo separato separato "serve-statico".
Oleg,

18

Installa express usando npm: https://expressjs.com/en/starter/installing.html

Crea un file chiamato server.js allo stesso livello di index.html con questo contenuto:

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

Se desideri inserirlo in una posizione diversa, imposta il percorso sulla terza riga:

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

CD nella cartella contenente il file ed eseguire il nodo dalla console con questo comando:

node server.js

Passare a localhost: 8080


1
Ciao, posso eseguirlo correttamente, ma mostra Cannot GET /. Uso AWS EC2 per eseguire il server.
Wei Xia,

1
@Wei Ciao, risposta in ritardo. Da quello che posso vedere da una rapida ricerca su Google sembra che la tua struttura di directory potrebbe essere sbagliata. Deve esserci un file index.html nella posizione di destinazione. L'impostazione dell'esempio sopra per l'esecuzione dovrebbe richiedere 5 minuti e ho ricontrollato che funzioni così com'è. Da lì è possibile modificare il percorso in base alla struttura della directory e verificare che il server trovi ancora i file necessari per il server.
pasx,

path.join(__dirname, 'public')è più multipiattaforma.
sdgfsdh,

17

Prove One-line ™ anziché promesse

inserisci qui la descrizione dell'immagine

Il primo è http-server, hs- link

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

Il secondo è servedi ZEIT.co - link

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

Di seguito sono disponibili le opzioni, se questo è ciò che ti aiuta a decidere.

C: \ Users \ Qwerty> http-server --help
utilizzo: http-server [percorso] [opzioni]

opzioni:
  -p Porta da usare [8080]
  -a indirizzo da usare [0.0.0.0]
  -d Mostra gli elenchi di directory [true]
  -i Visualizza autoIndex [true]
  -g --gzip Serve file gzip quando possibile [falso]
  -e --ext Estensione di file predefinita se nessuna fornita [nessuna]
  -s --silent Elimina i messaggi di registro dall'output
  --cors [= headers] Abilita CORS tramite l'intestazione "Access-Control-Allow-Origin"
                     Facoltativamente, fornire un elenco di intestazioni CORS separato da virgole
  -o [percorso] Apre la finestra del browser dopo aver avviato il server
  -c Tempo di cache (età massima) in secondi [3600], ad esempio -c10 per 10 secondi.
               Per disabilitare la memorizzazione nella cache, utilizzare -c-1.
  -U --utc Utilizza il formato ora UTC nei messaggi di registro.

  -P - proxy fallback proxy se la richiesta non può essere risolta. ad es .: http://someurl.com

  -S --ssl Abilita https.
  -C --cert Percorso del file ssl cert (impostazione predefinita: cert.pem).
  -K --key Percorso del file chiave ssl (impostazione predefinita: key.pem).

  -r --robots Rispondi a /robots.txt [User-agent: * \ nDisallow: /]
  -h --help Stampa questo elenco ed esce.
C: \ Users \ Qwerty> serve --help

  Utilizzo: serve.js [opzioni] [comando]

  comandi:

    help Visualizza aiuto

  Opzioni:

    -a, --auth Servire dietro l'autenticazione di base
    -c, --cache Tempo in millisecondi per la memorizzazione nella cache dei file nel browser
    -n, --clipless Non copiare l'indirizzo negli Appunti (disabilitato per impostazione predefinita)
    -C, --cors Setup * Intestazioni CORS per consentire richieste da qualsiasi origine (disabilitato per impostazione predefinita)
    -h, --help Informazioni sull'utilizzo dell'output
    -i, --ignore File e directory da ignorare
    -o, --open Apri l'indirizzo locale nel browser (disabilitato per impostazione predefinita)
    -p, --port Port su cui ascoltare (il valore predefinito è 5000)
    -S, --silent Non registra nulla sulla console
    -s, --single Serve applicazioni a pagina singola (imposta `-c` su 1 giorno)
    -t, --treeless Non visualizzare l'albero statico (disabilitato per impostazione predefinita)
    -u, --unzipped Disabilita la compressione GZIP
    -v, --version Emette il numero di versione

Se hai bisogno di guardare per i cambiamenti, vedi hostr, accredita la risposta di Henry Tseng


14

SOLO SERVER DEMO / PROTO

Se è tutto ciò di cui hai bisogno, prova questo:

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

nota: è necessario utilizzare "/index.html" come parte del proprio indirizzo, ad esempio " http: // localhost: 3000 / index.html "


2
Non utilizzare la versione di sincronizzazione. Istruzioni per creare pipe per res da readStream.
Eduard Bondarenko,

1
La migliore risposta se hai bisogno di un pony una tantum veloce e sporco.
collapsar

1
Se vuoi evitare di utilizzare index.htmlcome parte del tuo indirizzo, aggiungi if (req.url === '/') req.url = '/index.html';subito dopo res.writeHead(200);.
Joseph Cho,

3
@EduardBondarenko ha ragione. const stream = fs.createReadStream(...); stream.pipe(res);è tutto ciò di cui hai bisogno
Justin Meiners,

8

C'è un altro server web statico che è abbastanza carino: sincronizzazione del browser.

Può essere scaricato utilizzando il gestore pacchetti nodo:

npm install -g browser-sync

Dopo l'installazione, accedere alla cartella del progetto nel prompt cmd ed eseguire semplicemente quanto segue:

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

Inizierà il catering di tutti i file nella cartella corrente nel browser.

Altre informazioni sono disponibili su BrowserSync

Grazie.


2
Il vantaggio dell'utilizzo di Browsersync piuttosto che di altri server statici è che aggiorna la pagina in tempo reale ogni volta che --filescambiano i file specificati dal flag (nb. Non è necessario specificare ./*- solo quelli che si desidera che Browsersync attivamente cerchi aggiornamenti, ad es. . css/*.css)
Nick F,

7

Non ho avuto molta fortuna con nessuna delle risposte in questa pagina, tuttavia, di seguito sembrava fare il trucco.

Aggiungi un server.jsfile con il seguente contenuto:

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)

Assicurati anche di aver bisogno express. Esegui yarn add express --saveo a npm install express --saveseconda della configurazione (posso consigliare yarnche è abbastanza veloce).

È possibile passare dista qualsiasi cartella si sta offrendo il contenuto. Per il mio semplice progetto, non stavo servendo da nessuna cartella, quindi ho semplicemente rimosso il distnome file.

Quindi puoi correre node server.js. Dato che dovevo caricare il mio progetto su un server Heroku, dovevo aggiungere quanto segue al mio package.jsonfile:

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

6

Se si utilizza il framework Express , questa funzionalità è pronta per l'uso.

Per configurare un'app di file semplice, basta fare questo:

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

Posso $ npm installare -g express; loro $ express?
Paul Verest,

Ho seguito i tuoi passi, ma il mio espresso non ha una cartella bin
Qwerty,

6

Ecco il mio progetto per pet-web server web statico a file singolo / leggero node.js senza alcuna dipendenza che credo sia uno strumento rapido e ricco che il suo utilizzo è facile come emettere questo comando sul tuo terminale Linux / Unix / macOS ( o termux su Android) quando nodejs-legacyè installato node.js (o su Debian / Ubuntu):

curl pad.js.org | node 

(esistono diversi comandi per gli utenti Windows nella documentazione)

Supporta diverse cose che ritengo possano essere utili,

  • Creazione / pubblicazione dell'indice di directory gerarchiche
    • Con capacità di ordinamento sui diversi criteri
    • Il caricamento dal browser tramite [multi-file] trascina e rilascia e copia / incolla file / solo testo e copia schermo negli Appunti di sistema su Chrome, Firefox e altri browser potrebbe presentare alcune limitazioni (che possono essere disattivate dalla riga di comando opzioni che fornisce)
    • Pulsante cartella / creazione note / caricamento
  • Fornire MIME corretti per tipi di file noti (con possibilità di disabilitarlo)
  • Possibilità di installazione come pacchetto npm e strumento locale o, installazione lineare come servizio permanente con Docker
  • Pubblicazione di file HTTP 206 (trasferimento di file in più parti) per trasferimenti più veloci
  • Upload da terminale e console del browser (in effetti era originariamente inteso come proxy del file system per la console dei browser JS su altre pagine / domini)
  • Download / upload CORS (che possono anche essere disattivati)
  • Facile integrazione HTTPS
  • Opzioni della riga di comando leggere per ottenere una migliore sicurezza in servizio con esso:
    • Con la mia patch su node.js 8 , puoi avere accesso alle opzioni senza prima installazione:curl pad.js.org | node - -h
    • O prima installalo come pacchetto npm globale del sistema [sudo] npm install -g pad.jse poi usa la sua versione installata per avere accesso alle sue opzioni:pad -h
    • Oppure utilizza l'immagine Docker fornita che utilizza le opzioni relativamente sicure per impostazione predefinita. [sudo] docker run --restart=always -v /files:/files --name pad.js -d -p 9090:9090 quay.io/ebraminio/pad.js

Schermata di un indice di una cartella utilizzando lo strumento

Le funzionalità sopra descritte sono per lo più documentate nella pagina principale dello strumento http://pad.js.org che, per qualche bel trucco che ho usato, è anche il luogo da cui viene servita anche la fonte dello strumento stesso!

La fonte dello strumento è su GitHub che accoglie i tuoi feedback, richieste di funzionalità e così via!


5

Da npm@5.2.0, ha npminiziato l'installazione di un nuovo binario accanto al solito npm chiamato npx. Quindi ora, una fodera per creare un server http statico dalla directory corrente:

npx serve

o

npx http-server

4

Per un sano aumento delle prestazioni usando il nodo per servire risorse statiche, consiglio di usare Buffet . Funziona in modo simile a un acceleratore di applicazioni Web noto anche come proxy inverso HTTP con memorizzazione nella cache, ma carica semplicemente la directory scelta in memoria.

Buffet adotta un approccio completamente bufferizzato: tutti i file vengono caricati completamente in memoria all'avvio dell'app, quindi non sentirai mai la bruciatura del filesystem. In pratica, questo è immensamente efficiente. Tanto che mettere Varnish davanti alla tua app potrebbe anche renderlo più lento! 

Lo usiamo sul sito codePile e abbiamo riscontrato un aumento di ~ 700 richieste / sec a> 4k richieste / sec su una pagina che scarica 25 risorse con un carico di connessione utente simultaneo di 1k.

Esempio:

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

Di seguito ha funzionato per me:

Crea un file app.jscon i seguenti contenuti:

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

Crea un file index.htmlcon i seguenti contenuti:

Hi

Avvia una riga di comando:

cmd

Esegui di seguito in cmd:

node app.js

Vai sotto l'URL, in Chrome:

http://localhost:8080/index.html

È tutto. Spero che aiuti.

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


3

Puoi provare a servirmi

Usarlo è così semplice:

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

È tutto.

PD: la cartella servita per impostazione predefinita è "pubblica".



3

In node.js semplice:

const http = require('http')
const fs = require('fs')
const path = require('path')

process.on('uncaughtException', err => console.error('uncaughtException', err))
process.on('unhandledRejection', err => console.error('unhandledRejection', err))

const publicFolder = process.argv.length > 2 ? process.argv[2] : '.'
const port = process.argv.length > 3 ? process.argv[3] : 8080

const mediaTypes = {
  zip: 'application/zip',
  jpg: 'image/jpeg',
  html: 'text/html',
  /* add more media types */
}

const server = http.createServer(function(request, response) {
  console.log(request.method + ' ' + request.url)

  const filepath = path.join(publicFolder, request.url)
  fs.readFile(filepath, function(err, data) {
    if (err) {
      response.statusCode = 404
      return response.end('File not found or you made an invalid request.')
    }

    let mediaType = 'text/html'
    const ext = path.extname(filepath)
    if (ext.length > 0 && mediaTypes.hasOwnProperty(ext.slice(1))) {
      mediaType = mediaTypes[ext.slice(1)]
    }

    response.setHeader('Content-Type', mediaType)
    response.end(data)
  })
})

server.on('clientError', function onClientError(err, socket) {
  console.log('clientError', err)
  socket.end('HTTP/1.1 400 Bad Request\r\n\r\n')
})

server.listen(port, '127.0.0.1', function() {
  console.log('👨‍🔧 Development server is online.')
})

Questo è un semplice server node.js che serve solo i file richiesti in una determinata directory.

Uso:

node server.js folder port

folderpuò essere assoluto o relativo a seconda della server.jsposizione. Il valore predefinito .è la directory in cui si esegue il node server.jscomando.

port è 8080 per impostazione predefinita, ma è possibile specificare qualsiasi porta disponibile nel sistema operativo.

Nel tuo caso, farei:

cd D:\Folder
node server.js

Puoi sfogliare i file D:\Folderda un browser digitandohttp://127.0.0.1:8080/somefolder/somefile.html



2

A beneficio dei ricercatori, mi è piaciuta la risposta di Jakub g, ma volevo un piccolo errore nella gestione. Ovviamente è meglio gestire gli errori correttamente , ma ciò dovrebbe aiutare a prevenire l'arresto di un sito in caso di errore. Codice sotto:

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

Aggiornamento: la mia risposta funziona, ma ora utilizzo la risposta di @Matt Self sull'uso di http-server. Sembra che funzioni bene.
HockeyJ,

2

Per prima cosa installare il server nodo statico tramite npm install node-static -g -g è installarlo globale sul proprio sistema, quindi navigare nella directory in cui si trovano i file, avviare il server con static esso in ascolto sulla porta 8080, naviaget sul browser e digitare localhost: 8080 / yourhtmlfilename .


2

È possibile utilizzare il NPM servono pacchetto per questo, se non è necessario il NodeJS roba si tratta di un veloce e facile da strumento di uso:

1 - Installa il pacchetto sul tuo PC:

npm install -g serve

2 - Servi la tua cartella statica con serve <path>:

d:> serve d:\StaticSite

Ti mostrerà quale porta viene servita la tua cartella statica, basta andare all'host come:

http://localhost:3000

Ti rendi conto che npmè il gestore dei pacchetti di nodi, quindi stai effettivamente usando le cose
NodeJS

Quello che intendevo come "roba di NodeJS" era usare NodeJS ed express per servire i file come suggerito dalla maggior parte delle risposte. Serve è un eseguibile indipendente, NPM viene utilizzato solo per installarlo, è possibile scaricarlo direttamente.
Diego Mendes,

1

Cercando nel registro NPM https://npmjs.org/search?q=server , ho trovato static-server https://github.com/maelstrom/static-server

Hai mai avuto bisogno di inviare un file a un collega, ma non puoi preoccuparti di inviare un'email alla bestia da 100 MB? Volevi eseguire una semplice applicazione JavaScript di esempio, ma hai avuto problemi con eseguirla attraverso il protocollo file: ///? Volevi condividere la tua directory multimediale su una LAN senza configurare Samba o FTP o qualsiasi altra cosa che richiedesse di modificare i file di configurazione? Quindi questo file server renderà la tua vita un po 'più semplice.

Per installare il semplice server roba statico, utilizzare npm:

npm install -g static-server

Quindi per servire un file o una directory, esegui semplicemente

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

Ciò potrebbe anche elencare il contenuto della cartella.

Sfortunatamente, non è stato possibile pubblicare file :)


5
Ho costruito quel server. Quel file server è stato creato su una versione molto vecchia di Node, quindi perché non funziona più. In questo momento non ho tempo per sistemarlo. Suggerisco di usare la risposta di @Oleg sopra. Può essere facilmente raggruppato in un piccolo eseguibile nodo, ed è essenzialmente ciò che il mio ha fatto comunque.
Tim Heap,

Grazie Tim, risposta molto professionale. Non eliminerei il codice però, ma aggiornerò il file Leggimi.
Paul Verest,

1

Un semplice server statico che utilizza 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);

Vedi anche Utilizzo di node.js come semplice server Web



1

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


È necessario aggiungere alcune spiegazioni con questo codice.
Abhinav Gauniyal,

1

Se sei interessato al server http ultraleggero senza alcun prerequisito, dovresti dare un'occhiata a: mongoose



Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.