Wprowadzenie

W tym poście dowiesz się, jak wykonywać podstawowe operacje zarządzania dokumentami PDF w Go przy użyciu Aspose.PDF FOSS: otwieranie i zapisywanie dokumentów, tworzenie nowych plików PDF, dzielenie dokumentu na pliki pojedynczych stron, łączenie wielu plików PDF, wyodrębnianie zakresów stron oraz odczytywanie lub zapisywanie metadanych dokumentu. Wszystkie operacje są dostępne bez żadnych natywnych zależności C lub C++.

Biblioteka jest modułem Go pod adresem github.com/aspose-pdf-foss/aspose-pdf-foss-for-go, licencjonowana na licencji MIT i wymaga Go 1.24 lub nowszej.

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

Ten post obejmuje typy Document, Page, PageRange i DocumentInfo, które tworzą podstawowy interfejs zarządzania dokumentami.

Podstawowe operacje

Otwieranie i zapisywanie dokumentów

pdf.Open ładuje PDF z dysku i zwraca *Document. OpenWithPassword robi to samo dla plików zabezpieczonych hasłem. Document.Save zapisuje wynik z powrotem do ścieżki pliku. Document.WriteTo zapisuje do io.Writer w scenariuszach pamięciowych lub sieciowych.

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

Tworzenie nowego dokumentu

pdf.NewDocument tworzy pusty *Document. Użyj AddBlankPageFromFormat, aby dodać pustą stronę o standardowym rozmiarze papieru. PageFormat udostępnia nazwane stałe formatów (PageFormatA4, PageFormatLetter, itp.).

doc := pdf.NewDocumentFromFormat(pdf.PageFormatA4)

doc.Save("new_document.pdf")

Dzielenie dokumentu

Document.Split dzieli PDF na indywidualne wartości *Document dla każdej strony. Każdy zwrócony dokument zawiera dokładnie jedną stronę i może być zapisywany niezależnie. Jest to przydatne przy dzieleniu raportów generowanych w partiach lub rozdzielaniu stron faktur.

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

Łączenie wielu plików PDF

Document.Append łączy drugi *Document z odbiorcą w miejscu, dołączając wszystkie strony ze źródła. Wywołuj Append wielokrotnie, aby łączyć wiele dokumentów przed pojedynczym Save. Dokument źródłowy nie jest modyfikowany.

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

Wyodrębnianie zakresu stron

PageRange reprezentuje zakres inkluzywny (liczony od 1, przy użyciu pól From/To). Przekaż zakresy do Document.Extract, aby utworzyć nowy *Document zawierający tylko wybrane strony. Jest to przydatne przy tworzeniu eksportów rozdział po rozdziale lub redagowanych kopii, które pomijają określone strony.

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

Odczytywanie i zapisywanie metadanych dokumentu

Document.Info zwraca strukturę DocumentInfo udostępniającą pola słownika Info: Title, Author, Subject, Keywords, Creator, Producer, CreationDate i ModDate. Zmodyfikuj pola bezpośrednio, a następnie wywołaj Document.SetInfo, aby zapisać zaktualizowaną strukturę, przed wywołaniem 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")

Dostęp do poszczególnych stron

Document.Page(n) pobiera *Page według indeksu liczonego od 1. Document.PageCount zwraca łączną liczbę stron. Strony udostępniają właściwości geometrii do odczytu ramek strony i rozmiaru.

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)

Szybki start

Zainstaluj moduł za pomocą go get, a następnie uruchom poniższy kompletny przykład. Przykład otwiera dokument źródłowy, wyodrębnia jego pierwsze trzy strony do nowego dokumentu, aktualizuje pola metadanych DocumentInfo i zapisuje wynik na dysku.

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

Pełny przykład, który otwiera dokument, wyodrębnia strony 1–3 i zapisuje wynik z zaktualizowanymi metadanymi:

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 i licencjonowanie

Aspose.PDF FOSS dla Go jest udostępniony na licencji MIT. Nie ma ograniczeń użytkowania, opłat za uruchomienie ani wymagań rejestracji. Kod źródłowy jest dostępny pod adresem github.com/aspose-pdf-foss/aspose-pdf-foss-for-go.

Rozpoczęcie

Powiązane zasoby