Introduction

Aspose.Cells FOSS pour Go est une bibliothèque pure-Go pour travailler avec les feuilles de calcul Excel. Elle expose un API pour créer de nouveaux classeurs à partir de zéro, écrire et styliser les valeurs des cellules, appliquer des règles de validation des données, construire des tableaux structurés, intégrer des images, et lire de gros fichiers .xlsx ligne par ligne — le tout sans aucune dépendance native C ou C++.

La bibliothèque est disponible en tant que module Go à l’adresse github.com/aspose-cells-foss/Aspose.Cells-FOSS-for-Go et est publiée sous licence MIT. Installez-la avec go get github.com/aspose-cells-foss/Aspose.Cells-FOSS-for-Go/v26 dans n’importe quel projet Go 1.24+.

Cet article couvre les fonctionnalités principales : stylisation des cellules, validation des données, tableaux, images et lectures en flux.

Fonctionnalités clés

Mise en forme des cellules

Regroupez les paramètres Font, Fill, Alignment et Border dans un Style réutilisable, puis appliquez-le à une cellule avec Cell.SetStyle :

wb := cells_foss.NewWorkbook()
ws := wb.Worksheets[0]

boldStyle := cells_foss.NewStyle()
boldStyle.Font.Bold = true
boldStyle.Font.Size = 12

cell, _ := ws.Cells().Get("A1")
cell.SetStyle(boldStyle)

Alignment contrôle Horizontal, Vertical et WrapText ; Border contrôle la visibilité des règles Top, Bottom, Left et Right ainsi que la Color.

Validation des données

Worksheet.AddDataValidation attache une règle de validation à une plage de cellules. La structure DataValidation contient la règle Type, une ou deux valeurs Formula, ainsi que des champs de message d’erreur :

wb := cells_foss.NewWorkbook()
ws := wb.Worksheets[0]

dv := &cells_foss.DataValidation{
	Type:             cells_foss.DataValidationTypeList,
	Formula1:         `"Apple,Banana,Cherry,Dragonfruit"`,
	AllowBlank:       true,
	ShowErrorMessage: true,
	ErrorTitle:       "Invalid Fruit",
	ErrorMessage:     "Please pick a fruit from the list.",
	ErrorStyle:       cells_foss.ErrorStyleStop,
}
ws.AddDataValidation("A2:A10", dv)

Tableaux

Worksheet.AddTable crée un Table structuré sur une plage, avec une ligne d’en-tête optionnelle et un style de tableau nommé :

wb := cells_foss.NewWorkbook()
ws := wb.Worksheets[0]
ws.Cells().Set("A1", "Item")
ws.Cells().Set("B1", "Qty")

tbl := ws.AddTable("A1:B2")
tbl.HasHeaderRow = true
tbl.StyleName = "TableStyleMedium6"

Images

Worksheet.AddPicture intègre une image ; Picture.SetAnchor(row, col) la positionne :

wb := cells_foss.NewWorkbook()
ws := wb.Worksheets[0]
imageBytes := []byte{} // populate with real image bytes before use

pic := &cells_foss.Picture{Data: imageBytes, Format: "png"}
ws.AddPicture(pic)
pic.SetAnchor(5, 0)

Diffusion en continu de gros fichiers

StreamingReader lit une feuille de calcul ligne par ligne via un rappel, de sorte qu’un classeur de plusieurs milliers de lignes n’a jamais besoin d’être chargé complètement en mémoire :

sr := cells_foss.NewStreamingReader("large_workbook.xlsx")
err := sr.ProcessRows("Sheet1", func(rowIdx int, cells map[string]string) error {
	// process one row at a time
	return nil
})
if err != nil {
	fmt.Printf("Error streaming: %v\n", err)
}

Démarrage rapide

Installez le module :

go get github.com/aspose-cells-foss/Aspose.Cells-FOSS-for-Go/v26

Un flux de travail minimal — créez un classeur, écrivez deux cellules, mettez l’en-tête en gras et enregistrez :

package main

import (
	"fmt"

	cells_foss "github.com/aspose-cells-foss/Aspose.Cells-FOSS-for-Go/v26/aspose/cells_foss"
)

func main() {
	wb := cells_foss.NewWorkbook()
	ws := wb.Worksheets[0]

	ws.Cells().Set("A1", "Product")
	ws.Cells().Set("B1", "Revenue")

	boldStyle := cells_foss.NewStyle()
	boldStyle.Font.Bold = true
	for _, ref := range []string{"A1", "B1"} {
		cell, _ := ws.Cells().Get(ref)
		cell.SetStyle(boldStyle)
	}

	if err := wb.Save("report.xlsx"); err != nil {
		fmt.Printf("Error saving workbook: %v\n", err)
		return
	}
	fmt.Println("Workbook saved to report.xlsx")
}

Formats pris en charge

FormatExtensionLireÉcrire
XLSX.xlsx—✓
CSV.csv✓✓

Les classeurs XLSX sont créés en mémoire avec NewWorkbook et écrits avec Workbook.Save. CSV est bidirectionnel via Workbook.ImportFromCSV et Workbook.ExportToCSV.

Open Source & Licences

Aspose.Cells FOSS pour Go est publié sous licence MIT. Il n’y a aucune restriction d’utilisation, aucun frais d’exécution et aucune exigence d’enregistrement. Le code source est disponible à github.com/aspose-cells-foss/Aspose.Cells-FOSS-for-Go.

L’utilisation commerciale est autorisée selon les termes de la licence MIT. Si votre projet nécessite un support de niveau entreprise, une couverture étendue des formats ou une intégration cloud, le Aspose.Cells — Enterprise Product Family est une offre commerciale distincte.

Premiers pas

Ressources associées