Accédez à la bibliothèque pour travailler avec des documents Excel XLSX

Premiers pas avec Xlsx2Go

La méthode recommandée pour installer xlsx est à partir de GitHub, veuillez utiliser la commande suivante pour une installation fluide.

go get https://github.com/tealeg/xlsx.git

Création de NOUVEAUX fichiers XLSX via Go Library

La bibliothèque open source xlsx donne aux développeurs de logiciels la possibilité de créer un nouveau fichier XLSX vide à partir de zéro à l'aide de quelques commandes Go. Les développeurs peuvent utiliser la nouvelle fonction NewFile() pour générer un nouveau fichier. Une fois créé, vous pouvez facilement ajouter du nouveau contenu au classeur. Vous pouvez facilement ajouter une nouvelle feuille ou ajouter une feuille existante. Une fois créé et le travail terminé, veuillez enregistrer votre travail, il est recommandé de fermer() la feuille.

// Demonstrates how to create/open/save XLSX files
func Example_files() {
	// Create a new XLSX file
	xl := xlsx.New()
	// Open the XLSX file using file name
	xl, err := xlsx.Open("./test_files/example_simple.xlsx")
	if err != nil {
		log.Fatal(err)
	}
	defer xl.Close()
	// Open the XLSX file using file handler
	zipFile, err := os.Open("./test_files/example_simple.xlsx")
	if err != nil {
		log.Fatal(err)
	}
	xl, err = xlsx.Open(zipFile)
	if err != nil {
		log.Fatal(err)
	}
	// Update the existing XLSX file
	err = xl.Save()
	if err != nil {
		log.Fatal(err)
	}
	// Save the XLSX file under different name
	err = xl.SaveAs("new_file.xlsx")
	if err != nil {
		log.Fatal(err)
	}
}

Accéder et lire les fichiers XLSX

La bibliothèque open source xlsx a fourni un ensemble de fonctions qui permettent aux développeurs d'accéder, d'ouvrir et de lire un fichier de feuille de calcul XLSX existant dans leurs propres applications Go. Vous pouvez également accéder facilement aux feuilles d'un classeur avec seulement quelques commandes Go. Les développeurs peuvent également accéder facilement à une feuille particulière de leur choix.

func Example_access() {
	xl, err := xlsx.Open("./test_files/example_simple.xlsx")
	if err != nil {
		log.Fatal(err)
	}
	defer xl.Close()
	// Get sheet by 0-based index
	sheet := xl.Sheet(0)
	// Get cell by 0-based indexes
	cell := sheet.Cell(13, 27)
	fmt.Println(cell.Value())
	// Get cell by reference
	cell = sheet.CellByRef("N28")
	fmt.Println(cell.Value())
	// Get row by 0-based index
	row := sheet.Row(9)
	fmt.Println(strings.Join(row.Values(), ","))
	// Get cell of row at 0-based col index
	cell = row.Cell(0)
	fmt.Println(cell.Value())
	// Get col by 0-based index
	col := sheet.Col(3)
	fmt.Println(strings.Join(col.Values(), ","))
	// Get cell of col at 0-based row index
	cell = col.Cell(0)
	fmt.Println(cell.Value())
	// Get range by references
	area := sheet.RangeByRef("D10:H13")
	fmt.Println(strings.Join(area.Values(), ","))
}

Gestion des lignes et des colonnes dans les feuilles de calcul

Les cellules sont l'épine dorsale d'une feuille de calcul Excel. Une feuille de calcul est composée de cellules organisées en lignes et en colonnes. La bibliothèque xlsx offre aux développeurs de logiciels un large éventail de fonctionnalités pour gérer les lignes et les colonnes dans leurs applications à l'aide des commandes Go. Il prend en charge l'ajout de nouvelles lignes et colonnes, l'itération de lignes et de colonnes, la suppression de lignes et de colonnes indésirables, l'ajout de nouvelles cellules à une ligne, l'obtention de la valeur d'une cellule, l'application de la mise en forme à une plage de cellules, etc.

func Example_insert() {
	xl, err := xlsx.Open("./test_files/example_simple.xlsx")
	if err != nil {
		log.Fatal(err)
	}
	defer xl.Close()
	sheet := xl.Sheet(0)
	fmt.Println(sheet.Dimension())
	fmt.Println(strings.Join(sheet.Col(3).Values(), ","))
	// Insert a new col
	sheet.InsertCol(3)
	fmt.Println(sheet.Dimension())
	fmt.Println(strings.Join(sheet.Col(3).Values(), ","))
	fmt.Println(strings.Join(sheet.Col(4).Values(), ","))
	// Insert a new row
	fmt.Println(strings.Join(sheet.Row(9).Values(), ","))
	sheet.InsertRow(3)
	fmt.Println(sheet.Dimension())
	fmt.Println(strings.Join(sheet.Row(9).Values(), ","))
	fmt.Println(strings.Join(sheet.Row(10).Values(), ","))
}

Appliquer les styles et la mise en forme

La bibliothèque Free library xlsx a fourni plusieurs fonctions importantes qui permettent aux développeurs de logiciels d'appliquer facilement la mise en forme et les styles à leurs feuilles de calcul. Les styles fournissent la disposition et la décoration des cellules comme la police, la couleur, l'alignement du contenu, la taille de la police, le remplissage, etc. Vous pouvez facilement appliquer le style à une plage de cellules avec seulement quelques lignes de code. Il vous suffit de créer un style une fois et de le réutiliser en cas de besoin. Vous pouvez également appliquer des formats de nombre et de date aux cellules.

gfunc Example_formatting() {
	xl, err := xlsx.Open("./test_files/example_simple.xlsx")
	if err != nil {
		log.Fatal(err)
	}
	defer xl.Close()
	// Create a new format for a bold font with red color and yellow solid background
	redBold := styles.New(
		styles.Font.Bold,
		styles.Font.Color("#ff0000"),
		styles.Fill.Background("#ffff00"),
		styles.Fill.Type(styles.PatternTypeSolid),
	)
	// Add formatting to xlsx
	styleID := xl.AddStyles(redBold)
	sheet := xl.Sheet(0)
	// Set formatting for cell
	sheet.CellByRef("N28").SetStyles(styleID)
	// Set DEFAULT formatting for row. Affects cells not yet allocated in the row.
	// In other words, this style applies to new cells.
	sheet.Row(9).SetStyles(styleID)
	// Set DEFAULT formatting for col. Affects cells not yet allocated in the col.
	// In other words, this style applies to new cells.
	sheet.Col(3).SetStyles(styleID)
	//set formatting for all cells in range
	sheet.RangeByRef("D10:H13").SetStyles(styleID)
}