Vai alla libreria per lavorare con i documenti XLSX di Excel

Guida introduttiva a Xlsx2Go

Il modo consigliato per installare xlsx è da GitHub, utilizzare il comando seguente per un'installazione senza problemi.

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

Creazione di NUOVI file XLSX tramite Go Library

La libreria open source xlsx offre agli sviluppatori di software la possibilità di creare un nuovo file XLSX vuoto da zero utilizzando un paio di comandi Go. Gli sviluppatori possono utilizzare la nuova funzione NewFile() per generare un nuovo file. Una volta creato, puoi facilmente aggiungere nuovi contenuti alla cartella di lavoro. Puoi aggiungere un nuovo foglio o aggiungere facilmente un foglio esistente. Una volta creato e completato il lavoro, salva il tuo lavoro, si consiglia di chiudere() il foglio.

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

Accedi e leggi i file XLSX

La libreria Open source xlsx ha fornito una serie di funzioni che consentono agli sviluppatori di accedere e leggere un foglio di calcolo XLSX esistente all'interno delle proprie applicazioni Go. Puoi anche accedere facilmente ai fogli di una cartella di lavoro con solo un paio di comandi Vai. Gli sviluppatori possono anche accedere facilmente a un foglio particolare di loro scelta.

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

Gestione di righe e colonne nei fogli di lavoro

Le celle sono la spina dorsale di un foglio di lavoro di Excel. Un foglio di lavoro è composto da celle organizzate in righe e colonne. La libreria xlsx offre agli sviluppatori di software un'ampia gamma di funzionalità per la gestione di righe e colonne all'interno delle loro app utilizzando i comandi Go. Supporta l'aggiunta di nuove righe e colonne, l'iterazione di righe e colonne, l'eliminazione di righe e colonne indesiderate, l'aggiunta di nuove celle a una riga, l'ottenimento di valore da una cella, l'applicazione della formattazione a un intervallo di celle e molti altri.

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

Applicare stili e formattazione

La libreria Free Library xlsx ha fornito diverse importanti funzioni che consentono agli sviluppatori di software di applicare facilmente la formattazione e gli stili ai propri fogli di calcolo. Gli stili forniscono il layout e la decorazione di celle come carattere, colore, allineamento del contenuto, dimensione del carattere, riempimento, ecc. Puoi facilmente applicare lo stile a un intervallo di celle con solo un paio di righe di codice. Devi solo creare uno stile una volta e riutilizzarlo quando necessario. Puoi anche applicare formati di numero e data per le celle.

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