Como baixar um arquivo com nó.js (sem usar bibliotecas de terceiros)?

como é que faço o download de um ficheiro com um nó.js sem usar bibliotecas de terceiros ?

Não preciso de nada especial. Eu só quero baixar um arquivo de um dado URL, e depois salvá-lo para um determinado diretório.

Author: KARTHIKEYAN.A, 2012-08-14
Source

19 answers

Você pode criar um pedido HTTP GET e canalizar o seu response para uma transmissão de ficheiros: 

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

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

Se quiser suportar a recolha de informações na linha de comandos--como Indicar um ficheiro de destino ou directório,ou URL -- verifique algo como Comandante .

 399
Author: Michelle Tilley, 2014-04-12 01:04:59
Não se esqueça de lidar com erros! O seguinte código é baseado na resposta de Augusto Roman. 
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);
  });
};
 430
Author: Vince Yuan, 2014-04-07 08:24:11
Como Brandon Tilley disse, mas com o fluxo de controlo adequado. 
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);
    });
  });
}

Sem esperar pelo evento finish, os programas ingênuos podem acabar com um ficheiro incompleto.

Editar: graças a @Augusto Roman por apontar que cb deve ser passado para file.close, Não chamado explicitamente.

 118
Author: gfxmonk, 2014-04-12 23:59:20
Por falar em lidar com erros, é ainda melhor ouvir os erros dos pedidos. Até validava verificando o código de resposta. Aqui é considerado sucesso apenas para 200 código de resposta, mas outros códigos podem ser bons. 
var fs = require('fs');
var http = require('http');

var download = function(url, dest, cb) {
    var file = fs.createWriteStream(dest);
    var request = http.get(url, function(response) {

        // check if response is success
        if (response.statusCode !== 200) {
            return cb('Response status was ' + response.statusCode);
        }

        response.pipe(file);

        file.on('finish', function() {
            file.close(cb);  // close() is async, call cb after close completes.
        });
    });

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

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

Apesar da relativa simplicidade deste código, eu aconselharia usar o Módulo pedido como ele lida com muitos mais protocolos (hello HTTPS!) que não são nativamente suportados por http.

Isso seria feito assim. 
var fs = require('fs');
var request = require('request');

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

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

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

    sendReq.pipe(file);

    file.on('finish', function() {
        file.close(cb);  // close() is async, call cb after close completes.
    });

    file.on('error', function(err) { // Handle errors
        fs.unlink(dest); // Delete the file async. (But we don't check the result)
        return cb(err.message);
    });
};
 50
Author: Buzut, 2017-11-22 01:53:27

A resposta do Gfxmonk tem uma corrida de dados muito apertada entre o callback e a conclusão file.close(). file.close() na verdade faz um callback que é chamado quando o close tiver terminado. Caso contrário, os usos imediatos do arquivo podem falhar (muito raramente!).

Uma solução completa é: 

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

Sem esperar pelo evento final, os programas ingênuos podem acabar com um ficheiro incompleto. Sem agendar a chamada de volta cb através de close, você pode obter uma corrida entre o acesso ao arquivo e o o ficheiro está pronto.

 37
Author: Augusto Roman, 2018-05-02 20:32:07

Solução com tempo-limite, evitar fugas de memória:

O seguinte código é baseado na resposta de Brandon Tilley: 
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();
    });
});

Não faça o ficheiro quando tiver um erro, e prefira usar o tempo-limite para fechar o seu pedido após o X secondes.

 14
Author: Hors Sujet, 2018-05-02 19:11:12
Para aqueles que vieram em busca de uma promessa baseada no estilo es6, acho que seria algo como: 
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));
 12
Author: mido, 2015-12-30 07:49:28
Talvez nodo.js mudou, mas parece que existem alguns problemas com as outras soluções (usando o nó v8.1.2):
    Não precisas de ligar para o evento. Por omissão, o fs.createWriteStream está configurado para autoClose: https://nodejs.org/api/fs.html#fs_fs_createwritestream_path_options
  1. file.close() deve ser chamado por erro. Talvez isto não seja necessário quando o ficheiro é apagado (unlink()), mas normalmente é: https://nodejs.org/api/stream.html#stream_readable_pipe_destination_options
  2. o ficheiro Temp não é apagado em statusCode !== 200
  3. fs.unlink() sem um callback é desactualizado (Aviso de saída)
  4. Se o ficheiro dest existe; é substituído

Abaixo está uma solução modificada (usando ES6 e promessas) que lida com estes problemas.

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);
            }
        });
    });
}
 9
Author: Bjarke Pjedsted, 2017-07-10 08:52:43
O código do Vince Yuan é óptimo, mas parece haver algo errado. 
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);
        });
    });
}
 4
Author: weed, 2014-12-02 07:06:09

Pode usar https://github.com/douzi8/ajax-request#download

request.download('http://res.m.ctrip.com/html5/Content/images/57.png', 
  function(err, res, body) {}
);
 4
Author: douzi, 2014-12-04 03:11:44 
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));
 4
Author: kayz1, 2017-01-18 21:14:47

Localização: img tipo: jpg uniqid Aleatório 

    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;
}
 1
Author: databilim, 2015-08-23 15:54:10

Se estiver a utilizar o método expresso res.download (). caso contrário, utilizar o módulo fs.

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

(ou) 

   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");
          }
        });  
    }
 1
Author: KARTHIKEYAN.A, 2018-09-18 09:19:50

Faça o Download usando o promise, que resolve um fluxo legível. coloque lógica extra para lidar com o redirecionamento.

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);
    }
});
 0
Author: wdanxna, 2016-04-12 02:33:36 
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);
  });
};
 0
Author: Alex Pilugin, 2018-04-09 05:25:46

Você pode tentar usar res.redirect para o url de download do ficheiro https, e então ele irá transferir o ficheiro.

Tipo ...: res.redirect('https//static.file.com/file.txt');
 0
Author: Yin, 2018-06-07 13:03:01
Sem a biblioteca pode ser um buggy só para assinalar. Aqui estão algumas:
  • não consegue lidar com o redireccionamento http, como este url https://calibre-ebook.com/dist/portable que é binário.
  • o módulo http não consegue o url do https, você irá obter Protocol "https:" not supported.
Eis a minha sugestão:
  • Call system tool like wget or curl
  • use alguma ferramenta como node-wget-promise que também é muito simples de usar. var wget = require('node-wget-promise'); wget('http://nodejs.org/images/logo.svg');
 -1
Author: Geng Jiawen, 2018-02-25 03:25:42 
var requestModule=require("request");

requestModule(filePath).pipe(fs.createWriteStream('abc.zip'));
 -2
Author: Chandrakant Thakkar, 2017-06-01 09:30:21

Podemos usar o módulo do nó de download e o seu muito simples, por favor consulte abaixo https://www.npmjs.com/package/download

 -2
Author: Iyyappan Subramani, 2017-08-18 05:20:42