AIDE SUR LES NœUDS

xml2js npm (Comment cela fonctionne pour les développeurs)

Publié septembre 29, 2024

Introduction

Les développeurs peuvent facilement intégrer des fonctionnalités d'analyse des données XML et de création de PDF dans leurs applications en combinant XML2JS avec IronPDF dans Node.js. Un package Node.js populaire appelé XML2JS facilite la transformation des données XML en objets JavaScript, ce qui permet une manipulation et une utilisation programmatiques du contenu XML. Inversement, IronPDF se spécialise dans la production de documents PDF de haute qualité avec des tailles de page, des marges et des en-têtes ajustables à partir deHTML, y compris le matériel créé dynamiquement.

Les développeurs peuvent désormais créer dynamiquement des rapports PDF, des factures ou d'autres documents imprimables directement à partir de sources de données XML grâce à XML2JS et IronPDF. Afin d'automatiser les processus de génération de documents et d'assurer l'exactitude et la flexibilité dans la gestion des données basées sur XML pour les sorties PDF dans les applications Node.js, cette intégration utilise les points forts des deux bibliothèques.

Qu'est-ce que xml2js ?

Un package Node.js appelé XML2JS facilite l'analyse et la création d'un XML simple.(Langage de balisage extensible)en convertisseur d'objet JavaScript. En offrant des moyens de lire des fichiers ou des textes XML et de les convertir en objets JavaScript structurés, cela facilite le traitement des documents XML. Cette procédure offre aux applications la liberté d'interpréter et d'utiliser les données XML en fournissant des options pour gérer uniquement les attributs XML, le contenu texte, les espaces de noms, fusionner des attributs ou attribuer des attributs clés, ainsi que d'autres caractéristiques spécifiques au XML.

xml2js npm(Comment cela fonctionne pour les développeurs) : Figure 1

La bibliothèque peut gérer de vastes documents XML ou des situations nécessitant une analyse non-bloquante car elle prend en charge à la fois les opérations d'analyse synchrones et asynchrones. De plus, XML2JS propose des mécanismes pour valider et résoudre les erreurs lors de la conversion des XML en objets JavaScript, garantissant ainsi la stabilité et la fiabilité des opérations de traitement des données. Tout bien considéré, les applications Node.js utilisent fréquemment XML2JS pour intégrer des sources de données basées sur XML, configurer des logiciels, modifier les formats de données et rationaliser les procédures de test automatisées.

XML2JS est un outil flexible et indispensable pour travailler avec des données XML dans des applications Node.js en raison des caractéristiques suivantes :

Analyse XML

Avec l'aide de XML2JS, les développeurs peuvent accéder plus rapidement aux données XML et les gérer en utilisant la syntaxe JavaScript bien connue, en simplifiant le traitement des chaînes ou fichiers XML en objets JavaScript.

Conversion d'objet JavaScript

Travailler avec des données XML dans des applications JavaScript est simplifié grâce à la conversion fluide des données XML en objets JavaScript structurés.

Options Configurables

Une variété d'options de configuration sont fournies par XML2JS pour vous permettre de modifier la façon dont les données XML sont analysées et converties en objets JavaScript. Cela couvre la gestion des espaces de noms, du contenu textuel, des attributs et d'autres éléments.

Conversion bidirectionnelle

Les modifications des données aller-retour sont rendues possibles grâce à ses capacités de conversion bidirectionnelle, qui permettent de transformer des objets JavaScript en chaînes XML simples.

Analyse asynchrone

Les grands documents XML peuvent être bien gérés grâce à la prise en charge des processus d'analyse asynchrones par la bibliothèque, ce qui n'interfère pas avec la boucle d'événements de l'application.

Gestion des erreurs

Pour gérer les problèmes de validation et les erreurs d'analyse qui peuvent survenir pendant le processus d'analyse et de transformation XML, XML2JS offre des méthodes solides de gestion des erreurs.

Intégration avec les Promesses

Il fonctionne bien avec les Promesses JavaScript, rendant les modèles de code asynchrones pour la gestion des données XML plus clairs et plus faciles à gérer.

Hooks de parsing personnalisables

Les développeurs peuvent augmenter la flexibilité des processus de traitement des données en créant des crochets de parsing personnalisés qui leur permettent des options spéciales pour intercepter et modifier le comportement de parsing XML.

Créer et configurer xml2js

L'installation de la bibliothèque et sa configuration pour répondre à vos besoins sont les premières étapes de l'utilisation de XML2JS dans une application Node.js. Il s'agit d'un guide détaillé pour configurer et créer XML2JS.

Installer XML2JS npm

Assurez-vous que npm et Node.js sont d'abord installés. XML2JS peut être installé avec npm :

npm install xml2js

Utilisation de base de XML2JS

Voici une simple illustration de l'utilisation de XML2JS pour analyser du texte XML en objets JavaScript :

const xml2js = require('xml2js');
// Example XML content
const xmlContent = `
<bookstore>
  <book category="fiction">
    <title>Harry Potter</title>
    <author>J.K. Rowling</author>
  </book>
  <book category="nonfiction">
    <title>Thinking, Fast and Slow</title>
    <author>Daniel Kahneman</author>
  </book>
</bookstore>
`;
// Configure XML2JS parser
const parser = new xml2js.Parser();
// Parse XML content
parser.parseString(xmlContent, (err, result) => {
  if (err) {
    console.error('Error parsing XML:', err);
    return;
  }
  console.log('Parsed XML to JavaScript object:', result);
});

const xml2js = require('xml2js');
// Example XML content
const xmlContent = `
<bookstore>
  <book category="fiction">
    <title>Harry Potter</title>
    <author>J.K. Rowling</author>
  </book>
  <book category="nonfiction">
    <title>Thinking, Fast and Slow</title>
    <author>Daniel Kahneman</author>
  </book>
</bookstore>
`;
// Configure XML2JS parser
const parser = new xml2js.Parser();
// Parse XML content
parser.parseString(xmlContent, (err, result) => {
  if (err) {
    console.error('Error parsing XML:', err);
    return;
  }
  console.log('Parsed XML to JavaScript object:', result);
});

JAVASCRIPT

xml2js npm(Comment ça fonctionne pour les développeurs) : Figure 2

Options de configuration

XML2JS propose une gamme d'options de configuration et de paramètres par défaut qui vous permettent de modifier le comportement de l'analyse. Voici une illustration de la façon de définir les paramètres d'analyse par défaut pour XML2JS :

const xml2js = require('xml2js');
// Example XML content
const xmlContent = `
<bookstore>
  <book category="fiction">
    <title>Harry Potter</title>
    <author>J.K. Rowling</author>
  </book>
  <book category="nonfiction">
    <title>Thinking, Fast and Slow</title>
    <author>Daniel Kahneman</author>
  </book>
</bookstore>
`;
// Configure XML2JS parser with options
const parser = new xml2js.Parser({
  explicitArray: false, // Convert child elements to objects instead of arrays when there is only one child
  trim: true, // Trim leading/trailing whitespace from text nodes
});
// Parse XML content
parser.parseString(xmlContent, (err, result) => {
  if (err) {
    console.error('Error parsing XML:', err);
    return;
  }
  console.log('Parsed XML to JavaScript object with options:', result);
});

const xml2js = require('xml2js');
// Example XML content
const xmlContent = `
<bookstore>
  <book category="fiction">
    <title>Harry Potter</title>
    <author>J.K. Rowling</author>
  </book>
  <book category="nonfiction">
    <title>Thinking, Fast and Slow</title>
    <author>Daniel Kahneman</author>
  </book>
</bookstore>
`;
// Configure XML2JS parser with options
const parser = new xml2js.Parser({
  explicitArray: false, // Convert child elements to objects instead of arrays when there is only one child
  trim: true, // Trim leading/trailing whitespace from text nodes
});
// Parse XML content
parser.parseString(xmlContent, (err, result) => {
  if (err) {
    console.error('Error parsing XML:', err);
    return;
  }
  console.log('Parsed XML to JavaScript object with options:', result);
});

JAVASCRIPT

Gestion de l'analyse asynchrone

L'analyse asynchrone est prise en charge par XML2JS, ce qui est utile pour gérer de grands documents XML sans arrêter la boucle d'événements. Voici une illustration de l'utilisation de la syntaxe async/await avec XML2JS :

const xml2js = require('xml2js');
// Example XML content (assume it's loaded asynchronously, e.g., from a file)
const xmlContent = `
<bookstore>
  <book category="fiction">
    <title>Harry Potter</title>
    <author>J.K. Rowling</author>
  </book>
  <book category="nonfiction">
    <title>Thinking, Fast and Slow</title>
    <author>Daniel Kahneman</author>
  </book>
</bookstore>
`;
// Configure XML2JS parser
const parser = new xml2js.Parser();
// Async function to parse XML content
async function parseXml(xmlContent) {
  try {
    const result = await parser.parseStringPromise(xmlContent);
    console.log('Parsed XML to JavaScript object (async):', result);
  } catch (err) {
    console.error('Error parsing XML (async):', err);
  }
}
// Call async function to parse XML content
parseXml(xmlContent);

const xml2js = require('xml2js');
// Example XML content (assume it's loaded asynchronously, e.g., from a file)
const xmlContent = `
<bookstore>
  <book category="fiction">
    <title>Harry Potter</title>
    <author>J.K. Rowling</author>
  </book>
  <book category="nonfiction">
    <title>Thinking, Fast and Slow</title>
    <author>Daniel Kahneman</author>
  </book>
</bookstore>
`;
// Configure XML2JS parser
const parser = new xml2js.Parser();
// Async function to parse XML content
async function parseXml(xmlContent) {
  try {
    const result = await parser.parseStringPromise(xmlContent);
    console.log('Parsed XML to JavaScript object (async):', result);
  } catch (err) {
    console.error('Error parsing XML (async):', err);
  }
}
// Call async function to parse XML content
parseXml(xmlContent);

JAVASCRIPT

Pour commencer

Pour utiliser IronPDF et XML2JS dans une application Node.js, vous devez d'abord lire les données XML, puis créer un document PDF à partir du contenu qui a été traité. Voici un guide détaillé qui vous aidera à installer et configurer ces bibliothèques.

Qu'est-ce qu'IronPDF ?

LesIronPDFbibliothèque est une puissante bibliothèque Node.js pour travailler avec des PDFs. Son objectif est de convertir du contenu HTML en documents PDF avec une qualité exceptionnelle. Il simplifie le processus de conversion des fichiers HTML, CSS et autres fichiers JavaScript en PDFs correctement formatés sans compromettre le contenu en ligne original. C'est un outil très utile pour les applications web qui doivent produire des documents dynamiques et imprimables tels que des factures, des certifications et des rapports.

IronPDF possède plusieurs fonctionnalités, dont des paramètres de page personnalisables, des en-têtes, des pieds de page, et la capacité d'insérer des polices et des images. Il prend en charge des mises en page et des styles complexes pour garantir que tous les PDF de sortie du test suivent le design spécifié. De plus, IronPDF contrôle l'exécution de JavaScript au sein de HTML, permettant un rendu précis du contenu dynamique et interactif.

xml2js npm(Comment cela fonctionne pour les développeurs) : Figure 3

Caractéristiques d'IronPDF

**Génération de PDF à partir de HTML

Convertissez HTML, CSS et JavaScript en PDF. Prend en charge deux normes web modernes : les requêtes multimédias et le responsive design. Utile pour utiliser HTML et CSS pour décorer dynamiquement les factures, rapports et documents PDF.

Édition PDF

Il est possible d'ajouter du texte, des images et d'autres éléments à des PDF déjà existants. Extraction de texte et d'images à partir de fichiers PDF. Fusionnez de nombreux fichiers PDF en un seul fichier. Divisez les fichiers PDF en plusieurs documents distincts. Ajouter des en-têtes, des pieds de page, des annotations et des filigranes.

Performance et fiabilité

Dans les contextes industriels, les performances élevées et la fiabilité sont des attributs souhaitables de la conception. Gère facilement de grands ensembles de documents.

Installer IronPDF

Pour obtenir les outils nécessaires pour travailler avec des PDF dans des projets Node.js, installez le package IronPDF.

npm install @ironsoftware/ironpdf

Analyser XML et Générer PDF

Pour illustrer, générons un fichier XML basique appelé example.xml :

<!-- example.xml -->
<bookstore>
  <book category="fiction">
    <title>Harry Potter</title>
    <author>J.K. Rowling</author>
  </book>
  <book category="nonfiction">
    <title>Thinking, Fast and Slow</title>
    <author>Daniel Kahneman</author>
  </book>
</bookstore>

<!-- example.xml -->
<bookstore>
  <book category="fiction">
    <title>Harry Potter</title>
    <author>J.K. Rowling</author>
  </book>
  <book category="nonfiction">
    <title>Thinking, Fast and Slow</title>
    <author>Daniel Kahneman</author>
  </book>
</bookstore>

JAVASCRIPT

Créez le script Node.js GeneratePdf.js, qui lit le fichier XML, utilise XML2JS pour le convertir en un objet JavaScript, puis utilise IronPDF pour créer un PDF à partir de l'objet résultant des données analysées.

// generatePdf.js
const fs = require('fs');
const xml2js = require('xml2js');
const IronPdf = require("@ironsoftware/ironpdf");
const fs = require('fs');
const document=IronPdf.PdfDocument;
var config=IronPdf.IronPdfGlobalConfig
config.setConfig({licenseKey:''});
// Function to read and parse XML
parseXml=async (filePath)=> {
  const parser = new xml2js.Parser();
  const xmlContent = fs.readFileSync(filePath, 'utf8');
  return awaitparser.parseStringPromise(xmlContent);
}
// Function to generate HTML content from the parser object
function generateHtml(parsedXml) {
  let htmlContent = `
    <!DOCTYPE html>
    <html lang="en">
    <head>
      <meta charset="UTF-8">
      <title>Bookstore</title>
      <style>
        body { font-family: Arial, sans-serif; }
        .book { margin-bottom: 20px; }
      </style>
    </head>
    <body>
      <h1>Bookstore</h1>
  `;
// root node mapping
  parsedXml.bookstore.book.forEach(book => {
    htmlContent += `
      <div class="book">
        <h2>${book.title}</h2>
        <p><strong>Category:</strong> ${book.$.category}</p>
        <p><strong>Author:</strong> ${book.author}</p>
      </div>
    `;
  });
  htmlContent += `
    </body>
    </html>
  `;
  return htmlContent;
}
// Main function to generate PDF
generatePdf=async()=> {
  try {
    var parser = await parseXml('./example.xml');
    const htmlContent = generateHtml(parser);
    document.fromHtml(htmlContent).then((pdfres)=>{
        const filePath = `${Date.now()}.pdf`;
          pdfres.saveAs(filePath).then(()=>{
            console.log('PDF saved successfully!');
         }).catch((e)=>{
            console.log(e);
         });
        });
  } catch (error) {
    console.error('Error:', error);
  }
}
// Run the main function
generatePdf();

// generatePdf.js
const fs = require('fs');
const xml2js = require('xml2js');
const IronPdf = require("@ironsoftware/ironpdf");
const fs = require('fs');
const document=IronPdf.PdfDocument;
var config=IronPdf.IronPdfGlobalConfig
config.setConfig({licenseKey:''});
// Function to read and parse XML
parseXml=async (filePath)=> {
  const parser = new xml2js.Parser();
  const xmlContent = fs.readFileSync(filePath, 'utf8');
  return awaitparser.parseStringPromise(xmlContent);
}
// Function to generate HTML content from the parser object
function generateHtml(parsedXml) {
  let htmlContent = `
    <!DOCTYPE html>
    <html lang="en">
    <head>
      <meta charset="UTF-8">
      <title>Bookstore</title>
      <style>
        body { font-family: Arial, sans-serif; }
        .book { margin-bottom: 20px; }
      </style>
    </head>
    <body>
      <h1>Bookstore</h1>
  `;
// root node mapping
  parsedXml.bookstore.book.forEach(book => {
    htmlContent += `
      <div class="book">
        <h2>${book.title}</h2>
        <p><strong>Category:</strong> ${book.$.category}</p>
        <p><strong>Author:</strong> ${book.author}</p>
      </div>
    `;
  });
  htmlContent += `
    </body>
    </html>
  `;
  return htmlContent;
}
// Main function to generate PDF
generatePdf=async()=> {
  try {
    var parser = await parseXml('./example.xml');
    const htmlContent = generateHtml(parser);
    document.fromHtml(htmlContent).then((pdfres)=>{
        const filePath = `${Date.now()}.pdf`;
          pdfres.saveAs(filePath).then(()=>{
            console.log('PDF saved successfully!');
         }).catch((e)=>{
            console.log(e);
         });
        });
  } catch (error) {
    console.error('Error:', error);
  }
}
// Run the main function
generatePdf();

JAVASCRIPT

Une façon simple de convertir des données XML et d'analyser plusieurs fichiers en documents PDF est de combiner IronPDF et XML2JS dans une application Node.js. En utilisant XML2JS, le contenu XML de plusieurs fichiers est analysé en un objet JavaScript une fois que le fichier XML est d'abord lu à l'aide du module fs de Node.js. Ensuite, le texte HTML qui constitue la base du PDF (EN ANGLAIS)est généré dynamiquement en utilisant ces données traitées.

Le script commence par lire le texte XML d'un fichier et utilise xml2js pour le parser en un objet JavaScript. À partir de l'objet de données analysé, une fonction personnalisée crée du contenu HTML, le structurant avec les éléments nécessaires—par exemple, auteurs et titres pour une librairie. Cet HTML est ensuite rendu dans un tampon PDF en utilisant IronPDF. Le PDF produit est ensuite enregistré dans le système de fichiers.

xml2js npm(Comment ça fonctionne pour les développeurs) : Figure 4

En utilisant la conversion HTML en PDF efficace d'IronPDF et les capacités robustes d'analyse XML de XML2JS, cette méthode offre un moyen simplifié de créer des PDF à partir de données XML dans des applications Node.js. La connexion permet de transformer des données XML dynamiques en documents PDF qui sont imprimables et bien formatés. Cela le rend parfait pour les applications nécessitant la génération automatisée de documents à partir de sources XML.

xml2js npm(Comment cela fonctionne pour les développeurs) : Figure 5

Conclusion

En résumé, XML2JS et IronPDF ensemble dans une application Node.js offrent une méthode puissante et adaptable pour transformer des données XML en documents PDF de haute qualité. L'analyse XML efficace en objets JavaScript à l'aide de XML2JS simplifie l'extraction et la manipulation des données. Après que les données ont été analysées, elles peuvent être modifiées dynamiquement en texte HTML, qu'IronPDF peut ensuite convertir facilement en fichiers PDF correctement structurés.

Les applications nécessitant la création automatisée de documents tels que des rapports, factures et certificats à partir de sources de données XML peuvent trouver cette combinaison particulièrement utile. Les développeurs peuvent garantir des sorties PDF précises et esthétiquement plaisantes, rationaliser les flux de travail et améliorer la capacité des applications Node.js à gérer les tâches de génération de documents en utilisant les avantages des deux bibliothèques.

IronPDF offre aux développeurs plus de fonctionnalités ainsi qu'un développement plus efficace, tout en utilisant les systèmes et la suite hautement flexibles d'Iron Software.

Il est plus facile pour les développeurs de choisir le meilleur modèle lorsque les options de licence sont explicites et spécifiques au projet. Ces fonctionnalités permettent aux développeurs de résoudre une variété de problèmes de manière facile à utiliser, efficace et cohérente.

< PRÉCÉDENT
LoopBack node js (Comment cela fonctionne pour les développeurs)

SUIVANT >
répliquer npm (Comment ça fonctionne pour les développeurs)