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


642

¿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


Escribí un módulo llamado Cachemere que te permite hacer esto. También almacena automáticamente en caché todos sus recursos. Compruébalo: github.com/topcloud/cachemere
Jon

npmjs.com/package/local-web-server - servidor web estático ligero, configuración cero
Victor

Respuestas:


1092

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


10
Esto es asombroso Necesitaba especificar una dirección bc por alguna razón, la 0.0.0.0 predeterminada no cooperaba con mi entorno de desarrollo. http-server -a localhosttengo er dun.
Sam Berry

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

10
También vale la pena verificar la sincronización del navegador , que puede hacer más o menos lo mismo, pero con la ventaja adicional de la actualización en vivo cuando se modifican los archivos.
Nick F

3
--corsenviar Access-Control-Allow-Origin:*junto con los encabezados de respuesta (es decir, cuando se sirve un archivo json)
Daniel F

99
npx http-server- npx lo convierte en una línea que descarga los archivos necesarios y lo ejecuta.
Mike McKay

186

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

2
Seguramente response.writeHead(200debería ser response.writeHead(404;)
Thomas Hunter II

14
¿Ese código no permitiría subir al árbol de archivos haciendo algo como 127.0.0.1/../../../etc/passwd ? No veo controles contra eso.
Rolf

3
Si alguien interesado en la versión ES6 +, creé un servidor de archivos estático que maneja los tipos MIME: gist.github.com/amejiarosario/53afae82e18db30dadc9bc39035778e5
Adrian

1
@Adrian Este código es muy impresionante, pero he encontrado una forma de obtener acceso de root con él. La solución es limitar la cantidad de períodos iniciales en el nombre del archivo a uno para que no pueda hacer ../../etc/passwordcosas. gist.github.com/amejiarosario/53afae82e18db30dadc9bc39035778e5
Seph Reed

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

79

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

1
FYI Esto no funcionó para mí. Instalé filehandler usando npm install filehandlery el paquete aparece en el node_modulesdirectorio. Pero cuando ejecuto el myapp.jsnodo arroja un error, diciendo Error: cannot find module filehandler. Si comento el requisito de cargar el controlador de archivos, la aplicación carga serve-static muy bien, por lo que parece que hay algo mal con el paquete de controlador de archivos. Hoy es 12 de diciembre de 2014, ¿quizás el paquete ha cambiado desde que se publicó esta respuesta?
Lee Jenkins

77
No es finalcontroladorfile
jakub.g

Otra ventaja de esta solución es que los archivos no se almacenan en caché, por lo que no es necesario reiniciar un proceso al realizar cambios en el código.
klimat

59

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

python -m SimpleHTTPServer [port]

Funciona bien y viene con Python.


16
Python3 equivalente: python -m http.server [port](el mencionado es para Python2)
jakub.g

Python falla para mí cuando se trata de servir archivos grandes como imágenes del sistema operativo. Fedora 23
Zimy

99
Y en PHP:php -S localhost:8000
dennis

Lo uso para servir rápidamente contenido de una carpeta todo el tiempo.
Adrian Lynch

33

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

44
Esto ya no funciona a partir de connect 3, ya que no expone connect.static; vea mi respuesta a continuación para un reemplazo
jakub.g

44
Creo que todavía está incluido con express de forma predeterminada, pero de hecho existe ahora en un requiremódulo capaz separado "serve-static".
Oleg

18

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


1
Hola, puedo ejecutarlo correctamente, pero se nota Cannot GET /. Yo uso AWS EC2 para ejecutar el servidor.
Wei Xia

1
@Wei Hola, respuesta tardía. Por lo que puedo ver en una búsqueda rápida en Google, parece que la estructura de su directorio podría estar equivocada. Debe haber un archivo index.html en la ubicación a la que se dirige. La configuración del ejemplo anterior para ejecutarse debería tomar 5 minutos y verifiqué dos veces que funciona tal como está. Desde allí, puede ajustar la ruta para adaptarla a la estructura de su directorio y verificar que el servidor aún encuentre los archivos que necesita.
pasx

path.join(__dirname, 'public')Es más multiplataforma.
sdgfsdh

17

Pruebas One-line ™ en lugar de promesas

ingrese la descripción de la imagen aquí

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


14

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 "


2
No uses la versión de sincronización. Instread crear tubería para res de readStream.
Eduard Bondarenko

1
La mejor respuesta si necesita un pony rápido y sucio de una sola vez.
collapsar

1
Si desea evitar el uso index.htmlcomo parte de su dirección, simplemente agregue if (req.url === '/') req.url = '/index.html';justo después res.writeHead(200);.
Joseph Cho

3
@EduardBondarenko tiene razón. const stream = fs.createReadStream(...); stream.pipe(res);es todo lo que necesitas
Justin Meiners

8

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.


2
La ventaja de usar Browsersync en lugar de otros servidores estáticos es que viven actualizaciones de la página cada vez que los archivos especificados por el --filescambio de pabellón (nota: no es necesario especificar. ./*- sólo los que desee Browsersync para ver de forma activa para las actualizaciones, por ejemplo, . css/*.css)
Nick F

7

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

6

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

¿Puedo $ npm install -g express; ellos $ express?
Paul Verest

Seguí tus pasos, pero mi expreso no tiene la carpeta bin
Qwerty

6

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

Captura de pantalla de un índice de carpeta usando la herramienta

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.


5

Desde npm@5.2.0, 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

4

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

});


4

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/


3

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



3

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


2

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


2

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

Actualización: mi respuesta funciona, pero ahora uso la respuesta de @Matt Self de usar http-server. Parece que trabaja adecuadamente.
HockeyJ

2

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 .


2

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

Te das cuenta de que npmes el administrador de paquetes de nodos, así que de hecho estás usando las cosas de
NodeJS

Sí, lo que quise decir como "cosas de NodeJS" fue usar NodeJS y express para servir los archivos como la mayoría de las respuestas sugeridas. Serve es un ejecutable independiente, NPM se usa solo para instalarlo, simplemente puede descargarlo directamente.
Diego Mendes

1

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


55
Yo construí ese servidor. Ese servidor de archivos fue construido contra una versión muy antigua de Node, de ahí que ya no funcione. No tengo tiempo ahora para arreglarlo. Sugiero usar la respuesta de @Oleg arriba. Se puede agrupar fácilmente en un pequeño nodo ejecutable, y es esencialmente lo que hizo el mío de todos modos.
Tim Heap

Gracias Tim, respuesta muy profesional. Sin embargo, no eliminaría el código, pero actualizaría el archivo Léame.
Paul Verest

1

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



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


Debe agregar alguna explicación alog con este código.
Abhinav Gauniyal

1

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



Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.