Ga naar Bibliotheek om te werken met Excel XLSX-documenten

Aan de slag met Xlsx2Go

De aanbevolen manier om xlsx te installeren is vanaf GitHub. Gebruik de volgende opdracht voor een vlotte installatie.

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

NIEUWE XLSX-bestanden maken via Go Library

De Open source xlsx-bibliotheek geeft softwareontwikkelaars de mogelijkheid om met een paar Go-commando's een nieuw leeg XLSX-bestand te maken. De ontwikkelaars kunnen de nieuwe functie NewFile() gebruiken om een nieuw bestand te genereren. Zodra het is gemaakt, kunt u eenvoudig nieuwe inhoud aan de werkmap toevoegen. U kunt eenvoudig een nieuw blad toevoegen of een bestaand blad toevoegen. Eenmaal gemaakt en het werk is voltooid, sla uw werk op, het wordt aanbevolen Sluit()het blad.

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

XLSX-bestanden openen en lezen

De Open source xlsx-bibliotheek heeft een reeks functies geboden waarmee ontwikkelaars een bestaand XLSX-spreadsheetbestand kunnen openen en lezen in hun eigen Go-applicaties. U kunt ook gemakkelijk toegang krijgen tot bladen van een werkmap met slechts een paar Go-opdrachten. Ontwikkelaars hebben ook gemakkelijk toegang tot een bepaald blad naar keuze.

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(), ","))
}

Omgaan met rijen en kolommen in werkbladen

Cellen vormen de ruggengraat van een Excel-werkblad. Een werkblad bestaat uit cellen die in rijen en kolommen zijn gerangschikt. De xlsx-bibliotheek biedt softwareontwikkelaars een breed scala aan functies voor het verwerken van rijen en kolommen in hun apps met behulp van Go-opdrachten. Het ondersteunt het toevoegen van nieuwe rijen en kolommen, het herhalen van rijen en kolommen, het verwijderen van ongewenste rijen en kolommen, het toevoegen van nieuwe cellen aan een rij, het verkrijgen van waarde uit een cel, het toepassen van opmaak op een reeks cellen en nog veel meer.

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(), ","))
}

Stijlen en opmaak toepassen

De gratis bibliotheek xlsx-bibliotheek heeft verschillende belangrijke functies geboden waarmee softwareontwikkelaars gemakkelijk opmaak en stijlen op hun spreadsheets kunnen toepassen. Stijlen bieden lay-out en decoratie van cellen, zoals lettertype, kleur, uitlijning van inhoud, lettergrootte, opvulling, enz. U kunt de stijl eenvoudig toepassen op een reeks cellen met slechts een paar regels code. U hoeft slechts één keer een stijl te maken en deze indien nodig opnieuw te gebruiken. U kunt ook getal- en datumnotaties toepassen op cellen.

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