Introductie

In dit bericht leer je hoe je kernbewerkingen voor PDF-documenten uitvoert in Go met behulp van Aspose.PDF FOSS: documenten openen en opslaan, nieuwe PDF’s maken, een document splitsen in bestanden per pagina, meerdere PDF’s samenvoegen, paginabereiken extraheren, en documentmetadata lezen of schrijven. Alle bewerkingen zijn beschikbaar zonder enige native C- of C++-afhankelijkheden.

De bibliotheek is een Go-module op github.com/aspose-pdf-foss/aspose-pdf-foss-for-go, MIT-licentie, en vereist Go 1.24 of hoger.

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

Dit bericht behandelt de Document, Page, PageRange en DocumentInfo types die het kerndocumentbeheeroppervlak vormen.

Kernbewerkingen

Documenten openen en opslaan

pdf.Open laadt een PDF van schijf en retourneert een *Document. OpenWithPassword doet hetzelfde voor met wachtwoord beveiligde bestanden. Document.Save schrijft het resultaat terug naar een bestandspad. Document.WriteTo schrijft naar een io.Writer voor in-memory of netwerkscenario’s.

// 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())

Een nieuw document maken

pdf.NewDocument maakt een lege *Document. Gebruik AddBlankPageFromFormat om een lege pagina toe te voegen met een standaard papierformaat. PageFormat biedt benoemde formaatconstanten (PageFormatA4, PageFormatLetter, enz.).

doc := pdf.NewDocumentFromFormat(pdf.PageFormatA4)

doc.Save("new_document.pdf")

Een document splitsen

Document.Split verdeelt een PDF in individuele per-pagina *Document-waarden. Elk geretourneerd document bevat precies één pagina en kan onafhankelijk worden opgeslagen. Dit is handig voor het splitsen van batch-gegenereerde rapporten of het scheiden van factuurpagina’s.

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))

Meerdere PDF’s samenvoegen

Document.Append voegt een tweede *Document in-place samen met de ontvanger, waarbij alle pagina’s van de bron worden toegevoegd. Roep Append herhaaldelijk aan om meerdere documenten te koppelen vóór één enkele Save. Het brondocument wordt niet gewijzigd.

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")

Een paginabereik extraheren

PageRange vertegenwoordigt een inclusieve reeks (1-gebaseerd, met gebruik van de velden From/To). Geef reeksen door aan Document.Extract om een nieuw *Document te maken dat alleen de geselecteerde pagina’s bevat. Dit is handig voor het maken van per-hoofdstuk-exports of geredigeerde exemplaren die bepaalde pagina’s weglaten.

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")

Lezen en schrijven van documentmetadata

Document.Info retourneert een DocumentInfo struct die de Info-woordenboekvelden blootlegt: Title, Author, Subject, Keywords, Creator, Producer, CreationDate en ModDate. Wijzig de velden direct, roep vervolgens Document.SetInfo aan om de bijgewerkte struct terug te schrijven voordat je Save aanroept.

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")

Toegang tot individuele pagina’s

Document.Page(n) haalt een *Page op via een 1-gebaseerde index. Document.PageCount geeft het totale aantal pagina’s terug. Pagina’s bieden geometrische eigenschappen om paginavakken en afmetingen te lezen.

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)

Snelstart

Installeer de module met go get, en voer vervolgens het volledige voorbeeld hieronder uit. Het voorbeeld opent een brondocument, extraheert de eerste drie pagina’s naar een nieuw document, werkt de DocumentInfo metadata-velden bij, en slaat het resultaat op schijf.

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

Een volledig voorbeeld dat een document opent, pagina’s 1–3 extraheert en het resultaat opslaat met bijgewerkte metadata:

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())
}

Open source en licensering

Aspose.PDF FOSS voor Go wordt uitgebracht onder de MIT-licentie. Er zijn geen gebruiksbeperkingen, geen runtime kosten, en geen registratievereisten. De broncode is beschikbaar op github.com/aspose-pdf-foss/aspose-pdf-foss-for-go.

Aan de slag

Gerelateerde bronnen