Node.js (तृतीय-पक्ष पुस्तकालयों का उपयोग किए बिना) के साथ एक फ़ाइल कैसे डाउनलोड करें?

Question

मैं तीसरे पक्ष के पुस्तकालयों का उपयोग किए बिना Node.js के साथ एक फ़ाइल कैसे डाउनलोड करूं ?

मुझे कुछ विशेष की आवश्यकता नहीं है। मैं केवल किसी दिए गए URL से एक फ़ाइल डाउनलोड करना चाहता हूं, और फिर इसे किसी दिए गए निर्देशिका में सहेजें।

Comments

"नोड के साथ एक फ़ाइल डाउनलोड करें।" - क्या आपको सर्वर पर अपलोड करने का मतलब है? या अपने सर्वर का उपयोग कर एक दूरस्थ सर्वर से एक फ़ाइल पुनः प्राप्त करें? या अपने नोड.जेएस सर्वर से डाउनलोड के लिए क्लाइंट को एक फ़ाइल परोसें?

— यूसुफ

"मैं केवल किसी दिए गए यूआरएल से एक फ़ाइल डाउनलोड करना चाहता हूं, और फिर इसे दिए गए निर्देशिका में सहेजें," यह बहुत स्पष्ट लगता है। :)

— मिशेल Tilley

यूसुफ एक गलत दावा कर रहा है कि सभी नोड प्रक्रियाएं सर्वर प्रक्रियाएं हैं

— नेतृत्व किया

@lededje किसी फ़ाइल को डाउनलोड करने और सर्वर पर निर्देशिका में सहेजने से सर्वर प्रक्रिया को क्या रोकता है? यह पूरी तरह से उल्लेखनीय है।

— घुमारवीं

Answer 1

आप एक HTTP GETअनुरोध बना सकते हैं और उसे पाइप कर सकते हैंresponse इसे एक योग्य फ़ाइल स्ट्रीम में :

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

const file = fs.createWriteStream("file.jpg");
const request = http.get("http://i3.ytimg.com/vi/J---aiyznGQ/mqdefault.jpg", function(response) {
  response.pipe(file);
});

यदि आप कमांड लाइन पर जानकारी इकट्ठा करने का समर्थन करना चाहते हैं - जैसे लक्ष्य फ़ाइल या निर्देशिका या URL निर्दिष्ट करना - कमांडर जैसी किसी चीज़ की जाँच करें ।

Comments

मैं निम्नलिखित सांत्वना उत्पादन हो गया, जब मैं इस स्क्रिप्ट चलाने: node.js:201 throw e; // process.nextTick error, or 'error' event on first tick ^ Error: connect ECONNREFUSED at errnoException (net.js:646:11) at Object.afterConnect [as oncomplete] (net.js:637:18) ।

— एंडरसन ग्रीन

http.getलाइन पर एक अलग URL का उपयोग करने का प्रयास करें ; हो सकता है http://i3.ytimg.com/vi/J---aiyznGQ/mqdefault.jpg(और के file.pngसाथ बदलें file.jpg)।

— मिशेल टिली

क्या यह कोड स्क्रिप्ट के समाप्त होने पर फ़ाइल को ठीक से बंद कर देता है या यह डेटा खो देगा?

— शाम

@quantumpotato आपके अनुरोध से वापस मिल रही प्रतिक्रिया पर एक नज़र डालें

— मिशेल टायली

यह req url प्रकार पर निर्भर करता है यदि आप अनुरोध httpsकर रहे हैं कि आपको httpsइसका उपयोग करना चाहिए अन्यथा यह त्रुटि फेंक देगा।

— कृष्णदास PC

Answer 2

त्रुटियों को संभालने के लिए मत भूलना! निम्नलिखित कोड ऑगस्टो रोमन के उत्तर पर आधारित है।

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

var download = function(url, dest, cb) {
  var file = fs.createWriteStream(dest);
  var request = http.get(url, function(response) {
    response.pipe(file);
    file.on('finish', function() {
      file.close(cb);  // close() is async, call cb after close completes.
    });
  }).on('error', function(err) { // Handle errors
    fs.unlink(dest); // Delete the file async. (But we don't check the result)
    if (cb) cb(err.message);
  });
};

Comments

@ विंस-युआन download()ही pipeसक्षम है?

— रासक्स

@theGrayFox क्योंकि इस उत्तर में कोड स्वीकार किए जाते हैं की तुलना में लंबा है। :)

— पूत

@ अब्दुल लगता है कि आप बहुत नए हैं। नोड / जावास्क्रिप्ट। इस ट्यूटोरियल पर एक नज़र डालें: tutorialspoint.com/nodejs/nodejs_callbacks_concept.htm यह जटिल नहीं है।

— विंस युआन

@ अब्दुल शायद यह अच्छा होगा यदि आप बाकी वर्ग के साथ साझा करते हैं जो आपने सोचा है?

— कर्टवाग्नेर 1984

क्या डाउनलोड की गति देखने का कोई तरीका है? जैसे ट्रैक कर सकते हैं कितने mb / s? धन्यवाद!

— तिनो सीर

Answer 3

जैसा कि मिशेल टाइली ने कहा, लेकिन उचित नियंत्रण प्रवाह के साथ:

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

var download = function(url, dest, cb) {
  var file = fs.createWriteStream(dest);
  http.get(url, function(response) {
    response.pipe(file);
    file.on('finish', function() {
      file.close(cb);
    });
  });
}

बिना इंतजार किए finishघटना की , भोली स्क्रिप्ट एक अधूरी फ़ाइल के साथ समाप्त हो सकती है।

संपादित करें: @Augusto रोमन को इंगित करने के लिए धन्यवाद कि cbइसे पास किया जाना चाहिए file.close, स्पष्ट रूप से नहीं कहा जाता है।

Comments

कॉलबैक मुझे भ्रमित कर रहा है। अगर मैं अब आह्वान करता हूं download(), तो मैं यह कैसे करूंगा? मैं cbतर्क के रूप में क्या जगह दूंगा? मेरे पास है, download('someURI', '/some/destination', cb)लेकिन यह समझ में नहीं आता कि cb में क्या रखा जाए

— अब्दुल

@ अब्दुल आप किसी फ़ंक्शन के साथ कॉलबैक को केवल तभी निर्दिष्ट करते हैं जब आपको फ़ाइल को सफलतापूर्वक लाने के बाद कुछ करने की आवश्यकता होती है।

— कैटलिनबेर्टा

Answer 4

त्रुटियों से निपटने की बात करें, तो त्रुटियों का अनुरोध करना भी बेहतर है। मैं भी प्रतिक्रिया कोड की जाँच करके मान्य होगा। यहां इसे केवल 200 प्रतिक्रिया कोड के लिए सफलता माना जाता है, लेकिन अन्य कोड अच्छे हो सकते हैं।

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

const download = (url, dest, cb) => {
    const file = fs.createWriteStream(dest);

    const request = http.get(url, (response) => {
        // check if response is success
        if (response.statusCode !== 200) {
            return cb('Response status was ' + response.statusCode);
        }

        response.pipe(file);
    });

    // close() is async, call cb after close completes
    file.on('finish', () => file.close(cb));

    // check for request error too
    request.on('error', (err) => {
        fs.unlink(dest);
        return cb(err.message);
    });

    file.on('error', (err) => { // Handle errors
        fs.unlink(dest); // Delete the file async. (But we don't check the result) 
        return cb(err.message);
    });
};

इस कोड की सापेक्ष सादगी के बावजूद, मैं अनुरोध मॉड्यूल का उपयोग करने की सलाह दूंगा क्योंकि यह कई अधिक प्रोटोकॉल (हैलो HTTPS!) को मूल रूप से समर्थित नहीं है।http ।

ऐसा ही किया जाएगा:

const fs = require('fs');
const request = require('request');

const download = (url, dest, cb) => {
    const file = fs.createWriteStream(dest);
    const sendReq = request.get(url);

    // verify response code
    sendReq.on('response', (response) => {
        if (response.statusCode !== 200) {
            return cb('Response status was ' + response.statusCode);
        }

        sendReq.pipe(file);
    });

    // close() is async, call cb after close completes
    file.on('finish', () => file.close(cb));

    // check for request errors
    sendReq.on('error', (err) => {
        fs.unlink(dest);
        return cb(err.message);
    });

    file.on('error', (err) => { // Handle errors
        fs.unlink(dest); // Delete the file async. (But we don't check the result)
        return cb(err.message);
    });
};

Comments

अनुरोध मॉड्यूल सिर्फ HTTP के लिए सीधे काम करता है। ठंडा!

— थियागो सी। एस। वेंचुरा

@ventura हां, btw, वहाँ भी देशी https मॉड्यूल है कि अब सुरक्षित कनेक्शन संभाल कर सकते हैं।

— बूजुत

यह एक शक के बिना अधिक त्रुटि प्रवण है। वैसे भी, किसी भी मामले में जहां अनुरोध मॉड्यूल का उपयोग करना एक विकल्प है, मैं इसे उच्च स्तर तक ले जाने की सलाह दूंगा और इस प्रकार, आसान और कुशल।

— बुजुत

@ एलेक्स, नहीं, यह एक त्रुटि संदेश है और एक वापसी है। तो अगर response.statusCode !== 200पर cb finishकभी नहीं बुलाया जाएगा।

— बुजुत

अनुरोध मॉड्यूल का उपयोग करके उदाहरण दिखाने के लिए धन्यवाद।

— पीट एल्विन

Answer 5

gfxmonk के उत्तर में कॉलबैक और a के बीच बहुत कड़ी डेटा दौड़ है file.close() पूर्णता के । file.close()वास्तव में एक कॉलबैक लेता है जिसे करीबी पूरा होने पर बुलाया जाता है। अन्यथा, फ़ाइल का तत्काल उपयोग विफल हो सकता है (बहुत कम ही!)।

एक पूर्ण समाधान है:

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

var download = function(url, dest, cb) {
  var file = fs.createWriteStream(dest);
  var request = http.get(url, function(response) {
    response.pipe(file);
    file.on('finish', function() {
      file.close(cb);  // close() is async, call cb after close completes.
    });
  });
}

फिनिश इवेंट की प्रतीक्षा किए बिना, भोली स्क्रिप्ट एक अधूरी फ़ाइल के साथ समाप्त हो सकती है। cbकॉलबैक को पास से शेड्यूल किए बिना , आपको फ़ाइल तक पहुँचने और वास्तव में तैयार होने वाली फ़ाइल के बीच एक दौड़ मिल सकती है।

Comments

क्या आप एक चर में अनुरोध संग्रहीत कर रहे हैं?

— polkovnikov.ph

वह इसे एक चर में "स्टोर" करता है, इसलिए यह डिफ़ॉल्ट रूप से एक वैश्विक चर नहीं बनता है।

— जूल

@philk आप कैसे जानते हैं कि यदि var request =हटा दिया जाए तो एक वैश्विक चर बनाया जाता है?

— ma11hew28

आप सही हैं, अनुरोध को बचाने की कोई आवश्यकता नहीं है, वैसे भी इसका उपयोग नहीं किया गया है। यही आपका मतलब है?

— philk

Answer 6

शायद नोड.जेएस बदल गया है, लेकिन ऐसा लगता है कि अन्य समाधानों के साथ कुछ समस्याएं हैं (नोड v8.1.2 का उपयोग करके):

1. आपको ईवेंट file.close()में कॉल करने की आवश्यकता नहीं है finish। डिफ़ॉल्ट रूप fs.createWriteStreamसे AutoClose पर सेट किया गया है: https://nodejs.org/api/fs.html#fs_fs_createwritestream_path_options
2. file.close()त्रुटि पर बुलाया जाना चाहिए। हो सकता है कि फ़ाइल डिलीट होने ( unlink()) के समय इसकी आवश्यकता न हो , लेकिन आम तौर पर यह है: https://nodejs.org/api/stream.html#stream_readable_pipe_destination_options
3. Temp फ़ाइल को हटाया नहीं गया है statusCode !== 200
4. fs.unlink() कॉलबैक के बिना पदावनत किया जाता है (आउटपुट चेतावनी)
5. यदि destफ़ाइल मौजूद है; यह ओवरराइड है

नीचे एक संशोधित समाधान है (ES6 और वादों का उपयोग करके) जो इन समस्याओं को संभालता है।

const http = require("http");
const fs = require("fs");

function download(url, dest) {
    return new Promise((resolve, reject) => {
        const file = fs.createWriteStream(dest, { flags: "wx" });

        const request = http.get(url, response => {
            if (response.statusCode === 200) {
                response.pipe(file);
            } else {
                file.close();
                fs.unlink(dest, () => {}); // Delete temp file
                reject(`Server responded with ${response.statusCode}: ${response.statusMessage}`);
            }
        });

        request.on("error", err => {
            file.close();
            fs.unlink(dest, () => {}); // Delete temp file
            reject(err.message);
        });

        file.on("finish", () => {
            resolve();
        });

        file.on("error", err => {
            file.close();

            if (err.code === "EEXIST") {
                reject("File already exists");
            } else {
                fs.unlink(dest, () => {}); // Delete temp file
                reject(err.message);
            }
        });
    });
}

Comments

इस पर दो टिप्पणियाँ: 1) यह त्रुटि वस्तुओं को अस्वीकार करना चाहिए, तार नहीं, 2) fununlink चुपचाप त्रुटियों को निगल जाएगा जो जरूरी नहीं हो सकता है कि आप क्या करना चाहते हैं

— रिचर्ड नीनाबेर

यह महान काम करता है! और यदि आपके URL, HTTPS का उपयोग करें, सिर्फ विकल्प const https = require("https");के लिएconst http = require("http");

— रस

Answer 7

मध्यांतर के साथ समाधान, स्मृति रिसाव को रोकने:

निम्नलिखित कोड ब्रैंडन टायली के उत्तर पर आधारित है:

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

var request = http.get("http://example12345.com/yourfile.html", function(response) {
    if (response.statusCode === 200) {
        var file = fs.createWriteStream("copy.html");
        response.pipe(file);
    }
    // Add timeout.
    request.setTimeout(12000, function () {
        request.abort();
    });
});

जब आपको कोई त्रुटि मिलती है, तो फ़ाइल न करें, और एक्स सेकंड के बाद अपने अनुरोध को बंद करने के लिए टाइमआउट का उपयोग करने का पूर्वाभास करें।

Comments

यह केवल एक फ़ाइल है, जिसमें कोई प्रोटोकॉल या सर्वर से डाउनलोड नहीं करना है ...http.get("http://example.com/yourfile.html",function(){})

— mjz19910

क्या इस उत्तर में मेमोरी लीक है: stackoverflow.com/a/22793628/242933 ?

— ma11hew28

आप टाइमआउट जोड़ सकते हैं जैसे मैंने किया था http.get। मेमोरी लीक केवल तभी होती है जब फ़ाइल को डाउनलोड होने में बहुत लंबा समय लगता है।

— A-312

Answer 8

उन लोगों के लिए जो एस 6-शैली वादे के आधार पर खोज करते हैं, मुझे लगता है कि यह कुछ इस तरह होगा:

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

function pDownload(url, dest){
  var file = fs.createWriteStream(dest);
  return new Promise((resolve, reject) => {
    var responseSent = false; // flag to make sure that response is sent only once.
    http.get(url, response => {
      response.pipe(file);
      file.on('finish', () =>{
        file.close(() => {
          if(responseSent)  return;
          responseSent = true;
          resolve();
        });
      });
    }).on('error', err => {
        if(responseSent)  return;
        responseSent = true;
        reject(err);
    });
  });
}

//example
pDownload(url, fileLocation)
  .then( ()=> console.log('downloaded file no issues...'))
  .catch( e => console.error('error while downloading', e));

Comments

responseSetध्वज का कारण, किसी कारण से, जिसकी जांच के लिए मेरे पास समय नहीं था, मेरी फ़ाइल अपूर्ण रूप से डाउनलोड की जानी थी। कोई त्रुटि नहीं हुई, लेकिन .txt फ़ाइल मैं पॉप्युलेट कर रहा था जिसमें पंक्तियों का आधा हिस्सा था जो वहां होना चाहिए। झंडे के लिए तर्क को हटाकर इसे ठीक कर दिया। बस यह इंगित करना चाहता था कि अगर किसी के पास दृष्टिकोण के साथ मुद्दे थे। फिर भी, +1

— मिलान वेलेबिट

Answer 9

विंस युआन का कोड बहुत अच्छा है लेकिन यह कुछ गलत लगता है।

function download(url, dest, callback) {
    var file = fs.createWriteStream(dest);
    var request = http.get(url, function (response) {
        response.pipe(file);
        file.on('finish', function () {
            file.close(callback); // close() is async, call callback after close completes.
        });
        file.on('error', function (err) {
            fs.unlink(dest); // Delete the file async. (But we don't check the result)
            if (callback)
                callback(err.message);
        });
    });
}

Comments

क्या हम गंतव्य फ़ोल्डर निर्दिष्ट कर सकते हैं?

Answer 10

मैं अनुरोध () पसंद करता हूं क्योंकि आप इसके साथ http और https दोनों का उपयोग कर सकते हैं।

request('http://i3.ytimg.com/vi/J---aiyznGQ/mqdefault.jpg')
  .pipe(fs.createWriteStream('cat.jpg'))

Comments

अनुरोध की तरह दिखता है पदावनत किया गया है github.com/request/request/issues/3142 "As of Feb 11th 2020, request is fully deprecated. No new changes are expected to land. In fact, none have landed for some time."

— माइकल Kubler

Answer 11

const download = (url, path) => new Promise((resolve, reject) => {
http.get(url, response => {
    const statusCode = response.statusCode;

    if (statusCode !== 200) {
        return reject('Download error!');
    }

    const writeStream = fs.createWriteStream(path);
    response.pipe(writeStream);

    writeStream.on('error', () => reject('Error writing to file!'));
    writeStream.on('finish', () => writeStream.close(resolve));
});}).catch(err => console.error(err));

Answer 12

हाय Hi मुझे लगता है कि आप child_process मॉड्यूल और कर्ल कमांड का उपयोग कर सकते हैं ।

const cp = require('child_process');

let download = async function(uri, filename){
    let command = `curl -o ${filename}  '${uri}'`;
    let result = cp.execSync(command);
};


async function test() {
    await download('http://zhangwenning.top/20181221001417.png', './20181221001417.png')
}

test()

इसके अलावा ， जब आप बड़ी ， एकाधिक फ़ाइलें डाउनलोड करना चाहते हैं तो use आप अधिक सीपीयू कोर का उपयोग करने के लिए क्लस्टर मॉड्यूल का उपयोग कर सकते हैं ।

Answer 13

आप https://github.com/douzi8/ajax-request#download का उपयोग कर सकते हैं

request.download('http://res.m.ctrip.com/html5/Content/images/57.png', 
  function(err, res, body) {}
);

Comments

अगर फ़ाइल का नाम जापानी में है तो यह फ़ाइल नाम के अलावा अन्य नाम से कचरा पात्र लौटा रहा है।

— दीपक गोयल

क्या आपको लगता ajax-requestहै कि थर्ड पार्टी लाइब्रेरी नहीं है?

— मुरात Murorlu

Answer 14

वादा का उपयोग करके डाउनलोड करें, जो एक पठनीय धारा को हल करता है। रीडायरेक्ट को संभालने के लिए अतिरिक्त तर्क रखें।

var http = require('http');
var promise = require('bluebird');
var url = require('url');
var fs = require('fs');
var assert = require('assert');

function download(option) {
    assert(option);
    if (typeof option == 'string') {
        option = url.parse(option);
    }

    return new promise(function(resolve, reject) {
        var req = http.request(option, function(res) {
            if (res.statusCode == 200) {
                resolve(res);
            } else {
                if (res.statusCode === 301 && res.headers.location) {
                    resolve(download(res.headers.location));
                } else {
                    reject(res.statusCode);
                }
            }
        })
        .on('error', function(e) {
            reject(e);
        })
        .end();
    });
}

download('http://localhost:8080/redirect')
.then(function(stream) {
    try {

        var writeStream = fs.createWriteStream('holyhigh.jpg');
        stream.pipe(writeStream);

    } catch(e) {
        console.error(e);
    }
});

Comments

302 URL रीडायरेक्ट के लिए HTTP स्टेटस कोड भी है, इसलिए आपको इस स्टेटमेंट में [301,302] .indexOf (res.statusCode)! == -1 का उपयोग करना चाहिए

— sidanmor

प्रश्न थर्ड पार्टी मोड्स को शामिल नहीं करने के लिए विशिष्ट थे :)

— डेविड गट्टी

Answer 15

यदि आप एक्सप्रेस का उपयोग कर रहे हैं res.download () विधि। अन्यथा एफएस मॉड्यूल का उपयोग करें।

app.get('/read-android', function(req, res) {
   var file = "/home/sony/Documents/docs/Android.apk";
    res.download(file) 
}); 

(या)

   function readApp(req,res) {
      var file = req.fileName,
          filePath = "/home/sony/Documents/docs/";
      fs.exists(filePath, function(exists){
          if (exists) {     
            res.writeHead(200, {
              "Content-Type": "application/octet-stream",
              "Content-Disposition" : "attachment; filename=" + file});
            fs.createReadStream(filePath + file).pipe(res);
          } else {
            res.writeHead(400, {"Content-Type": "text/plain"});
            res.end("ERROR File does NOT Exists.ipa");
          }
        });  
    }

Answer 16

All यदि आप पाइपलाइन का उपयोग करते हैं , तो यह अन्य सभी धाराओं को बंद कर देगा और सुनिश्चित करेगा कि मेमोरी लीक न हों।

कार्य उदाहरण:

const http = require('http');
const { pipeline } = require('stream');
const fs = require('fs');

const file = fs.createWriteStream('./file.jpg');

http.get('http://via.placeholder.com/150/92c952', response => {
  pipeline(
    response,
    file,
    err => {
      if (err)
        console.error('Pipeline failed.', err);
      else
        console.log('Pipeline succeeded.');
    }
  );
});

से मेरा उत्तर करने के लिए "क्या .pipe और नदियों पर .pipeline के बीच का अंतर है" ।

Answer 17

पथ: img प्रकार: jpg यादृच्छिक uniqid

    function resim(url) {

    var http = require("http");
    var fs = require("fs");
    var sayi = Math.floor(Math.random()*10000000000);
    var uzanti = ".jpg";
    var file = fs.createWriteStream("img/"+sayi+uzanti);
    var request = http.get(url, function(response) {
  response.pipe(file);
});

        return sayi+uzanti;
}

Answer 18

पुस्तकालय के बिना यह केवल इंगित करने के लिए छोटी गाड़ी हो सकती है। यहाँ कुछ है:

• यह url https://calibre-ebook.com/dist/portable जैसे http पुनर्निर्देशन को संभाल नहीं सकता जो बाइनरी है।
• http मॉड्यूल https url नहीं कर सकता, आपको मिलेगा Protocol "https:" not supported.

यहाँ मेरा सुझाव है:

• कॉल सिस्टम टूल जैसे wget याcurl
• नोड-वेज-वादे जैसे कुछ टूल का उपयोग करें जो उपयोग करने के लिए बहुत सरल है। var wget = require('node-wget-promise'); wget('http://nodejs.org/images/logo.svg');

Answer 19

function download(url, dest, cb) {

  var request = http.get(url, function (response) {

    const settings = {
      flags: 'w',
      encoding: 'utf8',
      fd: null,
      mode: 0o666,
      autoClose: true
    };

    // response.pipe(fs.createWriteStream(dest, settings));
    var file = fs.createWriteStream(dest, settings);
    response.pipe(file);

    file.on('finish', function () {
      let okMsg = {
        text: `File downloaded successfully`
      }
      cb(okMsg);
      file.end(); 
    });
  }).on('error', function (err) { // Handle errors
    fs.unlink(dest); // Delete the file async. (But we don't check the result)
    let errorMsg = {
      text: `Error in file downloadin: ${err.message}`
    }
    if (cb) cb(errorMsg);
  });
};

Answer 20

आप प्रयोग करके देख सकते हैं res.redirect https फ़ाइल डाउनलोड url देख , और फिर वह फ़ाइल डाउनलोड हो जाएगी।

पसंद: res.redirect('https//static.file.com/file.txt');

Answer 21

var fs = require('fs'),
    request = require('request');

var download = function(uri, filename, callback){
    request.head(uri, function(err, res, body){
    console.log('content-type:', res.headers['content-type']);
    console.log('content-length:', res.headers['content-length']);
    request(uri).pipe(fs.createWriteStream(filename)).on('close', callback);

    }); 
};   

download('https://www.cryptocompare.com/media/19684/doge.png', 'icons/taskks12.png', function(){
    console.log('done');
});

Answer 22

तीसरे पक्ष की निर्भरता के बिना इसे संभालने का एक और तरीका अभी भी है और पुनर्निर्देश की खोज भी कर रहा है:

        var download = function(url, dest, cb) {
            var file = fs.createWriteStream(dest);
            https.get(url, function(response) {
                if ([301,302].indexOf(response.statusCode) !== -1) {
                    body = [];
                    download(response.headers.location, dest, cb);
                  }
              response.pipe(file);
              file.on('finish', function() {
                file.close(cb);  // close() is async, call cb after close completes.
              });
            });
          }

Answer 23

download.js (यानी /project/utils/download.js)

const fs = require('fs');
const request = require('request');

const download = (uri, filename, callback) => {
    request.head(uri, (err, res, body) => {
        console.log('content-type:', res.headers['content-type']);
        console.log('content-length:', res.headers['content-length']);

        request(uri).pipe(fs.createWriteStream(filename)).on('close', callback);
    });
};

module.exports = { download };

app.js

... 
// part of imports
const { download } = require('./utils/download');

...
// add this function wherever
download('https://imageurl.com', 'imagename.jpg', () => {
  console.log('done')
});

Answer 24

हम डाउनलोड नोड मॉड्यूल और इसके बहुत सरल का उपयोग कर सकते हैं, कृपया नीचे देखें https://www.npmjs.com/package/download

Comments

सवाल पूछ रहा है कि यह कैसे करना है "तीसरे पक्ष के पुस्तकालयों का उपयोग किए बिना"।

— ma11hew28

Answer 25

var requestModule=require("request");

requestModule(filePath).pipe(fs.createWriteStream('abc.zip'));

Comments

कोड डंप आम तौर पर उपयोगी नहीं होते हैं और इन्हें हटाया या हटाया जा सकता है। यह कम से कम यह समझाने के लायक होगा कि भविष्य के आगंतुकों के लिए कोड क्या कर रहा है।

— कीड़े