Servidor de arquivos rápido do Node.js. (arquivos estáticos sobre HTTP)


642

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


Eu escrevi um módulo chamado Cachemere, que permite fazer isso. Ele também armazena em cache automaticamente todos os seus recursos. Confira: github.com/topcloud/cachemere
Jon

npmjs.com/package/local-web-server - servidor Web estático leve, configuração zero
Victor

Respostas:


1091

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


10
Isso é incrível. Eu precisava especificar um endereço bc por algum motivo, o 0.0.0.0 padrão não estava cooperando com meu ambiente de desenvolvimento. http-server -a localhostficou er dun.
Sam Berry

41
Eu usohttp-server -a localhost -p 80
Muhammad Umer

10
Também vale a pena verificar a sincronização do navegador , que pode fazer mais ou menos a mesma coisa, mas com o bônus adicional de atualização ao vivo quando os arquivos são modificados.
Nick F

3
--corspara enviar Access-Control-Allow-Origin:*juntamente com os cabeçalhos de resposta (ou seja, ao servir um arquivo JSON)
Daniel F

9
npx http-server- o npx o transforma em uma linha que baixa os arquivos necessários e os executa.
9788 Mike McKay #

186

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

2
Certamente, response.writeHead(200deve ser response.writeHead(404;)
Thomas Hunter II

14
Esse código não permitiria subir na árvore de arquivos fazendo algo como 127.0.0.1/../../../etc/passwd ? Não vejo cheques contra isso.
Rolf

3
Se qualquer pessoa interessada na versão ES6 +, eu criei um servidor de arquivo estático que alças MIME tipos: gist.github.com/amejiarosario/53afae82e18db30dadc9bc39035778e5
Adrian

1
@ Adrian Este código é muito impressionante, mas eu encontrei uma maneira de obter acesso root com ele. A solução é limitar a quantidade de períodos iniciais no nome do arquivo para um, para que você não possa fazer nada ../../etc/password. gist.github.com/amejiarosario/53afae82e18db30dadc9bc39035778e5
Seph Reed

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

79

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

1
FYI Isso não funcionou para mim. Eu instalei o manipulador de arquivos usando npm install filehandlere o pacote está listado no node_modulesdiretório Mas quando eu corro myapp.jsnó lança um erro, dizendo Error: cannot find module filehandler. Se eu comentar sobre a exigência de ststment para carregar o manipulador de arquivos, o aplicativo carrega a estática de servir muito bem, então parece que há algo errado com o pacote filhandler. Hoje é 12 de dezembro de 2014, então talvez o pacote tenha sido alterado desde que esta resposta foi publicada?
Lee Jenkins

7
É finalmanipulador nãofile
jakub.g 12/12

outra vantagem dessa solução é que os arquivos não são armazenados em cache; portanto, você não precisa reiniciar um processo ao fazer alterações no código.
klimat

59

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

python -m SimpleHTTPServer [port]

Funciona bem e vem com o Python.


16
Python3 equivalentes: python -m http.server [port](a mencionada é para python2)
jakub.g

O Python falha para mim quando se trata de servir arquivos grandes, como imagens de SO. Fedora 23
Zimy 08/04

9
E no PHP:php -S localhost:8000
dennis

Eu uso isso para veicular rapidamente conteúdo de uma pasta o tempo todo.
Adrian Lynch

33

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

4
Isso não funciona mais na conexão 3, pois não expõe connect.static; ver a minha resposta abaixo de um substituto
jakub.g

4
Acredito que ele ainda esteja empacotado com o express por padrão, mas realmente existe agora em um requiremódulo capaz separado "serve-estático".
Oleg

18

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


1
Oi, eu posso executá-lo corretamente, mas mostra Cannot GET /. Eu uso o AWS EC2 para executar o servidor.
Wei Xia

1
@ Oi Oi, resposta tardia. Pelo que posso ver em uma rápida pesquisa no Google, parece que sua estrutura de diretórios pode estar errada. Deve haver um arquivo index.html no local que você está segmentando. A configuração do exemplo acima para execução deve levar 5 minutos e verifiquei se ele funciona como está. A partir daí, você pode ajustar o caminho para se adequar à sua estrutura de diretórios e verificar se o servidor ainda encontra os arquivos necessários para o servidor.
pasx

path.join(__dirname, 'public')é mais multiplataforma.
Sdgfsdh 2/08

17

Provas de uma linha ™ em vez de promessas

insira a descrição da imagem aqui

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


14

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 "


2
Não use a versão de sincronização. Instread criar pipe para res de readStream.
Eduard Bondarenko 28/06

1
Melhor resposta se você precisar de um pônei de truque único, rápido e sujo.
Collapsar

1
Se você deseja evitar o uso index.htmlcomo parte do seu endereço, adicione-o if (req.url === '/') req.url = '/index.html';logo em seguida res.writeHead(200);.
Joseph Cho

3
@EduardBondarenko está certo. const stream = fs.createReadStream(...); stream.pipe(res);é tudo que você precisa #
Justin Meiners

8

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.


2
A vantagem de usar o Browsersync em vez de outros servidores estáticos é que ele atualiza a página sempre que os arquivos especificados pelo --filessinalizador são alterados (por exemplo, você não precisa especificar ./*- apenas aqueles que você deseja que o Browsersync observe ativamente para atualizações, por exemplo, . css/*.css)
Nick F

7

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

6

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

Posso $ npm instalar -g express; eles $ express?
Paul Verest

Eu segui os seus passos, mas a minha expresso não tem bin pasta
Qwerty

6

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

Captura de tela de um índice de pasta usando a ferramenta

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!


5

A partir do npm@5.2.0, 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

4

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

});

4

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


4

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/


3

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



3

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


2

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


2

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

Atualização - Minha resposta funciona, mas agora uso a resposta do @Matt Self ao usar o servidor http. Isso parece funcionar bem.
HockeyJ

2

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 .


2

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

Você percebe que npmé o gerenciador de pacotes nó assim que você está de fato usando o material NodeJS
derickito

Entendo, o que eu quis dizer com "coisas do NodeJS" estava usando o NodeJS e expresso para servir os arquivos como a maioria das respostas sugeridas. O Serve é um executável independente, o NPM é usado apenas para instalá-lo, você pode fazer o download diretamente.
Diego Mendes

1

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


5
Eu construí esse servidor. Esse servidor de arquivos foi construído com uma versão muito antiga do Node, portanto, por que não funciona mais. Eu não tenho tempo agora para consertar isso. Sugiro usar a resposta de @Oleg acima. Ele pode ser facilmente empacotado em um pequeno nó executável e é essencialmente o que o meu fez de qualquer maneira.
Tim Heap

Obrigado Tim, resposta muito profissional. Eu não excluiria o código, mas atualizaria o leia-me.
Paul Verest

1

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



1

const http = require('http');
const fs = require('fs');
const url = require('url');
const path = require('path');


let mimeTypes = {
  '.html': 'text/html',
  '.css': 'text/css',
  '.js': 'text/javascript',
  '.jpg': 'image/jpeg',
  '.png': 'image/png',
  '.ico': 'image/x-icon',
  '.svg': 'image/svg+xml',
  '.eot': 'appliaction/vnd.ms-fontobject',
  '.ttf': 'aplication/font-sfnt'
};



http.createServer(function (request, response) {
  let pathName = url.parse(request.url).path;
  if(pathName === '/'){
    pathName = '/index.html';
  }
  pathName = pathName.substring(1, pathName.length);
  let extName = path.extName(pathName);
  let staticFiles = `${__dirname}/template/${pathName}`;

      if(extName =='.jpg' || extName == '.png' || extName == '.ico' || extName == '.eot' || extName == '.ttf' || extName == '.svg')
      {
          let file = fr.readFileSync(staticFiles);
          res.writeHead(200, {'Content-Type': mimeTypes[extname]});
          res.write(file, 'binary');
          res.end();
      }else {
        fs.readFile(staticFiles, 'utf8', function (err, data) {
          if(!err){
            res.writeHead(200, {'Content-Type': mimeTypes[extname]});
            res.end(data);
          }else {
            res.writeHead(404, {'Content-Type': 'text/html;charset=utf8'});
            res.write(`<strong>${staticFiles}</strong>File is not found.`);
          }
          res.end();
        });
      }
}).listen(8081);


Você deve adicionar alguma explicação alog com este código.
Abhinav Gauniyal 23/02

1

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



0

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/

Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.