Introduction

Dans ce post, vous apprendrez comment effectuer les opérations de gestion du document PDF dans Go en utilisant Aspose.PDF FOSS: ouvrir et sauvegarder des documents, créer de nouveaux PDFs, diviser un document en fichiers par page, mélanger plusieurs PDF, extraire des rangs de pages, et lire ou écrire des métadonnées du dossier. Toutes les Opéralités sont disponibles sans dépendance C ou C++ native.

La bibliothèque est un module de github.com/aspose-pdf-foss/aspose-pdf-foss-for-go, MIT licencé, et nécessite Go 1.24 ou plus tard. go get github.com/aspose-pdf-foss/aspose-pdf-foss-for-go.

Ce post couvre les Document, Page, PageRange,et DocumentInfo Les types de cette forme La surface de gestion du document.

Opérations de base

ouverture et économie de documents

pdf.Open télécharger un PDF sur le disque et retourner une *Document. OpenWithPassword Il fait Il en est de même pour les fichiers protégés par mot de passe. Document.Save Il récite le résultat à un Le chemin de fichier. Document.WriteTo Il écrit à un io.Writer Pour la mémoire ou le réseau scénarios .

// Open a standard PDF
doc, err := pdf.Open("input.pdf")
if err != nil {
	panic(err)
}

// Open an encrypted PDF
protected, err := pdf.OpenWithPassword("locked.pdf", "userpassword")
if err != nil {
	panic(err)
}

// Save to a new path
err = doc.Save("output.pdf")
fmt.Println(protected.PageCount())

Créer un nouveau document

pdf.NewDocument Créer un vide *Document.Utiliser AddBlankPageFromFormat Pour appliquer une page blanche avec un papier standard. PageFormat Il est donc possible de définir les formats (PageFormatA4, PageFormatLetter,et etc.).

doc := pdf.NewDocumentFromFormat(pdf.PageFormatA4)

doc.Save("new_document.pdf")

Diviser un document

Document.Split Diviser un PDF en page individuelle *Document Les valeurs, chacun Le document retourné contient exactement une page et peut être sauvé indépendamment. Il est utile pour la répartition de rapports générés par un groupe ou le séparation des pages de facture.

doc, _ := pdf.Open("multi_page.pdf")
pages, err := doc.Split()
if err != nil {
	panic(err)
}

for i, p := range pages {
	filename := fmt.Sprintf("page_%03d.pdf", i+1)
	if err := p.Save(filename); err != nil {
		fmt.Printf("Failed to save page %d: %v\n", i+1, err)
	}
}
fmt.Printf("Split into %d pages\n", len(pages))

Mélanger plusieurs PDFs

Document.Append Fusion une seconde *Document dans le récepteur en place, appendant Toutes les pages de la source. appeler Append de plusieurs documents avant la Un seul Save.Le document source n’est pas modifié.

base, _ := pdf.Open("report_intro.pdf")
section1, _ := pdf.Open("section1.pdf")
section2, _ := pdf.Open("section2.pdf")
appendix, _ := pdf.Open("appendix.pdf")

base.Append(section1)
base.Append(section2)
base.Append(appendix)

base.Save("complete_report.pdf")

Extrait d’une page Range

PageRange Il s’agit d’une gamme inclusive (1 basée sur un, utilisant une From/To Les rangs passent à Document.Extract Pour produire un nouveau *Document contenant uniquement les éléments sélectionnés Ceci est utile pour la construction d’exports par chapitre ou de copies rédigées qui Évitez certaines pages.

doc, _ := pdf.Open("long_report.pdf")

// Extract pages 3 through 7
subset, err := doc.Extract(pdf.PageRange{From: 3, To: 7})
if err != nil {
	panic(err)
}
subset.Save("pages_3_to_7.pdf")

Lire et écrire des métadonnées de document

Document.Info Retour à A DocumentInfo Structure exposée Informations sur les champs de dictionnaire : Title, Author, Subject, Keywords, Creator, Producer, CreationDate,et ModDate.Modifiez les champs directement, puis appelez Document.SetInfo Écrire la structure mise à jour avant de faire appel Save.

doc, _ := pdf.Open("report.pdf")
info, _ := doc.Info()

// Read current values
fmt.Printf("Title: %s\nAuthor: %s\n", info.Title, info.Author)

// Update fields
info.Title = "Annual Report 2026"
info.Author = "Finance Team"
info.Keywords = "annual, report, finance, 2026"

doc.SetInfo(info)
doc.Save("report_updated.pdf")

Accès aux pages individuelles

Document.Page(n) Récupérer A *Page 1 sur le index. Document.PageCount Retourner le nombre total de pages. les pages exposent des propriétés géométrie pour les boîtes de page et taille .

doc, _ := pdf.Open("document.pdf")
fmt.Printf("Page count: %d\n", doc.PageCount())

page, _ := doc.Page(1)
size, err := page.Size()
if err != nil {
	panic(err)
}
fmt.Printf("Page 1 size: %.0f x %.0f pt\n", size.Width, size.Height)

Démarrage rapide

Installation du module avec go get, puis rattachez l’exemple complet ci-dessous. l’example s’ouvre un document source, extrait ses trois premières pages dans un nouveau document, met à jour le DocumentInfo Les méta-data sont enregistrés et les résultats sont sauvegardés sur le disque.

go get github.com/aspose-pdf-foss/aspose-pdf-foss-for-go

Un exemple complet qui ouvre un document, extrait les pages 1 à 3 et sauvage le résultat avec des métadonnées mises à jour:

package main

import (
	"fmt"
	pdf "github.com/aspose-pdf-foss/aspose-pdf-foss-for-go"
)

func main() {
	// Open source document
	src, err := pdf.Open("source.pdf")
	if err != nil {
		panic(err)
	}

	// Extract pages 1-3
	subset, err := src.Extract(pdf.PageRange{From: 1, To: 3})
	if err != nil {
		panic(err)
	}

	// Update metadata
	info, _ := subset.Info()
	info.Title = "Pages 1-3 Extract"
	info.Author = "Document Pipeline"
	subset.SetInfo(info)

	if err := subset.Save("extract_pages_1_3.pdf"); err != nil {
		panic(err)
	}
	fmt.Printf("Saved %d pages\n", subset.PageCount())
}

Source ouverte et licence

Aspose.PDF FOSS for Go is released under the MIT license. There are no usage restrictions, pas de frais d’exécution, et aucun requis d’enregistrement. le code source est disponible à la github.com/aspose-pdf-foss/axe-PDF-Foss-for-go.

Pour commencer

Ressources associées