Existe uma ferramenta pronta para uso do Node.js. (instalada com npm), que me ajudaria a expor o conteúdo da pasta como servidor de arquivos por HTTP.

Exemplo, se eu tiver

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

Começando em, D:\Folder\ node node-file-server.js eu poderia acessar o arquivo via

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

Por que meu servidor de arquivos estático do nó está descartando solicitações? referenciar alguns místicos

servidor de arquivos estático node.js padrão

Se não houver essa ferramenta, qual estrutura devo usar?

Relacionado: Servidor de arquivos estático básico no NodeJS

Uma boa opção "ferramenta pronta para uso" pode ser o servidor http:

npm install http-server -g

Para usá-lo:

cd D:\Folder
http-server

Ou assim:

http-server D:\Folder

Confira: https://github.com/nodeapps/http-server

Se você não quiser usar a ferramenta pronta, poderá usar o código abaixo, conforme demonstrado por mim em 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/');

ATUALIZAR Se você precisar acessar seu servidor a partir de demanda / arquivo externo, precisará superar o CORS, no arquivo node.js, escrevendo o abaixo, como mencionei em uma resposta anterior aqui

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

ATUALIZAR

Como Adrian mencionou, nos comentários, ele escreveu um código ES6 com explicações completas aqui , apenas re-publiquei seu código abaixo, caso o código saia do site original por qualquer motivo:

const http = require('http');
const url = require('url');
const fs = require('fs');
const path = require('path');
const port = process.argv[2] || 9000;

http.createServer(function (req, res) {
  console.log(`${req.method} ${req.url}`);

  // parse URL
  const parsedUrl = url.parse(req.url);
  // extract URL path
  let pathname = `.${parsedUrl.pathname}`;
  // based on the URL path, extract the file extention. e.g. .js, .doc, ...
  const ext = path.parse(pathname).ext;
  // maps file extention to MIME typere
  const map = {
    '.ico': 'image/x-icon',
    '.html': 'text/html',
    '.js': 'text/javascript',
    '.json': 'application/json',
    '.css': 'text/css',
    '.png': 'image/png',
    '.jpg': 'image/jpeg',
    '.wav': 'audio/wav',
    '.mp3': 'audio/mpeg',
    '.svg': 'image/svg+xml',
    '.pdf': 'application/pdf',
    '.doc': 'application/msword'
  };

  fs.exists(pathname, function (exist) {
    if(!exist) {
      // if the file is not found, return 404
      res.statusCode = 404;
      res.end(`File ${pathname} not found!`);
      return;
    }

    // if is a directory search for index file matching the extention
    if (fs.statSync(pathname).isDirectory()) pathname += '/index' + ext;

    // read file from file system
    fs.readFile(pathname, function(err, data){
      if(err){
        res.statusCode = 500;
        res.end(`Error getting the file: ${err}.`);
      } else {
        // if the file is found, set Content-type and send data
        res.setHeader('Content-type', map[ext] || 'text/plain' );
        res.end(data);
      }
    });
  });


}).listen(parseInt(port));

console.log(`Server listening on port ${port}`);

Para pessoas que desejam um servidor executável no script NodeJS:

Você pode usar expressjs / serve-static, que substitui connect.static(que não está mais disponível a partir do connect 3):

myapp.js:

var http = require('http');

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

var serve = serveStatic("./");

var server = http.createServer(function(req, res) {
  var done = finalhandler(req, res);
  serve(req, res, done);
});

server.listen(8000);

e depois na linha de comando:

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

Eu sei que não é Node, mas usei o SimpleHTTPServer do Python:

python -m SimpleHTTPServer [port]

Funciona bem e vem com o Python.

conectar pode ser o que você está procurando.

Instalado facilmente com:

npm install connect

Em seguida, o servidor de arquivos estático mais básico pode ser escrito como:

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

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

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

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

Crie um arquivo chamado server.js no mesmo nível do seu index.html com este conteúdo:

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

Se você deseja colocá-lo em um local diferente, defina o caminho na terceira linha:

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

CD na pasta que contém seu arquivo e execute o nó no console com este comando:

node server.js

Navegue até o host local: 8080

Provas de uma linha ™ em vez de promessas

O primeiro é http-server, hs- link

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

O segundo é serveda ZEIT.co - link

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

A seguir estão as opções disponíveis, se é isso que ajuda você a decidir.

C: \ Usuários \ Qwerty> servidor http --help
uso: servidor http [caminho] [opções]

opções:
  -p Porta para usar [8080]
  -a Endereço para usar [0.0.0.0]
  -d Mostrar listagens de diretório [true]
  -i Exibir autoIndex [true]
  -g --gzip Exibir arquivos gzip quando possível [false]
  -e --ext Extensão de arquivo padrão, se nenhuma for fornecida [nenhuma]
  -s --silent Suprime mensagens de log da saída
  --cors [= headers] Habilite o CORS através do cabeçalho "Access-Control-Allow-Origin"
                     Opcionalmente, forneça lista de cabeçalhos CORS separados por vírgulas
  -o [caminho] Abre a janela do navegador após iniciar o servidor
  -c Tempo do cache (idade máxima) em segundos [3600], por exemplo, -c10 por 10 segundos.
               Para desativar o cache, use -c-1.
  -U --utc Use o formato de hora UTC nas mensagens de log.

  -P --proxy Proxy Fallback se a solicitação não puder ser resolvida. por exemplo: http://someurl.com

  -S --ssl Ativa https.
  -C --cert Caminho para o arquivo cert SSL (padrão: cert.pem).
  -K --key Caminho para o arquivo de chaves ssl (padrão: key.pem).

  -r --robots Responda a /robots.txt [Agente do usuário: * \ nDisallow: /]
  -h --help Imprima esta lista e saia.

C: \ Usuários \ Qwerty> serve --help

  Uso: serve.js [opções] [comando]

  Comandos:

    help Exibir ajuda

  Opções:

    -a, --auth Serve atrás da autenticação básica
    -c, --cache Tempo em milissegundos para armazenar arquivos em cache no navegador
    -n, --clipless Não copia o endereço para a área de transferência (desativado por padrão)
    -C, --cors Setup * cabeçalhos CORS para permitir solicitações de qualquer origem (desativada por padrão)
    -h, --help Informações de uso da saída
    -i, --ignore Arquivos e diretórios a serem ignorados
    -o, --open Abrir endereço local no navegador (desativado por padrão)
    -p, --port Port para escutar (o padrão é 5000)
    -S, --silent Não registra nada no console
    Servir aplicativos de página única (define `-c` para 1 dia)
    -t, --treeless Não exibe árvore estática (desativado por padrão)
    -u, --unzipped Desativar compactação GZIP
    -v, --version Mostra o número da versão

Se você precisar prestar atenção nas mudanças, veja hostr, credite a resposta de Henry Tseng

SOMENTE DEMO / PROTO SERVER

Se é tudo o que você precisa, tente o seguinte:

const http = require('http');
const fs = require('fs');
const port = 3000;
const app = http.createServer((req,res) => {
    res.writeHead(200);
    if (req.url === '/') req.url = '/index.html'; // courtesy of @JosephCho
    res.end(fs.readFileSync(__dirname + req.url));
});

app.listen(port);

Nota: Você precisa usar "/index.html" como parte do seu endereço, por exemplo, " http: // localhost: 3000 / index.html "

Há outro servidor Web estático que é bastante interessante: sincronização do navegador.

Pode ser baixado usando o gerenciador de pacotes do nó:

npm install -g browser-sync

Após a instalação, navegue até a pasta do projeto no prompt do cmd e execute o seguinte:

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

Ele iniciará a restauração de todos os arquivos na pasta atual do navegador.

Mais informações podem ser encontradas no BrowserSync

Obrigado.

Não tive muita sorte com nenhuma das respostas nesta página, no entanto, abaixo parecia fazer o truque.

Adicione um server.jsarquivo com o seguinte conteúdo:

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)

Também verifique se você precisa express. Execute yarn add express --saveou npm install express --savedependendo da sua configuração (recomendo yarnque seja bem rápido).

Você pode mudar distpara qualquer pasta em que estiver exibindo seu conteúdo. Para o meu projeto simples, eu não estava servindo de nenhuma pasta, então simplesmente removi o distnome do arquivo.

Então você pode correr node server.js. Como tive que carregar meu projeto em um servidor Heroku, precisei adicionar o seguinte ao meu package.jsonarquivo:

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

Se você usar a estrutura Express , essa funcionalidade estará pronta.

Para configurar um aplicativo de veiculação de arquivo simples, faça o seguinte:

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

Aqui está meu projeto pet de servidor estático de arquivo único / node.js, arquivo estático, sem dependência, que acredito ser uma ferramenta rápida e rica, cuja utilização é tão fácil quanto emitir este comando no terminal Linux / Unix / macOS ( ou termux no Android) quando o node.js (ou nodejs-legacyno Debian / Ubuntu) estiver instalado:

curl pad.js.org | node 

(existem comandos diferentes para usuários do Windows na documentação)

Ele suporta coisas diferentes que acredito que podem ser úteis,

• Criação / veiculação de índice de diretório hierárquico
  • Com capacidade de classificação nos diferentes critérios
  • Carregar do navegador por arrastar e soltar [vários arquivos] e copiar / colar somente arquivo / texto e colar com captura de tela da área de transferência do sistema no Chrome, Firefox e outros navegadores podem ter algumas limitações (que podem ser desativadas pela linha de comando opções fornecidas)
  • Botão Pasta / criação de notas / upload
• Servindo MIMEs corretas para tipos de arquivos conhecidos (com possibilidade de desabilitar isso)
• Possibilidade de instalação como um pacote npm e ferramenta local ou instalação linear como um serviço permanente com o Docker
• Serviço de arquivos HTTP 206 (transferência de arquivos com várias partes) para transferências mais rápidas
• Uploads do terminal e do console do navegador (na verdade, ele foi originalmente concebido como um proxy do sistema de arquivos para o console JS dos navegadores em outras páginas / domínios)
• Download / upload de CORS (que também pode ser desativado)
• Fácil integração HTTPS
• Opções leves de linha de comando para obter uma melhor veiculação segura com ele:
  • Com meu patch no node.js 8 , você pode ter acesso às opções sem a primeira instalação:curl pad.js.org | node - -h
  • Ou primeiro instale-o como um pacote npm global do sistema [sudo] npm install -g pad.jse, em seguida, use sua versão instalada para ter acesso às suas opções:pad -h
  • Ou use a imagem do Docker fornecida, que usa opções relativamente seguras por padrão. [sudo] docker run --restart=always -v /files:/files --name pad.js -d -p 9090:9090 quay.io/ebraminio/pad.js

Os recursos descritos acima estão principalmente documentados na página principal da ferramenta http://pad.js.org, que por algum truque interessante que usei também é o local em que a fonte da ferramenta também é servida!

A fonte da ferramenta está no GitHub, que recebe seus comentários, solicitações de recursos e ⭐s!

A partir do [email protected], npmcomeçou a instalar um novo binário ao lado do npm usual chamado npx. Então agora, um forros para criar um servidor http estático a partir do diretório atual:

npx serve

ou

npx http-server

Para um aumento saudável do desempenho usando o nó para servir recursos estáticos, recomendo usar o Buffet . Funciona de maneira semelhante a um acelerador de aplicativos da web, também conhecido como proxy reverso HTTP em cache, mas apenas carrega o diretório escolhido na memória.

O Buffet adota uma abordagem totalmente em buffer - todos os arquivos são totalmente carregados na memória quando o aplicativo é inicializado, para que você nunca sinta a queima do sistema de arquivos. Na prática, isso é imensamente eficiente. Tanto que colocar o Verniz na frente do seu aplicativo pode torná-lo mais lento! 

Nós o usamos no site codePile e descobrimos um aumento de ~ 700 solicitações / s para> 4k solicitações / s em uma página que baixa 25 recursos sob uma carga de conexão simultânea de 1k do usuário.

Exemplo:

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

});

Dê uma olhada nesse link .

Você precisa apenas instalar o módulo expresso de node js.

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

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

Você pode acessar seu arquivo como http: //hostname/Folder/file.zip

Abaixo trabalhou para mim:

Crie um arquivo app.jscom o conteúdo abaixo:

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

Crie um arquivo index.htmlcom o conteúdo abaixo:

Hi

Inicie uma linha de comando:

cmd

Execute abaixo em cmd:

node app.js

Vá para o URL abaixo, no chrome:

http://localhost:8080/index.html

Isso é tudo. Espero que ajude.

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

Você pode tentar me servir

Usá-lo é tão fácil:

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

Isso é tudo.

PD: a pasta servida por padrão é "pública".

Aqui está outro servidor web simples.

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

Instalar

npm install -g hostr

Mudar diretor de trabalho

cd myprojectfolder/

E começar

hostr

No node.js simples:

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

Este é um servidor node.j simples que serve apenas os arquivos solicitados em um determinado diretório.

Uso:

node server.js folder port

folderpode ser absoluto ou relativo, dependendo da server.jslocalização. O valor padrão é .qual é o diretório que você executa o node server.jscomando.

port é 8080 por padrão, mas você pode especificar qualquer porta disponível no seu sistema operacional.

No seu caso, eu faria:

cd D:\Folder
node server.js

Você pode procurar os arquivos em D:\Folderum navegador digitandohttp://127.0.0.1:8080/somefolder/somefile.html

Ainda não está no NPM, mas eu construí um servidor estático simples no Express que também permite aceitar envios de formulários e enviá-los por email através de um serviço de email transacional (Sendgrid por enquanto, Mandrill chegando).

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

Para o benefício dos pesquisadores, gostei da resposta de Jakub g, mas queria um pouco de tratamento de erros. Obviamente, é melhor lidar com os erros corretamente , mas isso deve ajudar a impedir que um site seja interrompido se ocorrer um erro. Código abaixo:

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

Primeiro instale o servidor estático do nó via npm install node-static -g -g é instalá-lo globalmente em seu sistema e, em seguida, navegue até o diretório em que seus arquivos estão localizados, inicie o servidor com static a escuta na porta 8080, navegue até o navegador e digite localhost: 8080 / yourhtmlfilename .

Você pode usar o pacote de veiculação do NPM para isso, se não precisar do material do NodeJS, é uma ferramenta rápida e fácil de usar:

1 - Instale o pacote no seu PC:

npm install -g serve

2 - Sirva sua pasta estática com serve <path>:

d:> serve d:\StaticSite

Ele mostrará qual porta sua pasta estática está sendo servida, basta navegar para o host como:

http://localhost:3000

Pesquisando no registro NPM https://npmjs.org/search?q=server , encontrei o static-server https://github.com/maelstrom/static-server

Você já precisou enviar um arquivo para um colega, mas não pode se incomodar em enviar um e-mail para a besta de 100 MB? Queria executar um exemplo de aplicativo JavaScript simples, mas teve problemas ao executá-lo através do arquivo: /// protocol? Queria compartilhar seu diretório de mídia em uma LAN sem configurar o Samba, FTP ou qualquer outra coisa que exija a edição de arquivos de configuração? Então esse servidor de arquivos facilitará sua vida um pouco.

Para instalar o servidor estático simples, use o npm:

npm install -g static-server

Para servir um arquivo ou diretório, basta executar

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

Isso pode até listar o conteúdo da pasta.

Infelizmente, não foi possível veicular arquivos :)

Um Static-Server simples usando o connect

var connect = require('connect'),
  directory = __dirname,
  port = 3000;

connect()
  .use(connect.logger('dev'))
  .use(connect.static(directory))
  .listen(port);

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

Consulte também Usando o node.js como um servidor da web simples

Para trabalho em desenvolvimento, você pode usar (express 4) https://github.com/appsmatics/simple-httpserver.git

Se você está interessado em um servidor http ultraleve, sem pré-requisitos, consulte: mongoose

Uso Houston no trabalho e em projetos pessoais, funciona bem para mim.

https://github.com/alejandro/Houston

Você também perguntou por que as solicitações estão caindo - não tenho certeza qual é o motivo específico do seu caso, mas, em geral, você melhora o conteúdo estático do servidor usando middleware dedicado (nginx, S3, CDN) porque o Node realmente não é otimizado para esse padrão de rede. Veja mais explicações aqui (ponto 13): http://goldbergyoni.com/checklist-best-practice-of-node-js-in-production/