Introduzione
In questo post, imparerai come eseguire le operazioni core di gestione dei documenti PDF in Go utilizzando Aspose.PDF FOSS: aprire e salvare i documenti, creare nuovi PDF, suddividere un documento in file per pagina, unire più PDF, estrarre intervalli di pagine e leggere o scrivere i metadati del documento. Tutte le operazioni sono disponibili senza alcuna dipendenza nativa C o C++.
La libreria è un modulo Go disponibile su github.com/aspose-pdf-foss/aspose-pdf-foss-for-go, con licenza MIT, e richiede Go 1.24 o versioni successive.
go get github.com/aspose-pdf-foss/aspose-pdf-foss-for-goQuesto post copre i tipi Document, Page, PageRange e DocumentInfo che costituiscono la superficie core della gestione dei documenti.
Operazioni Core
Apertura e Salvataggio dei Documenti
pdf.Open carica un PDF dal disco e restituisce un *Document. OpenWithPassword fa lo stesso per i file protetti da password. Document.Save scrive il risultato di nuovo in un percorso file. Document.WriteTo scrive in un io.Writer per scenari in memoria o di rete.
// 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())
Creare un nuovo documento
pdf.NewDocument crea un *Document vuoto. Usa AddBlankPageFromFormat per aggiungere una pagina vuota con una dimensione carta standard. PageFormat fornisce costanti di formato nominate (PageFormatA4, PageFormatLetter, ecc.).
doc := pdf.NewDocumentFromFormat(pdf.PageFormatA4)
doc.Save("new_document.pdf")
Dividere un documento
Document.Split divide un PDF in valori *Document individuali per pagina. Ogni documento restituito contiene esattamente una pagina e può essere salvato in modo indipendente. Questo è utile per suddividere report generati in batch o per separare le pagine delle fatture.
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))
Unire più PDF
Document.Append unisce un secondo *Document nel destinatario in loco, aggiungendo tutte le pagine dalla sorgente. Chiama Append ripetutamente per concatenare più documenti prima di un unico Save. Il documento di origine non viene modificato.
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")
Estrarre un intervallo di pagine
PageRange rappresenta un intervallo inclusivo (basato su 1, usando i campi From/To). Passa gli intervalli a Document.Extract per produrre un nuovo *Document contenente solo le pagine selezionate. Questo è utile per creare esportazioni per capitolo o copie redatte che omettono alcune pagine.
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")
Lettura e scrittura dei metadati del documento
Document.Info restituisce una struct DocumentInfo che espone i campi del dizionario Info: Title, Author, Subject, Keywords, Creator, Producer, CreationDate e ModDate. Modifica i campi direttamente, quindi chiama Document.SetInfo per scrivere la struct aggiornata prima di chiamare 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")
Accesso alle singole pagine
Document.Page(n) recupera un *Page tramite indice basato su 1. Document.PageCount restituisce il numero totale di pagine. Le pagine espongono proprietà geometriche per leggere le box delle pagine e le dimensioni.
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)
Avvio rapido
Installa il modulo con go get, poi esegui l’esempio completo qui sotto. L’esempio apre un documento sorgente, estrae le sue prime tre pagine in un nuovo documento, aggiorna i campi di metadati DocumentInfo e salva il risultato su disco.
go get github.com/aspose-pdf-foss/aspose-pdf-foss-for-goUn esempio completo che apre un documento, estrae le pagine 1–3 e salva il risultato con i metadati aggiornati:
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 e Licenze
Aspose.PDF FOSS per Go è rilasciato sotto licenza MIT. Non ci sono restrizioni d’uso, né costi di runtime, né requisiti di registrazione. Il codice sorgente è disponibile su github.com/aspose-pdf-foss/aspose-pdf-foss-for-go.
