Szybki serwer plików Node.js (pliki statyczne przez HTTP)


642

Czy jest gotowe narzędzie Node.js (zainstalowane z npm), które pomogłoby mi ujawnić zawartość folderu jako serwer plików przez HTTP.

Przykład, jeśli mam

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

Następnie zaczynając za D:\Folder\ node node-file-server.js , mogłem uzyskać dostęp do pliku przez

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

Dlaczego mój statyczny serwer plików odrzuca żądania? odnoszą się do mistycznych

standardowy statyczny serwer plików node.js

Jeśli nie ma takiego narzędzia, jakich ram powinienem użyć?

Powiązane: Podstawowy statyczny serwer plików w NodeJS


Napisałem moduł o nazwie Cachemere, który pozwala ci to zrobić. Automatycznie buforuje również wszystkie zasoby. Sprawdź to: github.com/topcloud/cachemere
Jon

npmjs.com/package/local-web-server - lekki statyczny serwer WWW, zerowa konfiguracja
Victor

Odpowiedzi:


1090

Dobrym „gotowym do użycia narzędziem” może być serwer http:

npm install http-server -g

Aby go użyć:

cd D:\Folder
http-server

Lub tak:

http-server D:\Folder

Sprawdź to: https://github.com/nodeapps/http-server


10
To jest niesamowite. Musiałem podać adres bc z jakiegoś powodu domyślne 0.0.0.0 nie współpracowało w moim środowisku programistycznym. http-server -a localhostdostałam dun.
Sam Berry,

41
używamhttp-server -a localhost -p 80
Muhammad Umer

10
Warto również sprawdzić synchronizację przeglądarki , która może zrobić mniej więcej to samo, ale z dodatkową zaletą aktualizacji na żywo po zmodyfikowaniu plików.
Nick F

3
--corswysyłać Access-Control-Allow-Origin:*wraz z nagłówkami odpowiedzi (tj. podczas udostępniania pliku json)
Daniel F

9
npx http-server- npx zamienia go w jeden wiersz, który pobiera niezbędne pliki i uruchamia je.
Mike McKay,

185

Jeśli nie chcesz używać gotowego narzędzia, możesz użyć poniższego kodu, co pokazałem na 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/');

AKTUALIZACJA Jeśli potrzebujesz uzyskać dostęp do swojego serwera z zewnętrznego pliku / żądania, musisz pokonać CORS w pliku node.js, pisząc poniżej, jak wspomniałem w poprzedniej odpowiedzi tutaj

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

AKTUALIZACJA

Jak wspomniał Adrian, w komentarzach napisał kod ES6 z pełnym wyjaśnieniem tutaj , po prostu ponownie zamieszczam jego kod poniżej, na wypadek gdyby kod zniknął z oryginalnej strony z jakiegokolwiek powodu:

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
Z pewnością response.writeHead(200powinno być response.writeHead(404;)
Thomas Hunter II

14
Czy ten kod nie pozwoliłby wejść na drzewo plików, wykonując coś takiego jak 127.0.0.1/../../../etc/passwd ? Nie widzę w tym żadnych kontroli.
Rolf

3
Jeśli ktoś jest zainteresowany wersją ES6 +, stworzyłem statyczny serwer plików, który obsługuje typy MIME: gist.github.com/amejiarosario/53afae82e18db30dadc9bc39035778e5
Adrian

1
@Adrian Ten kod jest bardzo niesamowity, ale znalazłem sposób na uzyskanie dostępu do roota. Rozwiązaniem jest ograniczenie liczby wiodących okresów w nazwie pliku do jednego, aby nie można było nic robić ../../etc/password. gist.github.com/amejiarosario/53afae82e18db30dadc9bc39035778e5
Seph Reed

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

79

Dla osób chcących uruchomić serwer z poziomu skryptu NodeJS:

Możesz użyć expressjs / serve-static, który zastępuje connect.static(który nie jest już dostępny od 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);

a następnie z wiersza poleceń:

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

1
Do twojej wiadomości To nie działało dla mnie. Zainstalowałem moduł obsługi plików za pomocą, npm install filehandlera pakiet znajduje się w node_moduleskatalogu. Ale kiedy uruchamiam myapp.jswęzeł zgłasza błąd, mówiąc Error: cannot find module filehandler. Jeśli skomentuję wymaganą ststment, aby załadować moduł obsługi plików, aplikacja ładuje statyczno-statyczną, więc wygląda na to, że coś jest nie tak z pakietem modułu do obsługi plików. Dzisiaj jest 12 grudnia 2014 roku, więc może pakiet zmienił się od czasu opublikowania tej odpowiedzi?
Lee Jenkins,

7
To nie jest finalhandlerfile
jakub.g

Kolejną zaletą tego rozwiązania jest to, że pliki nie są buforowane, więc nie trzeba ponownie uruchamiać procesu podczas wprowadzania zmian w kodzie.
klimat

59

Wiem, że to nie jest Węzeł, ale użyłem SimpleHTTPServera Pythona:

python -m SimpleHTTPServer [port]

Działa dobrze i jest wyposażony w Python.


16
Odpowiednik Python3: python -m http.server [port](wspomniany dotyczy Python2)
jakub.g

Python kończy się niepowodzeniem, gdy chodzi o udostępnianie dużych plików, takich jak obrazy systemu operacyjnego. Fedora 23
Zimy

9
I na PHP:php -S localhost:8000
dennis

Używam tego do szybkiego wyświetlania zawartości z folderu przez cały czas.
Adrian Lynch

33

połączyć może być tym, czego szukasz.

Łatwa instalacja dzięki:

npm install connect

Następnie najbardziej podstawowy statyczny serwer plików można zapisać jako:

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

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

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

4
To nie działa już od Connect 3, ponieważ nie ujawnia connect.static; zobacz moją odpowiedź poniżej, aby
zamienić

4
Uważam, że domyślnie jest w pakiecie z express , ale tak naprawdę istnieje teraz w osobnym, requirezdolnym module „służyć-statycznie”.
Oleg

18

Zainstaluj ekspres za pomocą npm: https://expressjs.com/en/starter/installing.html

Utwórz plik o nazwie server.js na tym samym poziomie indeksu.html z tą zawartością:

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

Jeśli chcesz umieścić go w innym miejscu, ustaw ścieżkę w trzecim wierszu:

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

CD do folderu zawierającego plik i uruchom węzeł z konsoli za pomocą tego polecenia:

node server.js

Przejdź do localhost: 8080


1
Cześć, mogę uruchomić go poprawnie, ale pokazuje Cannot GET /. Do uruchomienia serwera używam AWS EC2.
Wei Xia

1
@Wei Cześć, późna odpowiedź. Z tego, co widzę po szybkim wyszukiwaniu w Google, wygląda na to, że struktura katalogu może być niepoprawna. W miejscu docelowym musi znajdować się plik index.html. Ustawienie powyższego przykładu do uruchomienia powinno zająć 5 minut i dwukrotnie sprawdziłem, czy działa tak, jak jest. Stamtąd możesz dostosować ścieżkę do struktury katalogu i sprawdzić, czy serwer nadal znajduje potrzebne pliki.
pasx

path.join(__dirname, 'public')jest bardziej wieloplatformowy.
sdgfsdh

16

One-line ™ Dowody zamiast obietnic

wprowadź opis zdjęcia tutaj

Pierwszym z nich jest http-server, hs- Link

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

Drugi to serveZEIT.co - link

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

Poniżej znajdują się dostępne opcje, jeśli to pomoże ci zdecydować.

C: \ Users \ Qwerty> serwer http --help
użycie: serwer http [ścieżka] [opcje]

opcje:
  -p Port do użycia [8080]
  -a Adres do użycia [0.0.0.0]
  -d Pokaż listy katalogów [prawda]
  -i Wyświetl autoIndex [prawda]
  -g --gzip W miarę możliwości wyświetlaj pliki gzip [false]
  -e --ext Domyślne rozszerzenie pliku, jeśli nie podano [brak]
  -s --silent Pomija komunikaty dziennika od wyjścia
  --cors [= nagłówki] Włącz CORS za pomocą nagłówka „Access-Control-Allow-Origin”
                     Opcjonalnie podaj listę nagłówków CORS oddzieloną przecinkami
  -o [ścieżka] Otwórz okno przeglądarki po uruchomieniu serwera
  -c Czas pamięci podręcznej (maksymalny wiek) w sekundach [3600], np. -c10 przez 10 sekund.
               Aby wyłączyć buforowanie, użyj -c-1.
  -U --utc Użyj formatu czasu UTC w komunikatach dziennika.

  -P --proxy Fallback proxy, jeśli żądania nie można rozwiązać. np .: http://someurl.com

  -S --ssl Włącz https.
  -C --cert Ścieżka do pliku certyfikatu ssl (domyślnie: cert.pem).
  -K --key Ścieżka do pliku kluczy ssl (domyślnie: key.pem).

  -r --robots Odpowiedz na /robots.txt [Agent użytkownika: * \ nDisallow: /]
  -h --help Wydrukuj tę listę i zakończ.
C: \ Users \ Qwerty> służyć --help

  Użycie: serve.js [opcje] [polecenie]

  Polecenia:

    pomoc Wyświetl pomoc

  Opcje:

    -a, --auth Podaj podstawowe uwierzytelnianie
    -c, --cache Czas w milisekundach do buforowania plików w przeglądarce
    -n, --clipless Nie kopiuj adresu do schowka (domyślnie wyłączone)
    -C, --cors Konfiguracja * Nagłówki CORS zezwalają na żądania z dowolnego źródła (domyślnie wyłączone)
    -h, --help Wyświetla informacje o użyciu
    -i, --ignore Pliki i katalogi należy zignorować
    -o, --open Otwórz adres lokalny w przeglądarce (domyślnie wyłączony)
    -p, --port Port do nasłuchiwania (domyślnie 5000)
    -S, --silent Nie loguj niczego do konsoli
    -s, --single Serwuj aplikacje jednostronicowe (ustawia „-c” na 1 dzień)
    -t, --treeless Nie wyświetlaj drzewa statystyk (domyślnie wyłączone)
    -u, --unzipped Wyłącz kompresję GZIP
    -v, --version Wypisuje numer wersji

Jeśli trzeba obserwować zmiany, zobaczyć hostr, kredyt odpowiedź Henry'ego Tseng za


14

TYLKO SERWER DEMO / PROTO

Jeśli to wszystko, czego potrzebujesz, spróbuj:

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

Uwaga: musisz użyć „/index.html” jako części adresu, tj. „ http: // localhost: 3000 / index.html


2
Nie używaj wersji synchronizacji. Instread utwórz potok do res z readStream.
Eduard Bondarenko,

1
Najlepsza odpowiedź, jeśli potrzebujesz szybkiego i brudnego, jednorazowego kucyka.
collapsar

1
Jeśli chcesz uniknąć stosując index.htmljako część adresu wystarczy dodać if (req.url === '/') req.url = '/index.html';tuż po res.writeHead(200);.
Joseph Cho

3
@EduardBondarenko ma rację. const stream = fs.createReadStream(...); stream.pipe(res);to wszystko, czego potrzebujesz
Justin Meiners

8

Jest jeszcze jeden statyczny serwer WWW, który jest całkiem niezły: synchronizacja przeglądarki.

Można go pobrać za pomocą menedżera pakietów węzłów:

npm install -g browser-sync

Po instalacji przejdź do folderu projektu w wierszu polecenia cmd i uruchom następujące polecenie:

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

Rozpocznie się catering wszystkich plików w bieżącym folderze w przeglądarce.

Więcej można znaleźć w BrowserSync

Dzięki.


2
Zaletą korzystania z Browsersync zamiast innych statycznych serwerów jest to, że na żywo aktualizuje stronę za każdym razem, gdy --fileszmieniają się pliki określone przez flagę (nb. Nie musisz tego określać ./*- tylko te, które chcesz, aby Browsersync aktywnie szukał aktualizacji, np. . css/*.css)
Nick F

7

Nie miałem dużo szczęścia z żadną z odpowiedzi na tej stronie, jednak poniższe wydawały się załatwić sprawę.

Dodaj server.jsplik o następującej treści:

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)

Upewnij się także, że potrzebujesz express. Uruchom yarn add express --savelub w npm install express --savezależności od konfiguracji (mogę polecić, yarnże jest dość szybki).

Możesz przejść distdo dowolnego folderu, w którym udostępniasz swoje treści. W moim prostym projekcie nie wyświetlałem żadnych folderów, więc po prostu usunąłem distnazwę pliku.

Wtedy możesz uciec node server.js. Ponieważ musiałem przesłać swój projekt na serwer Heroku, musiałem dodać do mojego package.jsonpliku:

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

6

Jeśli korzystasz z frameworka Express , ta funkcja jest gotowa do użycia.

Aby skonfigurować prostą aplikację do udostępniania plików, wykonaj następujące czynności:

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

Czy mogę npm zainstalować -g express; im $ express?
Paul Verest

Postępowałem zgodnie z Twoimi instrukcjami, ale mój ekspres nie ma folderu bin
Qwerty

6

Oto mój projekt dla zwierząt domowych na jednym serwerze z jednym plikiem / statycznym plikiem node.js bez żadnych zależności, który moim zdaniem jest szybkim i bogatym narzędziem, którego użycie jest tak proste, jak wydanie polecenia na terminalu Linux / Unix / macOS ( lub termux na Androida), gdy nodejs-legacyjest zainstalowany node.js (lub na Debian / Ubuntu):

curl pad.js.org | node 

(w dokumentacji istnieją różne polecenia dla użytkowników systemu Windows)

Obsługuje różne rzeczy, które moim zdaniem mogą być przydatne,

  • Hierarchiczne tworzenie indeksów katalogów
    • Z możliwością sortowania według różnych kryteriów
    • Przesyłanie z przeglądarki przez przeciąganie i upuszczanie oraz wklejanie i kopiowanie tylko plików / tekstów i zrzutów ekranowych ze schowka systemowego w przeglądarce Chrome, Firefox i innych przeglądarkach może mieć pewne ograniczenia (które można wyłączyć za pomocą wiersza polecenia opcje, które zapewnia)
    • Przycisk tworzenia folderów / notatek / przesyłania
  • Podawanie poprawnych MIME dla dobrze znanych typów plików (z możliwością wyłączenia)
  • Możliwość instalacji jako pakietu npm i lokalnego narzędzia lub instalacji jedno-liniowej jako stałej usługi z Dockerem
  • Udostępnianie plików HTTP 206 (przesyłanie plików wieloczęściowych) w celu szybszego przesyłania
  • Przesyłanie z terminala i konsoli przeglądarki (w rzeczywistości pierwotnie miało to być proxy systemu plików dla konsoli JS przeglądarek na innych stronach / domenach)
  • Pobieranie / wysyłanie CORS (które można również wyłączyć)
  • Łatwa integracja HTTPS
  • Lekkie opcje wiersza poleceń pozwalające uzyskać z nim lepszą bezpieczną obsługę:
    • Dzięki mojej łatce na node.js 8 możesz mieć dostęp do opcji bez pierwszej instalacji:curl pad.js.org | node - -h
    • Lub najpierw zainstaluj go jako globalny systemowy pakiet npm, [sudo] npm install -g pad.jsa następnie użyj jego zainstalowanej wersji, aby uzyskać dostęp do jego opcji:pad -h
    • Lub użyj dostarczonego obrazu Docker, który domyślnie używa stosunkowo bezpiecznych opcji. [sudo] docker run --restart=always -v /files:/files --name pad.js -d -p 9090:9090 quay.io/ebraminio/pad.js

Zrzut ekranu indeksu folderu za pomocą narzędzia

Funkcje opisane powyżej są w większości udokumentowane na stronie głównej narzędzia http://pad.js.org, która według jakiejś fajnej sztuczki, której użyłem, jest również miejscem, z którego samo źródło narzędzia jest również obsługiwane!

Źródło narzędzia znajduje się na GitHub, który chętnie przyjmuje Twoje opinie, prośby o funkcje i odpowiedzi!


5

Od npm@5.2.0, npmzaczął instalować nowy plik binarny obok zwykłego npm o nazwie npx. Tak więc teraz jeden liner do stworzenia statycznego serwera http z bieżącego katalogu:

npx serve

lub

npx http-server

4

Aby uzyskać zdrowy wzrost wydajności przy użyciu węzła do obsługi zasobów statycznych, zalecam użycie bufora . Działa podobnie jak akcelerator aplikacji internetowych znany również jako buforujące odwrotne proxy HTTP, ale po prostu ładuje wybrany katalog do pamięci.

Bufet przyjmuje podejście w pełni buforowane - wszystkie pliki są w pełni ładowane do pamięci podczas uruchamiania aplikacji, więc nigdy nie poczujesz wypalenia systemu plików. W praktyce jest to niezwykle wydajne. Tak bardzo, że umieszczenie Lakieru przed aplikacją może nawet spowolnić! 

Używamy go w witrynie codePile i stwierdziliśmy wzrost ~ 700 żądań / s do> 4k żądań / s na stronie, która pobiera 25 zasobów przy obciążeniu równoczesnym połączeniem użytkownika 1k.

Przykład:

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

Poniżej pracował dla mnie:

Utwórz plik app.jsz poniższą zawartością:

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

Utwórz plik index.htmlz poniższą zawartością:

Hi

Uruchom wiersz poleceń:

cmd

Uruchom poniżej w cmd:

node app.js

Idź poniżej adresu URL, w chromie:

http://localhost:8080/index.html

To wszystko. Mam nadzieję, że to pomaga.

Źródło: https://nodejs.org/en/knowledge/HTTP/servers/how-to-serve-static-files/


3

Możesz spróbować służyć mi

Korzystanie z niego jest takie proste:

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

To wszystko.

PD: Folder domyślnie obsługiwany to „public”.



3

W zwykłym node.js:

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.')
})

Jest to prosty serwer node.js, który obsługuje tylko żądane pliki w określonym katalogu.

Stosowanie:

node server.js folder port

foldermoże być bezwzględny lub względny w zależności od server.jslokalizacji. Wartością domyślną jest .katalog, który wykonujesz node server.js.

port Domyślnie jest to 8080, ale można określić dowolny port dostępny w systemie operacyjnym.

W twoim przypadku zrobiłbym:

cd D:\Folder
node server.js

Możesz przeglądać pliki w D:\Folderprzeglądarce, pisząchttp://127.0.0.1:8080/somefolder/somefile.html


2

Nie jest jeszcze na NPM, ale zbudowałem prosty serwer statyczny na Expressie, który pozwala również akceptować przesyłanie formularzy i wysyłać je pocztą elektroniczną za pośrednictwem transakcyjnej usługi e-mail (na razie Sendgrid, Mandrill).

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


2

Z korzyścią dla wyszukiwarek podobała mi się odpowiedź Jakuba g, ale chciałem trochę obsługiwać błędy. Oczywiście najlepiej jest prawidłowo obsługiwać błędy , ale powinno to pomóc w zapobieganiu zatrzymaniu witryny w przypadku wystąpienia błędu. Kod poniżej:

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

Aktualizacja - Moja odpowiedź działa, ale teraz używam odpowiedzi @Matt Self dotyczącej używania serwera HTTP. Wygląda na to, że działa dobrze.
HokejJ

2

Najpierw zainstaluj serwer z węzłem statycznym przez npm install node-static -g -g, aby zainstalować go globalnie w systemie, a następnie przejdź do katalogu, w którym znajdują się twoje pliki, uruchom serwer, static aby nasłuchiwał na porcie 8080, nawiguj w przeglądarce i wpisz localhost: 8080 / yourhtmlfilename .


2

Można użyć NPM służyć pakiet dla tego, jeśli nie potrzebujemy NodeJS rzeczy jest to szybkie i łatwe w użyciu narzędzie:

1 - Zainstaluj pakiet na komputerze:

npm install -g serve

2 - Podaj swój folder statyczny za pomocą serve <path>:

d:> serve d:\StaticSite

Pokaże Ci, który port jest obsługiwany przez twój folder statyczny, po prostu przejdź do hosta, na przykład:

http://localhost:3000

Zdajesz sobie sprawę, że npmto menedżer pakietów węzłów, więc w rzeczywistości korzystasz z NodeJS
derickito,

Rozumiem, co miałem na myśli jako „NodeJS”, używając NodeJS i express do obsługi plików, jak sugeruje większość odpowiedzi. Serve to niezależny plik wykonywalny, NPM służy tylko do jego instalacji, wystarczy pobrać go bezpośrednio.
Diego Mendes,

1

Przeszukując rejestr NPM https://npmjs.org/search?q=server , znalazłem static-server https://github.com/maelstrom/static-server

Czy kiedykolwiek potrzebowałeś wysłać koledze plik, ale nie możesz przejmować się wysyłaniem wiadomości e-mail do bestii o rozmiarze 100 MB? Chciałeś uruchomić prostą przykładową aplikację JavaScript, ale miałeś problemy z uruchomieniem jej przez protokół file: ///? Czy chcesz udostępnić swój katalog multimediów w sieci LAN bez konfigurowania Samby, FTP lub czegokolwiek innego, co wymaga edycji plików konfiguracyjnych? Ten serwer plików sprawi, że twoje życie stanie się trochę łatwiejsze.

Aby zainstalować prosty statyczny serwer rzeczy, użyj npm:

npm install -g static-server

Następnie, aby podać plik lub katalog, po prostu uruchom

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

To może nawet wyświetlać zawartość folderu.

Niestety nie mógł obsłużyć plików :)


5
Zbudowałem ten serwer. Ten serwer plików został zbudowany na bardzo starej wersji węzła, dlatego nie działa. Nie mam teraz czasu, żeby to naprawić. Sugeruję użycie odpowiedzi @Oleg powyżej. Można go łatwo spakować w plik wykonywalny małego węzła, i tak właściwie to zrobiła moja.
Tim Heap

Dziękuję Tim, bardzo profesjonalna odpowiedź. Nie usunę jednak kodu, ale zaktualizuję plik readme.
Paul Verest

1

Prosty serwer statyczny za pomocą połączenia

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

Zobacz także Używanie node.js jako prostego serwera WWW



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


W tym kodzie należy dodać wyjaśnienie alog.
Abhinav Gauniyal

1

Jeśli jesteś zainteresowany ultra lekkim serwerem http bez żadnych wymagań, powinieneś spojrzeć na: mangusta



0

Zapytałeś również, dlaczego żądania są odrzucane - nie jestem pewien, jaki jest konkretny powód twojej sprawy, ale ogólnie lepiej lepszą statyczną zawartość serwera za pomocą dedykowanego oprogramowania pośredniego (nginx, S3, CDN), ponieważ Węzeł tak naprawdę nie jest zoptymalizowany dla tego wzorca sieci. Zobacz dalsze wyjaśnienia tutaj (punkt 13): http://goldbergyoni.com/checklist-best-practice-of-node-js-in-production/

Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.