Existe-t-il un outil prêt à l'emploi Node.js (installé avec npm), qui m'aiderait à exposer le contenu du dossier en tant que serveur de fichiers sur HTTP.

Exemple, si j'ai

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

Puis en commençant, D:\Folder\ node node-file-server.js je pouvais accéder au fichier via

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

Pourquoi le serveur de fichiers statique de mon nœud abandonne-t-il les demandes? référence à certains mystique

serveur de fichiers statique node.js standard

S'il n'y a pas un tel outil, quel cadre dois-je utiliser?

Connexes: serveur de fichiers statiques de base dans NodeJS

Un bon "outil prêt à l'emploi" pourrait être le serveur http:

npm install http-server -g

Pour l'utiliser:

cd D:\Folder
http-server

Ou, comme ceci:

http-server D:\Folder

Découvrez-le: https://github.com/nodeapps/http-server

Si vous ne souhaitez pas utiliser l'outil prêt, vous pouvez utiliser le code ci-dessous, comme démontré par moi à 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/');

MISE À JOUR Si vous devez accéder à votre serveur à partir d'une demande / d'un fichier externe, vous devez surmonter le CORS, dans votre fichier node.js en écrivant ce qui suit, comme je l'ai mentionné dans une réponse précédente ici

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

MISE À JOUR

Comme Adrian l'a mentionné, dans les commentaires, il a écrit un code ES6 avec une explication complète ici , je viens de son code ci-dessous, au cas où le code serait parti du site d'origine pour une raison quelconque:

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

Pour les personnes souhaitant un serveur exécutable à partir du script NodeJS:

Vous pouvez utiliser expressjs / serve-static qui remplace connect.static(qui n'est plus disponible à 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);

puis à partir de la ligne de commande:

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

Je sais que ce n'est pas Node, mais j'ai utilisé SimpleHTTPServer de Python:

python -m SimpleHTTPServer [port]

Cela fonctionne bien et est livré avec Python.

se connecter pourrait être ce que vous recherchez.

Installé facilement avec:

npm install connect

Le serveur de fichiers statique le plus basique pourrait alors s'écrire:

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

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

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

Installez express en utilisant npm: https://expressjs.com/en/starter/installing.html

Créez un fichier nommé server.js au même niveau que votre index.html avec ce contenu:

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

Si vous souhaitez le placer dans un emplacement différent, définissez le chemin sur la troisième ligne:

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

CD dans le dossier contenant votre fichier et exécutez le nœud à partir de la console avec cette commande:

node server.js

Naviguer vers localhost: 8080

Des épreuves One-line ™ au lieu de promesses

Le premier est http-server, hs- lien

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

Le second est servepar ZEIT.co - lien

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

Voici les options disponibles, si c'est ce qui vous aide à décider.

C: \ Users \ Qwerty> http-server --help
utilisation: http-server [chemin] [options]

options:
  -p Port à utiliser [8080]
  -une adresse à utiliser [0.0.0.0]
  -d Afficher les listes de répertoires [true]
  -i Afficher autoIndex [true]
  -g --gzip Servir les fichiers gzip si possible [false]
  -e --ext Extension de fichier par défaut si aucune n'est fournie [aucune]
  -s --silent Supprime les messages du journal de la sortie
  --cors [= headers] Activer CORS via l'en-tête "Access-Control-Allow-Origin"
                     Fournit éventuellement une liste d'en-têtes CORS séparés par des virgules
  -o [chemin] Ouvre la fenêtre du navigateur après le démarrage du serveur
  -c Temps de cache (max-age) en secondes [3600], par exemple -c10 pendant 10 secondes.
               Pour désactiver la mise en cache, utilisez -c-1.
  -U --utc Utiliser le format d'heure UTC dans les messages du journal.

  -P --proxy Proxy de secours si la demande ne peut pas être résolue. par exemple: http://someurl.com

  -S --ssl Activer https.
  -C --cert Chemin vers le fichier cert SSL (par défaut: cert.pem).
  -K --key Chemin d'accès au fichier de clés SSL (par défaut: key.pem).

  -r --robots Répondre à /robots.txt [User-agent: * \ nDisallow: /]
  -h --help Imprimez cette liste et quittez.

C: \ Users \ Qwerty> serve --help

  Utilisation: serve.js [options] [commande]

  Commandes:

    help Afficher l'aide

  Options:

    -a, --auth Servir derrière l'authentification de base
    -c, --cache Temps en millisecondes pour la mise en cache des fichiers dans le navigateur
    -n, --clipless Ne pas copier l'adresse dans le presse-papiers (désactivé par défaut)
    -C, --cors Setup * En-têtes CORS pour autoriser les requêtes de toute origine (désactivée par défaut)
    -h, --help Afficher les informations d'utilisation
    -i, --ignore Fichiers et répertoires à ignorer
    -o, --open Ouvrir l'adresse locale dans le navigateur (désactivé par défaut)
    -p, --port Port d'écoute (par défaut 5000)
    -S, --silent Ne rien enregistrer sur la console
    -s, --single Servir des applications d'une seule page (définit `-c` sur 1 jour)
    -t, --treeless N'affiche pas l'arbre statique (désactivé par défaut)
    -u, --unzipped Désactiver la compression GZIP
    -v, --version Affiche le numéro de version

Si vous devez surveiller les changements, voyez hostr, créditez la réponse de Henry Tseng

SERVEUR DEMO / PROTO UNIQUEMENT

Si c'est tout ce dont vous avez besoin, essayez ceci:

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

remarque: vous devez utiliser "/index.html" dans votre adresse, c'est-à-dire " http: // localhost: 3000 / index.html "

Il y a un autre serveur web statique qui est plutôt sympa: la synchronisation du navigateur.

Il peut être téléchargé à l'aide du gestionnaire de packages de nœuds:

npm install -g browser-sync

Après l'installation, accédez au dossier du projet dans l'invite cmd et exécutez simplement ce qui suit:

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

Il commencera à traiter tous les fichiers du dossier actuel dans le navigateur.

Vous pouvez en savoir plus sur BrowserSync

Merci.

Je n'ai pas eu beaucoup de chance avec l'une des réponses sur cette page, cependant, ci-dessous semble faire l'affaire.

Ajoutez un server.jsfichier avec le contenu suivant:

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)

Assurez-vous également que vous en avez besoin express. Exécutez yarn add express --saveou en npm install express --savefonction de votre configuration (je peux recommander que yarnce soit assez rapide).

Vous pouvez modifier le distdossier dans lequel vous diffusez votre contenu. Pour mon projet simple, je ne servais à partir d'aucun dossier, j'ai donc simplement supprimé le distnom de fichier.

Ensuite, vous pouvez courir node server.js. Comme je devais télécharger mon projet sur un serveur Heroku, j'ai dû ajouter ce qui suit à mon package.jsonfichier:

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

Si vous utilisez le framework Express , cette fonctionnalité est prête à l'emploi.

Pour configurer une application de service de fichiers simple, procédez comme suit:

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

Voici mon projet pour animaux de compagnie de serveur Web de fichier statique node.js à un fichier / léger sans dépendance qui, je crois, est un outil rapide et riche dont son utilisation est aussi simple que d'émettre cette commande sur votre terminal Linux / Unix / macOS ( ou termux sur Android) lorsque node.js (ou nodejs-legacysur Debian / Ubuntu) est installé:

curl pad.js.org | node 

(différentes commandes existent pour les utilisateurs de Windows dans la documentation)

Il prend en charge différentes choses qui, selon moi, peuvent être utiles,

• Création / diffusion d'index de répertoire hiérarchique
  • Avec possibilité de tri selon les différents critères
  • Télécharger à partir du navigateur par glisser-déposer [multi-fichiers] et copier-coller de fichier / texte uniquement et coller la capture d'écran du presse-papiers du système sur Chrome, Firefox et d'autres navigateurs peuvent avec certaines limitations (qui peuvent être désactivées par ligne de commande) options qu'il fournit)
  • Bouton de création de dossier / note / téléchargement
• Servir les MIME corrects pour les types de fichiers bien connus (avec possibilité de les désactiver)
• Possibilité d'installation en tant que package npm et outil local ou, installation linéaire en tant que service permanent avec Docker
• Serveur de fichiers HTTP 206 (transfert de fichiers en plusieurs parties) pour des transferts plus rapides
• Téléchargements à partir du terminal et de la console du navigateur (en fait, il était initialement destiné à être un proxy du système de fichiers pour la console JS des navigateurs sur d'autres pages / domaines)
• Téléchargement / téléchargement CORS (qui peut également être désactivé)
• Intégration HTTPS facile
• Options de ligne de commande légères pour obtenir un meilleur service sécurisé avec:
  • Avec mon patch sur node.js 8 , vous pouvez avoir accès aux options sans première installation:curl pad.js.org | node - -h
  • Ou installez-le d'abord en tant que package npm global du système par [sudo] npm install -g pad.js, puis utilisez sa version installée pour avoir accès à ses options:pad -h
  • Ou utilisez l'image Docker fournie qui utilise des options relativement sécurisées par défaut. [sudo] docker run --restart=always -v /files:/files --name pad.js -d -p 9090:9090 quay.io/ebraminio/pad.js

Les fonctionnalités décrites ci-dessus sont principalement documentées sur la page principale de l'outil http://pad.js.org qui, par une belle astuce que j'ai utilisée, est également l'endroit d'où la source de l'outil elle-même est également servie!

La source de l'outil est sur GitHub qui accueille vos commentaires, demandes de fonctionnalités et ⭐s!

À partir de [email protected], a npmcommencé l'installation d'un nouveau binaire à côté du npm habituel appelé npx. Alors maintenant, un liners pour créer un serveur http statique à partir du répertoire actuel:

npx serve

ou

npx http-server

Pour une augmentation saine des performances en utilisant le nœud pour servir les ressources statiques, je recommande d'utiliser Buffet . Il fonctionne de manière similaire à un accélérateur d'applications Web, également appelé proxy inverse HTTP de mise en cache, mais il charge simplement le répertoire choisi en mémoire.

Buffet adopte une approche entièrement tamponnée - tous les fichiers sont entièrement chargés en mémoire lorsque votre application démarre, vous ne sentirez donc jamais la brûlure du système de fichiers. En pratique, c'est extrêmement efficace. À tel point que mettre Varnish devant votre application pourrait même le ralentir! 

Nous l'utilisons sur le site codePile et avons constaté une augmentation de ~ 700 requêtes / sec à> 4k requêtes / sec sur une page qui télécharge 25 ressources sous une charge de connexion utilisateur simultanée de 1k.

Exemple:

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

});

Jetez un oeil sur ce lien .

Il vous suffit d'installer le module express de node js.

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

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

Vous pouvez accéder à votre fichier comme http: //hostname/Folder/file.zip

Ci-dessous a fonctionné pour moi:

Créez un fichier app.jsavec le contenu ci-dessous:

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

Créez un fichier index.htmlavec le contenu ci-dessous:

Hi

Démarrez une ligne de commande:

cmd

Exécutez ci-dessous dans cmd:

node app.js

Aller sous l'URL, en chrome:

http://localhost:8080/index.html

C'est tout. J'espère que cela pourra aider.

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

Vous pouvez essayer de me servir

Son utilisation est si simple:

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

C'est tout.

PD: Le dossier servi par défaut est "public".

Voici un autre serveur Web simple.

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

Installer

npm install -g hostr

Changer de directeur de travail

cd myprojectfolder/

Et commence

hostr

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

Il s'agit d'un simple serveur node.js qui ne sert que les fichiers demandés dans un certain répertoire.

Usage:

node server.js folder port

folderpeut être absolu ou relatif selon l' server.jsemplacement. La valeur par défaut .est le répertoire dans lequel vous exécutez la node server.jscommande.

port est 8080 par défaut mais vous pouvez spécifier n'importe quel port disponible dans votre système d'exploitation.

Dans votre cas, je ferais:

cd D:\Folder
node server.js

Vous pouvez parcourir les fichiers sous D:\Folderdepuis un navigateur en tapanthttp://127.0.0.1:8080/somefolder/somefile.html

Ce n'est pas encore sur NPM, mais j'ai construit un serveur statique simple sur Express qui vous permet également d'accepter les soumissions de formulaires et de les envoyer par e-mail via un service de messagerie transactionnel (Sendgrid pour l'instant, Mandrill à venir).

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

Pour le bénéfice des chercheurs, j'ai aimé la réponse de Jakub g, mais je voulais un peu de gestion des erreurs. Évidemment, il est préférable de gérer correctement les erreurs , mais cela devrait aider à empêcher un site de s'arrêter si une erreur se produit. Code ci-dessous:

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

Installez d'abord le serveur statique de nœuds via npm install node-static -g -g pour l'installer globalement sur votre système, puis accédez au répertoire où se trouvent vos fichiers, démarrez le serveur avec static lui écoute sur le port 8080, naviguez vers le navigateur et tapez localhost: 8080 / yourhtmlfilename .

Vous pouvez utiliser le package NPM serve pour cela, si vous n'avez pas besoin du truc NodeJS, c'est un outil rapide et facile à utiliser:

1 - Installez le package sur votre PC:

npm install -g serve

2 - Servir votre dossier statique avec serve <path>:

d:> serve d:\StaticSite

Il vous montrera quel port votre dossier statique est servi, accédez simplement à l'hôte comme:

http://localhost:3000

En cherchant dans le registre NPM https://npmjs.org/search?q=server , j'ai trouvé un serveur statique https://github.com/maelstrom/static-server

Avez-vous déjà eu besoin d'envoyer un fichier à un collègue, mais cela ne vous dérange pas d'envoyer un e-mail à la bête de 100 Mo? Vous vouliez exécuter un exemple simple d'application JavaScript, mais vous avez eu des problèmes pour l'exécuter via le protocole file: ///? Vous vouliez partager votre répertoire multimédia sur un réseau local sans configurer Samba, ou FTP, ou quoi que ce soit d'autre vous obligeant à modifier les fichiers de configuration? Ensuite, ce serveur de fichiers vous facilitera la vie.

Pour installer le serveur de trucs statiques simples, utilisez npm:

npm install -g static-server

Ensuite, pour servir un fichier ou un répertoire, exécutez simplement

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

Cela pourrait même répertorier le contenu des dossiers.

Malheureusement, il n'a pas pu servir les fichiers :)

Un simple serveur statique utilisant 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);

Voir aussi Utilisation de node.js comme simple serveur Web

Pour le travail de développement, vous pouvez utiliser (express 4) https://github.com/appsmatics/simple-httpserver.git

Si vous êtes intéressé par un serveur http ultra-léger sans aucune condition préalable, vous devriez jeter un œil à: mangouste

J'utilise Houston au travail et pour des projets personnels, cela fonctionne bien pour moi.

https://github.com/alejandro/Houston

Vous avez également demandé pourquoi les demandes diminuent - vous ne savez pas quelle est la raison spécifique de votre cas, mais dans l'ensemble, vous améliorez le contenu statique du serveur en utilisant un middleware dédié (nginx, S3, CDN) car Node n'est vraiment pas optimisé pour ce modèle de réseau. Voir plus d'explications ici (puce 13): http://goldbergyoni.com/checklist-best-practice-of-node-js-in-production/