एक साधारण वेब सर्वर के रूप में node.js का उपयोग करना




server webserver (17)

मैं एक बहुत ही सरल HTTP सर्वर चलाने के लिए चाहता हूँ। example.com प्रत्येक जीईटी अनुरोध को index.html प्राप्त करना चाहिए, लेकिन नियमित HTML पृष्ठ के रूप में (यानी, जब आप सामान्य वेब पेज पढ़ते हैं तो वही अनुभव)।

नीचे दिए गए कोड का उपयोग करके, मैं index.html की सामग्री पढ़ सकता हूं। मैं नियमित वेब पेज के रूप में index.html सेवा कैसे करूं?

var http = require('http');
var fs = require('fs');
var index = fs.readFileSync('index.html');

http.createServer(function (req, res) {
  res.writeHead(200, {'Content-Type': 'text/plain'});
  res.end(index);
}).listen(9615);

नीचे एक सुझाव जटिल है और मुझे प्रत्येक संसाधन (सीएसएस, जावास्क्रिप्ट, छवियों) फ़ाइल के लिए एक गेट लाइन लिखने की आवश्यकता है जिसे मैं उपयोग करना चाहता हूं।

मैं कुछ छवियों, सीएसएस और जावास्क्रिप्ट के साथ एक HTML पृष्ठ कैसे सेवा कर सकता हूं?


संपादित करें:

Node.js नमूना ऐप नोड चैट में इच्छित कार्यक्षमता है।
इसमें README.textfile
3. वह कदम है जिसे आप ढूंढ रहे हैं।

चरण 1

  • पोर्ट 8002 पर हैलो वर्ल्ड के साथ प्रतिक्रिया देने वाला एक सर्वर बनाएं

चरण 2

  • index.html बनाएं और इसकी सेवा करें

चरण 3

  • util.js परिचय
  • तर्क बदलें ताकि किसी भी स्थिर फ़ाइल परोसा जा सके
  • अगर कोई फाइल नहीं मिलती है तो 404 दिखाएं

चरण 4

  • jquery-1.4.2.js जोड़ें
  • क्लाइंट.जेएस जोड़ें
  • उपनाम के लिए उपयोगकर्ता को संकेत देने के लिए index.html बदलें

server.js यहाँ है

यहां util.js


अगर आपके पास पीसी पर नोड स्थापित है तो शायद आपके पास एनपीएम है, अगर आपको नोडजेएस सामान की आवश्यकता नहीं है, तो आप इसके लिए serve पैकेज का उपयोग कर सकते हैं:

1 - अपने पीसी पर पैकेज स्थापित करें:

npm install -g serve

2 - अपने स्थिर फ़ोल्डर की सेवा करें:

serve <path> 
d:> serve d:\StaticSite

यह आपको दिखाएगा कि आपका स्थिर फ़ोल्डर किस पोर्ट को परोसा जा रहा है, बस मेजबान पर नेविगेट करें जैसे:

http://localhost:3000

आपको एक्सप्रेस की आवश्यकता नहीं है। आपको कनेक्ट करने की आवश्यकता नहीं है। Node.js http NATIVELY करता है। आपको बस इतना करना है कि अनुरोध पर निर्भर फ़ाइल लौटाएं:

var http = require('http')
var url = require('url')
var fs = require('fs')

http.createServer(function (request, response) {
    var requestUrl = url.parse(request.url)    
    response.writeHead(200)
    fs.createReadStream(requestUrl.pathname).pipe(response)  // do NOT use fs's sync methods ANYWHERE on production (e.g readFileSync) 
}).listen(9615)    

अनुरोधों को सुनिश्चित करने वाला एक और पूर्ण उदाहरण आधार-निर्देशिका के नीचे फ़ाइलों तक नहीं पहुंच सकता है, और उचित त्रुटि प्रबंधन करता है:

var http = require('http')
var url = require('url')
var fs = require('fs')
var path = require('path')
var baseDirectory = __dirname   // or whatever base directory you want

var port = 9615

http.createServer(function (request, response) {
    try {
        var requestUrl = url.parse(request.url)

        // need to use path.normalize so people can't access directories underneath baseDirectory
        var fsPath = baseDirectory+path.normalize(requestUrl.pathname)

        var fileStream = fs.createReadStream(fsPath)
        fileStream.pipe(response)
        fileStream.on('open', function() {
             response.writeHead(200)
        })
        fileStream.on('error',function(e) {
             response.writeHead(404)     // assume the file doesn't exist
             response.end()
        })
   } catch(e) {
        response.writeHead(500)
        response.end()     // end the response so browsers don't hang
        console.log(e.stack)
   }
}).listen(port)

console.log("listening on port "+port)

आपको सरल सर्वर चलाने के लिए किसी भी एनपीएम मॉड्यूल का उपयोग करने की आवश्यकता नहीं है, नोड के लिए " एनपीएम फ्री सर्वर " नामक एक बहुत छोटी लाइब्रेरी है:

कोड की 50 लाइनें, आउटपुट अगर आप किसी फ़ाइल या फ़ोल्डर का अनुरोध कर रहे हैं और इसे काम करने में असफल होने पर इसे लाल या हरा रंग देता है। आकार में 1KB से कम (minified)।


ऊपर दिए गए अधिकांश उत्तर बहुत अच्छी तरह से वर्णन करते हैं कि सामग्रियों की सेवा कैसे की जा रही है। जो मैं अतिरिक्त के रूप में देख रहा था वह निर्देशिका की सूची थी ताकि निर्देशिका की अन्य सामग्री ब्राउज़ की जा सके। आगे पाठकों के लिए मेरा समाधान यहां है:

'use strict';

var finalhandler = require('finalhandler');
var http = require('http');
var serveIndex = require('serve-index');
var serveStatic = require('serve-static');
var appRootDir = require('app-root-dir').get();
var log = require(appRootDir + '/log/bunyan.js');

var PORT = process.env.port || 8097;

// Serve directory indexes for reports folder (with icons)
var index = serveIndex('reports/', {'icons': true});

// Serve up files under the folder
var serve = serveStatic('reports/');

// Create server
var server = http.createServer(function onRequest(req, res){
    var done = finalhandler(req, res);
    serve(req, res, function onNext(err) {
    if (err)
        return done(err);
    index(req, res, done);
    })
});


server.listen(PORT, log.info('Server listening on: ', PORT));

एक साधारण nodejs server लिए पहले से ही कुछ शानदार समाधान हैं। यदि आपको अपनी फ़ाइलों में बदलाव किए जाने पर live-reloading आवश्यकता होती है तो एक और समाधान होता है।

npm install lite-server -g

अपनी निर्देशिका नेविगेट करें और करें

lite-server

यह आपके लिए लाइव-रीलोडिंग के साथ ब्राउज़र खोल देगा।


चरण 1 (कमांड प्रॉम्प्ट के अंदर [मुझे आशा है कि आप अपने फ़ोल्डर्स को सीडी करें]): npm install express

चरण 2: एक फ़ाइल server.js बनाएँ

var fs = require("fs");
var host = "127.0.0.1";
var port = 1337;
var express = require("express");

var app = express();
app.use(express.static(__dirname + "/public")); //use static files in ROOT/public folder

app.get("/", function(request, response){ //root dir
    response.send("Hello!!");
});

app.listen(port, host);

कृपया ध्यान दें, आपको वॉचफ़ाइल (या नोडमन का उपयोग भी) जोड़ना चाहिए। उपरोक्त कोड केवल एक साधारण कनेक्शन सर्वर के लिए है।

चरण 3: node server.js या nodemon server.js

यदि आप बस मेजबान सरल HTTP सर्वर चाहते हैं तो अब और अधिक आसान तरीका है। npm install -g http-server

और हमारी निर्देशिका खोलें और http-server टाइप http-server

https://www.npmjs.org/package/http-server


जिस तरह से मैं इसे करने के लिए वैश्विक स्तर पर सभी स्थापित नोड स्थिर सर्वर के पहले है

npm install node-static -g

फिर उस निर्देशिका में नेविगेट करें जिसमें आपकी HTML फ़ाइलें शामिल हैं और स्थैतिक सर्वर static साथ प्रारंभ करें।

ब्राउज़र पर जाएं और localhost:8080/"yourHtmlFile" टाइप करें localhost:8080/"yourHtmlFile"


मुझे एनपीएम पर एक दिलचस्प लाइब्रेरी मिली जो आपके लिए कुछ उपयोग हो सकती है। इसे माइम ( npm install mime या https://github.com/broofa/node-mime ) कहा जाता है और यह फ़ाइल के माइम प्रकार को निर्धारित कर सकता है। यहां उपयोग किए गए वेबसर्वर का एक उदाहरण यहां दिया गया है:

var mime = require("mime"),http = require("http"),fs = require("fs");
http.createServer(function (req, resp) {
path  = unescape(__dirname + req.url)
var code = 200
 if(fs.existsSync(path)) {
    if(fs.lstatSync(path).isDirectory()) {
        if(fs.existsSync(path+"index.html")) {
        path += "index.html"
        } else {
            code = 403
            resp.writeHead(code, {"Content-Type": "text/plain"});
            resp.end(code+" "+http.STATUS_CODES[code]+" "+req.url);
        }
    }
    resp.writeHead(code, {"Content-Type": mime.lookup(path)})
    fs.readFile(path, function (e, r) {
    resp.end(r);

})
} else {
    code = 404
    resp.writeHead(code, {"Content-Type":"text/plain"});
    resp.end(code+" "+http.STATUS_CODES[code]+" "+req.url);
}
console.log("GET "+code+" "+http.STATUS_CODES[code]+" "+req.url)
}).listen(9000,"localhost");
console.log("Listening at http://localhost:9000")

यह किसी भी नियमित पाठ या छवि फ़ाइल (.html, .css, .js, .pdf, .jpg, .png, .m4a और .mp3 एक्सटेंशन का परीक्षण करेगा, लेकिन यह सिद्धांत है कि यह सबकुछ के लिए काम करना चाहिए)

डेवलपर नोट्स

आउटपुट का एक उदाहरण यहां दिया गया है जो मुझे मिला:

Listening at http://localhost:9000
GET 200 OK /cloud
GET 404 Not Found /cloud/favicon.ico
GET 200 OK /cloud/icon.png
GET 200 OK /
GET 200 OK /501.png
GET 200 OK /cloud/manifest.json
GET 200 OK /config.log
GET 200 OK /export1.png
GET 200 OK /Chrome3DGlasses.pdf
GET 200 OK /cloud
GET 200 OK /-1
GET 200 OK /Delta-Vs_for_inner_Solar_System.svg

पथ निर्माण में unescape समारोह पर ध्यान दें। यह रिक्त स्थान और एन्कोडेड वर्णों के साथ फ़ाइल नामों की अनुमति देना है।


मुझे यकीन नहीं है कि यह वही है जो आप चाहते थे, हालांकि, आप बदलने का प्रयास कर सकते हैं:

{'Content-Type': 'text/plain'}

इसके लिए:

{'Content-Type': 'text/html'}

यह ब्राउज़र क्लाइंट फ़ाइल को सादा पाठ के बजाय HTML के रूप में प्रदर्शित करेगा।


मूल रूप से स्वीकृत उत्तर की प्रतिलिपि बनाते हैं, लेकिन एक जेएस फ़ाइल बनाने से परहेज करते हैं।

$ node
> var connect = require('connect'); connect().use(static('.')).listen(8000);

इसे बहुत दृढ़ पाया।

अद्यतन करें

एक्सप्रेस के नवीनतम संस्करण के रूप में, सर्विस-स्टेटिक एक अलग मिडलवेयर बन गया है। सेवा के लिए इसका इस्तेमाल करें:

require('http').createServer(require('serve-static')('.')).listen(3000)

पहले serve-static स्थापित करें।


मैं एक सरल वेब सर्वर शुरू करने के लिए कोड का उपयोग करता हूं जो यूआरएल में उल्लिखित कोई फ़ाइल नहीं है, तो डिफ़ॉल्ट HTML फ़ाइल प्रस्तुत करता है।

var http = require('http'),
fs = require('fs'),
url = require('url'),
rootFolder = '/views/',
defaultFileName = '/views/5 Tips on improving Programming Logic   Geek Files.htm';


http.createServer(function(req, res){

    var fileName = url.parse(req.url).pathname;
    // If no file name in Url, use default file name
    fileName = (fileName == "/") ? defaultFileName : rootFolder + fileName;

    fs.readFile(__dirname + decodeURIComponent(fileName), 'binary',function(err, content){
        if (content != null && content != '' ){
            res.writeHead(200,{'Content-Length':content.length});
            res.write(content);
        }
        res.end();
    });

}).listen(8800);

यह सभी जेएम, सीएसएस और छवि फ़ाइल, सभी एचटीएमएल सामग्री के साथ प्रस्तुत करेगा।

कथन पर सहमति दें " कोई सामग्री-प्रकार गलत से बेहतर नहीं है "


यह वेब पृष्ठों को तुरंत देखने के लिए उपयोग किए जाने वाले सबसे तेज़ समाधानों में से एक है

sudo npm install ripple-emulator -g

तब से बस अपनी एचटीएमएल फाइलों की निर्देशिका दर्ज करें और चलाएं

ripple emulate

फिर डिवाइस को नेक्सस 7 परिदृश्य में बदलें।


यहां जटिल उत्तरों की पागल राशि। यदि आप नोडजेएस फाइल / डेटाबेस को संसाधित करने का इरादा नहीं रखते हैं, लेकिन बस अपने प्रश्न के अनुसार स्थिर एचटीएमएल / सीएसएस / जेएस / छवियों की सेवा करना चाहते हैं तो बस pushstate-server मॉड्यूल या इसी तरह स्थापित करें;

यहां एक "एक लाइनर" है जो एक मिनी साइट बना और लॉन्च करेगा। उचित टर्मिनल में बस अपने टर्मिनल में उस पूरे ब्लॉक को पेस्ट करें।

mkdir mysite; \
cd mysite; \
npm install pushstate-server --save; \
mkdir app; \
touch app/index.html; \
echo '<h1>Hello World</h1>' > app/index.html; \
touch server.js; \
echo "var server = require('pushstate-server');server.start({ port: 3000, directory: './app' });" > server.js; \
node server.js

ब्राउज़र खोलें और http: // localhost: 3000 पर जाएं । किया हुआ।

सर्वर से फाइलों की सेवा के लिए रूट के रूप में app डीआईआर का उपयोग करेगा। अतिरिक्त संपत्तियों को जोड़ने के लिए बस उन्हें उस निर्देशिका के अंदर रखें।


सरल संस्करण जो मैंने पार किया है वह निम्नानुसार है। शिक्षा के प्रयोजनों के लिए, यह सबसे अच्छा है, क्योंकि यह किसी भी अमूर्त पुस्तकालयों का उपयोग नहीं करता है।

var http = require('http'),
url = require('url'),
path = require('path'),
fs = require('fs');

var mimeTypes = {
  "html": "text/html",
  "mp3":"audio/mpeg",
  "mp4":"video/mp4",
  "jpeg": "image/jpeg",
  "jpg": "image/jpeg",
  "png": "image/png",
  "js": "text/javascript",
  "css": "text/css"};

http.createServer(function(req, res) {
    var uri = url.parse(req.url).pathname;
    var filename = path.join(process.cwd(), uri);
    fs.exists(filename, function(exists) {
        if(!exists) {
            console.log("not exists: " + filename);
            res.writeHead(200, {'Content-Type': 'text/plain'});
            res.write('404 Not Found\n');
            res.end();
            return;
        }
        var mimeType = mimeTypes[path.extname(filename).split(".")[1]];
        res.writeHead(200, {'Content-Type':mimeType});

        var fileStream = fs.createReadStream(filename);
        fileStream.pipe(res);

    }); //end path.exists
}).listen(1337);

अब ब्राउज़र पर जाएं और निम्न खोलें:

http://127.0.0.1/image.jpg

यहां image.jpg इस फ़ाइल के समान निर्देशिका में होना चाहिए। उम्मीद है कि यह किसी की मदद करता है :)


तेज़ तरीका:

var express = require('express');
var app = express();
app.use('/', express.static(__dirname + '/../public')); // ← adjust
app.listen(3000, function() { console.log('listening'); });

आपका रास्ता:

var http = require('http');
var fs = require('fs');

http.createServer(function (req, res) {
    console.dir(req.url);

    // will get you  '/' or 'index.html' or 'css/styles.css' ...
    // • you need to isolate extension
    // • have a small mimetype lookup array/object
    // • only there and then reading the file
    // •  delivering it after setting the right content type

    res.writeHead(200, {'Content-Type': 'text/html'});

    res.end('ok');
}).listen(3001);

var http = require('http');
var fs = require('fs');
var index = fs.readFileSync('index.html');

http.createServer(function (req, res) {
res.writeHead(200, {'Content-Type': 'html'});
res.end(index);
}).listen(9615);

//Just Change The CONTENT TYPE to 'html'




webserver