Самый простой сервер Node.js - это просто:

$ npm install http-server -g

Теперь вы можете запустить сервер с помощью следующих команд:

$ cd MyApp

$ http-server

Если вы используете NPM 5.2.0 или новее, вы можете использовать http-server, не устанавливая его с npx. Это не рекомендуется для использования в производственной среде, но это отличный способ быстро запустить сервер на localhost.

$ npx http-server

Или вы можете попробовать это, чтобы открыть ваш веб-браузер и разрешить запросы CORS:

$ http-server -o --cors

Дополнительные параметры см. В документации для http-server на GitHub или выполните:

$ http-server --help

Множество других приятных функций и невероятно простое развертывание в NodeJitsu.

Функциональные вилки

Конечно, вы можете легко пополнить возможности собственным форком. Возможно, вы обнаружите, что это уже сделано в одной из существующих более 800 форков этого проекта:

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

Легкий сервер: альтернатива автообновлению

Хорошая альтернатива http-server - light-server. Он поддерживает просмотр файлов и автоматическое обновление, а также многие другие функции.

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

Добавить в контекстное меню каталога в проводнике Windows

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

Простой сервер JSON REST

Если вам нужно создать простой REST-сервер для прототипа проекта, тогда json-server может быть тем, чем вы ищем.

Автообновление редакторов

Большинство редакторов веб-страниц и инструментов IDE теперь включают веб-сервер, который будет отслеживать ваши исходные файлы и автоматически обновлять вашу веб-страницу при их изменении.

Я использую Live Server с Visual Studio Code.

Текстовый редактор с открытым исходным кодом Brackets также включает статический веб-сервер NodeJS. Просто откройте любой HTML-файл в скобках, нажмите Live Preview, и он запустит статический сервер и откроет ваш браузер на странице. Браузер будет автоматически обновляться всякий раз, когда вы редактируете и сохраняете HTML-файл. Это особенно полезно при тестировании адаптивных веб-сайтов. Откройте свою HTML-страницу в разных браузерах / размерах окон / устройствах. Сохраните свою HTML-страницу и сразу проверьте, работают ли ваши адаптивные элементы, поскольку они все обновляются автоматически.

Веб-разработчики / веб-сайты / SPA / PWA / мобильные устройства / ПК / браузеры (Ext)

Некоторые фреймворки SPA включают встроенную версию Webpack DevServer, которая может обнаруживать изменения исходного файла. и запускать инкрементную перестройку и исправление (так называемую горячую перезагрузку) вашего веб-приложения SPA или PWA. Вот несколько популярных фреймворков SPA, которые могут это сделать.

Разработчики VueJS

Для разработчиков VueJS фаворитом является Quasar Framework, который из коробки включает Webpack DevServer с переключателями для поддержки рендеринга на стороне сервера. (SSR) и правила прокси для устранения проблем с CORS. Он включает в себя большое количество оптимизированных компонентов, предназначенных для адаптации как для мобильных, так и для настольных компьютеров. Это позволяет вам создавать одно приложение для ВСЕХ платформ (SPA, SPA + SSR, PWA, PWA + SSR, приложения Cordova и Capacitor Mobile AppStore, приложения Electron Desktop Node + VueJS и даже расширения для браузера).

Другой популярный - NuxtJS, который также поддерживает генерацию статического кода HTML / CSS, а также режимы сборки SSR или без SSR с плагинами. для других наборов компонентов пользовательского интерфейса.

Разработчики React Framework

Разработчики ReactJS также могут настроить горячую перезагрузку.

Разработчики Cordova / Capacitor + Ionic Framework

Iconic - это только для мобильных гибридных компонентов, которые теперь поддерживают разработку на VueJS, React и Angular. Локальный сервер с функциями автоматического обновления встроен в инструмент ionic. Просто запустите ionic serve из папки вашего приложения. Еще лучше ... ionic serve --lab, чтобы просматривать автоматически обновляющиеся параллельные представления iOS и Android .

Примечание. Это ответ 2011 года. Однако он все еще действителен.

Вы можете использовать Connect и ServeStatic с Node.js для этого:

1. Установите connect и serve-static с помощью NPM

    $ npm install connect serve-static
   

2. Создайте файл server.js с таким содержимым:

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

3. Запускаем с Node.js

    $ node server.js
   

Теперь вы можете перейти к http://localhost:8080/yourfile.html

Ознакомьтесь с этой сутью. Я воспроизвожу его здесь для справки, но суть регулярно обновляется.

Статический файловый веб-сервер Node.JS. Поместите его в свой путь для запуска серверов в любом каталоге, принимает необязательный аргумент порта.

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

Обновить

Суть действительно обрабатывает файлы css и js. Сам использовал. Использование чтения / записи в «двоичном» режиме не проблема. Это просто означает, что файл не интерпретируется библиотекой файлов как текст и не связан с типом содержимого, возвращаемым в ответе.

Проблема с вашим кодом в том, что вы всегда возвращаете тип содержимого «текст / простой». Приведенный выше код не возвращает какой-либо тип содержимого, но если вы просто используете его для HTML, CSS и JS, браузер может легко вывести их. Нет лучше, чем неправильный тип содержания.

Обычно тип содержимого - это конфигурация вашего веб-сервера. Так что извините, если это не решит вашу проблему, но он работал для меня как простой сервер разработки и думал, что это может помочь другим людям. Если вам действительно нужны правильные типы содержимого в ответе, вам нужно либо явно определить их, как у joeytwiddle, либо использовать библиотеку, такую ​​как Connect, с разумными значениями по умолчанию. Приятно то, что он простой и самодостаточный (без зависимостей).

Но я чувствую вашу проблему. Итак, вот комбинированное решение.

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

Экспресс не нужен. Вам не нужно подключаться. Node.js делает http ЕСТЕСТВЕННО. Все, что вам нужно сделать, это вернуть файл, зависящий от запроса:

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)    

Более полный пример, который гарантирует, что запросы не могут получить доступ к файлам в базовом каталоге и правильно обрабатывает ошибки:

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)

Я думаю, что вам сейчас не хватает того, что вы отправляете:

Content-Type: text/plain

Если вы хотите, чтобы веб-браузер отображал HTML, вы должны изменить это на:

Content-Type: text/html

Шаг 1 (внутри командной строки [надеюсь, вы перейдете в СВОЮ ПАПКУ]): npm install express

Шаг 2. Создайте файл 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);

Обратите внимание, вы также должны добавить WATCHFILE (или использовать nodemon). Приведенный выше код предназначен только для простого сервера подключения.

ШАГ 3: node server.js или nodemon server.js

Теперь есть более простой способ, если вам просто нужен простой HTTP-сервер. npm install -g http-server

и откройте наш каталог и введите http-server

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

Быстрый способ:

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

Ваш путь:

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

Я считаю, что лучше искать тип контента в словаре, чем иметь дело с оператором switch:

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

...

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

В основном это обновленная версия принятого ответа для версии подключения 3:

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

var app = connect();

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

Я также добавил параметр по умолчанию, чтобы index.html использовался по умолчанию.

Вам не нужно использовать какие-либо модули NPM для запуска простого сервера, для Node есть очень крошечная библиотека под названием «NPM Free Server»:

• Бесплатный сервер NPM на GitHub

50 строк кода, выводит, если вы запрашиваете файл или папку, и дает им красный или зеленый цвет, если он не сработал. Размер менее 1 КБ (уменьшенный).

если на вашем ПК установлен узел, вероятно, у вас есть NPM, если вам не нужны материалы NodeJS, вы можете использовать serve для этого:

1 - Установите пакет на свой компьютер:

npm install -g serve

2 - Обслуживайте свою статическую папку:

serve <path> 
d:> serve d:\StaticSite

Он покажет вам, какой порт обслуживается вашей статической папкой, просто перейдите к хосту, например:

http://localhost:3000

Вы можете просто ввести их в свою оболочку

npx serve

Репо: https://github.com/zeit/serve.

Я нашел интересную библиотеку на npm, которая может быть вам полезна. Это называется пантомима (npm install mime или https://github.com/broofa/node-mime) и может определять пантомиму тип файла. Вот пример написанного мной веб-сервера:

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

Он будет обслуживать любой обычный текстовый или графический файл (.html, .css, .js, .pdf, .jpg, .png, .m4a и .mp3 - это расширения, которые я тестировал, но теоретически он должен работать для всего)

Примечания разработчика

Вот пример вывода, который я получил с ним:

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

Обратите внимание на функцию unescape в построении пути. Это позволяет использовать имена файлов с пробелами и закодированными символами.

Редактировать:

Пример приложения Node.js Node Chat имеет нужную вам функциональность.
В нем README.textfile
3. Шаг - это то, что вы ищете.

шаг 1

• создать сервер, который отвечает hello world на порту 8002

шаг 2

• создать index.html и обслужить его

шаг 3

• представить util.js
• изменить логику, чтобы обслуживать любой статический файл
• показать 404, если файл не найден

step4

• добавить jquery-1.4.2.js
• добавить client.js
• измените index.html, чтобы запрашивать у пользователя псевдоним

Вот server.js

Вот util.js

Я делаю это, прежде всего, глобально установить статический сервер узла через

npm install node-static -g

затем перейдите в каталог, содержащий ваши html-файлы, и запустите статический сервер с static.

Зайдите в браузер и введите 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);

Я думаю, вы искали это. В вашем index.html просто заполните его обычным html-кодом - все, что вы хотите отобразить на нем, например:

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

В основном копирование принятого ответа, но избегание создания файла js.

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

Было очень удобно.

Обновлять

В последней версии Express serve-static стал отдельным промежуточным программным обеспечением. Используйте это, чтобы служить:

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

Сначала установите serve-static.

Я использую приведенный ниже код для запуска простого веб-сервера, который отображает html-файл по умолчанию, если в 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);

Он отобразит все файлы js, css и изображения вместе со всем содержимым html.

Согласитесь с утверждением "Нет лучше неправильного типа содержания"

из w3schools

довольно легко создать сервер узла для обслуживания любого запрошенного файла, и вам не нужно устанавливать для него какие-либо пакеты

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

будет обслуживать file.html с диска

Я не уверен, что это именно то, что вы хотели, однако вы можете попробовать изменить:

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

к этому:

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

Это заставит клиент браузера отображать файл как html вместо обычного текста.

Экспресс-функция sendFile делает именно то, что вам нужно, и, поскольку вам нужна функциональность веб-сервера от узла, экспресс является естественным выбором, и тогда обслуживание статических файлов становится таким же простым, как:

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

подробнее читайте здесь: https://expressjs.com/en/api.html#res.sendFile

Небольшой пример с экспресс-веб-сервером для узла:

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

запустите это и перейдите к http://localhost:8080

Чтобы расширить это, чтобы вы могли обслуживать статические файлы, такие как css и изображения, вот еще один пример:

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

поэтому создайте подпапку css, поместите в нее свой статический контент, и он будет доступен в вашем index.html для удобства, например:

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

Обратите внимание на относительный путь в href!

вуаля!

Немного более подробная экспресс-версия 4.x, но обеспечивающая перечисление каталогов, сжатие, кеширование и ведение журнала запросов в минимальном количестве строк.

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 !")

Безумное количество сложных ответов. Если вы не собираетесь обрабатывать файлы / базу данных nodeJS, а просто хотите обслуживать статические html / css / js / images, как предлагает ваш вопрос, просто установите pushstate-server или аналогичный;

Вот «один лайнер», который создаст и запустит мини-сайт. Просто вставьте весь этот блок в свой терминал в соответствующий каталог.

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

Откройте браузер и перейдите по адресу http://localhost:3000. Выполнено.

Сервер будет использовать каталог app в качестве корневого каталога для обслуживания файлов. Чтобы добавить дополнительные ресурсы, просто поместите их в этот каталог.

Уже есть отличные решения для простого nodejs server. Есть еще одно решение, если вам нужно live-reloading, когда вы вносите изменения в свои файлы.

npm install lite-server -g

перейдите в свой каталог и сделайте

lite-server

он откроет для вас браузер с перезагрузкой в ​​реальном времени.

Большинство ответов выше очень хорошо описывают, как обслуживается содержимое. Что я искал как дополнительный, так это перечисление каталога, чтобы можно было просматривать другое содержимое каталога. Вот мое решение для дальнейших читателей:

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

Более простая версия, с которой я столкнулся, выглядит следующим образом. Это лучше всего для образовательных целей, поскольку в нем не используются абстрактные библиотеки.

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

Теперь перейдите в браузер и откройте следующее:

http://127.0.0.1/image.jpg

Здесь image.jpg должен находиться в том же каталоге, что и этот файл. Надеюсь, это кому-то поможет :)

Определенно стоит взглянуть на локальный веб-сервер! Вот отрывок из ридми:

локальный веб-сервер

Компактный модульный веб-сервер для быстрой полнофункциональной разработки.

• Поддерживает HTTP, HTTPS и HTTP2.
• Маленький и на 100% персонализированный. Загружайте и используйте только то поведение, которое требуется для вашего проекта.
• Прикрепите настраиваемый вид, чтобы персонализировать визуализацию деятельности.
• Программные интерфейсы и интерфейсы командной строки.

Используйте этот инструмент, чтобы:

• Создавайте интерфейсные веб-приложения любого типа (статические, динамические, одностраничные, прогрессивные веб-приложения, React и т. Д.).
• Прототип серверной службы (REST API, микросервис, веб-сокет, служба событий, отправленных сервером и т. Д.).
• Отслеживайте активность, анализируйте производительность, экспериментируйте со стратегией кеширования и т. Д.

Локальный веб-сервер - это распространение lws в комплекте с «стартовым пакетом» полезного промежуточного программного обеспечения.

Синопсис

Этот пакет устанавливает инструмент командной строки ws (ознакомьтесь с использованием руководство).

Статический веб-сайт

Запуск ws без аргументов приведет к размещению текущего каталога как статического веб-сайта. При переходе к серверу отобразится список каталогов или ваш index.html, если этот файл существует.

$ ws
Listening on http://mbp.local:8000, http://127.0.0.1:8000, http://192.168.0.100:8000

Руководство по статическим файлам.

В этом ролике демонстрируется статический хостинг плюс пара форматов вывода журнала - dev и stats.

Одностраничное приложение

Serving a Single Page Application (an app with client-side routing, e.g. a React or Angular app) is as trivial as specifying the name of your single page:

$ ws --spa index.html

Для статического сайта запросы на типичные пути SPA (например, /user/1, /login) вернут 404 Not Found, поскольку файл в этом месте не существует. Однако, помечая index.html как SPA, вы создаете это правило:

Если запрошен статический файл (например, /css/style.css), тогда обслуживайте его, если нет (например, /login), то обслуживайте указанный SPA и обрабатывайте маршрут на стороне клиента.

SPA, руководство.

Перезапись URL и прокси-запросы

Другой распространенный вариант использования - пересылка определенных запросов на удаленный сервер.

Следующая команда передает запросы сообщений в блоге по любому пути, начинающемуся с /posts/ до https://jsonplaceholder.typicode.com/posts/. Например, запрос на /posts/1 будет проксирован на https://jsonplaceholder.typicode.com/posts/1.

$ ws --rewrite '/posts/(.*) -> https://jsonplaceholder.typicode.com/posts/$1'

Руководство по перезаписи.

Этот клип демонстрирует вышесказанное плюс использование --static.extensions для указания расширения файла по умолчанию и --verbose для отслеживания активности.

HTTPS и HTTP2

For HTTPS or HTTP2, pass the --https or --http2 flags respectively. See the wiki for further configuration options and a guide on how to get the "green padlock" in your browser.

$ lws --http2
Listening at https://mba4.local:8000, https://127.0.0.1:8000, https://192.168.0.200:8000

Веб-сервер Node.js с нуля

Отсутствие сторонних фреймворков; Разрешает строку запроса; Добавляет завершающую косую черту; Обрабатывает 404

Создайте public_html подпапку и поместите в нее все свое содержимое.

Суть: https://gist.github.com/veganaize/fc3b9aa393c54c688a284/ а>

var fs = require('fs');

require('http').createServer(function(request, response) {
  var path = 'public_html'+ request.url.slice(0,
      (request.url.indexOf('?')+1 || request.url.length+1) - 1);
      
  fs.stat(path, function(bad_path, path_stat) {
    if (bad_path) respond(404);
    else if (path_stat.isDirectory() && path.slice(-1) !== '/') {
      response.setHeader('Location', path.slice(11)+'/');
      respond(301);
    } else fs.readFile(path.slice(-1)==='/' ? path+'index.html' : path,
          function(bad_file, file_content) {
      if (bad_file) respond(404);
      else respond(200, file_content);
    });
  });
 
  function respond(status, content) {
    response.statusCode = status;
    response.end(content);
  }
}).listen(80, function(){console.log('Server running on port 80...')});

Это одно из самых быстрых решений, которые я использую для быстрого просмотра веб-страниц.

sudo npm install ripple-emulator -g

С этого момента просто войдите в каталог ваших html-файлов и запустите

ripple emulate

затем измените устройство на Nexus 7 в альбомной ориентации.

Я также могу порекомендовать SugoiJS, он очень прост в настройке, дает возможность быстро начать писать и имеет отличные функции.

Чтобы начать работу, загляните сюда: http://demo.sugoijs.com/, документация: https://wiki.sugoijs.com/

Он имеет декораторы обработки запросов, политики запросов и декораторы политик авторизации.

Например:

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

Это очень просто с множеством представленных сегодня библиотек. Ответы здесь функциональные. Если вам нужна другая версия для более быстрого и простого запуска

Конечно, сначала установите node.js. Потом:

> # 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

Здесь содержимое "https://raw.githubusercontent.com/voxsoftware/kawix-core/master/example/npmrequire/express-static.js "(вам не нужно загружать его, я опубликовал, чтобы понять, как работает)

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

Создайте простой веб-сервер Node.js и асинхронно обслуживайте HTML-страницу из файла

Создавая свой первый сервер node.js, я нашел простой и эффективный способ сделать это.

Вместо того, чтобы загружать HTML для каждого запроса, мы можем загрузить его один раз в начале. Затем верните данные, которые мы загрузили при запуске.

const host = "localhost";
const port = 5000;
const http = require("HTTP");
const fs = require("fs").promises;

let htmlFile;
const reqListenerFunc = function (req, resp) {
    resp.setHeader("Content-Type", "text/html");
    resp.writeHead(200);
    resp.end(htmlFile);
};
const simpleServer = http.createServer(reqListenerFunc);

// // Using Arrow function directly
// const simpleServer = http.createServer( (req, resp) => {
//     resp.setHeader("Content-Type", "text/html");
//     resp.writeHead(200);
//     resp.end(htmlFile);
// });

fs.readFile(__dirname + "/index.html")
    .then(content => {
        htmlFile = content;
        simpleServer.listen(port, host, () => {
            console.log(`Node.js web server is running on http://${host}:${port}`);
        });
    })
    .catch(err => {
        console.error(`Cannot read index.html file. <br> Error: ${err}`);
        process.exit(1);
    });

Подробнее: https://www.digitalocean.com/community/tutorials/how-to-create-a-web-server-in-node-js-with-the-http-module