Gehen Sie zur Bibliothek, um mit Excel-XLSX-Dokumenten zu arbeiten

Erste Schritte mit Xsx2Go

Die empfohlene Methode zur Installation von xlsx ist von GitHub. Bitte verwenden Sie den folgenden Befehl für eine reibungslose Installation.

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

Erstellen von NEUEN XLSX-Dateien über die Go-Bibliothek

Die Open-Source-xlsx-Bibliothek gibt Softwareentwicklern die Möglichkeit, mit ein paar Go-Befehlen eine neue leere XLSX-Datei von Grund auf neu zu erstellen. Die Entwickler können die neue NewFile()-Funktion verwenden, um eine neue Datei zu generieren. Sobald es erstellt ist, können Sie der Arbeitsmappe ganz einfach neue Inhalte hinzufügen. Sie können ganz einfach ein neues Blatt hinzufügen oder ein vorhandenes Blatt anhängen. Sobald die Arbeit erstellt und abgeschlossen ist, speichern Sie bitte Ihre Arbeit, es wird empfohlen, das Blatt zu schließen.

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

Greifen Sie auf XLSX-Dateien zu und lesen Sie sie

Die Open-Source-xlsx-Bibliothek hat eine Reihe von Funktionen bereitgestellt, die es Entwicklern ermöglichen, auf eine vorhandene XLSX-Tabellenkalkulationsdatei in ihren eigenen Go-Anwendungen zuzugreifen und sie zu lesen. Mit nur wenigen Go-Befehlen können Sie auch ganz einfach auf Blätter einer Arbeitsmappe zugreifen. Entwickler können auch problemlos auf ein bestimmtes Blatt ihrer Wahl zugreifen.

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

Umgang mit Zeilen und Spalten in Arbeitsblättern

Zellen sind das Rückgrat eines Excel-Arbeitsblatts. Ein Arbeitsblatt besteht aus Zellen, die in Zeilen und Spalten organisiert sind. Die xlsx-Bibliothek bietet Softwareentwicklern eine breite Palette von Funktionen zum Umgang mit Zeilen und Spalten in ihren Apps mithilfe von Go-Befehlen. Es unterstützt das Hinzufügen neuer Zeilen und Spalten, das Iterieren von Zeilen und Spalten, das Löschen unerwünschter Zeilen und Spalten, das Hinzufügen neuer Zellen zu einer Zeile, das Abrufen von Werten aus einer Zelle, das Anwenden von Formatierungen auf einen Bereich von Zellen und vieles mehr.

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

Stile und Formatierung anwenden

Die xlsx-Bibliothek der kostenlosen Bibliothek hat mehrere wichtige Funktionen bereitgestellt, die es Softwareentwicklern ermöglichen, Formatierungen und Stile problemlos auf ihre Tabellenkalkulationen anzuwenden. Stile bieten Layout und Dekoration von Zellen wie Schriftart, Farbe, Inhaltsausrichtung, Schriftgröße, Füllung usw. Sie können den Stil mit nur wenigen Codezeilen ganz einfach auf eine Reihe von Zellen anwenden. Sie müssen einen Stil nur einmal erstellen und ihn bei Bedarf wiederverwenden. Sie können auch Zahlen- und Datumsformate für Zellen anwenden.

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