¿Qué bibliotecas se deben utilizar para generar PDF en GO?

Para generar PDF en Go, use gofpdf o Maroto para tareas simples, y Unipdf o pdfcpu para tareas avanzadas.

Generar informes PDF en GO

Bien. Ahora generando PDFs en GO!

Índice

Generar documentos PDF de forma programática puede ser una función importante en tu aplicación. Aquí exploramos y damos una breve revisión con ejemplos de las bibliotecas disponibles en el lenguaje de programación Go (Golang) para generar archivos PDF.

Las soluciones adecuadas pueden variar, por ejemplo, para la creación de documentos simples o para la generación de PDFs complejos y con muchas funcionalidades.

go, pdf! Sí, la imagen es generada por IA, el modelo es Flux1.Dev.

Bibliotecas y herramientas

gofpdf

GoPdf es una biblioteca sencilla para crear PDFs. Permite agregar texto, imágenes, formas, tablas y manejar varias páginas. Adecuada para tareas de creación de PDFs simples a moderadamente complejas.

Mantenedor: Jung Kurt (descatalogada pero aún utilizada).

Limitación: Falta de actualizaciones, aunque su uso persiste.

Ejemplo:

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

Mantenedor: signintech (mantenida activamente).

En el lenguaje de programación Go, una de las bibliotecas que destaca para este propósito es gopdf, desarrollada por SignInTech. Esta biblioteca proporciona una forma sencilla de crear PDFs de forma programática sin depender de bibliotecas externas o C.

gopdf es una biblioteca puramente en Go diseñada específicamente para crear documentos PDF. Ofrece una API simple y eficiente centrada principalmente en la generación de PDF, lo que facilita su uso para tareas básicas mientras mantiene la flexibilidad necesaria para operaciones más complejas.

Funciones clave:

Implementación pura en Go: No se requieren dependencias externas ni bibliotecas en C.
API sencilla: Funciones fáciles de usar para generar PDFs.
Rendimiento eficiente: Optimizada para la creación rápida y eficiente de PDFs.

Uso Ejemplo

Para ilustrar cómo se puede usar gopdf, veamos un ejemplo básico de creación de un documento PDF simple:

package main

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

func main() {
    // Crear una nueva instancia de PDF
    pdf := gopdf.New()

    // Establecer el tamaño de página y márgenes
    pdf.SetPageSize(gopdf.PageSizeA4)
    pdf.AddPage()

    // Agregar algún texto al PDF
    pdf.SetFont("Arial", "", 12)
    pdf.Write(50, 50, "Hello, World!")

    // Guardar el PDF en un archivo
    err := pdf.SaveToFile("example.pdf")
    if err != nil {
        panic(err)
    }
}

Este ejemplo demuestra cómo crear un nuevo documento PDF, agregar texto a él y guardarlo como un archivo.

Funciones avanzadas de gopdf:

Agregar imágenes: Puedes insertar imágenes en tus documentos PDF usando el método AddImage.
Dibujar formas: La biblioteca proporciona funciones para dibujar líneas, rectángulos y otras formas.
Protección de PDF: Puedes establecer protección con contraseña en tus PDFs para restringir el acceso.

pdfcpu

Mantenedor: Equipo de pdfcpu (https://github.com/pdfcpu/pdfcpu).
Casos de uso: Manipulación y análisis de PDFs a gran escala.

Otra de las poderosas bibliotecas disponibles para la manipulación de PDFs en Go es pdfcpu. Esta biblioteca ofrece un conjunto completo de funciones para crear, modificar e inspeccionar archivos PDF a través de una API y una interfaz de línea de comandos (CLI). A continuación, exploramos la descripción, ejemplos de uso y funciones clave de pdfcpu.

pdfcpu es una biblioteca de procesamiento de PDF basada en Go que admite encriptación y ofrece herramientas robustas para manejar diversos aspectos de documentos PDF. Es compatible con todas las versiones de PDF, incluyendo mejoras continuas para PDF 2.0 (ISO-32000-2). La biblioteca tiene como objetivo proporcionar un rango completo de funciones de procesamiento de PDF, lo que la hace adecuada tanto para casos de uso simples como complejos.

Funciones clave

Soporte de encriptación: pdfcpu admite encriptación, permitiendo a los desarrolladores proteger eficazmente sus documentos PDF.
API y CLI: Ofrece tanto una API para acceso programático como una interfaz de línea de comandos (CLI) para operaciones rápidas.
Procesamiento por lotes: Fuerte soporte para procesamiento por lotes mediante la línea de comandos rica, lo que lo hace eficiente para manejar múltiples archivos a la vez.
Compatibilidad: Compatible con todas las versiones de PDF, incluyendo soporte básico y mejoras continuas para PDF 2.0.

Para comenzar con pdfcpu, necesitas instalarlo usando el sistema de gestión de paquetes de Go:

go get github.com/pdfcpu/pdfcpu

Operaciones básicas de línea de comandos

pdfcpu proporciona una variedad de comandos para diferentes operaciones. Aquí hay algunos ejemplos:

Crear un PDF desde imágenes

Puedes convertir uno o más archivos de imagen en un archivo PDF con el siguiente comando:

pdfcpu img2pdf out.pdf image1.jpg image2.png

Este comando creará un PDF donde cada imagen se renderizará en una página separada.

Para fusionar varios archivos PDF en un solo documento, usa el comando merge:

pdfcpu merge output.pdf file1.pdf file2.pdf

Ejemplo de uso de pdfcpu

Para operaciones más complejas, puedes usar la API proporcionada por pdfcpu. Aquí hay un ejemplo de cómo crear un nuevo PDF y agregar texto usando código Go:

package main

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

func main() {
    // Crear un nuevo documento PDF
    doc := pdfcpu.NewPDF(0, 0)
    defer doc.Close()

    // Añadir una página al documento
    page := doc.AddPage()
    page.SetMediaBox(pdfcpu.MediaBox{
        LLX: 0,
        LLY: 0,
        URX: 612,
        URY: 792,
    })

    // Añadir texto a la página
    content := "Hello, World!"
    font := pdfcpu.NewFont("Helvetica", "")
    page.AddText(content, font, 12, 100, 750)

    // Guardar el documento
    err := doc.Save("output.pdf")
    if err != nil {
        log.Fatal(err)
    }
}

Este ejemplo muestra cómo crear un nuevo PDF, añadir una página y escribir texto en ella usando la API de pdfcpu.

Maroto

Mantenedor: Equipo de go-playground (https://github.com/go-playground/maroto).
Casos de uso: Desarrolladores que prefieren un enfoque basado en el diseño (similar a Bootstrap).
Inspirado en Bootstrap; diseñado para ser fácil de usar con un estilo declarativo similar al HTML/CSS.
Construido sobre gofpdf, simplifica el proceso de creación mientras mantiene opciones poderosas de personalización.

Maroto es otra biblioteca de Go para crear PDFs, pero se centra en simplificar el proceso abstrayendo detalles de nivel inferior. Se construye sobre la biblioteca gofpdf y proporciona una API más amigable para generar documentos.

Ejemplo de uso de Maroto

Aquí hay un ejemplo de cómo puedes usar Maroto para crear un PDF simple:

package main

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

func main() {
    // Crear un nuevo documento PDF con dimensiones especificadas
    m := maroto.NewPDF(595, 842) // Tamaño A4 en puntos

    // Añadir algún texto a la primera página
    m.AddText("Hello, Maroto!", 0, 0)

    // Guardar el PDF en un archivo
    err := m.OutputFileAndClose("example.pdf")
    if err != nil {
        panic(err)
    }
}

Este ejemplo muestra cómo crear un nuevo documento PDF con una página y añadir texto a él usando Maroto.

Unipdf

UniPDF es otra biblioteca poderosa y completa para crear y procesar archivos PDF en Golang (Go). Ofrece una amplia gama de funciones que la hacen popular entre los desarrolladores que necesitan generar, modificar y extraer contenido de documentos PDF.

Mantenedor: UnidocLib (https://unidoc.io).
Casos de uso: Procesamiento avanzado de PDF (encriptación, fusión, scripting).
Biblioteca poderosa para crear y procesar PDFs (puro Go).
Ofrece funciones extensas, incluyendo elementos interactivos como enlaces, marcadores, fusión/segmentación, encriptación, entre otros.
API completa para leer y escribir objetos PDF (diccionarios, flujos).
Adecuada para aplicaciones que necesiten capacidades robustas de generación de PDF.

Instalación de UniPDF

Para comenzar con UniPDF, necesitas instalar la biblioteca. Sigue estos pasos:

# Crear un nuevo directorio:
mkdir go-pdf-generator cd go-pdf-generator
# Inicializar el módulo Go:
go mod init go-pdf-generator
# Instalar la biblioteca UniPDF:
go get github.com/unidoc/unipdf/v3

Esto configurará tu proyecto e instalará las dependencias necesarias.

Ejemplo de uso básico

Aquí hay un ejemplo sencillo para crear un documento PDF usando UniPDF:

package main

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

func main() {
    // Crear un nuevo documento PDF
    pdf := creator.New()

    // Añadir una página al PDF
    page := pdf.NewPage()

    // Configurar el flujo de contenido para la página
    contentStream := model.NewContentStream()
    page.SetContents(contentStream)

    // Añadir texto a la página
    text := "Hello, UniPDF!"
    font := creator.NewStandardFont(creator.FontHelvetica)
    textObject := model.NewText(text, font, 12)
    contentStream.Add(textObject)

    // Guardar el documento PDF
    err := pdf.WriteToFile("example.pdf")
    if err != nil {
        panic(err)
    }
}

Este ejemplo demuestra cómo crear un nuevo documento PDF, añadir una página y escribir texto en él. El archivo resultante example.pdf contendrá el texto “Hello, UniPDF!”.

Wrapper de wkhtmltopdf

https://github.com/SebastiaanKlippert/go-wkhtmltopdf
Dependencia: Requiere que wkhtmltopdf esté instalado mediante brew o apt-get.
Casos de uso: Generar PDFs desde contenido HTML dinámico (por ejemplo, facturas, informes).

Funciones:

Convierte plantillas HTML (renderizadas con html/template de Go) a PDF.
Márgenes, orientación de página y encabezados/pie de página personalizables.
Adecuado cuando el diseño del documento es complejo y involucra estilos HTML/CSS.
Usa wkhtmltopdf como backend para convertir contenido HTML en formato PDF.

Ejemplo de uso de go-wkhtmltopdf

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 (de EndFirstCorp):

Una herramienta de línea de comandos para diversas operaciones con PDF como validación, optimización, segmentación/fusión.
Útil para procesamiento por lotes y tareas administrativas relacionadas con documentos PDF.

Visión general de pdflib

La biblioteca pdflib está diseñada para ser un procesador de PDF completo para el lenguaje de programación Go. Soporta diversas funcionalidades como validar, optimizar, segmentar, fusionar, extraer contenido de y recortar PDFs. La biblioteca sigue el estándar PDF 32000-1:2008 (PDF 1.7), asegurando compatibilidad con una amplia gama de documentos PDF.

Funciones clave

Validación: Asegura que los archivos PDF cumplan con el estándar PDF 1.7.
Optimización: Reduce el tamaño del archivo eliminando recursos redundantes.
Segmentación y fusión: Permite segmentar PDFs de varias páginas en PDFs de una página o fusionar varios PDFs en uno.
Extracción: Extrae imágenes, fuentes, contenido y páginas de un PDF.
Recorte: Crea versiones recortadas de documentos PDF.

Instalación

Para usar pdflib, debes instalarlo mediante el sistema de gestión de paquetes de Go. Puedes hacerlo ejecutando:

go get github.com/EndFirstCorp/pdflib

Ejemplo de uso básico - Validar un PDF

Aquí hay un ejemplo sencillo que demuestra cómo usar la biblioteca pdflib para realizar operaciones básicas de PDF:

Para validar un PDF contra el estándar PDF 1.7, puedes usar el siguiente código:

package main

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

func main() {
   // Validar un archivo PDF
   err := pdflib.Validate("example.pdf")
   if err != nil {
     fmt.Println("La validación falló:", err)
   } else {
     fmt.Println("El PDF es válido.")
   }
}

Conclusión

Para generar PDFs en Go, la elección de la biblioteca depende de la complejidad y los requisitos específicos de tu proyecto. Las siguientes recomendaciones se proporcionan:

Documentos simples: Usa gofpdf o Maroto. Estas bibliotecas ofrecen simplicidad y facilidad de uso para tareas sencillas.
Diseños complejos con HTML/CSS: Utiliza el wkhtmltopdf Wrapper, que aprovecha wkhtmltopdf para manejar contenido HTML complejo y estilos.
Procesamiento avanzado de PDF: Opta por Unipdf o pdfcpu cuando tu aplicación requiera características avanzadas como encriptación, elementos interactivos, formateo detallado y capacidades de manipulación completas.

Cada una de estas bibliotecas ofrece fortalezas únicas que satisfacen necesidades diferentes en la generación de PDF, proporcionando a los desarrolladores una variedad de herramientas para elegir según sus requisitos específicos.