Chcę uruchomić bardzo prosty serwer HTTP. Każde żądanie GET example.compowinno zostać index.htmldoręczone, ale jako zwykła strona HTML (tj. Takie same wrażenia, jak podczas czytania normalnych stron internetowych).

Korzystając z poniższego kodu, mogę przeczytać treść index.html. Jak mogę służyć index.htmljako zwykła strona internetowa?

var http = require('http');
var fs = require('fs');
var index = fs.readFileSync('index.html');

http.createServer(function (req, res) {
  res.writeHead(200, {'Content-Type': 'text/plain'});
  res.end(index);
}).listen(9615);

Jedna z poniższych sugestii jest skomplikowana i wymaga ode mnie napisania getwiersza dla każdego pliku zasobów (CSS, JavaScript, obrazy), którego chcę użyć.

Jak mogę obsłużyć jedną stronę HTML z kilkoma obrazkami, CSS i JavaScript?

Najprostszy serwer Node.js to:

$ npm install http-server -g

Teraz możesz uruchomić serwer za pomocą następujących poleceń:

$ cd MyApp

$ http-server

Jeśli używasz NPM 5.2.0 lub nowszej wersji, możesz korzystać z niej http-serverbez instalacji npx. Nie jest to zalecane do użytku w produkcji, ale jest to świetny sposób na szybkie uruchomienie serwera na localhost.

$ npx http-server

Możesz także wypróbować tę opcję, która otwiera przeglądarkę internetową i włącza żądania CORS:

$ http-server -o --cors

Aby uzyskać więcej opcji, zapoznaj się z dokumentacją w http-serverwitrynie GitHub lub uruchom:

$ http-server --help

Mnóstwo innych fajnych funkcji i niewiarygodnie proste wdrożenie na NodeJitsu.

Widelce funkcji

Oczywiście możesz łatwo uzupełnić funkcje własnym widelcem. Może się okazać, że zostało to już zrobione na jednym z ponad 800 wideł tego projektu:

• https://github.com/nodeapps/http-server/network

Serwer światła: alternatywa automatycznego odświeżania

Dobrą alternatywą http-serverjest light-server. Obsługuje oglądanie plików i automatyczne odświeżanie oraz wiele innych funkcji.

$ npm install -g light-server 
$ light-server

Dodaj do menu kontekstowego katalogu w Eksploratorze Windows

 reg.exe add HKCR\Directory\shell\LightServer\command /ve /t REG_EXPAND_SZ /f /d "\"C:\nodejs\light-server.cmd\" \"-o\" \"-s\" \"%V\""

Prosty serwer REST JSON

Jeśli potrzebujesz utworzyć prosty serwer REST dla projektu prototypowego, serwer json może być tym, czego szukasz.

Auto odświeżające edytory

Większość edytorów stron internetowych i narzędzi IDE zawiera teraz serwer WWW, który będzie oglądać twoje pliki źródłowe i automatycznie odświeżać twoją stronę internetową, gdy się zmienią.

Używam Live Server z Visual Studio Code.

W open source edytor tekstu Wsporniki zawiera również NodeJS statyczny serwer WWW. Wystarczy otworzyć dowolny plik HTML w nawiasach, nacisnąć przycisk „ Podgląd na żywo ”, co spowoduje uruchomienie serwera statycznego i otwarcie przeglądarki na stronie. Przeglądarka ** automatycznie odświeży się po każdej edycji i zapisaniu pliku HTML. Jest to szczególnie przydatne podczas testowania adaptacyjnych stron internetowych. Otwórz stronę HTML w wielu przeglądarkach / rozmiarach okien / urządzeniach. Zapisz swoją stronę HTML i od razu sprawdź, czy Twoje elementy adaptacyjne działają, ponieważ wszystkie automatycznie się odświeżają.

Programiści PhoneGap

Jeśli kodujesz hybrydową aplikację mobilną , możesz być zainteresowany tym, że zespół PhoneGap zastosował tę koncepcję automatycznego odświeżania w swojej nowej aplikacji PhoneGap . Jest to ogólna aplikacja mobilna, która podczas ładowania może ładować pliki HTML5 z serwera. Jest to bardzo sprytna sztuczka, ponieważ teraz możesz pomijać powolne kroki kompilacji / wdrażania w cyklu programowania hybrydowych aplikacji mobilnych, jeśli zmieniasz pliki JS / CSS / HTML - co robisz przez większość czasu. Zapewniają również statyczny serwer WWW NodeJS (uruchamiany phonegap serve), który wykrywa zmiany plików.

PhoneGap + Sencha Touch Developers

W dużym stopniu zaadaptowałem teraz serwer statyczny PhoneGap i aplikację dewelopera PhoneGap dla programistów Sencha Touch i jQuery Mobile. Sprawdź to na Sencha Touch Live . Obsługuje kody QR --qr i --localtunnel, który proxy twojego statycznego serwera z komputera stacjonarnego do adresu URL poza zaporą ogniową! Mnóstwo zastosowań. Ogromne przyspieszenie hybrydowych mobilnych programistów.

Cordova + Ionic Framework Developers

Lokalne funkcje serwera i automatycznego odświeżania są wstawiane do ionicnarzędzia. Po prostu uruchom ionic servez folderu aplikacji. Jeszcze lepiej ... ionic serve --lababy wyświetlać automatyczne odświeżanie obok siebie widoków na iOS i Androida.

Możesz użyć Connect i ServeStatic z Node.js do tego:

1. Zainstaluj Connect i podaj-static z NPM

   $ npm install connect serve-static

2. Utwórz plik server.js z tą zawartością:

   var connect = require('connect');
   var serveStatic = require('serve-static');
   
   connect()
       .use(serveStatic(__dirname))
       .listen(8080, () => console.log('Server running on 8080...'));

3. Uruchom z Node.js

   $ node server.js

Możesz teraz przejść do http://localhost:8080/yourfile.html

Sprawdź tę treść . Odtwarzam go tutaj w celach informacyjnych, ale treść jest regularnie aktualizowana.

Serwer WWW plików statycznych Node.JS. Umieść go na swojej drodze, aby uruchomić serwery w dowolnym katalogu, pobiera opcjonalny argument portu.

var http = require("http"),
    url = require("url"),
    path = require("path"),
    fs = require("fs"),
    port = process.argv[2] || 8888;

http.createServer(function(request, response) {

  var uri = url.parse(request.url).pathname
    , filename = path.join(process.cwd(), uri);

  fs.exists(filename, function(exists) {
    if(!exists) {
      response.writeHead(404, {"Content-Type": "text/plain"});
      response.write("404 Not Found\n");
      response.end();
      return;
    }

    if (fs.statSync(filename).isDirectory()) filename += '/index.html';

    fs.readFile(filename, "binary", function(err, file) {
      if(err) {        
        response.writeHead(500, {"Content-Type": "text/plain"});
        response.write(err + "\n");
        response.end();
        return;
      }

      response.writeHead(200);
      response.write(file, "binary");
      response.end();
    });
  });
}).listen(parseInt(port, 10));

console.log("Static file server running at\n  => http://localhost:" + port + "/\nCTRL + C to shutdown");

Aktualizacja

Gist obsługuje pliki css i js. Sam tego użyłem. Korzystanie z odczytu / zapisu w trybie „binarnym” nie stanowi problemu. Oznacza to po prostu, że plik nie jest interpretowany przez bibliotekę plików jako tekst i nie jest powiązany z typem treści zwróconym w odpowiedzi.

Problem z twoim kodem polega na tym, że zawsze zwracasz typ zawartości „tekst / zwykły”. Powyższy kod nie zwraca żadnego typu zawartości, ale jeśli używasz go tylko do HTML, CSS i JS, przeglądarka może wywnioskować je w porządku. Żaden typ zawartości nie jest lepszy niż niewłaściwy.

Zazwyczaj typem zawartości jest konfiguracja serwera WWW. Przykro mi, jeśli to nie rozwiąże twojego problemu, ale działało dla mnie jako prosty serwer programistyczny i pomyślałem, że może pomóc innym osobom. Jeśli potrzebujesz poprawnych typów zawartości w odpowiedzi, musisz jawnie zdefiniować je jako joeytwiddle lub użyć biblioteki takiej jak Connect, która ma sensowne wartości domyślne. Zaletą tego jest to, że jest prosty i samodzielny (bez zależności).

Ale czuję twój problem. Oto połączone rozwiązanie.

var http = require("http"),
    url = require("url"),
    path = require("path"),
    fs = require("fs")
    port = process.argv[2] || 8888;

http.createServer(function(request, response) {

  var uri = url.parse(request.url).pathname
    , filename = path.join(process.cwd(), uri);

  var contentTypesByExtension = {
    '.html': "text/html",
    '.css':  "text/css",
    '.js':   "text/javascript"
  };

  fs.exists(filename, function(exists) {
    if(!exists) {
      response.writeHead(404, {"Content-Type": "text/plain"});
      response.write("404 Not Found\n");
      response.end();
      return;
    }

    if (fs.statSync(filename).isDirectory()) filename += '/index.html';

    fs.readFile(filename, "binary", function(err, file) {
      if(err) {        
        response.writeHead(500, {"Content-Type": "text/plain"});
        response.write(err + "\n");
        response.end();
        return;
      }

      var headers = {};
      var contentType = contentTypesByExtension[path.extname(filename)];
      if (contentType) headers["Content-Type"] = contentType;
      response.writeHead(200, headers);
      response.write(file, "binary");
      response.end();
    });
  });
}).listen(parseInt(port, 10));

console.log("Static file server running at\n  => http://localhost:" + port + "/\nCTRL + C to shutdown");

Nie potrzebujesz ekspresu. Nie potrzebujesz połączenia. Node.js robi NATYCHMIAST http. Wszystko, co musisz zrobić, to zwrócić plik zależny od żądania:

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

http.createServer(function (request, response) {
    var requestUrl = url.parse(request.url)    
    response.writeHead(200)
    fs.createReadStream(requestUrl.pathname).pipe(response)  // do NOT use fs's sync methods ANYWHERE on production (e.g readFileSync) 
}).listen(9615)    

Bardziej pełny przykład, który zapewnia, że ​​żądania nie mogą uzyskać dostępu do plików pod katalogiem podstawowym, i poprawnie obsługuje błędy:

var http = require('http')
var url = require('url')
var fs = require('fs')
var path = require('path')
var baseDirectory = __dirname   // or whatever base directory you want

var port = 9615

http.createServer(function (request, response) {
    try {
        var requestUrl = url.parse(request.url)

        // need to use path.normalize so people can't access directories underneath baseDirectory
        var fsPath = baseDirectory+path.normalize(requestUrl.pathname)

        var fileStream = fs.createReadStream(fsPath)
        fileStream.pipe(response)
        fileStream.on('open', function() {
             response.writeHead(200)
        })
        fileStream.on('error',function(e) {
             response.writeHead(404)     // assume the file doesn't exist
             response.end()
        })
   } catch(e) {
        response.writeHead(500)
        response.end()     // end the response so browsers don't hang
        console.log(e.stack)
   }
}).listen(port)

console.log("listening on port "+port)

Myślę, że teraz tęsknisz za tym, że wysyłasz:

Content-Type: text/plain

Jeśli chcesz, aby przeglądarka internetowa renderowała HTML, powinieneś to zmienić na:

Content-Type: text/html

Krok 1 (wewnątrz wiersza polecenia [mam nadzieję, że cd do TWOJEGO FOLDERU]): npm install express

Krok 2: Utwórz plik server.js

var fs = require("fs");
var host = "127.0.0.1";
var port = 1337;
var express = require("express");

var app = express();
app.use(express.static(__dirname + "/public")); //use static files in ROOT/public folder

app.get("/", function(request, response){ //root dir
    response.send("Hello!!");
});

app.listen(port, host);

Pamiętaj, że powinieneś również dodać WATCHFILE (lub użyć nodemon). Powyższy kod dotyczy tylko prostego serwera połączeń.

KROK 3: node server.jslubnodemon server.js

Jest teraz łatwiejsza metoda, jeśli chcesz hostować prosty serwer HTTP. npm install -g http-server

i otwórz nasz katalog i typ http-server

https://www.npmjs.org/package/http-server

Szybki sposób:

var express = require('express');
var app = express();
app.use('/', express.static(__dirname + '/../public')); // ← adjust
app.listen(3000, function() { console.log('listening'); });

Na swój sposób:

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

http.createServer(function (req, res) {
    console.dir(req.url);

    // will get you  '/' or 'index.html' or 'css/styles.css' ...
    // • you need to isolate extension
    // • have a small mimetype lookup array/object
    // • only there and then reading the file
    // •  delivering it after setting the right content type

    res.writeHead(200, {'Content-Type': 'text/html'});

    res.end('ok');
}).listen(3001);

Zamiast zajmować się instrukcją switch, myślę, że lepiej jest wyszukać typ zawartości ze słownika:

var contentTypesByExtension = {
    'html': "text/html",
    'js':   "text/javascript"
};

...

    var contentType = contentTypesByExtension[fileExtension] || 'text/plain';

Jest to zasadniczo zaktualizowana wersja zaakceptowanej odpowiedzi dla wersji Connect 3:

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

var app = connect();

app.use(serveStatic(__dirname, {'index': ['index.html']}));
app.listen(3000);

Dodałem również domyślną opcję, aby index.html był wyświetlany jako domyślny.

Nie musisz używać żadnych modułów NPM do uruchomienia prostego serwera, istnieje bardzo mała biblioteka o nazwie „ NPM Free Server ” dla Node:

• Darmowy serwer NPM na GitHub

50 linii kodu, wyświetla wyjście, jeśli żądasz pliku lub folderu i nadaje mu czerwony lub zielony kolor, jeśli nie zadziałało. Rozmiar mniejszy niż 1 KB (zminimalizowany).

jeśli węzeł zainstalowany na swój komputer prawdopodobnie masz KMP, jeśli nie trzeba NodeJS rzeczy, można użyć służyć pakiet do tego:

1 - Zainstaluj pakiet na komputerze:

npm install -g serve

2 - Podaj swój folder statyczny:

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

Znalazłem ciekawą bibliotekę na npm, która może ci się przydać. Nazywa się mime ( npm install mimelub https://github.com/broofa/node-mime ) i może określać typ mime pliku. Oto przykład serwera, który napisałem przy jego użyciu:

var mime = require("mime"),http = require("http"),fs = require("fs");
http.createServer(function (req, resp) {
path  = unescape(__dirname + req.url)
var code = 200
 if(fs.existsSync(path)) {
    if(fs.lstatSync(path).isDirectory()) {
        if(fs.existsSync(path+"index.html")) {
        path += "index.html"
        } else {
            code = 403
            resp.writeHead(code, {"Content-Type": "text/plain"});
            resp.end(code+" "+http.STATUS_CODES[code]+" "+req.url);
        }
    }
    resp.writeHead(code, {"Content-Type": mime.lookup(path)})
    fs.readFile(path, function (e, r) {
    resp.end(r);

})
} else {
    code = 404
    resp.writeHead(code, {"Content-Type":"text/plain"});
    resp.end(code+" "+http.STATUS_CODES[code]+" "+req.url);
}
console.log("GET "+code+" "+http.STATUS_CODES[code]+" "+req.url)
}).listen(9000,"localhost");
console.log("Listening at http://localhost:9000")

Będzie to obsługiwać każdy zwykły plik tekstowy lub obrazkowy (.html, .css, .js, .pdf, .jpg, .png, .m4a i .mp3 to przetestowane przeze mnie rozszerzenia, ale teoria powinna działać na wszystko)

Uwagi dla programistów

Oto przykład wyniku, który otrzymałem:

Listening at http://localhost:9000
GET 200 OK /cloud
GET 404 Not Found /cloud/favicon.ico
GET 200 OK /cloud/icon.png
GET 200 OK /
GET 200 OK /501.png
GET 200 OK /cloud/manifest.json
GET 200 OK /config.log
GET 200 OK /export1.png
GET 200 OK /Chrome3DGlasses.pdf
GET 200 OK /cloud
GET 200 OK /-1
GET 200 OK /Delta-Vs_for_inner_Solar_System.svg

Zwróć uwagę na unescapefunkcję w konstrukcji ścieżki. Ma to na celu uwzględnienie nazw plików ze spacjami i zakodowanych znaków.

Edytować:

Przykładowa aplikacja Node.js Node Chat ma pożądaną funkcjonalność.
W pliku README.textfile
3. Krok jest tym, czego szukasz.

krok 1

• utwórz serwer, który odpowiada hello world na porcie 8002

krok 2

• utwórz plik index.html i podaj go

krok 3

• przedstawić util.js
• zmień logikę, aby każdy plik statyczny był obsługiwany
• pokaż 404, jeśli nie znaleziono pliku

krok 4

• dodaj jquery-1.4.2.js
• dodaj client.js
• zmień index.html, aby pytać użytkownika o pseudonim

Oto server.js

Oto util.js

Robię to przede wszystkim poprzez globalną instalację statycznego serwera węzłów

npm install node-static -g

następnie przejdź do katalogu zawierającego pliki HTML i uruchom serwer statyczny static.

Przejdź do przeglądarki i wpisz localhost:8080/"yourHtmlFile".

var http = require('http');
var fs = require('fs');
var index = fs.readFileSync('index.html');

http.createServer(function (req, res) {
    res.writeHead(200, {'Content-Type': 'text/html'});
    // change the to 'text/plain' to 'text/html' it will work as your index page
    res.end(index);
}).listen(9615);

Myślę, że szukasz tego. W pliku index.html po prostu wypełnij go zwykłym kodem HTML - cokolwiek chcesz na nim renderować, na przykład:

<html>
    <h1>Hello world</h1>
</html>

Zasadniczo kopiowanie zaakceptowanej odpowiedzi, ale unikanie tworzenia pliku js.

$ node
> var connect = require('connect'); connect().use(static('.')).listen(8000);

Uważam to za bardzo wygodne.

Aktualizacja

Od najnowszej wersji Express serw-static stał się oddzielnym oprogramowaniem pośrednim. Użyj tego do podania:

require('http').createServer(require('serve-static')('.')).listen(3000)

Zainstaluj serve-staticnajpierw.

od w3schools

bardzo łatwo jest utworzyć serwer węzłów, który będzie obsługiwał żądany plik, i nie trzeba instalować żadnych pakietów dla niego

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

http.createServer(function (req, res) {
  var q = url.parse(req.url, true);
  var filename = "." + q.pathname;
  fs.readFile(filename, function(err, data) {
    if (err) {
      res.writeHead(404, {'Content-Type': 'text/html'});
      return res.end("404 Not Found");
    }  
    res.writeHead(200, {'Content-Type': 'text/html'});
    res.write(data);
    return res.end();
  });
}).listen(8080);

http: // localhost: 8080 / file.html

poda plik.html z dysku

Możesz po prostu wpisać je w swojej powłoce

npx serve

Repo: https://github.com/zeit/serve .

Korzystam z poniższego kodu, aby uruchomić prosty serwer WWW, który wyświetla domyślny plik HTML, jeśli nie ma pliku wymienionego w Url.

var http = require('http'),
fs = require('fs'),
url = require('url'),
rootFolder = '/views/',
defaultFileName = '/views/5 Tips on improving Programming Logic   Geek Files.htm';


http.createServer(function(req, res){

    var fileName = url.parse(req.url).pathname;
    // If no file name in Url, use default file name
    fileName = (fileName == "/") ? defaultFileName : rootFolder + fileName;

    fs.readFile(__dirname + decodeURIComponent(fileName), 'binary',function(err, content){
        if (content != null && content != '' ){
            res.writeHead(200,{'Content-Length':content.length});
            res.write(content);
        }
        res.end();
    });

}).listen(8800);

Będzie renderować wszystkie pliki js, css i obraz, wraz z całą zawartością HTML.

Zgadzam się na stwierdzenie „ Żaden typ zawartości nie jest lepszy niż niewłaściwy ”

Nie jestem pewien, czy tego właśnie chciałeś, ale możesz spróbować zmienić:

{'Content-Type': 'text/plain'}

do tego:

{'Content-Type': 'text/html'}

Spowoduje to, że klient przeglądarki wyświetli plik jako HTML zamiast zwykłego tekstu.

var http = require('http');
var fs = require('fs');
var index = fs.readFileSync('index.html');

http.createServer(function (req, res) {
res.writeHead(200, {'Content-Type': 'html'});
res.end(index);
}).listen(9615);

//Just Change The CONTENT TYPE to 'html'

Nieco bardziej szczegółowa ekspresowa wersja 4.x, która zapewnia wyświetlanie katalogów, kompresję, buforowanie i rejestrowanie żądań w minimalnej liczbie wierszy

var express = require('express');
var compress = require('compression');
var directory = require('serve-index');
var morgan = require('morgan'); //logging for express

var app = express();

var oneDay = 86400000;

app.use(compress());
app.use(morgan());
app.use(express.static('filesdir', { maxAge: oneDay }));
app.use(directory('filesdir', {'icons': true}))

app.listen(process.env.PORT || 8000);

console.log("Ready To serve files !")

Szalona liczba skomplikowanych odpowiedzi tutaj. Jeśli nie zamierzasz przetwarzać plików / bazy danych nodeJS, a chcesz tylko wyświetlać statyczny plik HTML / CSS / JS / Images, jak sugeruje twoje pytanie, po prostu zainstaluj serwer pushstate moduł lub podobny;

Oto „jeden liner”, który utworzy i uruchomi mini-stronę. Po prostu wklej cały blok do terminala w odpowiednim katalogu.

mkdir mysite; \
cd mysite; \
npm install pushstate-server --save; \
mkdir app; \
touch app/index.html; \
echo '<h1>Hello World</h1>' > app/index.html; \
touch server.js; \
echo "var server = require('pushstate-server');server.start({ port: 3000, directory: './app' });" > server.js; \
node server.js

Otwórz przeglądarkę i przejdź do http: // localhost: 3000 . Gotowy.

Serwer użyje katalogu appjako katalogu głównego do udostępniania plików. Aby dodać dodatkowe zasoby, po prostu umieść je w tym katalogu.

Istnieją już świetne rozwiązania proste nodejs server. Jest jeszcze jedno rozwiązanie, jeśli potrzebujesz, live-reloadinggdy wprowadzasz zmiany w swoich plikach.

npm install lite-server -g

przeglądaj katalog i rób

lite-server

otworzy dla ciebie przeglądarkę z przeładowaniem na żywo.

Funkcja ekspresowa sendFile wykonuje dokładnie to, czego potrzebujesz, a ponieważ chcesz funkcjonować jako serwer sieciowy z węzła, ekspres jest naturalnym wyborem, a następnie udostępnianie plików statycznych staje się tak proste, jak:

res.sendFile('/path_to_your/index.html')

czytaj więcej tutaj: https://expressjs.com/en/api.html#res.sendFile

Mały przykład z ekspresowym serwerem WWW dla węzła:

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

app.get('/', function(req, res) {
    res.sendFile(path.join(__dirname + '/index.html'));
});

app.listen(8080);

uruchom to i przejdź do http: // localhost: 8080

Aby rozwinąć tę funkcję i umożliwić wyświetlanie plików statycznych, takich jak css i obrazy, oto inny przykład:

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

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

app.get('/', function(req, res) {
    res.sendFile(path.join(__dirname + '/index.html'));
});

app.listen(8080);

więc stwórz podfolder o nazwie css, umieść w nim zawartość statyczną, a będzie on dostępny dla twojego index.html dla łatwego odniesienia, np .:

<link type="text/css" rel="stylesheet" href="/css/style.css" />

Zwróć uwagę na względną ścieżkę w href!

voila!

Większość powyższych odpowiedzi bardzo ładnie opisuje, w jaki sposób podaje się treść. Dodatkowo szukałem dodatkowej listy katalogów, aby umożliwić przeglądanie innych treści katalogu. Oto moje rozwiązanie dla dalszych czytelników:

'use strict';

var finalhandler = require('finalhandler');
var http = require('http');
var serveIndex = require('serve-index');
var serveStatic = require('serve-static');
var appRootDir = require('app-root-dir').get();
var log = require(appRootDir + '/log/bunyan.js');

var PORT = process.env.port || 8097;

// Serve directory indexes for reports folder (with icons)
var index = serveIndex('reports/', {'icons': true});

// Serve up files under the folder
var serve = serveStatic('reports/');

// Create server
var server = http.createServer(function onRequest(req, res){
    var done = finalhandler(req, res);
    serve(req, res, function onNext(err) {
    if (err)
        return done(err);
    index(req, res, done);
    })
});


server.listen(PORT, log.info('Server listening on: ', PORT));

Jest to jedno z najszybszych rozwiązań, których używam do szybkiego przeglądania stron internetowych

sudo npm install ripple-emulator -g

Od tego momentu po prostu wpisz katalog swoich plików HTML i uruchom

ripple emulate

następnie zmień urządzenie na Nexus 7 landscape.

Prostsza wersja, z którą się spotkałem, jest następująca. Do celów edukacyjnych najlepiej jest, ponieważ nie korzysta z żadnych bibliotek abstrakcyjnych.

var http = require('http'),
url = require('url'),
path = require('path'),
fs = require('fs');

var mimeTypes = {
  "html": "text/html",
  "mp3":"audio/mpeg",
  "mp4":"video/mp4",
  "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);
    fs.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();
            return;
        }
        var mimeType = mimeTypes[path.extname(filename).split(".")[1]];
        res.writeHead(200, {'Content-Type':mimeType});

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

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

Teraz przejdź do przeglądarki i otwórz następujące:

http://127.0.0.1/image.jpg

Tutaj image.jpgpowinien znajdować się ten sam katalog co ten plik. Mam nadzieję, że to komuś pomoże :)

Mogę również polecić SugoiJS, jest bardzo łatwy w konfiguracji i daje możliwość szybkiego pisania i ma świetne funkcje.

Zajrzyj tutaj, aby rozpocząć: http://demo.sugoijs.com/ , dokumentacja: https://wiki.sugoijs.com/

Ma dekoratory obsługi żądań, polityki żądań i dekoratorów zasad autoryzacji.

Na przykład:

import {Controller,Response,HttpGet,RequestParam} from "@sugoi/server";
​
@Controller('/dashboard')
export class CoreController{
    constructor(){}
​
    @HttpGet("/:role")
    test(@RequestParam('role') role:string,
         @RequestHeader("role") headerRole:string){
        if(role === headerRole )
            return "authorized";
        else{
            throw new Error("unauthorized")
        }
    }
}

To jest bardzo łatwe z mnóstwem bibliotek prezentowanych dzisiaj. Odpowiedzi tutaj są funkcjonalne. Jeśli chcesz mieć inną wersję, aby rozpocząć szybciej i łatwiej

Oczywiście najpierw zainstaluj node.js. Później:

> # module with zero dependencies
> npm install -g @kawix/core@latest 
> # change /path/to/static with your folder or empty for current
> kwcore "https://raw.githubusercontent.com/voxsoftware/kawix-core/master/example/npmrequire/express-static.js" /path/to/static

Tutaj treść „ https://raw.githubusercontent.com/voxsoftware/kawix-core/master/example/npmrequire/express-static.js ” (nie musisz go pobierać, opublikowałem, aby zrozumieć, jak to działa)

// you can use like this:
// kwcore "https://raw.githubusercontent.com/voxsoftware/kawix-core/master/example/npmrequire/express.js" /path/to/static
// kwcore "https://raw.githubusercontent.com/voxsoftware/kawix-core/master/example/npmrequire/express.js" 

// this will download the npm module and make a local cache
import express from 'npm://express@^4.16.4'
import Path from 'path'

var folder= process.argv[2] || "."
folder= Path.resolve(process.cwd(), folder)
console.log("Using folder as public: " + folder)

var app = express() 
app.use(express.static(folder)) 
app.listen(8181)
console.log("Listening on 8181")