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

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

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

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

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.

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

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

One-line ™ Dowody zamiast obietnic

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

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 ”

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.

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"
  }

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

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

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!

Od [email protected], 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

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

});

Spójrz na ten link .

Wystarczy zainstalować moduł ekspresowy node js.

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

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

Możesz uzyskać dostęp do swojego pliku, np. Http: //nazwa_hosta/folder/plik.zip

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/

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”.

Oto kolejny prosty serwer WWW.

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

zainstalować

npm install -g hostr

Zmień dyrektora roboczego

cd myprojectfolder/

I zacznij

hostr

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

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

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

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 .

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

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

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

Do pracy deweloperskiej możesz użyć (ekspres 4) https://github.com/appsmatics/simple-httpserver.git

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

Używam Houston w pracy i do osobistych projektów, działa dobrze dla mnie.

https://github.com/alejandro/Houston

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/