Vilka bibliotek ska man använda för att generera PDF:er i GO?

För att generera PDF i Go, använd gofpdf eller Maroto för enkla uppgifter, och Unipdf eller pdfcpu för avancerade uppgifter.

Generera PDF-rapporter i GO

OK. Nu genererar vi PDF:er i GO!

Sidinnehåll

Att generera PDF-dokument programmatiskt kan vara en viktig funktion i din applikation. Här utforskar vi och ger en kort översikt med exempel på de bibliotek som finns tillgängliga i Go-programmeringsspråket (Golang) för att generera PDF-filer.

Lämpliga lösningar kan skilja sig åt för exempelvis enkel dokumentgenerering eller komplex och funktionell PDF-generering.

go, pdf! Ja, bilden är AI-genererad, modellen är Flux1.Dev.

Bibliotek och Verktyg

gofpdf

GoPdf är ett enkelt bibliotek för att skapa PDF-dokument. Det tillåter att lägga till text, bilder, former, tabeller och hantera flera sidor. Lämpligt för enkla till måttligt komplexa PDF-skapat uppgifter.

Underhållare: Jung Kurt (avslutad men fortfarande använd).

Begränsning: Brist på uppdateringar, även om befintlig användning fortfarande finns.

Exempel:

package main

import (
    "github.com/jung-kurt/gofpdf"
)

func main() {
    pdf := gofpdf.New("P", "mm", "A4", "")
    pdf.AddPage()
    pdf.SetFont("Arial", "B", 16)
    pdf.Cell(40, 10, "Hello World!")
    err := pdf.OutputFileAndClose("hello.pdf")
    if err != nil {
        panic(err)
    }
}

gopdf

Underhållare: signintech (aktivt underhåll).

I Go-programmeringsspråket är ett av biblioteken som sticker ut för detta ändamål gopdf, utvecklat av SignInTech. Detta bibliotek ger ett enkelt sätt att skapa PDF-dokument programmatiskt utan att förlita sig på externa beroenden eller C-bibliotek.

gopdf är ett rent Go-bibliotek som är speciellt utformat för att skapa PDF-dokument. Det erbjuder ett enkelt och effektivt API som fokuserar främst på PDF-generering, vilket gör det lättare att använda för grundläggande uppgifter samtidigt som det bibehåller flexibiliteten som krävs för mer komplexa operationer.

Nyckelfunktioner:

Rent Go-implementering: Inga externa beroenden eller C-bibliotek krävs.
Enkelt API: Lätta att använda funktioner för att generera PDF-dokument.
Effektiv prestanda: Optimerad för snabb och effektiv PDF-skapat.

Exempel på användning

För att illustrera hur gopdf kan användas, låt oss titta på ett grundläggande exempel på att skapa ett enkelt PDF-dokument:

package main

import (
    "github.com/signintech/gopdf"
)

func main() {
    // Skapa en ny PDF-instans
    pdf := gopdf.New()

    // Ställ in sidstorlek och marginaler
    pdf.SetPageSize(gopdf.PageSizeA4)
    pdf.AddPage()

    // Lägg till text i PDF-dokumentet
    pdf.SetFont("Arial", "", 12)
    pdf.Write(50, 50, "Hello, World!")

    // Spara PDF-dokumentet till en fil
    err := pdf.SaveToFile("example.pdf")
    if err != nil {
        panic(err)
    }
}

Detta exempel demonstrerar hur man skapar ett nytt PDF-dokument, lägger till text i det och sparar det som en fil.

Avancerade funktioner i gopdf:

Lägga till bilder: Du kan infoga bilder i dina PDF-dokument med metoden AddImage.
Rita former: Biblioteket erbjuder funktioner för att rita linjer, rektanglar och andra former.
PDF-skydd: Du kan sätta lösenordsskydd på dina PDF-dokument för att begränsa åtkomst.

pdfcpu

Underhållare: PDFCPU-teamet (https://github.com/pdfcpu/pdfcpu).
Användningsområden: Storskalig PDF-hantering och analys.

Ett annat av de kraftfulla biblioteken som finns tillgängliga för PDF-hantering i Go är pdfcpu. Detta bibliotek erbjuder en omfattande uppsättning funktioner för att skapa, modifiera och inspektera PDF-filer både via ett API och ett kommandoradsgränssnitt (CLI). Nedan går vi in på beskrivningen, användningsexempel och nyckelfunktioner för pdfcpu.

pdfcpu är ett Go-baserat PDF-behandlingsbibliotek som stöder kryptering och erbjuder robusta verktyg för att hantera olika aspekter av PDF-dokument. Det är kompatibelt med alla PDF-versioner, inklusive pågående förbättringar för PDF 2.0 (ISO-32000-2). Biblioteket syftar till att erbjuda en omfattande uppsättning PDF-behandlingsfunktioner, vilket gör det lämpligt för både enkla och komplexa användningsområden.

Nyckelfunktioner

Krypteringsstöd: pdfcpu stöder kryptering, vilket gör det möjligt för utvecklare att säkra sina PDF-dokument effektivt.
API och CLI: Det erbjuder både ett API för programmatisk åtkomst och ett kommandoradsgränssnitt (CLI) för snabba operationer.
Batchbehandling: Starkt stöd för batchbehandling via den rika kommandoraden gör det effektivt för att hantera flera filer samtidigt.
Kompatibilitet: Kompatibelt med alla PDF-versioner, inklusive grundläggande stöd och pågående förbättringar för PDF 2.0.

För att börja med pdfcpu måste du installera det med hjälp av Go:s pakethanteringssystem:

go get github.com/pdfcpu/pdfcpu

Grundläggande kommandoradsoperationer

pdfcpu erbjuder en mängd olika kommandon för olika operationer. Här är några exempel:

Skapa PDF från bilder

Du kan konvertera en eller flera bildfiler till en PDF-fil med följande kommando:

pdfcpu img2pdf out.pdf image1.jpg image2.png

Detta kommando kommer att skapa en PDF där varje bild renderas på en separat sida.

För att slå samman flera PDF-filer till ett enda dokument, använd merge-kommandot:

pdfcpu merge output.pdf file1.pdf file2.pdf

pdfcpu Användningsexempel

För mer komplexa operationer kan du använda API:t som erbjuds av pdfcpu. Här är ett exempel på hur man skapar ett nytt PDF-dokument och lägger till text med Go-kod:

package main

import (
    "github.com/pdfcpu/pdfcpu"
    "log"
)

func main() {
    // Skapa ett nytt PDF-dokument
    doc := pdfcpu.NewPDF(0, 0)
    defer doc.Close()

    // Lägg till en sida i dokumentet
    page := doc.AddPage()
    page.SetMediaBox(pdfcpu.MediaBox{
        LLX: 0,
        LLY: 0,
        URX: 612,
        URY: 792,
    })

    // Lägg till text på sidan
    content := "Hello, World!"
    font := pdfcpu.NewFont("Helvetica", "")
    page.AddText(content, font, 12, 100, 750)

    // Spara dokumentet
    err := doc.Save("output.pdf")
    if err != nil {
        log.Fatal(err)
    }
}

Detta exempel demonstrerar hur man skapar ett nytt PDF-dokument, lägger till en sida och skriver text på den med hjälp av pdfcpu:s API.

Maroto

Underhållare: go-playground-teamet (https://github.com/go-playground/maroto).
Användningsområden: Utvecklare som föredrar ett design-first-tillvägagångssätt (liknande Bootstrap).
Inspirerad av Bootstrap; utformad för att vara lätt att använda med en deklarativ stil liknande HTML/CSS.
Byggd på gofpdf, förenklar skapandeprocessen samtidigt som kraftfulla anpassningsalternativ bibehålls.

Maroto är ett annat Go-bibliotek för att skapa PDF-dokument, men det fokuserar på att förenkla processen genom att abstrahera bort lågnivådetaljer. Det bygger på gofpdf-biblioteket och erbjuder ett mer användarvänligt API för att generera dokument.

Maroto Användningsexempel

Här är ett exempel på hur du kan använda Maroto för att skapa en enkel PDF:

package main

import (
    "github.com/andreyhoffmann1103/maroto"
)

func main() {
    // Skapa ett nytt PDF-dokument med angivna dimensioner
    m := maroto.NewPDF(595, 842) // A4-storlek i poäng

    // Lägg till text på första sidan
    m.AddText("Hello, Maroto!", 0, 0)

    // Spara PDF-dokumentet till en fil
    err := m.OutputFileAndClose("example.pdf")
    if err != nil {
        panic(err)
    }
}

Detta exempel visar hur man skapar ett nytt PDF-dokument med en sida och lägger till text i det med Maroto.

Unipdf

UniPDF är ett annat kraftfullt och omfattande bibliotek för att skapa och bearbeta PDF-filer i Golang (Go). Det erbjuder en bred uppsättning funktioner som gör det populärt bland utvecklare som behöver generera, modifiera och extrahera innehåll från PDF-dokument.

Underhållare: UnidocLib (https://unidoc.io).
Användningsområden: Avancerad PDF-bearbetning (kryptering, sammanslagning, skriptning).
Kraftfullt bibliotek för att skapa och bearbeta PDF-dokument (rent Go).
Erbjuder omfattande funktioner inklusive interaktiva element som länkar, bokmärken, sammanslagning/delning, kryptering och mer.
Komplett API för att läsa och skriva PDF-objekt (ordlistor, strömmar).
Lämpligt för applikationer som behöver robusta PDF-genereringsfunktioner.

UniPDF Installation

För att börja med UniPDF måste du installera biblioteket. Följ dessa steg:

# Skapa en ny katalog:
mkdir go-pdf-generator
cd go-pdf-generator
# Initiera Go-modulen:
go mod init go-pdf-generator
# Installera UniPDF-biblioteket:
go get github.com/unidoc/unipdf/v3

Detta kommer att konfigurera ditt projekt och installera de nödvändiga beroenden.

Grundläggande användningsexempel

Här är ett enkelt exempel för att skapa ett PDF-dokument med UniPDF:

package main

import (
    "github.com/unidoc/unipdf/v3/core"
    "github.com/unidoc/unipdf/v3/model"
    "github.com/unidoc/unipdf/v3/creator"
)

func main() {
    // Skapa ett nytt PDF-dokument
    pdf := creator.New()

    // Lägg till en sida i PDF-dokumentet
    page := pdf.NewPage()

    // Konfigurera innehållsströmmen för sidan
    contentStream := model.NewContentStream()
    page.SetContents(contentStream)

    // Lägg till text på sidan
    text := "Hello, UniPDF!"
    font := creator.NewStandardFont(creator.FontHelvetica)
    textObject := model.NewText(text, font, 12)
    contentStream.Add(textObject)

    // Spara PDF-dokumentet
    err := pdf.WriteToFile("example.pdf")
    if err != nil {
        panic(err)
    }
}

Detta exempel demonstrerar hur man skapar ett nytt PDF-dokument, lägger till en sida och skriver text på den. Den resulterande filen example.pdf kommer att innehålla texten “Hello, UniPDF!”.

wkhtmltopdf Wrapper

https://github.com/SebastiaanKlippert/go-wkhtmltopdf
Beroende: Kräver wkhtmltopdf installerat via brew eller apt-get.
Användningsområden: Generera PDF-dokument från dynamiskt HTML-innehåll (t.ex. fakturor, rapporter).

Funktioner:

Konverterar HTML-mallar (renderade med Go:s html/template) till PDF.
Anpassningsbara marginaler, sidorientering och rubriker/fotnoter.
Lämpligt när dokumentets design är komplex och involverar HTML/CSS-stilning.
Använder wkhtmltopdf som bakgrund för att konvertera HTML-innehåll till PDF-format.

go-wkhtmltopdf användningsexempel

import (
    "bytes"
    "github.com/SebastiaanKlippert/go-wkhtmltopdf"
    "html/template"
)

type PDFService struct {}

func NewPDFService() *PDFService {
    return &PDFService{}
}

func (p PDFService) GeneratePDF(data interface{}) ([]byte, error) {
    var templ *template.Template
    var err error

    if templ, err = template.ParseFiles("pdf-template.html"); err != nil {
        return nil, err
    }

    var body bytes.Buffer
    if err := templ.Execute(&body, data); err != nil {
        return nil, err
    }

    pdfg, err := wkhtmltopdf.NewPDFGenerator()
    if err != nil {
        return nil, err
    }

    page := wkhtmltopdf.NewPageReader(bytes.NewReader(body.Bytes()))
    page.EnableLocalFileAccess.Set(true)

    pdfg.AddPage(page)
    pdfg.MarginLeft.Set(0)
    pdfg.MarginRight.Set(0)
    pdfg.Dpi.Set(300)
    pdfg.PageSize.Set(wkhtmltopdf.PageSizeA4)
    pdfg.Orientation.Set(wkhtmltopdf.OrientationLandscape)

    err = pdfg.Create()
    if err != nil {
        return nil, err
    }

    return pdfg.Bytes(), nil
}

pdflib (från EndFirstCorp):

Ett kommandoradsverktyg för olika PDF-operationer som validering, optimering, delning/sammanslagning.
Användbart för batchbehandling och administrativa uppgifter relaterade till PDF-dokument.

Översikt över pdflib

pdflib-biblioteket är utformat för att vara en omfattande PDF-processor för Go-programmeringsspråket. Det stöder olika funktioner såsom validering, optimering, delning, sammanslagning, extrahering av innehåll från och beskärning av PDF:er. Biblioteket följer PDF 32000-1:2008 (PDF 1.7)-standarden, vilket säkerställer kompatibilitet med ett brett utbud av PDF-dokument.

Nyckelfunktioner

Validering: Kontrollerar att PDF-filer uppfyller PDF 1.7-standarden.
Optimering: Minskar filstorlek genom att ta bort onödiga resurser.
Delning och sammanslagning: Tillåter att dela upp flersidiga PDF:er i enskilda sidor eller sammanföra flera PDF:er till en.
Extrahering: Extraherar bilder, typsnitt, innehåll och sidor från en PDF.
Beskärning: Skapar beskurna versioner av PDF-dokument.

Installation

För att använda pdflib måste du installera det via Go:s pakethanteringssystem. Du kan göra detta genom att köra:

go get github.com/EndFirstCorp/pdflib

Grundläggande användningsexempel - Validering av en PDF

Här är ett enkelt exempel som demonstrerar hur man använder pdflib-biblioteket för att utföra grundläggande PDF-operationer:

För att validera en PDF mot PDF 1.7-standarden kan du använda följande kod:

package main

import ( "fmt" "github.com/EndFirstCorp/pdflib/cmd/pdflib" )

func main() {
   // Validera en PDF-fil
   err := pdflib.Validate("example.pdf")
   if err != nil {
     fmt.Println("Validering misslyckades:", err)
   } else {
     fmt.Println("PDF är giltig.")
   }
}

Slutsats

För att generera PDF:er i Go beror valet av bibliotek på komplexiteten och de specifika kraven för ditt projekt. Följande rekommendationer ges:

Enkla dokument: Använd gofpdf eller Maroto. Dessa bibliotek erbjuder enkelhet och lättanvändhet för enkla uppgifter.
Komplexa design med HTML/CSS: Använd wkhtmltopdf Wrapper, som utnyttjar wkhtmltopdf för att hantera komplex HTML-innehåll och stil.
Avancerad PDF-behandling: Välj Unipdf eller pdfcpu när din applikation kräver avancerade funktioner som kryptering, interaktiva element, detaljerad formatering och omfattande manipuleringsegenskaper.

Var och en av dessa bibliotek erbjuder unika styrkor som passar olika behov vid PDF-generering, vilket ger utvecklare en variation av verktyg att välja mellan baserat på deras specifika krav.