Hoe download ik een bestand met Node.js zonder bibliotheken van derden te gebruiken?
Ik heb niets speciaals nodig. Ik wil alleen een bestand downloaden van een bepaalde URL en het dan opslaan in een bepaalde map.
Antwoord 1, autoriteit 100%
Je kunt een HTTP GET-verzoek maken en het responseervan doorsturen naar een beschrijfbare bestandsstroom:
const http = require('http'); // or 'https' for https:// URLs
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);
});
Als je het verzamelen van informatie op de opdrachtregel wilt ondersteunen, zoals het specificeren van een doelbestand of -map, of URL, bekijk dan iets als Commandant.
Antwoord 2, autoriteit 77%
Vergeet niet om fouten op te lossen! De volgende code is gebaseerd op het antwoord van 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);
});
};
Antwoord 3, autoriteit 23%
Zoals Michelle Tilley zei, maar met de juiste controlestroom:
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);
});
});
}
Zonder te wachten op de finishgeval kan naïef scripts eindigen met een onvolledig dossier.
Bewerken Met dank aan @Augusto Roman voor het erop te wijzen dat cbmoeten worden doorgegeven naar file.close, niet expliciet genoemd.
4, Autoriteit 10%
Spreken van de behandeling van fouten, het is nog beter luisteren naar verzoek fouten ook. Ik zou zelfs valideren door het controleren van response code. Hier wordt het beschouwd als succes alleen voor 200 response code, maar ook andere codes misschien goed.
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);
});
};
Ondanks de relatieve eenvoud van deze code, zou ik adviseren om de verzoekmodulete gebruiken, aangezien deze veel meer protocollen (hallo HTTPS!) die niet standaard worden ondersteund door http.
Dat zou zo worden gedaan:
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);
});
};
Antwoord 5, autoriteit 7%
Het antwoord van gfxmonk heeft een zeer strakke datarace tussen de callback en de voltooiing van file.close(). file.close()neemt in feite een callback die wordt aangeroepen wanneer de afsluiting is voltooid. Anders kan het onmiddellijke gebruik van het bestand mislukken (zeer zelden!).
Een complete oplossing is:
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.
});
});
}
Zonder te wachten op het afwerkingsgebeurtenis, kunnen naïeve scripts een onvolledig bestand eindigen. Zonder de cbterug te plannen via Sluiten, kunt u een race krijgen tussen het toegang tot het bestand en het bestand dat eigenlijk klaar is.
6, Autoriteit 3%
Misschien is Node.js veranderd, maar het lijkt erop dat er problemen zijn met de andere oplossingen (met behulp van knooppunt V8.1.2):
- U hoeft niet
file.close()IN DEfinishEvent te bellen. Per standaard Defs.createWriteStreamis ingesteld op AutoClose: https: // nodejs .org / api / fs.html # fs_fs_createwritestream_path_options file.close()moet worden opgeroepen. Misschien is dit niet nodig wanneer het bestand wordt verwijderd (unlink()), maar normaal gesproken is het: https://nodejs.org/api/stream.html#stream_readable_pipe_destation_options- TEMP-bestand is niet verwijderd op
statusCode !== 200 fs.unlink()Zonder een callback is verouderd (WAARSCHUWING)- Als
destbestand bestaat; Het is overschreven
Hieronder is een gewijzigde oplossing (met behulp van ES6 en beloften) die deze problemen afhandelt.
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);
}
});
});
}
Antwoord 7, autoriteit 3%
voor degenen die op zoek waren naar een op es6-stijl gebaseerde manier, denk ik dat het zoiets zou zijn als:
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));
8, Autoriteit 2%
Oplossing met time-out, voorkomen van geheugenlek:
De volgende code is gebaseerd op het antwoord van 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();
});
});
Maak geen bestand wanneer u een foutmelding krijgt en de voorkeur wilt gebruiken om uw verzoek na x seconden te sluiten.
9
Hallo, ik denk dat je child_process module en curl-opdracht kunt gebruiken.
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()
Bovendien, wanneer u grote, meerdere bestanden wilt downloaden, kunt u Cluster -module gebruiken om meer CPU-kernen te gebruiken.
10
De code van Vince Yuan is geweldig, maar het lijkt er iets mis te zijn.
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);
});
});
}
11
Ik geef de voorkeur aan aanvraag () omdat u zowel HTTP als HTTPS ermee kunt gebruiken.
request('http://i3.ytimg.com/vi/J---aiyznGQ/mqdefault.jpg')
.pipe(fs.createWriteStream('cat.jpg'))
12
Gebaseerd op de andere antwoorden hierboven en sommige Subtle -problemen, hier is mijn poging.
- Controleer het bestand niet alvorens het netwerk te raken met behulp van
fs.access. - Maak alleen de
fs.createWriteStreamals u een200 OKStatuscode ontvangt. Dit vermindert de hoeveelheidfs.unlinkopdrachten die nodig zijn om tijdelijke bestandshandvatten op te ruimen. - Zelfs op een
200 OKWe kunnen nog steeds mogelijkrejectVanwege eenEEXIST-bestand bestaat al. - Recursief bellen
downloadAls u een301 Moved Permanentlyof302 Found (Moved Temporarily)RECEIRECTION . - Het probleem met enkele van de andere antwoorden die recursief bellen met
downloadWas dat zeresolve(download)in plaats vandownload(...).then(() => resolve())dus dePromisezou terugkeren voordat de download daadwerkelijk is voltooid. Op deze manier lost de geneste keten van beloften op in de juiste volgorde. - Het lijkt misschien cool om het temp-bestand asynchroon op te ruimen, maar ik koos ervoor om alleen na die voltooide te weigeren, dus ik weet dat alles begint te voltooien wanneer deze belofte oplost of verwerpt of verwerpt.
const https = require('https');
const fs = require('fs');
/**
* Download a resource from `url` to `dest`.
* @param {string} url - Valid URL to attempt download of resource
* @param {string} dest - Valid path to save the file.
* @returns {Promise<void>} - Returns asynchronously when successfully completed download
*/
function download(url, dest) {
return new Promise((resolve, reject) => {
// Check file does not exist yet before hitting network
fs.access(dest, fs.constants.F_OK, (err) => {
if (err === null) reject('File already exists');
const request = https.get(url, response => {
if (response.statusCode === 200) {
const file = fs.createWriteStream(dest, { flags: 'wx' });
file.on('finish', () => resolve());
file.on('error', err => {
file.close();
if (err.code === 'EEXIST') reject('File already exists');
else fs.unlink(dest, () => reject(err.message)); // Delete temp file
});
response.pipe(file);
} else if (response.statusCode === 302 || response.statusCode === 301) {
//Recursively follow redirects, only a 200 will resolve.
download(response.headers.location, dest).then(() => resolve());
} else {
reject(`Server responded with ${response.statusCode}: ${response.statusMessage}`);
}
});
request.on('error', err => {
reject(err.message);
});
});
});
}
Antwoord 13
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));
Antwoord 14
✅Dus als je pijplijngebruikt, zou het alle andere streams sluiten en ervoor zorgen dat er geen geheugenlekken zijn.
Werkvoorbeeld:
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.'); } ); });
Van mijn antwoordnaar ” Wat is het verschil tussen .pipe en .pipeline op streams”.
Antwoord 15
Moderne versie (ES6, Promise, Node 12.x+ ) werkt voor https/http. Ook ondersteunt het omleidingen 302 & 301. Ik heb besloten om geen bibliotheken van derden te gebruiken omdat dit gemakkelijk kan worden gedaan met standaard Node.js-bibliotheken.
// download.js
import fs from 'fs'
import https from 'https'
import http from 'http'
import { basename } from 'path'
import { URL } from 'url'
const TIMEOUT = 10000
function download (url, dest) {
const uri = new URL(url)
if (!dest) {
dest = basename(uri.pathname)
}
const pkg = url.toLowerCase().startsWith('https:') ? https : http
return new Promise((resolve, reject) => {
const request = pkg.get(uri.href).on('response', (res) => {
if (res.statusCode === 200) {
const file = fs.createWriteStream(dest, { flags: 'wx' })
res
.on('end', () => {
file.end()
// console.log(`${uri.pathname} downloaded to: ${path}`)
resolve()
})
.on('error', (err) => {
file.destroy()
fs.unlink(dest, () => reject(err))
}).pipe(file)
} else if (res.statusCode === 302 || res.statusCode === 301) {
// Recursively follow redirects, only a 200 will resolve.
download(res.headers.location, dest).then(() => resolve())
} else {
reject(new Error(`Download request failed, response status: ${res.statusCode} ${res.statusMessage}`))
}
})
request.setTimeout(TIMEOUT, function () {
request.abort()
reject(new Error(`Request timeout after ${TIMEOUT / 1000.0}s`))
})
})
}
export default download
Een pluim voor Andrey Tkachenkovoor zijn gistdie ik heb aangepast
Neem het op in een ander bestand en gebruik
const download = require('./download.js')
const url = 'https://raw.githubusercontent.com/replace-this-with-your-remote-file'
console.log('Downloading ' + url)
async function run() {
console.log('Downloading file')
try {
await download(url, 'server')
console.log('Download done')
} catch (e) {
console.log('Download failed')
console.log(e.message)
}
}
run()
Antwoord 16
Je kunt https://github.com/douzi8/ajax-request#download
request.download('http://res.m.ctrip.com/html5/Content/images/57.png',
function(err, res, body) {}
);
Antwoord 17
Download met behulp van belofte, waarmee een leesbare stream wordt opgelost. voeg extra logica toe om de omleiding af te handelen.
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);
}
});
Antwoord 18
download.js(d.w.z. /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')
});
Antwoord 19
Als je express gebruikt, gebruik dan de res.download()-methode. anders fs-module gebruiken.
app.get('/read-android', function(req, res) {
var file = "/home/sony/Documents/docs/Android.apk";
res.download(file)
});
(of)
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");
}
});
}
Antwoord 20
De http2-module gebruiken
Ik heb antwoorden gezien met behulp van de modules http, httpsen verzoek. Ik wil er graag een toevoegen met nog een andere native NodeJS-module die het http- of https-protocol ondersteunt:
Oplossing
Ik heb verwezen naar de officiële NodeJS API, evenals enkele van de andere antwoorden op deze vraag voor iets dat ik aan het doen ben. Het volgende was de test die ik schreef om het uit te proberen, wat werkte zoals bedoeld:
import * as fs from 'fs';
import * as _path from 'path';
import * as http2 from 'http2';
/* ... */
async function download( host, query, destination )
{
return new Promise
(
( resolve, reject ) =>
{
// Connect to client:
const client = http2.connect( host );
client.on( 'error', error => reject( error ) );
// Prepare a write stream:
const fullPath = _path.join( fs.realPathSync( '.' ), destination );
const file = fs.createWriteStream( fullPath, { flags: "wx" } );
file.on( 'error', error => reject( error ) );
// Create a request:
const request = client.request( { [':path']: query } );
// On initial response handle non-success (!== 200) status error:
request.on
(
'response',
( headers/*, flags*/ ) =>
{
if( headers[':status'] !== 200 )
{
file.close();
fs.unlink( fullPath, () => {} );
reject( new Error( `Server responded with ${headers[':status']}` ) );
}
}
);
// Set encoding for the payload:
request.setEncoding( 'utf8' );
// Write the payload to file:
request.on( 'data', chunk => file.write( chunk ) );
// Handle ending the request
request.on
(
'end',
() =>
{
file.close();
client.close();
resolve( { result: true } );
}
);
/*
You can use request.setTimeout( 12000, () => {} ) for aborting
after period of inactivity
*/
// Fire off [flush] the request:
request.end();
}
);
}
Dan, bijvoorbeeld:
/* ... */
let downloaded = await download( 'https://gitlab.com', '/api/v4/...', 'tmp/tmpFile' );
if( downloaded.result )
{
// Success!
}
// ...
Externe referenties
- https://nodejs.org/api/http2.html#http2_client_side_example
- https://nodejs.org/api/http2.html#http2_clienthttp2session_request_headers_options
INFORMATIE BEWERKEN
- De oplossing is geschreven voor typoscript, de functie een klassemethode– maar zonder dit op te merken zou de oplossing niet hebben gewerkt voor de veronderstelde javascript-gebruiker zonder correct gebruik van de
functionverklaring, die onze bijdrager zo snel heeft toegevoegd. Bedankt!
Antwoord 21
Pad : img
type: jpg
willekeurige 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;
}
Antwoord 22
Zonder bibliotheek kan het een bug zijn om erop te wijzen. Hier zijn er een paar:
- Kan http-omleiding niet aan, zoals deze url https://calibre-ebook.com/dist /portablewat binair is.
- http-module kan geen https-url, u krijgt
Protocol "https:" not supported.
Hier mijn suggestie:
- Oproepsysteemtool zoals
wgetofcurl - gebruik een tool zoals node-wget-promisedie ook heel eenvoudig te gebruiken is .
var wget = require('node-wget-promise');
wget('http://nodejs.org/images/logo.svg');
Antwoord 23
Mijn eigen oplossing schrijven omdat de bestaande niet aan mijn eisen voldeed.
Wat dit omvat:
- HTTPS-download (schakel het pakket over naar
httpvoor HTTP-downloads) - Op belofte gebaseerde functie
- Doorgestuurd pad afhandelen (status 302)
- browser header – vereist op een paar CDNS
- bestandsnaam uit URL (evenals hardcoded)
- FOUTHANDELING
Het is getypt, het is veiliger. Voel je vrij om de typen te laten vallen als je werkt met gewoon JS (geen stroom, geen ts) of converteert naar een .d.tsbestand
index.js
import httpsDownload from httpsDownload;
httpsDownload('https://example.com/file.zip', './');
HTTPSDOELLOAD. [JS | TS]
import https from "https";
import fs from "fs";
import path from "path";
function download(
url: string,
folder?: string,
filename?: string
): Promise<void> {
return new Promise((resolve, reject) => {
const req = https
.request(url, { headers: { "User-Agent": "javascript" } }, (response) => {
if (response.statusCode === 302 && response.headers.location != null) {
download(
buildNextUrl(url, response.headers.location),
folder,
filename
)
.then(resolve)
.catch(reject);
return;
}
const file = fs.createWriteStream(
buildDestinationPath(url, folder, filename)
);
response.pipe(file);
file.on("finish", () => {
file.close();
resolve();
});
})
.on("error", reject);
req.end();
});
}
function buildNextUrl(current: string, next: string) {
const isNextUrlAbsolute = RegExp("^(?:[a-z]+:)?//").test(next);
if (isNextUrlAbsolute) {
return next;
} else {
const currentURL = new URL(current);
const fullHost = `${currentURL.protocol}//${currentURL.hostname}${
currentURL.port ? ":" + currentURL.port : ""
}`;
return `${fullHost}${next}`;
}
}
function buildDestinationPath(url: string, folder?: string, filename?: string) {
return path.join(folder ?? "./", filename ?? generateFilenameFromPath(url));
}
function generateFilenameFromPath(url: string): string {
const urlParts = url.split("/");
return urlParts[urlParts.length - 1] ?? "";
}
export default download;
Antwoord 24
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);
});
};
Antwoord 25
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');
});
26
Hier is nog een andere manier om het aan te gaan zonder afhankelijkheid van de derde partij en ook op zoek naar omleidingen:
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.
});
});
}
27
Ik heb deze benadering gevonden om het meest nuttig te zijn, vooral als het gaat om PDF’s en willekeurige andere bestanden.
import fs from "fs";
fs.appendFile("output_file_name.ext", fileDataInBytes, (err) => {
if (err) throw err;
console.log("File saved!");
});
28
Ik stel u aan om res.downloadhetzelfde als volgt te gebruiken:
app.get('/download', function(req, res){
const file = `${__dirname}/folder/abc.csv`;
res.download(file); // Set disposition and send it.
});
29
var requestModule=require("request");
requestModule(filePath).pipe(fs.createWriteStream('abc.zip'));