Ein Vergleich zwischen PDFKit npm & IronPDF for Node.js

Einführung

Dieser Lehrgang behandelt IronPDF und PDFKit - zwei große Namen der JavaScript-PDF-Bibliotheken. Beide sind eine gute Wahl für Node.js-Projekte, aber sie haben ihre Stärken und Schwächen.

Dieser Artikel soll den Lesern einen Eindruck davon vermitteln, wie IronPDF und die PDFKit-Werkzeuge in den Node.js-Workflow eines Entwicklers passen können. Egal, ob Sie einfache PDFs erstellen oder mit komplizierten Layouts arbeiten, Sie sollten verstehen, was IronPDF und PDFKit können (und kann nicht) tun, ist super wichtig.

PDFKit

PDFKit ist eine fortschrittliche JavaScript-Bibliothek zur PDF-Erzeugung für Node.js und Browser-Umgebungen. Mit seinen umfassenden Werkzeugen ist es ideal für die einfache Erstellung mehrseitiger, druckfähiger Dokumente. Die Bibliothek ist so konzipiert, dass sie einfach zu bedienen ist und den Prozess der Erstellung komplexer Dokumente vereinfacht.

PDFKit zeichnet sich durch leistungsstarke Vektorgrafikfunktionen, umfangreiche Text- und Schriftstiloptionen, Funktionen zum Einbetten von Bildern und Unterstützung für interaktive und sichere PDF-Dokumente aus. Seine Benutzerfreundlichkeit in Kombination mit seiner Vielseitigkeit sowohl für serverseitige als auch für Browser-Umgebungen macht es zu einem wertvollen Werkzeug für Entwickler, die benutzerdefinierte PDFs in einer Vielzahl von Anwendungen erzeugen müssen.

Hauptmerkmale von PDFKit

• Flexible PDF-Erstellung

   PDFKit verlässt sich nicht auf die HTML-zu-PDF-Konvertierung; stattdessen werden PDFs direkt durch JavaScript-Code erzeugt. Dieser Ansatz bietet Entwicklern eine präzise Kontrolle über das Layout, den Stil und den Inhalt der von ihnen erstellten PDF-Dateien, wodurch die Erstellung komplexer Dokumente erleichtert wird.

• Grafiken und Textformatierung

   Die Bibliothek unterstützt erweiterte Grafikfunktionen wie Linien, Kurven, Rechtecke, Kreise und vieles mehr. Textformatierungsfunktionen wie benutzerdefinierte Schriftarten, Größen und Farben ermöglichen die Erstellung visuell ansprechender Dokumente.

• Bildeinbettung und Vektorgrafik

   PDFKit erlaubt die Einbettung von Bildern in verschiedenen Formaten und unterstützt Vektorgrafiken, was es ideal für hochwertige Druckdokumente macht. Das Einbetten von Bildern unterstützt JPEG- und PNG-Dateien.

• Erweiterte Dokumentenfunktionen

   Entwickler können Anmerkungen, Lesezeichen und Hyperlinks zu ihren PDFs hinzufügen. Die Bibliothek unterstützt auch die Erstellung von Kopf- und Fußzeilen sowie die Einbindung von Seitenzahlen und benutzerdefiniertem JavaScript.

• Anpassbare und wiederverwendbare Komponenten

   Die PDFKit-API erleichtert die Erstellung wiederverwendbarer Komponenten und rationalisiert den Entwicklungsprozess für Dokumente mit sich wiederholenden Strukturen wie Rechnungen oder Berichte.

• Vektorgrafik

   PDFKit bietet eine HTML5-Canvas-ähnliche API für Vektorgrafiken, einschließlich Pfadoperationen, SVG-Pfadparsing, Transformationen und Farbverläufe. Dies ist ideal für die Erstellung skalierbarer, hochwertiger Grafiken in PDFs. Die Bibliothek unterstützt Zeilenumbrüche, verschiedene Textausrichtungen und Aufzählungslisten.

• Eingebettete Schriftarten

   PDFKit unterstützt eine Vielzahl von Schriftformaten wie TrueType, OpenType, WOFF und andere, was eine einheitliche Typografie in PDFs ermöglicht. Es gibt auch eine Untereinstellung für die Schriftart, die dafür sorgt, dass die Größe des Dokuments überschaubar bleibt.

IronPDF Node.js

Mit IronPDF können Sie ganz einfach HTML-Strings, Dateien oder sogar ganze Webseiten in PDFs konvertieren, die genau wie der Originalinhalt aussehen, komplett mit CSS-Styling und Bildern. Dies ist von entscheidender Bedeutung für die Bereitstellung professioneller Dokumente wie Rechnungen, Verträge und Berichte, bei denen das Branding und Layout des Webdesigns beibehalten werden muss.

Hauptmerkmale von IronPDF for Node.js

Konvertierung von HTML in PDF

IronPDF eignet sich hervorragend für die Konvertierung von HTML-Inhalten in originalgetreue PDF-Dokumente. Seine Fähigkeiten umfassen:

• HTML-String in PDF: Mit dieser Funktion können dynamische HTML-Strings direkt in PDFs umgewandelt werden.
• HTML-Datei in PDF: Damit können statische HTML-Dateien nahtlos in das PDF-Format umgewandelt werden, wobei das Layout und das Styling erhalten bleiben.
• URL zu PDF: IronPDF kann ganze Webseiten per URL erfassen und in PDFs umwandeln, was sich perfekt für die Archivierung und den Offline-Zugriff eignet.

Formatierung von PDFs

IronPDF bietet umfassende Formatierungswerkzeuge, die die Anpassung und Verbesserung von PDFs ermöglichen, die aus HTML-Inhalten erstellt wurden, wie z. B:

• JavaScript in HTML to PDF: IronPDF kann vor der Konvertierung JavaScript innerhalb von HTML ausführen und so das Rendern dynamischer Daten oder interaktiver Elemente in das statische Format einer PDF-Datei ermöglichen.
• Strichcodes in HTML zu PDF hinzufügen: IronPDF unterstützt die Einbettung von Barcodes in PDF-Dateien, eine Funktion, die für Dokumente in der Logistik, im Einzelhandel und in der Bestandsverwaltung unerlässlich ist.
• Seitenvorlagen anwenden: Standardisieren Sie das Erscheinungsbild Ihrer Dokumente durch die Anwendung von Seitenvorlagen, bei denen es sich um vordefinierte Layouts handelt, die die Konsistenz mehrerer PDFs gewährleisten.
• Benutzerdefinierte Schriftarten im HTML-PDF-Format: IronPDF ermöglicht die Einbettung benutzerdefinierter Schriftarten direkt aus dem HTML-Inhalt in das PDF-Dokument, wodurch sichergestellt wird, dass Branding und Design in allen Dokumenten kohärent und konsistent sind.

Seiteninhalt bearbeiten

IronPDF verfügt über umfangreiche Bearbeitungsfunktionen, mit denen sich vorhandene PDF-Dateien an spezielle Anforderungen anpassen lassen:

• Text suchen und ersetzen: Diese Funktion ermöglicht das Suchen und Ersetzen von Text in der PDF-Datei, so dass Aktualisierungen und Korrekturen leicht möglich sind.
• Effizientes Hinzufügen von HTML-Inhalten: Benutzer können weitere HTML-Inhalte in eine bestehende PDF-Datei einfügen. Diese Funktion wurde optimiert, um sicherzustellen, dass zusätzliche Inhalte die Leistung oder Ladezeiten des Dokuments nicht beeinträchtigen.
• Stempeln neuer Inhalte: IronPDF kann neue Inhalte auf eine bestehende PDF-Seite stempeln oder überlagern. Dies ist nützlich für das Hinzufügen von offiziellen Wasserzeichen, vertraulichen Stempeln oder die Aktualisierung von Informationen auf bereits vorhandenen Dokumenten.

PDF-Formulare verwenden

IronPDF unterstützt die Erstellung und Bearbeitung von PDF-Formularen und ermöglicht interaktive Elemente innerhalb der PDF-Datei:

PDF-Formulare: Dazu gehört die Erstellung von Formularen, die digital ausgefüllt werden können, so dass die Unternehmen den Datenerfassungsprozess automatisieren können. Mit IronPDF können Sie Formulare programmgesteuert erstellen, Felder ausfüllen und sogar Informationen abrufen, was Arbeitsabläufe rationalisiert und die manuelle Dateneingabe reduziert.

Plattformübergreifende Kompatibilität

IronPDF unterstützt verschiedene Plattformen und ist damit vielseitig für unterschiedliche Entwicklungsumgebungen einsetzbar. Es ist kompatibel mit Node.js Version 12.0 und höher und kann unter Windows, Linux, Mac und Docker verwendet werden.

Benutzerfreundlichkeit und Zugänglichkeit

• Einfache Installation: Die Einrichtung von IronPDF ist mit einfachen npm- oder yarn-Befehlen problemlos möglich. Die IronPDF Engine, die für das Funktionieren der Bibliothek erforderlich ist, wird beim ersten Start automatisch heruntergeladen.
• Beispielcode für den Schnellstart: Die Bibliothek bietet Beispielcode für verschiedene Funktionen, wie z. B. die Konvertierung von HTML in PDF, was den Implementierungsprozess für Entwickler vereinfacht.

Erstellen des JavaScript-Projekts in Visual Studio Code

Einrichten Ihrer Entwicklungsumgebung

Bevor Sie in die Welt der PDF-Erstellung eintauchen, müssen Sie Ihre Projektumgebung einrichten. Visual Studio-Code (VS-Code) bietet dafür eine ideale, benutzerfreundliche Plattform. Starten Sie VS Code und erstellen Sie ein neues JavaScript-Projekt. Sie können dies tun, indem Sie einen neuen Ordner für Ihr Projekt einrichten und ihn in VS Code öffnen. In dieser Umgebung werden Sie Ihren Code schreiben und die Dateien Ihres Projekts verwalten.

Initialisierung Ihres Projekts

Sobald Ihr Ordner in VS Code geöffnet ist, besteht der nächste Schritt darin, ein neues JavaScript-Projekt zu initialisieren. Öffnen Sie das integrierte Terminal in VS Code (normalerweise unter Terminal > Neues Terminal im Menü zu finden) und geben Sie npm init ein. Dieser Befehl führt Sie durch die Erstellung einer package.json-Datei, die für die Verwaltung der Abhängigkeiten und Metadaten Ihres Projekts entscheidend ist.

IronPDF-Bibliothek installieren

Hinzufügen von IronPDF zu Ihrem Projekt

Nachdem Sie Ihr JavaScript-Projekt eingerichtet haben, ist es an der Zeit, die IronPDF-Bibliothek zu installieren. Führen Sie in Ihrem VS-Code-Terminal den folgenden Befehl aus:

npm install ironpdf

npm install ironpdf

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'npm install ironpdf

Dieser Befehl holt und installiert die IronPDF-Bibliothek und fügt sie zu den Abhängigkeiten Ihres Projekts hinzu.

Überprüfung der Installation

Vergewissern Sie sich nach der Installation, dass IronPDF in Ihrer package.json-Datei unter dem Abschnitt Abhängigkeiten aufgeführt ist. Dadurch wird sichergestellt, dass IronPDF korrekt in Ihr Projekt integriert ist und den Weg für eine nahtlose PDF-Erstellung und -Bearbeitung ebnet.

PDFKit-Bibliothek installieren

PDFKit einbinden

Als nächstes ist PDFKit an der Reihe, eine robuste und vielseitige Bibliothek zur Erzeugung von PDF-Dokumenten. Um PDFKit zu Ihrem Projekt hinzuzufügen, führen Sie den folgenden Befehl in Ihrem Terminal innerhalb von Vs Code aus:

npm install pdfkit

npm install pdfkit

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'npm install pdfkit

Dies installiert PDFKit und fügt es zu den Abhängigkeiten Ihres Projekts hinzu.

Sicherstellung der korrekten Einrichtung

Überprüfen Sie nach erfolgreicher Installation, ob PDFKit in den Abhängigkeiten Ihrer package.json-Datei aufgeführt ist. Diese Bestätigung ist entscheidend dafür, dass Ihr Projekt nun mit den notwendigen Werkzeugen für die Erstellung komplexer, detaillierter und visuell ansprechender PDF-Dateien ausgestattet ist.

Vergleich der HTML-zu-PDF-Funktion in IronPDF und PDFKit

IronPDF HTML-zu-PDF-Konvertierung

IronPDF for Node.js zeichnet sich durch die Konvertierung von HTML in PDF aus und bietet eine effiziente Lösung für Entwickler. Diese Bibliothek ist in der Lage, komplexe Aufgaben wie das Rendern von CSS-Stilen, die Ausführung von JavaScript und das Einfügen von benutzerdefinierten Kopf- und Fußzeilen zu bewältigen. Diese Funktionen verbessern die Fähigkeit, professionelle PDFs aus HTML-Quellen zu erstellen, erheblich. IronPDF for Node.js bietet drei praktische Methoden für diesen Konvertierungsprozess:

1. HTML-String zu PDF

2. HTML-Datei zu PDF

3. URL zu PDF: Diese einzigartige Funktion ermöglicht die Konvertierung von Webseiten in PDFs, indem einfach ihre URLs verwendet werden. Es ist ein effizienter Weg, um Live-Online-Inhalte im PDF-Format zu erfassen.

Konvertierung von HTML-Strings in PDF

Diese Methode ermöglicht es Entwicklern, HTML-Code-Strings direkt in PDF-Dateien zu konvertieren. Diese Funktion ist für Szenarien mit dynamischer Inhaltserstellung äußerst nützlich. Ganz gleich, ob Sie benutzerdefinierte Berichte erstellen, Rechnungen im Handumdrehen generieren oder datengesteuerte Inhalte in einem ausgefeilten, professionellen Format präsentieren müssen - diese Funktion vereinfacht den Prozess.

import { PdfDocument, PdfGenerator } from "@ironsoftware/ironpdf";
import { IronPdfGlobalConfig } from "@ironsoftware/ironpdf";
import fs from "fs";
(async function createPDFs() {
  try {
    // Input the license key
    const IronPdfConfig = {
      licenseKey:
        "Your-License-Key",
    };
    // Set the config with the license key
    IronPdfGlobalConfig.setConfig(IronPdfConfig);
    // Create a PDF from the HTML String
    const pdf = await PdfDocument.fromHtml(
      "<h1>Hello JavaScript Developers! This is an Example PDF created with IronPDF NodeJS!</h1>"
    );
    // Save the PDF document to the file system.
    await pdf.saveAs("HtmlStringToPDF.pdf");
  } catch (error) {
    // Handle errors here
    console.error("An error occurred:", error);
  }
})();

import { PdfDocument, PdfGenerator } from "@ironsoftware/ironpdf";
import { IronPdfGlobalConfig } from "@ironsoftware/ironpdf";
import fs from "fs";
(async function createPDFs() {
  try {
    // Input the license key
    const IronPdfConfig = {
      licenseKey:
        "Your-License-Key",
    };
    // Set the config with the license key
    IronPdfGlobalConfig.setConfig(IronPdfConfig);
    // Create a PDF from the HTML String
    const pdf = await PdfDocument.fromHtml(
      "<h1>Hello JavaScript Developers! This is an Example PDF created with IronPDF NodeJS!</h1>"
    );
    // Save the PDF document to the file system.
    await pdf.saveAs("HtmlStringToPDF.pdf");
  } catch (error) {
    // Handle errors here
    console.error("An error occurred:", error);
  }
})();

import
If True Then
	PdfDocument, PdfGenerator
End If
from "@ironsoftware/ironpdf"
import
If True Then
	IronPdfGlobalConfig
End If
from "@ironsoftware/ironpdf"
import fs from "fs"
(async [function] createPDFs() {
	try {
		const IronPdfConfig = { licenseKey:= "Your-License-Key"}; IronPdfGlobalConfig.setConfig(IronPdfConfig); const pdf = Await PdfDocument.fromHtml("<h1>Hello JavaScript Developers! This is an Example PDF created with IronPDF NodeJS!</h1>"); Await pdf.saveAs("HtmlStringToPDF.pdf");
	}
	catch ([error]) { console.error("An error occurred:", [error]); }
})()

Hier können Sie die Ausgabe des Codes sehen:

Konvertierung von HTML-Dateien in PDF

Mit dieser Funktion können Entwickler bestehende HTML-Dateien in PDFs umwandeln. Diese Funktionalität ist vor allem bei der Bearbeitung statischer HTML-Dokumente von Vorteil. Egal, ob Sie mit vorgefertigten Webseiten, standardisierten Formularen oder Informationsbroschüren arbeiten, mit dieser Funktion können Sie sie ganz einfach in PDF-Dateien umwandeln.

import { PdfDocument } from "@ironsoftware/ironpdf";
import { IronPdfGlobalConfig } from "@ironsoftware/ironpdf";
import fs from "fs";
(async function createPDFs() {
  try {
    // Input the license key
    const IronPdfConfig = {
      licenseKey:
        "Your-License-Key",
    };
    // Set the config with the license key
    IronPdfGlobalConfig.setConfig(IronPdfConfig);
    // Create a PDF from the HTML File"
    const pdf = await PdfDocument.fromFile("invoice.html");
    // Save the PDF document to the file system.
    await pdf.saveAs("invoice.pdf");
  } catch (error) {
    // Handle errors here
    console.error("An error occurred:", error);
  }
})();

import { PdfDocument } from "@ironsoftware/ironpdf";
import { IronPdfGlobalConfig } from "@ironsoftware/ironpdf";
import fs from "fs";
(async function createPDFs() {
  try {
    // Input the license key
    const IronPdfConfig = {
      licenseKey:
        "Your-License-Key",
    };
    // Set the config with the license key
    IronPdfGlobalConfig.setConfig(IronPdfConfig);
    // Create a PDF from the HTML File"
    const pdf = await PdfDocument.fromFile("invoice.html");
    // Save the PDF document to the file system.
    await pdf.saveAs("invoice.pdf");
  } catch (error) {
    // Handle errors here
    console.error("An error occurred:", error);
  }
})();

import
If True Then
	PdfDocument
End If
from "@ironsoftware/ironpdf"
import
If True Then
	IronPdfGlobalConfig
End If
from "@ironsoftware/ironpdf"
import fs from "fs"
(async [function] createPDFs() {
	try {
		const IronPdfConfig = { licenseKey:= "Your-License-Key"}; IronPdfGlobalConfig.setConfig(IronPdfConfig); const pdf = Await PdfDocument.fromFile("invoice.html"); Await pdf.saveAs("invoice.pdf");
	}
	catch ([error]) { console.error("An error occurred:", [error]); }
})()

Hier ist die erzeugte PDF-Ausgabe der Rechnung:

Konvertierung von URL in PDF

Diese Funktion ermöglicht die Konvertierung von Webseiten in PDFs, indem einfach deren URLs verwendet werden. Diese Funktion ist besonders nützlich für die Erfassung von Live-Inhalten im Internet. Ob es sich um die Archivierung von Webseiten, die Erstellung von Offline-Kopien von Online-Artikeln oder die Erstellung von Berichten aus webbasierten Daten handelt, diese Funktion erledigt alles mühelos.

import { PdfDocument } from "@ironsoftware/ironpdf";
import { IronPdfGlobalConfig } from "@ironsoftware/ironpdf";
import fs from "fs";
(async function createPDFs() {
  try {
    // Input the license key
    const IronPdfConfig = {
      licenseKey:
        "Your-License-Key",
    };
    // Set the config with the license key
    IronPdfGlobalConfig.setConfig(IronPdfConfig);
    // URL of the web page to convert to PDF
    const url = "https://en.wikipedia.org/wiki/PDF";
    // Convert the Web Page to a pixel-perfect PDF file.
    const urlPDF = await PdfDocument.fromUrl(url);
    // Save the document.
    await urlPDF.saveAs("UrlToPdf.pdf");
  } catch (error) {
    // Handle errors here
    console.error("An error occurred:", error);
  }
})();

import { PdfDocument } from "@ironsoftware/ironpdf";
import { IronPdfGlobalConfig } from "@ironsoftware/ironpdf";
import fs from "fs";
(async function createPDFs() {
  try {
    // Input the license key
    const IronPdfConfig = {
      licenseKey:
        "Your-License-Key",
    };
    // Set the config with the license key
    IronPdfGlobalConfig.setConfig(IronPdfConfig);
    // URL of the web page to convert to PDF
    const url = "https://en.wikipedia.org/wiki/PDF";
    // Convert the Web Page to a pixel-perfect PDF file.
    const urlPDF = await PdfDocument.fromUrl(url);
    // Save the document.
    await urlPDF.saveAs("UrlToPdf.pdf");
  } catch (error) {
    // Handle errors here
    console.error("An error occurred:", error);
  }
})();

import
If True Then
	PdfDocument
End If
from "@ironsoftware/ironpdf"
import
If True Then
	IronPdfGlobalConfig
End If
from "@ironsoftware/ironpdf"
import fs from "fs"
(async [function] createPDFs() {
	try {
		const IronPdfConfig = { licenseKey:= "Your-License-Key"}; IronPdfGlobalConfig.setConfig(IronPdfConfig); const url = "https://en.wikipedia.org/wiki/PDF"; const urlPDF = Await PdfDocument.fromUrl(url); Await urlPDF.saveAs("UrlToPdf.pdf");
	}
	catch ([error]) { console.error("An error occurred:", [error]); }
})()

Hier ist die aus der URL generierte PDF-Ausgabedatei:

PDFKit HTML zu PDF Konvertierung

PDFKit ist zwar nicht wie IronPDF in erster Linie für die Konvertierung von HTML in PDF konzipiert, bietet aber dennoch eine Möglichkeit, PDF-Dokumente direkt aus JavaScript-Code zu erstellen. Nachfolgend finden Sie ein Beispiel für die Erstellung einer einfachen PDF-Datei:

const PDFDocument = require('pdfkit');
const fs = require('fs');
let doc = new PDFDocument();
doc.pipe(fs.createWriteStream('output.pdf'));
doc.fontSize(25)
   .text('PDFKit - Text to PDF Example', 100, 100);
doc.end();

const PDFDocument = require('pdfkit');
const fs = require('fs');
let doc = new PDFDocument();
doc.pipe(fs.createWriteStream('output.pdf'));
doc.fontSize(25)
   .text('PDFKit - Text to PDF Example', 100, 100);
doc.end();

const PDFDocument = require( 'pdfkit');
const fs = require( 'fs');
Dim doc As let = New PDFDocument()
doc.pipe(fs.createWriteStream( 'output.pdf'));
doc.fontSize(25).text( 'PDFKit - Text @to PDF Example', 100, 100);
doc.end()

Dieses Code-Snippet erstellt eine PDF-Datei mit einer Textüberschrift. PDFKit konvertiert HTML zwar nicht direkt in PDF, ermöglicht aber eine detaillierte Steuerung der Textplatzierung und -formatierung.

Hier ist die von PDFKit erzeugte Ausgabedatei:

Flexibilität und erweiterte Funktionen

IronPDF for Node.js

Kennwörter, Sicherheit und Metadaten: IronPDF ermöglicht es Entwicklern, die Sicherheit ihrer PDF-Dateien durch verschiedene Funktionen zu erhöhen. Es ermöglicht die Festlegung von Passwörtern, wodurch eine zusätzliche Schutzebene hinzugefügt wird, bei der die Benutzer ein Passwort eingeben müssen, um das Dokument anzuzeigen. Darüber hinaus bietet IronPDF die Möglichkeit, Metadaten in die PDF-Datei einzubetten, die Autoreninformationen, Titel und Schlüsselwörter enthalten können, wodurch die Verwaltung und Organisation von Dokumenten verbessert wird.

import {PdfDocument} from "@ironsoftware/ironpdf";
(async () => {
    // Import a PDF document or create a new PDF from Html
    const pdf = await PdfDocument.open("encrypted.pdf", "password");
    // Create an empty Map
    const newMetadata = new Map();
    // Add key-value pairs of metadata
    newMetadata.set("Author", "Satoshi Nakamoto");
    newMetadata.set("Keywords", "SEO, Friendly");
    await pdf.overrideMetadata(newMetadata);
    await pdf.removePasswordsAndEncryption();
    // Make PDF read-only
    await pdf.makePdfDocumentReadOnly("secret-key");
    // Configure permissions
    const permissions = {
        AllowAnnotations: false,
        AllowExtractContent: false,
        AllowFillForms: false,
        AllowPrint: true,
    };
    await pdf.setPermission(permissions);
    // Change or set the document encrpytion password
    await pdf.saveAs("secured.pdf", {
        ownerPassword: "top-secret",
        userPassword: "my-password",
    });
})();

import {PdfDocument} from "@ironsoftware/ironpdf";
(async () => {
    // Import a PDF document or create a new PDF from Html
    const pdf = await PdfDocument.open("encrypted.pdf", "password");
    // Create an empty Map
    const newMetadata = new Map();
    // Add key-value pairs of metadata
    newMetadata.set("Author", "Satoshi Nakamoto");
    newMetadata.set("Keywords", "SEO, Friendly");
    await pdf.overrideMetadata(newMetadata);
    await pdf.removePasswordsAndEncryption();
    // Make PDF read-only
    await pdf.makePdfDocumentReadOnly("secret-key");
    // Configure permissions
    const permissions = {
        AllowAnnotations: false,
        AllowExtractContent: false,
        AllowFillForms: false,
        AllowPrint: true,
    };
    await pdf.setPermission(permissions);
    // Change or set the document encrpytion password
    await pdf.saveAs("secured.pdf", {
        ownerPassword: "top-secret",
        userPassword: "my-password",
    });
})();

import
If True Then
	PdfDocument
End If
from "@ironsoftware/ironpdf"
(Async Sub()
	const pdf = Await PdfDocument.open("encrypted.pdf", "password")
	const newMetadata = New Map()
	newMetadata.set("Author", "Satoshi Nakamoto")
	newMetadata.set("Keywords", "SEO, Friendly")
	Await pdf.overrideMetadata(newMetadata)
	Await pdf.removePasswordsAndEncryption()
	Await pdf.makePdfDocumentReadOnly("secret-key")
	const permissions = { AllowAnnotations: False, AllowExtractContent: False, AllowFillForms: False, AllowPrint: True}
	Await pdf.setPermission(permissions)
	Await pdf.saveAs("secured.pdf", {
		ownerPassword:= "top-secret",
		userPassword:= "my-password"
	})
End Sub)()

PDF-Verschlüsselung und -Entschlüsselung: Ver- und Entschlüsselung sind wichtige Komponenten der Dokumentensicherheit, die IronPDF mühelos bewältigt. Es bietet verschiedene Verschlüsselungsstufen, vom einfachen Passwortschutz bis hin zu fortschrittlichen Verschlüsselungsstandards, die gewährleisten, dass sensible Informationen sicher bleiben. Die Entschlüsselungsfunktion ist ebenso robust und bietet autorisierten Benutzern die Möglichkeit, auf verschlüsselte Dokumente zuzugreifen und sie zu ändern.

Digitale Signaturen: Im Zeitalter der digitalen Dokumentation sind Authentizität und Integrität von größter Bedeutung. Die digitalen Unterschriften von IronPDF diese Funktion ermöglicht es den Nutzern, ihre PDF-Dateien digital zu signieren, was nicht nur die Identität des Urhebers des Dokuments bestätigt, sondern auch anzeigt, dass das Dokument seit dem Aufbringen der Signatur nicht verändert wurde, wodurch seine Authentizität gewährleistet wird.

import {PdfDocument} from "@ironsoftware/ironpdf";
(async () => {
    // Step 1. Import a PDF
    const pdf = await PdfDocument.open("sample.pdf");
    // Step 2. Sign the PDF with digital certificate
    await pdf.signDigitalSignature({
        certificatePath: "IronSoftware.pfx",
        certificatePassword: "123456",
        signingReason: "To show how to sign a PDF",
        signingLocation: "Chicago, USA",
        signatureImage: {
            SignatureImagePath: "logo.png"
        }
    });
    //Step 3. The PDF is not signed until saved to file.
    await pdf.saveAs("signed.pdf");
})();

import {PdfDocument} from "@ironsoftware/ironpdf";
(async () => {
    // Step 1. Import a PDF
    const pdf = await PdfDocument.open("sample.pdf");
    // Step 2. Sign the PDF with digital certificate
    await pdf.signDigitalSignature({
        certificatePath: "IronSoftware.pfx",
        certificatePassword: "123456",
        signingReason: "To show how to sign a PDF",
        signingLocation: "Chicago, USA",
        signatureImage: {
            SignatureImagePath: "logo.png"
        }
    });
    //Step 3. The PDF is not signed until saved to file.
    await pdf.saveAs("signed.pdf");
})();

import
If True Then
	PdfDocument
End If
from "@ironsoftware/ironpdf"
(Async Function()
	const pdf = Await PdfDocument.open("sample.pdf")
	Await pdf.signDigitalSignature({
		certificatePath:= "IronSoftware.pfx",
		certificatePassword:= "123456",
		signingReason:= "To show how to sign a PDF",
		signingLocation:= "Chicago, USA",
		signatureImage:= { SignatureImagePath:= "logo.png" }
	})
	Await pdf.saveAs("signed.pdf")
End Function)()

PDF-Komprimierung: IronPDF erkennt den Bedarf an effizienter Speicherung und schnellem Austausch von Dokumenten. Sie umfasst eine PDF-Komprimierung funktion, die die Dateigröße erheblich reduziert, was für die Optimierung des Speicherplatzes und die schnellere Übertragung von Dokumenten entscheidend ist, ohne die Qualität und Integrität des Inhalts der PDF-Dateien zu beeinträchtigen.

import {PdfDocument} from "@ironsoftware/ironpdf";
(async () => {
    // Load the existing PDF document
    const pdf = await PdfDocument.fromFile("my-content.pdf");
    // Compress images with quality parameter (1-100)
    await pdf.compressSize(60);
    // Save the compressed PDF
    await pdf.saveAs("document_compressed.pdf");
    // Compress images and scale down based on visible size in the PDF document
    await pdf.compressSize(90, true);
    // Save the scaled and compressed PDF
    await pdf.saveAs("document_scaled_compressed.pdf");
});

import {PdfDocument} from "@ironsoftware/ironpdf";
(async () => {
    // Load the existing PDF document
    const pdf = await PdfDocument.fromFile("my-content.pdf");
    // Compress images with quality parameter (1-100)
    await pdf.compressSize(60);
    // Save the compressed PDF
    await pdf.saveAs("document_compressed.pdf");
    // Compress images and scale down based on visible size in the PDF document
    await pdf.compressSize(90, true);
    // Save the scaled and compressed PDF
    await pdf.saveAs("document_scaled_compressed.pdf");
});

import
If True Then
	PdfDocument
End If
from "@ironsoftware/ironpdf"
(Async Function()
	const pdf = Await PdfDocument.fromFile("my-content.pdf")
	Await pdf.compressSize(60)
	Await pdf.saveAs("document_compressed.pdf")
	Await pdf.compressSize(90, True)
	Await pdf.saveAs("document_scaled_compressed.pdf")
End Function)

Zwei oder mehr PDFs zusammenführen: IronPDF bietet eine unkomplizierte Lösung zum Zusammenführen von mehrere PDF-Dokumente in einer einzigen Datei. Diese Funktion ist äußerst nützlich, um verschiedene Dokumente wie Berichte, Verträge oder Formularserien zu kombinieren und so die Verwaltung und Verteilung von Dokumenten zu erleichtern.

Entfernen bestimmter PDF-Seiten: Flexibilität bei der Bearbeitung ist der Schlüssel für jedes PDF-Tool, und IronPDF bietet die Möglichkeit bestimmte Seiten aus einem PDF-Dokument entfernen. Dies ist besonders nützlich, wenn Inhalte für verschiedene Zielgruppen angepasst oder unnötige Seiten weggelassen werden sollen, um ein übersichtlicheres Dokument zu erstellen.

PDFKit Erweiterte Funktionen und Erweiterbarkeit

Anpassbare Layout-Engine: PDFKit bietet eine anpassbare Layout-Engine, die Entwicklern die Kontrolle über jeden Aspekt des PDF-Layouts gibt, von der Textpositionierung bis hin zu komplexen grafischen Elementen.

const PDFDocument = require('pdfkit');
const fs = require('fs');
let doc = new PDFDocument({ margin: 50 });
// Custom layouts
doc.text('Customized Layout Text', {
  align: 'center',
  valign: 'center'
});
doc.end();
doc.pipe(fs.createWriteStream('custom-layout.pdf'));

const PDFDocument = require('pdfkit');
const fs = require('fs');
let doc = new PDFDocument({ margin: 50 });
// Custom layouts
doc.text('Customized Layout Text', {
  align: 'center',
  valign: 'center'
});
doc.end();
doc.pipe(fs.createWriteStream('custom-layout.pdf'));

const PDFDocument = require( 'pdfkit');
const fs = require( 'fs');
Dim doc As let = New PDFDocument({ margin:= 50 })
' Custom layouts
doc.text( 'Customized Layout Text', { align: 'center', valign: 'center' });
doc.end()
doc.pipe(fs.createWriteStream( 'custom-layout.pdf'));

In diesem Beispiel wird PDFDocument verwendet, um ein individuelles Layout mit zentriertem Text zu erstellen.

Erweiterte Grafik- und Textfunktionen: PDFKit bietet fortschrittliche Grafik- und Textfunktionen, mit denen sich PDF-Dateien aufwändig gestalten und stylen lassen. Es ermöglicht das Zeichnen von Formen und das Hinzufügen von Bildern und SVGs. Für Text bietet PDFKit eine ganze Reihe von Layout-Optionen, von einfachen Textrahmen bis hin zu fortschrittlichen Typografie-Steuerungen, die sicherstellen, dass das Layout jeder Seite genau so ist, wie man es sich vorstellt.

const PDFDocument = require('pdfkit');
const fs = require('fs');
let doc = new PDFDocument();
// Advanced graphics
doc.moveTo(100, 150)
   .lineTo(100, 250)
   .lineTo(200, 250)
   .fill("#FF3300");
// Advanced text
doc.fontSize(15)
   .font('Times-Roman')
   .text('Advanced Text Features', 100, 300);
doc.end();
doc.pipe(fs.createWriteStream('advanced-graphics-text.pdf'));

const PDFDocument = require('pdfkit');
const fs = require('fs');
let doc = new PDFDocument();
// Advanced graphics
doc.moveTo(100, 150)
   .lineTo(100, 250)
   .lineTo(200, 250)
   .fill("#FF3300");
// Advanced text
doc.fontSize(15)
   .font('Times-Roman')
   .text('Advanced Text Features', 100, 300);
doc.end();
doc.pipe(fs.createWriteStream('advanced-graphics-text.pdf'));

const PDFDocument = require( 'pdfkit');
const fs = require( 'fs');
Dim doc As let = New PDFDocument()
' Advanced graphics
doc.moveTo(100, 150).lineTo(100, 250).lineTo(200, 250).fill("#FF3300")
' Advanced text
doc.fontSize(15).font( 'Times-Roman').text('Advanced Text Features', 100, 300);
doc.end()
doc.pipe(fs.createWriteStream( 'advanced-graphics-text.pdf'));

Stream- und Puffer-Verarbeitung: PDFKit zeichnet sich durch Stream- und Buffer-Handling aus und ermöglicht die effiziente Verwaltung großer PDF-Dateien und ihrer Daten.

const PDFDocument = require('pdfkit');
const fs = require('fs');
const stream = require('stream');
let doc = new PDFDocument();
let buffers = [];
let writableStream = new stream.Writable();
writableStream._write = (chunk, encoding, done) => {
  buffers.push(chunk);
  done();
};
doc.pipe(writableStream);
doc.text('Streaming PDF Content');
doc.end();
writableStream.on('finish', () => {
  let pdfData = Buffer.concat(buffers);
  fs.writeFileSync('streamed.pdf', pdfData);
});

const PDFDocument = require('pdfkit');
const fs = require('fs');
const stream = require('stream');
let doc = new PDFDocument();
let buffers = [];
let writableStream = new stream.Writable();
writableStream._write = (chunk, encoding, done) => {
  buffers.push(chunk);
  done();
};
doc.pipe(writableStream);
doc.text('Streaming PDF Content');
doc.end();
writableStream.on('finish', () => {
  let pdfData = Buffer.concat(buffers);
  fs.writeFileSync('streamed.pdf', pdfData);
});

const PDFDocument = require( 'pdfkit');
const fs = require( 'fs');
const stream = require( 'stream');
Dim doc As let = New PDFDocument()
Dim buffers As let = ()
Dim writableStream As let = New stream.Writable()
writableStream._write = Sub(chunk, encoding, done)
  buffers.push(chunk)
  done()
End Sub
doc.pipe(writableStream)
doc.text( 'Streaming PDF Content');
doc.end()
writableStream.on( 'finish', () =>
If True Then
	Dim pdfData As let = Buffer.concat(buffers)
	fs.writeFileSync( 'streamed.pdf', pdfData);
End If
)

Anpassbare Kopf- und Fußzeilen: Bei der Erstellung einer professionell aussehenden PDF-Datei kommt es auf die Liebe zum Detail an. Die anpassbare Kopf- und Fußzeilenfunktion von PDFKit ermöglicht die präzise Platzierung von Text und Grafiken am oberen und unteren Rand der Seiten. Dies ist besonders nützlich, um in einem mehrseitigen Dokument ein einheitliches Branding, Dokumententitel und eine einheitliche Paginierung hinzuzufügen.

Interaktive Formulare: PDFKit erweitert seine Fähigkeiten auf interaktive Formulare in Ihren PDF-Dateien und ermöglicht die Erstellung von Textfeldern, Kontrollkästchen und Optionsfeldern. Diese Funktion ist von unschätzbarem Wert für Benutzer, die Informationen sammeln oder interaktive Inhalte bereitstellen möchten, und verbessert die Benutzerfreundlichkeit und Funktionalität der PDF-Datei.

Dokumentation und Unterstützung

IronPDF for Node.js Dokumentation und Unterstützung

IronPDFs Dokumentation bietet eine umfassende Anleitung zur Verwendung der Bibliothek mit detaillierten Beispielen für wichtige Funktionen wie das Rendern einer URL als PDF und die Erstellung einer PDF-Datei aus einem HTML-String. Es bietet Anpassungsoptionen für den PDF-Druck, wie z. B. die Einstellung von Papiergröße und DPI, und für das Erscheinungsbild der Dokumente, wie z. B. Kopf- und Fußzeilen mit Seriendruckfeldern. Die Dokumentation behandelt auch fortgeschrittenere Aspekte wie die Verwendung benutzerdefinierter WebClients, die Erstellung bearbeitbarer PDF-Formulare und die Arbeit mit JavaScript in PDFs. In der Dokumentation finden Sie die vollständige Api-Dokumentation und weitere Beispiele.

Für die Einstellung von Kopf- und Fußzeilen sind sowohl die HTML- als auch die Textoptionen gut dokumentiert, so dass Metadaten mit Hilfe von Platzhalterzeichenfolgen eingefügt werden können. Es werden Einzelheiten zur Lizenzierung angegeben, die den Nutzern zeigen, wie sie Wasserzeichen entfernen und eine Lizenz erhalten können. Die Dokumentation enthält sogar Informationen zum Einrichten der ersten Seitenzahl für PDF-Kopf- und -Fußzeilen und Angaben dazu, wie lange nach dem HTML-Rendering vor dem Drucken gewartet werden soll, wobei die Darstellung von JavaScript, AJAX oder Animationen berücksichtigt wird.

Support-Optionen

IronPDF bietet eine Sammlung von Anleitungen zur Fehlerbehebung, die häufige Probleme behandeln und Schritt-für-Schritt-Lösungen anbieten. Dies kann die erste Anlaufstelle für Benutzer sein, die versuchen, ein Problem zu lösen. Für komplexere Probleme oder solche, die nicht mit Hilfe von Anleitungen gelöst werden können, bietet IronPDF technischen Support. Benutzer können eine Anfrage für technischen Support einreichen, die detaillierte Informationen über das Problem enthalten kann, wie z. B. Plattform- oder Laufzeitspezifikationen, um dem Support-Team zu helfen, das Problem zu replizieren und zu lösen. Sie können auch die Live-Chat-Option nutzen.

Qualität und Verfügbarkeit der PDFKit-Dokumentation

Die npm-Dokumentation von PDFKit beschreibt die Bibliothek als ein Werkzeug zur einfachen Erstellung komplexer, mehrseitiger, druckfähiger Dokumente. Es legt Wert auf die Verkettbarkeit seiner API und enthält sowohl Low-Level-Funktionen als auch Abstraktionen für Funktionen auf höherer Ebene, die so einfach gestaltet sind, dass die Erstellung komplexer Dokumente so einfach wie ein paar Funktionsaufrufe sein kann.

Der Funktionsbereich der Dokumentation ist sehr umfangreich und deckt Vektorgrafiken, Text, Schrifteinbettung, Bildeinbettung, Anmerkungen, Formularerstellung, Umrisse und PDF-Sicherheit ab, die alle die Fähigkeit der Bibliothek zur Erstellung barrierefreier und sicherer Dokumente demonstrieren.

Support-Optionen

Da es sich bei PDFKit um eine Open-Source-Bibliothek handelt, profitiert sie von der Unterstützung der Community. Probleme und Funktionsanfragen können über das GitHub-Repository bearbeitet werden, wo Benutzer zum Code beitragen, Probleme einreichen und Pull Requests stellen können. Die PDFKit-Community bietet möglicherweise auch inoffizielle Support-Kanäle wie Stack Overflow, wo Entwickler häufig ihr Wissen und ihre Lösungen teilen.

Modelle zur Lizenzierung

IronPDFs Lizenz

IronPDF arbeitet mit einem kommerziellen Lizenzmodell, d. h. Entwickler oder Unternehmen müssen eine Lizenz erwerben, um die Bibliothek in ihren Projekten uneingeschränkt nutzen zu können.

Lite: Diese einmalige Gebühr zum Preis von "LiteLicense" ist ein Basispaket für kleinere Projekte.

Professional: Mit einem Preis von 1.499 $ ist diese Stufe für den professionellen Einsatz gedacht und bietet mehr Funktionen und Möglichkeiten.

Unbegrenzt: Die unbegrenzte Stufe kostet $2.999 und ist ideal für umfangreiche Implementierungen, da sie vollen Zugriff auf alle Funktionen ohne Einschränkungen bietet.

IronPDF bietet auch eine kostenloser Testund ermöglicht es Entwicklern, die Bibliothek vor dem Kauf zu bewerten. Es gibt weder eine kostenlose noch eine Freemium-Version, und es werden keine Premium-Beratungs- oder Integrationsdienste angeboten.

PDFKit-Lizenz

PDFKit ist eine Open-Source-Bibliothek, die unter der MIT-Lizenz verfügbar ist. Diese freizügige Lizenz erlaubt die freie Nutzung, Veränderung und Verbreitung der Software. Da PDFKit ein Open-Source-Projekt ist, hat es keine Preisstruktur. Es kann frei in jedes Projekt integriert werden, und die Nutzer können über GitHub zu seiner Entwicklung beitragen. Das Projekt nimmt Spenden entgegen, die nicht obligatorisch sind, aber die Weiterentwicklung und den Unterhalt der Bibliothek unterstützen.

Schlussfolgerung

Zusammenfassend lässt sich sagen, dass IronPDF for Node.js und PDFKit beide als leistungsstarke Werkzeuge für die PDF-Erzeugung und -Bearbeitung in ihren jeweiligen Umgebungen dienen, IronPDF for Node.js jedoch mit seinem umfangreichen, auf die Node.js-Plattform zugeschnittenen Funktionsumfang einen Vorteil hat.

Die Fähigkeiten von IronPDF bei der Konvertierung von HTML in PDFs, die erweiterte Bearbeitung und die umfassende Unterstützung von JavaScript und anderen Rich Media machen es zu einer vielseitigen Lösung für eine Vielzahl von PDF-Verarbeitungsaufgaben. Darüber hinaus bieten IronPDFs starker Fokus auf Sicherheit und seine detaillierte Dokumentation ein Maß an Sicherheit und Zugänglichkeit, das für Entwickler entscheidend ist.

Da PDFKit Open-Source ist, bietet es Flexibilität und Benutzerfreundlichkeit, was für Entwickler, die eine umfassende Unterstützung durch die Community und die Möglichkeit zur Änderung des Quellcodes bevorzugen, sehr attraktiv sein kann. Seine Fähigkeiten sind beeindruckend, insbesondere wenn man die Kostenvorteile einer Open-Source-Lösung bedenkt.

IronPDF bietet eine kostenlose Testversion, die es Entwicklern ermöglicht, den vollen Funktionsumfang zu testen, bevor sie sich finanziell binden. Außerdem, Iron Software's Iron Suitedie IronPDF neben anderen wertvollen Entwickler-Tools enthält, wie IronXL, IronBarcode, IronQRund IronOCRbietet ein kosteneffizientes Paket, das eine umfassende Reihe von Funktionen zum Preis von zwei Produkten bietet.

Letztendlich hängt die Wahl zwischen IronPDF for Node.js und PDFKit von den besonderen Anforderungen des Projekts und den Präferenzen des Entwicklers oder des Entwicklungsteams ab. IronPDF for Node.js ist die richtige Wahl für alle, die nach einem umfangreichen Funktionsumfang und einer ausführlichen Dokumentation für das Node.js-Ökosystem suchen.