node.js axios télécharger le flux de fichiers et writeFile

Ceci est mon exemple de code exécuté avec le nœud js Il y a une erreur de synctaxe

doit être writeFile et non WriteFile

%PDF-1.3
%����

1 0 obj
<<
/Type /Catalog
/Outlines 2 0 R
/Pages 3 0 R
>>
endobj

2 0 obj
<<
/Type /Outlines
/Count 0
>>
endobj

3 0 obj
<<
/Type /Pages
/Count 2
/Kids [ 4 0 R 6 0 R ] 
>>
endobj

Une fois le fichier enregistré, il peut ressembler à un éditeur de texte, mais le fichier a été enregistré correctement

const axios = require('axios');
const fs = require('fs');
axios.get('http://www.africau.edu/images/default/sample.pdf', {responseType: 'blob'}).then(response => {
  fs.writeFile('./my.pdf', response.data, (err) => {
        if (err) throw err;
        console.log('The file has been saved!');
    });
});

node fileSystem writeFile encode les données par défaut en UTF8. ce qui pourrait être un problème dans votre cas.

Essayez de définir votre encodage sur null et ignorez l'encodage des données reçues:

fs.writeFile('/temp/my.pdf', response.data, 'null', (err) => {...}

vous pouvez également décaler l'encodage en tant que chaîne (au lieu de l'objet d'options) si vous ne déclarez que l'encodage et aucune autre option. string sera traité comme valeur d'encodage. En tant que tel:

fs.writeFile('/temp/my.pdf', response.data, {encoding: null}, (err) => {...}

lire plus dans fileSystem API write_file

Vous pouvez simplement utiliser response.data.pipe et fs.createWriteStream pour fs.createWriteStream réponse vers le fichier

axios({
    method: "get",
    url: "https://xxx/my.pdf",
    responseType: "stream"
}).then(function (response) {
    response.data.pipe(fs.createWriteStream("/temp/my.pdf"));
});

J'ai essayé, et je suis sûr que l'utilisation de response.data.pipe et fs.createWriteStream peut fonctionner.

En plus, je veux ajouter ma situation et ma solution

Situation:

• utiliser koa pour développer un serveur node.js
• utiliser axios pour obtenir un pdf via url
• en utilisant pdf-parse pour analyser le pdf
• extraire des informations de pdf et les renvoyer en tant que json au navigateur

Solution:

const Koa = require('koa');
const app = new Koa();
const axios = require('axios')
const fs = require("fs")
const pdf = require('pdf-parse');
const utils = require('./utils')

app.listen(process.env.PORT || 3000)

app.use(async (ctx, next) => {
      let url = 'https://path/name.pdf'
      let resp = await axios({
          url: encodeURI(url),
          responseType: 'arraybuffer'
        })

        let data = await pdf(resp.data)

        ctx.body = {
            phone: utils.getPhone(data.text),
            email: utils.getEmail(data.text),
        }
})

Dans cette solution, il n'est pas nécessaire d'écrire et de lire un fichier, c'est plus efficace.

// This works perfectly well! 
const axios = require('axios'); 

axios.get('http://www.sclance.com/pngs/png-file-download/png_file_download_1057991.png', {responseType: "stream"} )  
.then(response => {  
// Saving file to working directory  
    response.data.pipe(fs.createWriteStream("todays_picture.png"));  
})  
    .catch(error => {  
    console.log(error);  
});  

En fait, je pense que la réponse précédemment acceptée a quelques défauts, car elle ne gérera pas correctement le flux d'écriture, donc si vous appelez "then ()" après qu'Axios vous a donné la réponse, vous finirez par avoir un fichier partiellement téléchargé.

C'est une solution plus appropriée lors du téléchargement de fichiers légèrement plus volumineux:

export async function downloadFile(fileUrl: string, outputLocationPath: string) {
  const writer = createWriteStream(outputLocationPath);

  return Axios({
    method: 'get',
    url: fileUrl,
    responseType: 'stream',
  }).then(response => {

    //ensure that the user can call `then()` only when the file has
    //been downloaded entirely.

    return new Promise((resolve, reject) => {
      response.data.pipe(writer);
      let error = null;
      writer.on('error', err => {
        error = err;
        writer.close();
        reject(err);
      });
      writer.on('close', () => {
        if (!error) {
          resolve(true);
        }
        //no need to call the reject here, as it will have been called in the
        //'error' stream;
      });
    });
  });
}

De cette façon, vous pouvez appeler downloadFile() , appeler then() sur la promesse retournée et vous assurer que le fichier téléchargé aura terminé le traitement.

import download from "downloadjs";

export const downloadFile = async (fileName) => {
    axios({
        method: "get",
        url: `/api/v1/users/resume/${fileName}`,
        responseType: "blob",
    }).then(function (response) {
        download(response.data, fileName);
    });
};
it's work fine to me

Le problème avec un fichier cassé est dû à la contre- pression dans les flux de nœuds . Vous pouvez trouver ce lien utile à lire: https://nodejs.org/es/docs/guides/backpressuring-in-streams/

Je ne suis pas vraiment fan de l'utilisation des objets déclaratifs de base Promise dans les codes JS car je pense que cela pollue la logique de base réelle et rend le code difficile à lire. En plus de cela, vous devez provisionner des gestionnaires d'événements et des écouteurs pour vous assurer que le code est terminé.

Une approche plus propre sur la même logique que celle proposée par la réponse acceptée est donnée ci-dessous. Il utilise les concepts de pipelines de flux .

const util = require("util");
const stream = require("stream");
const pipeline = util.promisify(stream.pipeline);

const downloadFile = async () => {
    try {
        await pipeline( axios.get('https://xxx/my.pdf', {responseType: 'blob'}), 
                            fs.createWriteStream("/temp/my.pdf"));
        console.log("donwload pdf pipeline successfull");   
    } catch (error) {
        console.error("donwload pdf pipeline failed", error);
    }
}

exports.downloadFile = downloadFile

J'espère que vous trouvez ça utile.