¿Existe una herramienta lista para usar Node.js (instalada con npm), que me ayudaría a exponer el contenido de la carpeta como servidor de archivos a través de HTTP.

Ejemplo, si tengo

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

Luego, comenzando D:\Folder\ node node-file-server.js , pude acceder al archivo a través de

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

¿Por qué mi servidor de archivos estáticos de nodo descarta las solicitudes? referencia alguna mística

servidor de archivos estático node.js estándar

Si no existe tal herramienta, ¿qué marco debo usar?

Relacionado: Servidor de archivos estático básico en NodeJS

Una buena opción de "herramienta lista para usar" podría ser http-server:

npm install http-server -g

Para usarlo:

cd D:\Folder
http-server

O así:

http-server D:\Folder

Compruébalo: https://github.com/nodeapps/http-server

Si no desea usar la herramienta ready, puede usar el código a continuación, como lo demostré en 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/');

ACTUALIZACIÓN Si necesita acceder a su servidor desde una demanda / archivo externo, debe superar el CORS, en su archivo node.js escribiendo lo siguiente, como mencioné en una respuesta anterior aquí

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

ACTUALIZAR

Como mencionó Adrian, en los comentarios, escribió un código ES6 con una explicación completa aquí , solo volví a publicar su código a continuación, en caso de que el código haya desaparecido del sitio original por algún 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 las personas que desean un servidor ejecutable desde el script NodeJS:

Puede usar expressjs / serve-static que reemplaza connect.static(que ya no está disponible a partir de 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);

y luego desde la línea de comando:

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

Sé que no es Node, pero he usado el SimpleHTTPServer de Python:

python -m SimpleHTTPServer [port]

Funciona bien y viene con Python.

conectar podría ser lo que estás buscando.

Instalado fácilmente con:

npm install connect

Entonces el servidor de archivos estático más básico podría escribirse como:

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

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

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

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

Cree un archivo llamado server.js en el mismo nivel de su index.html con este contenido:

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

Si desea colocarlo en una ubicación diferente, configure la ruta en la tercera línea:

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

CD a la carpeta que contiene su archivo y ejecute el nodo desde la consola con este comando:

node server.js

Navegar hasta localhost: 8080

Pruebas One-line ™ en lugar de promesas

El primero es http-server, hs- enlace

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

El segundo es servepor ZEIT.co - enlace

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

Las siguientes son opciones disponibles, si esto es lo que le ayuda a decidir.

C: \ Users \ Qwerty> http-server --help
uso: http-server [ruta] [opciones]

opciones:
  -p Puerto para usar [8080]
  -una dirección para usar [0.0.0.0]
  -d Mostrar listados de directorio [verdadero]
  -i Mostrar autoIndex [verdadero]
  -g --gzip Servir archivos gzip cuando sea posible [falso]
  -e --ext Extensión de archivo predeterminada si no se proporciona ninguna [ninguna]
  -s --silent Suprime los mensajes de registro de la salida
  --cors [= encabezados] Habilite CORS a través del encabezado "Access-Control-Allow-Origin"
                     Opcionalmente, proporcione la lista de encabezados CORS separados por comas
  -o [ruta] Abre la ventana del navegador después de iniciar el servidor
  -c Tiempo de caché (edad máxima) en segundos [3600], por ejemplo, -c10 durante 10 segundos.
               Para deshabilitar el almacenamiento en caché, use -c-1.
  -U --utc Usa el formato de hora UTC en los mensajes de registro.

  -P: proxy proxy alternativo si la solicitud no se puede resolver. Por ejemplo: http://someurl.com

  -S --ssl Habilitar https.
  -C --cert Path al archivo ssl cert (predeterminado: cert.pem).
  -K --key Ruta al archivo de clave ssl (predeterminado: key.pem).

  -r --robots Responde a /robots.txt [User-agent: * \ nDisallow: /]
  -h --help Imprime esta lista y sal.

C: \ Users \ Qwerty> serve --help

  Uso: serve.js [opciones] [comando]

  Comandos:

    ayuda Mostrar ayuda

  Opciones:

    -a, --auth Servir detrás de la autenticación básica
    -c, --cache Time en milisegundos para el almacenamiento en caché de archivos en el navegador
    -n, --clipless No copie la dirección al portapapeles (deshabilitado de forma predeterminada)
    -C, --cors Setup * Encabezados CORS para permitir solicitudes de cualquier origen (deshabilitado por defecto)
    -h, --help Información de uso de salida
    -i, - ignorar archivos y directorios a ignorar
    -o, --open Abrir dirección local en el navegador (deshabilitado por defecto)
    -p, --port Puerto para escuchar (predeterminado en 5000)
    -S, --silent No registre nada en la consola
    -s, --single Serve aplicaciones de una sola página (establece `-c` en 1 día)
    -t, --treeless No muestra el árbol de estadísticas (deshabilitado por defecto)
    -u, --unzipped Deshabilita la compresión GZIP
    -v, --version Muestra el número de versión

Si necesita ver los cambios, vea hostr, acredite la respuesta de Henry Tseng

SERVIDOR DEMO / PROTO SOLAMENTE

Si eso es todo lo que necesitas, prueba esto:

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: debe usar "/index.html" como parte de su dirección, es decir, " http: // localhost: 3000 / index.html "

Hay otro servidor web estático que es bastante agradable: sincronización de navegador.

Se puede descargar usando el administrador de paquetes de nodos:

npm install -g browser-sync

Después de la instalación, navegue a la carpeta del proyecto en el indicador de cmd y simplemente ejecute lo siguiente:

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

Comenzará a atender todos los archivos en la carpeta actual en el navegador.

Se puede encontrar más información desde BrowserSync

Gracias.

No he tenido mucha suerte con ninguna de las respuestas en esta página, sin embargo, a continuación, parecía ser el truco.

Agregue un server.jsarchivo con el siguiente contenido:

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)

También asegúrese de que lo requiera express. Correr yarn add express --saveonpm install express --save dependiendo de su configuración (puedo recomendar yarnque es bastante rápido).

Usted puede cambiar dist a la carpeta en la que está sirviendo su contenido. Para mi proyecto simple, no estaba sirviendo desde ninguna carpeta, así que simplemente eliminé el distnombre del archivo.

Entonces puedes correr node server.js. Como tenía que cargar mi proyecto en un servidor Heroku, necesitaba agregar lo siguiente a mi package.jsonarchivo:

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

Si usa el marco Express , esta funcionalidad viene lista para usar .

Para configurar una aplicación de servicio de archivos simple, simplemente haga esto:

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

Aquí está mi proyecto de mascota de servidor web de un solo archivo / peso ligero node.js sin dependencia que creo que es una herramienta rápida y rica cuyo uso es tan fácil como emitir este comando en su terminal Linux / Unix / macOS ( o termux en Android) cuando node.js (o nodejs-legacyen Debian / Ubuntu) está instalado:

curl pad.js.org | node 

(existen diferentes comandos para usuarios de Windows en la documentación)

Admite diferentes cosas que creo que pueden ser útiles,

• Creación / publicación de índice de directorio jerárquico
  • Con capacidad de clasificación según los diferentes criterios
  • Cargue desde el navegador arrastrando y soltando [varios archivos] y copiando / pegando solo archivos / texto y pegando capturas de pantalla del portapapeles del sistema en Chrome, Firefox y otros navegadores con algunas limitaciones (que pueden desactivarse mediante la línea de comandos opciones que proporciona)
  • Carpeta / creación de notas / botón de carga
• Sirviendo MIMEs correctos para tipos de archivos bien conocidos (con posibilidad de deshabilitar eso)
• Posibilidad de instalación como paquete npm y herramienta local o, instalación lineal como servicio permanente con Docker
• Publicación de archivos HTTP 206 (transferencia de archivos de varias partes) para transferencias más rápidas
• Cargas desde el terminal y la consola del navegador (de hecho, originalmente estaba destinado a ser un proxy del sistema de archivos para la consola JS de los navegadores en otras páginas / dominios)
• Descargas / cargas de CORS (que también se pueden desactivar)
• Fácil integración HTTPS
• Opciones de línea de comandos livianas para lograr un mejor servicio seguro con él:
  • Con mi parche en node.js 8 , puede tener acceso a las opciones sin la primera instalación:curl pad.js.org | node - -h
  • O primero instálelo como un paquete npm global del sistema [sudo] npm install -g pad.jsy luego use su versión instalada para tener acceso a sus opciones:pad -h
  • O use la imagen Docker proporcionada que usa opciones relativamente seguras de forma predeterminada. [sudo] docker run --restart=always -v /files:/files --name pad.js -d -p 9090:9090 quay.io/ebraminio/pad.js

Las características descritas anteriormente están documentadas principalmente en la página principal de la herramienta http://pad.js.org que por algún buen truco que utilicé también es el lugar desde el que también se sirve la fuente de la herramienta.

La fuente de la herramienta está en GitHub, que agradece sus comentarios, solicitudes de funciones y ⭐s.

Desde [email protected], npmcomencé a instalar un nuevo binario junto con el npm habitual llamado npx. Así que ahora, uno se alinea para crear un servidor http estático desde el directorio actual:

npx serve

o

npx http-server

Para un aumento saludable del rendimiento usando el nodo para servir recursos estáticos, recomiendo usar Buffet . Funciona de manera similar a un acelerador de aplicaciones web, también conocido como proxy inverso HTTP en caché, pero solo carga el directorio elegido en la memoria.

Buffet adopta un enfoque totalmente protegido: todos los archivos se cargan completamente en la memoria cuando se inicia la aplicación, por lo que nunca sentirá la quema del sistema de archivos. En la práctica, esto es inmensamente eficiente. ¡Tanto es así que poner Varnish frente a tu aplicación incluso podría hacerlo más lento! 

Lo usamos en el sitio codePile y encontramos un aumento de ~ 700 solicitudes / seg a> 4k solicitudes / seg en una página que descarga 25 recursos bajo una carga de conexión de usuario concurrente de 1k.

Ejemplo:

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

});

Echa un vistazo a ese enlace .

Solo necesita instalar el módulo express de node js.

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

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

Puede acceder a su archivo como http: //hostname/Folder/file.zip

A continuación funcionó para mí:

Cree un archivo app.jscon los siguientes contenidos:

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

Cree un archivo index.htmlcon los siguientes contenidos:

Hi

Comience una línea de comando:

cmd

Ejecutar a continuación en cmd:

node app.js

Ir a la URL debajo, en cromo:

http://localhost:8080/index.html

Eso es todo. Espero que ayude.

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

Puedes intentar servirme

Usarlo es muy fácil:

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

Eso es todo.

PD: la carpeta que se sirve de forma predeterminada es "pública".

Aquí hay otro servidor web simple.

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

Instalar en pc

npm install -g hostr

Cambiar director de trabajo

cd myprojectfolder/

Y empezar

hostr

En simple node.js:

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

process.on('uncaughtException', err => console.error('uncaughtException', err))
process.on('unhandledRejection', err => console.error('unhandledRejection', err))

const publicFolder = process.argv.length > 2 ? process.argv[2] : '.'
const port = process.argv.length > 3 ? process.argv[3] : 8080

const mediaTypes = {
  zip: 'application/zip',
  jpg: 'image/jpeg',
  html: 'text/html',
  /* add more media types */
}

const server = http.createServer(function(request, response) {
  console.log(request.method + ' ' + request.url)

  const filepath = path.join(publicFolder, request.url)
  fs.readFile(filepath, function(err, data) {
    if (err) {
      response.statusCode = 404
      return response.end('File not found or you made an invalid request.')
    }

    let mediaType = 'text/html'
    const ext = path.extname(filepath)
    if (ext.length > 0 && mediaTypes.hasOwnProperty(ext.slice(1))) {
      mediaType = mediaTypes[ext.slice(1)]
    }

    response.setHeader('Content-Type', mediaType)
    response.end(data)
  })
})

server.on('clientError', function onClientError(err, socket) {
  console.log('clientError', err)
  socket.end('HTTP/1.1 400 Bad Request\r\n\r\n')
})

server.listen(port, '127.0.0.1', function() {
  console.log('👨‍🔧 Development server is online.')
})

Este es un servidor simple de node.js que solo sirve archivos solicitados en un determinado directorio.

Uso:

node server.js folder port

folderpuede ser absoluto o relativo según la server.jsubicación. El valor predeterminado es .cuál es el directorio que ejecuta el node server.jscomando.

port es 8080 de forma predeterminada, pero puede especificar cualquier puerto disponible en su sistema operativo.

En su caso, yo haría:

cd D:\Folder
node server.js

Puede explorar los archivos D:\Folderdesde un navegador escribiendohttp://127.0.0.1:8080/somefolder/somefile.html

Todavía no está en NPM, pero construí un servidor estático simple en Express que también le permite aceptar envíos de formularios y enviarlos por correo electrónico a través de un servicio de correo electrónico transaccional (Sendgrid por ahora, Mandrill viene).

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

Para beneficio de los buscadores, me gustó la respuesta de Jakub g, pero quería un pequeño manejo de errores. Obviamente, es mejor manejar los errores correctamente , pero esto debería ayudar a evitar que un sitio se detenga si se produce un error. Código a continuación:

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

Primero instale el servidor nodo-estático a través de npm install node-static -g -g para instalarlo globalmente en su sistema, luego navegue al directorio donde se encuentran sus archivos, inicie el servidor con static él escucha en el puerto 8080, navegue al navegador y escriba localhost: 8080 / yourhtmlfilename .

Puede usar el paquete de servicio NPM para esto, si no necesita el material NodeJS, es una herramienta rápida y fácil de usar:

1 - Instala el paquete en tu PC:

npm install -g serve

2 - Sirve tu carpeta estática con serve <path>:

d:> serve d:\StaticSite

Le mostrará en qué puerto se está sirviendo su carpeta estática, solo navegue hasta el host como:

http://localhost:3000

Buscando en el registro NPM https://npmjs.org/search?q=server , he encontrado el servidor estático https://github.com/maelstrom/static-server

¿Alguna vez necesitó enviar un archivo a un colega, pero no puede molestarse en enviarle un correo electrónico a la bestia de 100 MB? ¿Quería ejecutar una aplicación JavaScript de ejemplo simple, pero tuvo problemas para ejecutarla a través del archivo: /// protocolo? ¿Desea compartir su directorio de medios en una LAN sin configurar Samba, FTP o cualquier otra cosa que requiera que edite los archivos de configuración? Entonces este servidor de archivos te hará la vida un poco más fácil.

Para instalar el servidor de material estático simple, use npm:

npm install -g static-server

Luego, para servir un archivo o un directorio, simplemente ejecute

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

Eso incluso podría enumerar el contenido de la carpeta.

Desafortunadamente, no pudo servir archivos :)

Un servidor estático simple usando 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 también Uso de node.js como un servidor web simple

Para el trabajo de desarrollo, puede usar (express 4) https://github.com/appsmatics/simple-httpserver.git

Si está interesado en un servidor http ultraligero sin ningún requisito previo, debería echar un vistazo a: mangosta

Uso Houston en el trabajo y para proyectos personales, me funciona bien.

https://github.com/alejandro/Houston

También preguntó por qué están cayendo las solicitudes: no estoy seguro de cuál es la razón específica de su caso, pero en general, mejor contenido estático del servidor utilizando middleware dedicado (nginx, S3, CDN) porque Node no está realmente optimizado para este patrón de red. Vea más explicaciones aquí (punto 13): http://goldbergyoni.com/checklist-best-practice-of-node-js-in-production/