Vollständiges funktionierendes Beispiel zum Kombinieren mehrerer Word‑Dokumente in Java

Dieses Beispiel zeigt, wie man mehrere Word‑Dokumente in Java mithilfe der Merger‑API kombiniert.

import com.groupdocs.merger.cloud.client.ApiClient;
import com.groupdocs.merger.cloud.client.ApiException;
import com.groupdocs.merger.cloud.api.MergerApi;
import com.groupdocs.merger.cloud.model.FileInfo;
import com.groupdocs.merger.cloud.model.MergeOptions;
import java.util.ArrayList;
import java.util.List;

public class CombineWordDocuments {
    public static void main(String[] args) {
        // Initialize the API client with your credentials
        ApiClient apiClient = new ApiClient("YOUR_CLIENT_ID", "YOUR_CLIENT_SECRET");
        MergerApi mergerApi = new MergerApi(apiClient);

try {
            // List of Word documents to combine
            List<FileInfo> sourceFiles = new ArrayList<>();
            sourceFiles.add(new FileInfo().setFilePath("input1.docx"));
            sourceFiles.add(new FileInfo().setFilePath("input2.docx"));
            sourceFiles.add(new FileInfo().setFilePath("input3.docx"));

// Configure merge options
            MergeOptions mergeOptions = new MergeOptions();
            mergeOptions.setOutputPath("merged_output.docx");
            mergeOptions.setFileInfos(sourceFiles);

// Execute the merge operation
            FileInfo result = mergerApi.merge(mergeOptions);

System.out.println("Merge completed successfully. Output file: " + result.getFilePath());
        } catch (ApiException e) {
            System.err.println("An error occurred while merging documents: " + e.getMessage());
        }
    }
}

Hinweis: Dieses Codebeispiel demonstriert die Kernfunktionalität. Bevor Sie es in Ihrem Projekt verwenden, stellen Sie sicher, dass Sie alle Dateipfade und Konfigurationswerte an Ihre tatsächliche Umgebung anpassen, überprüfen Sie, dass alle erforderlichen Abhängigkeiten korrekt installiert sind, und testen Sie gründlich in Ihrer Entwicklungsumgebung. Wenn Sie auf Probleme stoßen, lesen Sie bitte die offizielle Dokumentation oder wenden Sie sich an das Support-Team für Unterstützung.

Word-Dateien per REST-API mit cURL zusammenführen

Wenn Sie einen reinen REST-Ansatz bevorzugen, kann derselbe Zusammenführungsvorgang mit cURL-Aufrufen durchgeführt werden. Die nachstehenden Schritte zeigen, wie Sie ein Zugriffstoken erhalten, Quelldateien hochladen, die Zusammenführung anfordern und das Ergebnis herunterladen.

Authentifizieren und ein Zugriffstoken erhalten:

curl -X POST "https://api.groupdocs.cloud/v2.0/auth/token" \
     -H "Content-Type: application/json" \
     -d '{"client_id":"YOUR_CLIENT_ID","client_secret":"YOUR_CLIENT_SECRET"}'

Laden Sie jede DOCX-Datei in Ihren Cloud‑Speicher hoch (ersetzen Sie YOUR_ACCESS_TOKEN durch das Token aus dem vorherigen Schritt):

curl -X PUT "https://api.groupdocs.cloud/v2.0/storage/file/input1.docx" \
     -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
     -H "Content-Type: application/vnd.openxmlformats-officedocument.wordprocessingml.document" \
     --data-binary @input1.docx

Wiederholen Sie den Upload‑Befehl für input2.docx und input3.docx.

Erstelle die Merge‑Anfrage:

curl -X POST "https://api.groupdocs.cloud/v2.0/merger/merge" \
     -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
     -H "Content-Type: application/json" \
     -d '{
           "outputPath":"merged_output.docx",
           "fileInfos":[
               {"filePath":"input1.docx"},
               {"filePath":"input2.docx"},
               {"filePath":"input3.docx"}
           ]
         }'

Laden Sie das zusammengeführte Dokument herunter:

curl -X GET "https://api.groupdocs.cloud/v2.0/storage/file/merged_output.docx" \
     -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
     -o merged_output.docx

Weitere Details zu den Anforderungsparametern finden Sie in der offiziellen API-Dokumentation.

Verständnis des Prozesses zum Kombinieren von Word‑Dokumenten in Java

Im Folgenden finden Sie eine schrittweise Aufschlüsselung des zuvor gezeigten Codes.

1. Create an ApiClient - new ApiClient("YOUR_CLIENT_ID", "YOUR_CLIENT_SECRET") establishes a connection to the GroupDocs cloud service.

ApiClient apiClient = new ApiClient("YOUR_CLIENT_ID", "YOUR_CLIENT_SECRET");

2. Instantiate MergerApi - new MergerApi(apiClient) gives access to merge‑related endpoints.

MergerApi mergerApi = new MergerApi(apiClient);

3. Prepare source file list - Each FileInfo object points to a DOCX file stored in the cloud. The list is passed to MergeOptions.

List<FileInfo> sourceFiles = new ArrayList<>();
sourceFiles.add(new FileInfo().setFilePath("input1.docx"));

4. Configure MergeOptions - Set the desired output path and attach the list of source files.

MergeOptions mergeOptions = new MergeOptions();
mergeOptions.setOutputPath("merged_output.docx");
mergeOptions.setFileInfos(sourceFiles);

5. Execute merge - mergerApi.merge(mergeOptions) sends the request and returns a FileInfo for the merged document.

FileInfo result = mergerApi.merge(mergeOptions);

Für eine vollständige Liste der verfügbaren Eigenschaften, siehe die API-Referenz.

Voraussetzungen und Einrichtung für GroupDocs.Merger Cloud SDK

Bevor Sie den Code ausführen können, fügen Sie die Maven‑Abhängigkeit zu Ihrem Projekt hinzu und stellen Sie sicher, dass Sie ein gültiges GroupDocs‑Konto besitzen.

Fügen Sie das SDK zu Ihrer pom.xml hinzu:

<dependency>
    <groupId>com.groupdocs</groupId>
    <artifactId>groupdocs-merger-cloud</artifactId>
    <version>25.11</version>
</dependency>

Laden Sie die neuesten JARs und den Quellcode von der Download‑Seite herunter.
Sie benötigen außerdem Java 8 oder höher sowie Internetzugang für die Cloud‑Aufrufe.
Erstellen Sie ein GroupDocs‑Konto, erhalten Sie Ihre Client ID und Client Secret und bewahren Sie diese sicher auf.

Fazit

Das Zusammenführen von DOCX-Dateien programmgesteuert ist jetzt einfach mit dem GroupDocs.Merger Cloud SDK for Java. Der Beispielcode und die cURL‑Snippets zeigen zwei flexible Möglichkeiten, mehrere Word‑Dokumente in Java zu kombinieren, egal ob Sie eine native Bibliothek oder direkte REST‑Aufrufe bevorzugen. Denken Sie daran, Ihre Anmeldeinformationen zu konfigurieren, große Dateien bei Bedarf per Streaming zu verarbeiten und den Merge‑Vorgang mit repräsentativen Dokumenten zu testen. Für produktive Einsätze benötigen Sie eine kostenpflichtige Lizenz; Preisdetails finden Sie auf der Produktseite und Sie können eine temporäre Lizenz zur Evaluierung über die temporäre Lizenzseite anfordern.

FAQs

• Wie kann ich mehrere Word‑Dokumente in Java kombinieren, ohne eigenen Code für die Dateiverarbeitung zu schreiben?
  Verwenden Sie das GroupDocs.Merger Cloud SDK for Java. Das SDK abstrahiert alle Low‑Level‑Operationen und ermöglicht das Zusammenführen von DOCX‑Dateien mit wenigen API‑Aufrufen.

• Ist es möglich, Dokumente zusammenzuführen, die in verschiedenen Cloud-Ordnern gespeichert sind?
  Ja. Geben Sie die vollständigen Cloud-Dateipfade in den FileInfo-Objekten an, und die Zusammenführungsoperation ruft jede Datei von ihrem Speicherort ab, bevor sie kombiniert wird.

• Was soll ich tun, wenn das Zusammenführen mit einer ApiException fehlschlägt?
  Überprüfen Sie die Fehlermeldung auf Details wie fehlende Dateien oder Berechtigungsprobleme. Stellen Sie sicher, dass die Dateipfade korrekt sind und dass Ihr Konto Lese‑/Schreibzugriff auf den Speicher hat. Konsultieren Sie die offizielle Dokumentation für Fehlercodes.

• Brauche ich für jede Umgebung (Entwicklung, Staging, Produktion) eine separate Lizenz?
  Eine einzelne Lizenz deckt alle Umgebungen ab, aber Sie müssen die in Ihrer Lizenzvereinbarung festgelegten Nutzungslimits einhalten. Für Tests können Sie die oben verlinkte temporäre Lizenz verwenden.

Mehr lesen

• ZIP-Datei mit Passwortschutz-Software schützen
• Excel mit Passwortschutz-Service schützen
• Word-Dokumente in C# kombinieren

Was PowerPoint-Automatisierung in C# erfordert

Unternehmen erstellen häufig Folienpräsentationen aus Vorlagen, bei denen Titel, Untertitel oder Datenfelder automatisch aktualisiert werden müssen. Die Anforderungen an eine robuste Lösung umfassen:

• Fähigkeit, bestimmte Textzeichenfolgen in PPTX-Dateien zu finden und zu ersetzen.
• Unterstützung für cloudbasierte Verarbeitung, sodass der Code auf jedem Server ohne Installation von Office ausgeführt werden kann.
• Klare Fehlerbehandlung und einfache Konfiguration von Eingabe‑ und Ausgabepfaden.

Manuelles Bearbeiten oder die Verwendung generischer Dateisystem‑Skripte kann die Konsistenz über Dutzende von Präsentationen nicht garantieren, insbesondere wenn sich der Inhalt häufig ändert.

Der Ansatz: Cloud‑basiertes PowerPoint‑Editing

GroupDocs.Editor Cloud SDK for .NET adressiert diese Bedürfnisse mit einer REST‑basierten API, die vollständig in der Cloud arbeitet. Zu den wichtigsten Funktionen gehören:

• EditDocument – Ersetzen Sie Text, Bilder oder Formen in PPTX‑Dateien, ohne das gesamte Dokument herunterzuladen.
• FileInfo – Geben Sie Quelldateien an, die im GroupDocs Cloud‑Speicher gespeichert sind.
• EditDocumentOptions – Definieren Sie den Ausgabespeicherort und eine Liste von Text‑Ersetzungen.

Das SDK übernimmt die Authentifizierung, das Streamen von Dateien und format‑erhaltende Bearbeitungen, sodass Sie sich auf die Geschäftslogik konzentrieren können. Detaillierte Dokumentation ist unter der offiziellen Dokumentation verfügbar.

Implementieren von PowerPoint‑Präsentationen in C# mit GroupDocs.Editor Cloud

Im Folgenden finden Sie eine schrittweise Anleitung. Jeder Schritt enthält einen kurzen Codeauszug, der direkt aus dem vollständigen Beispiel entnommen wurde.

Installieren Sie das SDK und fügen Sie das NuGet-Paket hinzu

Fügen Sie zunächst die Bibliothek zu Ihrem Projekt hinzu.

dotnet add package GroupDocs.editor-Cloud

Sie können die neueste Version auch von der Download‑Seite herunterladen.

API-Anmeldeinformationen konfigurieren

Erstellen Sie ein Configuration-Objekt mit Ihrer Client-ID und Ihrem Geheimschlüssel.

var config = new Configuration
{
    ClientId = "YOUR_CLIENT_ID",
    ClientSecret = "YOUR_CLIENT_SECRET"
};

Die Configuration‑Klasse wird in der API‑Referenz beschrieben.

Initialisieren Sie die Editor‑API

Instanziieren Sie EditorApi mit der Konfiguration.

var editorApi = new EditorApi(config);

Dieses Objekt bietet alle Bearbeitungsoperationen.

Bearbeitungsoptionen definieren (Platzhaltertexte ersetzen)

Legen Sie die Quelldatei, den Ausgabepfad und die benötigten Textersetzungen fest.

var editOptions = new EditDocumentOptions
{
    FileInfo = new FileInfo { FilePath = "sample.pptx" },
    OutputPath = "sample_edited.pptx",
    EditTexts = new List<EditText>
    {
        new EditText { Text = "OldTitle", NewText = "New Title" },
        new EditText { Text = "OldSubtitle", NewText = "Updated Subtitle" }
    }
};

Die EditTexts-Sammlung ermöglicht es Ihnen, beliebig viele Platzhalter in einem Aufruf zu ersetzen.

Führen Sie die Edit-Operation aus und verarbeiten Sie die Antwort

Erstellen Sie die Anforderung und rufen Sie EditDocument auf.

var request = new EditDocumentRequest(editOptions);
var response = editorApi.EditDocument(request);
Console.WriteLine($"Edited PowerPoint saved to: {response.Path}");

Die Antwort enthält den Pfad zur bearbeiteten Datei im Cloud‑Speicher.

Vollständiges Codebeispiel: PowerPoint-Präsentationen in C# bearbeiten – Vollständiger Workflow

Der folgende Code demonstriert den gesamten Prozess von Anfang bis Ende.

using System;
using System.Collections.Generic;
using GroupDocs.Editor.Cloud.Sdk.Api;
using GroupDocs.Editor.Cloud.Sdk.Client;
using GroupDocs.Editor.Cloud.Sdk.Model;
using GroupDocs.Editor.Cloud.Sdk.Model.Requests;

namespace GroupDocsEditorDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            // Configure API credentials
            var config = new Configuration
            {
                ClientId = "YOUR_CLIENT_ID",
                ClientSecret = "YOUR_CLIENT_SECRET"
            };

// Initialize the Editor API
            var editorApi = new EditorApi(config);

// Define input and output PowerPoint files
            string inputFilePath = "sample.pptx";
            string outputFilePath = "sample_edited.pptx";

// Set up editing options (replace placeholder texts)
            var editOptions = new EditDocumentOptions
            {
                FileInfo = new FileInfo { FilePath = inputFilePath },
                OutputPath = outputFilePath,
                EditTexts = new List<EditText>
                {
                    new EditText { Text = "OldTitle", NewText = "New Title" },
                    new EditText { Text = "OldSubtitle", NewText = "Updated Subtitle" }
                }
            };

// Create the request
            var request = new EditDocumentRequest(editOptions);

try
            {
                // Perform the edit operation
                var response = editorApi.EditDocument(request);
                Console.WriteLine($"Edited PowerPoint saved to: {response.Path}");
            }
            catch (ApiException apiEx)
            {
                Console.WriteLine($"API error ({apiEx.ErrorCode}): {apiEx.Message}");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Unexpected error: {ex.Message}");
            }
        }
    }
}

Hinweis: Dieses Codebeispiel demonstriert die Kernfunktionalität. Bevor Sie es in Ihrem Projekt verwenden, stellen Sie sicher, dass Sie alle Dateipfade und Konfigurationswerte an Ihre tatsächliche Umgebung anpassen, überprüfen Sie, dass alle erforderlichen Abhängigkeiten ordnungsgemäß installiert sind, und testen Sie gründlich in Ihrer Entwicklungsumgebung. Wenn Sie auf Probleme stoßen, lesen Sie bitte die offizielle Dokumentation oder wenden Sie sich an das Support-Team für Unterstützung.

PowerPoint-Bearbeitung mit cURL und der REST-API

Wenn Sie einen sprachunabhängigen Ansatz bevorzugen, können Sie dieselbe Bearbeitungsoperation mit cURL-Aufrufen durchführen.

1. Authentifizieren und ein Zugriffstoken erhalten

curl -X POST "https://api.groupdocs.cloud/v2.0/auth/token" \
     -H "Content-Type: application/json" \
     -d '{"client_id":"YOUR_CLIENT_ID","client_secret":"YOUR_CLIENT_SECRET"}'

2. Laden Sie die Quell-PPTX-Datei hoch

curl -X POST "https://api.groupdocs.cloud/v2.0/storage/upload/sample.pptx" \
     -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
     -F "file=@sample.pptx"

3. Führen Sie den Bearbeitungsvorgang aus

curl -X POST "https://api.groupdocs.cloud/v2.0/editor/edit" \
     -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
     -H "Content-Type: application/json" \
     -d '{
           "fileInfo": { "filePath": "sample.pptx" },
           "outputPath": "sample_edited.pptx",
           "editTexts": [
               { "text": "OldTitle", "newText": "New Title" },
               { "text": "OldSubtitle", "newText": "Updated Subtitle" }
           ]
         }'

4. Laden Sie die bearbeitete PPTX-Datei herunter

curl -X GET "https://api.groupdocs.cloud/v2.0/storage/download/sample_edited.pptx" \
     -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
     -o sample_edited.pptx

Weitere Details zu den Anforderungspayloads finden Sie in der API-Referenz.

Feinabstimmung der PowerPoint-Bearbeitungsoptionen

Das SDK bietet zusätzliche Parameter, die Sie anpassen können:

• OutputPath - Wählen Sie einen anderen Ordner oder Dateinamen für die bearbeitete Präsentation.
• EditTexts - Fügen Sie so viele EditText‑Objekte hinzu, wie Sie benötigen, um mehrere Platzhalter zu ersetzen.
• FileInfo.StorageName - Geben Sie einen benutzerdefinierten Speicherort an, wenn Sie mehrere Cloud‑Speicher verwenden.

Diese Optionen sind Teil der EditDocumentOptions‑Klasse, die in der API‑Referenz referenziert wird.

Fazit

Das Bearbeiten von PowerPoint‑Präsentationen in C# wird mit dem GroupDocs.Editor Cloud SDK für .NET unkompliziert. Die Bibliothek übernimmt Authentifizierung, Dateiverwaltung und Textersetzung, sodass Sie sich auf die Geschäftslogik konzentrieren können. Denken Sie daran, für den Produktionseinsatz eine gültige Lizenz zu erwerben; Sie können mit einer temporären Lizenz von der temporären Lizenzseite beginnen. Mit dem bereitgestellten Codebeispiel und dem cURL‑Workflow sind Sie bereit, die dynamische Folienbearbeitung in jede .NET‑Anwendung zu integrieren.

FAQs

Wie bearbeite ich Powerpoint-Präsentationen in C# mit GroupDocs.Editor Cloud?
Verwenden Sie die EditDocument-Methode, nachdem Sie EditDocumentOptions mit Ihrer Quelldatei, dem Ausgabepfad und einer Liste von EditText-Ersetzungen konfiguriert haben. Das vollständige Beispiel wurde weiter oben in diesem Leitfaden gezeigt.

Kann ich mehrere Platzhalter in einer einzigen PowerPoint-Datei ersetzen?
Ja. Füllen Sie die EditTexts-Sammlung mit so vielen EditText-Objekten, wie erforderlich; das SDK verarbeitet alle Ersetzungen in einer einzigen Anforderung.

Was soll ich tun, wenn die bearbeitete Datei nicht erzeugt wird?
Stellen Sie sicher, dass OutputPath korrekt gesetzt ist und dass die API-Antwort einen gültigen Path enthält. Überprüfen Sie außerdem Ihre Anmeldeinformationen und Speicherberechtigungen über das GroupDocs-Portal.

Benötige ich eine Lizenz für Produktionsbereitstellungen?
Für die Produktion ist eine gültige Lizenz erforderlich. Sie können eine temporäre Lizenz von der Seite für temporäre Lizenzen erhalten, während Sie das SDK evaluieren.

Mehr lesen

• PowerPoint‑Präsentationen mit Python bearbeiten
• PowerPoint‑Dateien mit Java‑Bibliothek bearbeiten
• Best Practices für die CSV‑Editor‑Entwicklung in Java

Mehrere Word-Dokumente in Node.JS kombinieren – Vollständiges Codebeispiel

Dieses Beispiel demonstriert, wie man drei DOCX Dateien zu einem einzigen Dokument zusammenführt, indem man das GroupDocs.Merger Cloud SDK für Node.js verwendet.

const GroupDocsMergerCloud = require("@groupdocs/merger-cloud");

// ==== Configuration ====
// Replace with your actual credentials
const clientId = "YOUR_CLIENT_ID";
const clientSecret = "YOUR_CLIENT_SECRET";

const config = new GroupDocsMergerCloud.Configuration(clientId, clientSecret);
const mergeApi = new GroupDocsMergerCloud.MergeApi(config);

// ==== Input / Output paths ====
const inputFiles = [
    "documents/input1.docx",
    "documents/input2.docx",
    "documents/input3.docx"
];
const outputFile = "documents/combined_output.docx";

// ==== Build request ====
const documentEntries = inputFiles.map(path => {
    return new GroupDocsMergerCloud.Models.DocumentEntry({
        fileInfo: new GroupDocsMergerCloud.Models.FileInfo({
            filePath: path
        })
    });
});

const mergeRequest = new GroupDocsMergerCloud.Models.MergeDocumentsRequest({
    documents: documentEntries,
    outputPath: outputFile
});

// ==== Execute merge ====
(async () => {
    try {
        const result = await mergeApi.mergeDocuments(mergeRequest);
        console.log(`Merge completed successfully. Output file: ${result.path}`);
    } catch (error) {
        console.error("Error during merging:", error);
    }
})();

Hinweis: Dieses Codebeispiel demonstriert die Kernfunktionalität. Bevor Sie es in Ihrem Projekt verwenden, stellen Sie sicher, dass Sie die Dateipfade (input1.docx, combined_output.docx usw.) an Ihre tatsächlichen Speicherorte anpassen, überprüfen Sie, dass alle erforderlichen Abhängigkeiten ordnungsgemäß installiert sind, und testen Sie gründlich in Ihrer Entwicklungsumgebung. Wenn Sie auf Probleme stoßen, lesen Sie bitte die offizielle Dokumentation oder wenden Sie sich an das Support-Team für Unterstützung.

Zusammenführen von Word-Dokumenten über die REST-API mit cURL

Wenn Sie einen reinen REST‑Ansatz bevorzugen, kann dieselbe Merge‑Operation mit cURL‑Befehlen durchgeführt werden. Im Folgenden finden Sie einen kurzen Workflow, der authentifiziert, Quell‑Dateien hochlädt, den Merge ausführt und das Ergebnis herunterlädt.

1. Authentifizieren und Zugriffstoken erhalten

curl -X POST "https://api.groupdocs.cloud/v2.0/merger/authenticate" \
-H "Content-Type: application/json" \
-d '{"client_id":"YOUR_CLIENT_ID","client_secret":"YOUR_CLIENT_SECRET"}'

Die Antwort enthält ein access_token, das in nachfolgenden Aufrufen verwendet wird.

2. Laden Sie die Quelldateien hoch

Wiederholen Sie diesen Schritt für jede DOCX-Datei, die Sie zusammenführen möchten.

curl -X POST "https://api.groupdocs.cloud/v2.0/storage/file/upload?path=documents/input1.docx" \
-H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
-H "Content-Type: application/octet-stream" \
--data-binary "@path/to/input1.docx"

3. Merge-Vorgang ausführen

curl -X POST "https://api.groupdocs.cloud/v2.0/merger/merge" \
-H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
-H "Content-Type: application/json" \
-d '{
    "documents": [
        {"fileInfo": {"filePath": "documents/input1.docx"}},
        {"fileInfo": {"filePath": "documents/input2.docx"}},
        {"fileInfo": {"filePath": "documents/input3.docx"}}
    ],
    "outputPath": "documents/combined_output.docx"
}'

Die API gibt den Pfad der zusammengeführten Datei zurück.

4. Herunterladen des zusammengeführten Dokuments

curl -X GET "https://api.groupdocs.cloud/v2.0/storage/file/download?path=documents/combined_output.docx" \
-H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
-o combined_output.docx

Weitere Details zu den Anforderungs‑Payloads und Optionen finden Sie in der offiziellen API‑Dokumentation.

Wie das Zusammenführen mehrerer Word-Dokumente in Node.JS funktioniert

Das SDK abstrahiert den Merge‑Vorgang in einige logische Schritte:

1. Konfigurationserstellung - new GroupDocsMergerCloud.Configuration(clientId, clientSecret) erstellt den Authentifizierungskontext. Siehe die Klassenreferenz in der API-Referenz.

const config = new GroupDocsMergerCloud.Configuration(clientId, clientSecret);

2. API-Instanz - new GroupDocsMergerCloud.MergeApi(config) bietet Zugriff auf Merge-Operationen.

const mergeApi = new GroupDocsMergerCloud.MergeApi(config);

3. Document Entries - Jede Quelldatei wird in ein DocumentEntry eingeschlossen, das ein FileInfo mit dem Dateipfad enthält.

   const documentEntries = inputFiles.map(path => {
       return new GroupDocsMergerCloud.Models.DocumentEntry({
           fileInfo: new GroupDocsMergerCloud.Models.FileInfo({ filePath: path })
       });
   });
   

4. Merge Request - MergeDocumentsRequest fasst die Einträge und den gewünschten Ausgabepfad zusammen.

   const mergeRequest = new GroupDocsMergerCloud.Models.MergeDocumentsRequest({
       documents: documentEntries,
       outputPath: outputFile
   });
   

5. Ausführung - mergeApi.mergeDocuments(mergeRequest) sendet die Anfrage an den Cloud‑Dienst. Das Promise wird mit einem Ergebnisobjekt aufgelöst, das den Pfad der Ausgabedatei enthält.

   const result = await mergeApi.mergeDocuments(mergeRequest);
   console.log(`Merge completed successfully. Output file: ${result.path}`);
   

Diese Schritte ermöglichen es Ihnen, mehrere Word‑Dokumente effizient zu kombinieren, ohne Low‑Level‑Dateistreams zu handhaben.

Umgebung für GroupDocs.Merger einrichten

1. Installieren Sie das SDK

npm install groupdocs-merger-cloud

Das Paket ist über die offizielle Download-Seite verfügbar.

2. Node.js Version - Stellen Sie sicher, dass Sie Node.js 12 oder höher ausführen.

3. Anmeldeinformationen konfigurieren - Ersetzen Sie YOUR_CLIENT_ID und YOUR_CLIENT_SECRET im Code durch die Werte aus Ihrem GroupDocs Cloud‑Konto.

4. Projektordner erstellen - Platzieren Sie die Quell‑DOCX‑Dateien in einem Unterordner documents/, wie im Beispiel gezeigt.

Nachdem diese Schritte abgeschlossen sind, können Sie das Merge‑Skript ausführen oder die REST‑Endpunkte aufrufen.

Fazit

Das Kombinieren mehrerer Word‑Dokumente in Node.JS wird mit dem GroupDocs.Merger Cloud SDK for Node.js unkompliziert. Das SDK übernimmt das Hochladen von Dateien, die Zusammenführungslogik und die Ausgabeerstellung, sodass Sie sich auf die Geschäftslogik statt auf die Low‑Level‑Dateimanipulation konzentrieren können. Denken Sie daran, für die Produktion eine gültige Lizenz zu sichern; Sie können mit einer temporären Lizenz beginnen und bei wachsendem Bedarf auf ein Vollabo upgraden. Beginnen Sie noch heute mit dem Zusammenführen und optimieren Sie Ihre Dokumenten‑Workflows.

FAQs

• Wie kombiniere ich mehrere Word-Dokumente in Node.JS mit dem SDK?
  Verwenden Sie die Klasse MergeApi, um ein MergeDocumentsRequest zu erstellen, das jede DOCX-Datei als DocumentEntry auflistet. Das SDK führt die Zusammenführung in der angegebenen Reihenfolge durch und speichert das Ergebnis im angegebenen Ausgabepfad.

• Ist es möglich, PDFs mit demselben SDK zusammenzuführen?
  Ja, das Merger SDK unterstützt PDF, DOCX, ODT und mehrere weitere Formate. Ändern Sie einfach die Dateierweiterungen im inputFiles‑Array und das SDK führt die Konvertierung automatisch durch. Siehe die offizielle Dokumentation für Details zu den Formaten.

• Was sind die Grenzen für die Anzahl der Dokumente, die ich in einer einzigen Anfrage zusammenführen kann?
  Der Cloud-Dienst legt ein Größenlimit fest, anstatt einer strikten Stückzahl. Solange die kombinierte Größe innerhalb des Kontingents Ihres Kontos bleibt, können Sie Dutzende von Dateien zusammenführen. Für sehr große Stapel sollten Sie in Erwägung ziehen, die Dateien zuerst in den GroupDocs-Speicher hochzuladen und sie per ID zu referenzieren.

• Muss ich mir wegen Lizenzierung für Entwicklung gegenüber Produktion Sorgen machen?
  Entwicklung und Tests können eine temporäre Lizenz verwenden, die von der temporäre Lizenzseite erhalten wird. Für Produktionsbereitstellungen kaufen Sie eine Voll‑Lizenz, um unbegrenzte Zusammenführungen und vorrangigen Support freizuschalten.

Read More

• ZIP-Datei mit Passwortschutz mithilfe von Passwortschutz-Software
• Excel mit Passwortschutz mithilfe des Passwortschutz-Dienstes
• Word-Dokumente in C# kombinieren