excelize
Go language library for reading and writing Microsoft Excel™ (XLAM / XLSM / XLSX / XLTM / XLTX) spreadsheets
Top Related Projects
Go language library for reading and writing Microsoft Excel™ (XLAM / XLSM / XLSX / XLTM / XLTX) spreadsheets
Quick Overview
Excelize is a Go library for reading and writing Microsoft Excel (XLSX) files. It provides a simple and efficient way to manipulate spreadsheet data in Go applications.
Pros
- Cross-platform Compatibility: Excelize is a pure Go library, making it platform-independent and easy to integrate into various Go projects.
- Comprehensive Functionality: The library supports a wide range of Excel features, including creating, reading, and modifying worksheets, formatting cells, and working with charts and images.
- Performance: Excelize is designed to be efficient, with fast read and write operations, making it suitable for handling large Excel files.
- Active Development: The project is actively maintained, with regular updates and bug fixes, ensuring its continued reliability and functionality.
Cons
- Limited Compatibility with Older Excel Versions: Excelize primarily focuses on the XLSX format, which is the default format for Microsoft Excel since 2007. It may have limited support for older XLS format files.
- Lack of Advanced Formatting Options: While Excelize provides basic formatting capabilities, it may not offer the full range of formatting options available in Excel, limiting its usefulness for complex spreadsheet designs.
- Steep Learning Curve: The library's extensive functionality can make it challenging for beginners to quickly get up to speed, especially if they are new to working with Excel data in Go.
- Potential Performance Issues with Large Files: While Excelize is generally performant, working with extremely large Excel files may still result in performance degradation, depending on the specific use case.
Code Examples
Here are a few examples of how to use Excelize:
- Creating a New Spreadsheet:
package main
import (
"fmt"
"github.com/xuri/excelize/v2"
)
func main() {
f := excelize.NewFile()
f.SetCellValue("Sheet1", "A1", "Hello, world!")
if err := f.SaveAs("example.xlsx"); err != nil {
fmt.Println(err)
}
}
- Reading Data from a Spreadsheet:
package main
import (
"fmt"
"github.com/xuri/excelize/v2"
)
func main() {
f, err := excelize.OpenFile("example.xlsx")
if err != nil {
fmt.Println(err)
return
}
defer f.Close()
cell, err := f.GetCellValue("Sheet1", "A1")
if err != nil {
fmt.Println(err)
return
}
fmt.Println(cell)
}
- Modifying a Spreadsheet:
package main
import (
"fmt"
"github.com/xuri/excelize/v2"
)
func main() {
f, err := excelize.OpenFile("example.xlsx")
if err != nil {
fmt.Println(err)
return
}
defer f.Close()
f.SetCellValue("Sheet1", "A2", "Updated value")
if err := f.SaveAs("updated_example.xlsx"); err != nil {
fmt.Println(err)
}
}
- Working with Charts:
package main
import (
"fmt"
"github.com/xuri/excelize/v2"
)
func main() {
f := excelize.NewFile()
f.SetCellValue("Sheet1", "A1", 10)
f.SetCellValue("Sheet1", "A2", 20)
f.SetCellValue("Sheet1", "A3", 30)
if err := f.AddChart("Sheet1", "B1", `{
"type": "col3DClustered",
"series": [
{
"name": "Sheet1!$A$1",
"categories": "Sheet1!$A$2:$A$4",
"values": "Sheet1!$A$1:$A$3"
}
],
"title":
Competitor Comparisons
Go language library for reading and writing Microsoft Excel™ (XLAM / XLSM / XLSX / XLTM / XLTX) spreadsheets
Pros of Excelize
- More comprehensive documentation and examples
- Wider range of supported Excel features and functions
- Larger community and more frequent updates
Cons of Excelize
- Slightly higher memory usage for large spreadsheets
- Learning curve may be steeper for beginners
Code Comparison
Excelize:
f := excelize.NewFile()
f.SetCellValue("Sheet1", "A1", "Hello world!")
if err := f.SaveAs("Book1.xlsx"); err != nil {
fmt.Println(err)
}
Excelize>:
f := excelize.NewFile()
f.SetCellValue("Sheet1", "A1", "Hello world!")
if err := f.SaveAs("Book1.xlsx"); err != nil {
fmt.Println(err)
}
The code comparison shows that both libraries have similar syntax and usage for basic operations. However, Excelize offers more advanced features and functions for complex spreadsheet manipulations.
Excelize is generally considered more feature-rich and actively maintained, making it a better choice for most projects. However, Excelize> might be suitable for simpler use cases or projects with specific requirements that align with its feature set.
Convert designs to code with AI
Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.
Try Visual CopilotREADME
Excelize
Introduction
Excelize is a library written in pure Go providing a set of functions that allow you to write to and read from XLAM / XLSM / XLSX / XLTM / XLTX files. Supports reading and writing spreadsheet documents generated by Microsoft Excel™ 2007 and later. Supports complex components by high compatibility, and provided streaming API for generating or reading data from a worksheet with huge amounts of data. This library needs Go version 1.20 or later. There are some incompatible changes in the Go 1.21.0, the Excelize library can not working with that version normally, if you are using the Go 1.21.x, please upgrade to the Go 1.21.1 and later version. The full docs can be seen using go's built-in documentation tool, or online at go.dev and docs reference.
Basic Usage
Installation
go get github.com/xuri/excelize
- If your packages are managed using Go Modules, please install with following command.
go get github.com/xuri/excelize/v2
Create spreadsheet
Here is a minimal example usage that will create spreadsheet file.
package main
import (
"fmt"
"github.com/xuri/excelize/v2"
)
func main() {
f := excelize.NewFile()
defer func() {
if err := f.Close(); err != nil {
fmt.Println(err)
}
}()
// Create a new sheet.
index, err := f.NewSheet("Sheet2")
if err != nil {
fmt.Println(err)
return
}
// Set value of a cell.
f.SetCellValue("Sheet2", "A2", "Hello world.")
f.SetCellValue("Sheet1", "B2", 100)
// Set active sheet of the workbook.
f.SetActiveSheet(index)
// Save spreadsheet by the given path.
if err := f.SaveAs("Book1.xlsx"); err != nil {
fmt.Println(err)
}
}
Reading spreadsheet
The following constitutes the bare to read a spreadsheet document.
package main
import (
"fmt"
"github.com/xuri/excelize/v2"
)
func main() {
f, err := excelize.OpenFile("Book1.xlsx")
if err != nil {
fmt.Println(err)
return
}
defer func() {
// Close the spreadsheet.
if err := f.Close(); err != nil {
fmt.Println(err)
}
}()
// Get value from cell by given worksheet name and cell reference.
cell, err := f.GetCellValue("Sheet1", "B2")
if err != nil {
fmt.Println(err)
return
}
fmt.Println(cell)
// Get all the rows in the Sheet1.
rows, err := f.GetRows("Sheet1")
if err != nil {
fmt.Println(err)
return
}
for _, row := range rows {
for _, colCell := range row {
fmt.Print(colCell, "\t")
}
fmt.Println()
}
}
Add chart to spreadsheet file
With Excelize chart generation and management is as easy as a few lines of code. You can build charts based on data in your worksheet or generate charts without any data in your worksheet at all.
package main
import (
"fmt"
"github.com/xuri/excelize/v2"
)
func main() {
f := excelize.NewFile()
defer func() {
if err := f.Close(); err != nil {
fmt.Println(err)
}
}()
for idx, row := range [][]interface{}{
{nil, "Apple", "Orange", "Pear"}, {"Small", 2, 3, 3},
{"Normal", 5, 2, 4}, {"Large", 6, 7, 8},
} {
cell, err := excelize.CoordinatesToCellName(1, idx+1)
if err != nil {
fmt.Println(err)
return
}
f.SetSheetRow("Sheet1", cell, &row)
}
if err := f.AddChart("Sheet1", "E1", &excelize.Chart{
Type: excelize.Col3DClustered,
Series: []excelize.ChartSeries{
{
Name: "Sheet1!$A$2",
Categories: "Sheet1!$B$1:$D$1",
Values: "Sheet1!$B$2:$D$2",
},
{
Name: "Sheet1!$A$3",
Categories: "Sheet1!$B$1:$D$1",
Values: "Sheet1!$B$3:$D$3",
},
{
Name: "Sheet1!$A$4",
Categories: "Sheet1!$B$1:$D$1",
Values: "Sheet1!$B$4:$D$4",
}},
Title: []excelize.RichTextRun{
{
Text: "Fruit 3D Clustered Column Chart",
},
},
}); err != nil {
fmt.Println(err)
return
}
// Save spreadsheet by the given path.
if err := f.SaveAs("Book1.xlsx"); err != nil {
fmt.Println(err)
}
}
Add picture to spreadsheet file
package main
import (
"fmt"
_ "image/gif"
_ "image/jpeg"
_ "image/png"
"github.com/xuri/excelize/v2"
)
func main() {
f, err := excelize.OpenFile("Book1.xlsx")
if err != nil {
fmt.Println(err)
return
}
defer func() {
// Close the spreadsheet.
if err := f.Close(); err != nil {
fmt.Println(err)
}
}()
// Insert a picture.
if err := f.AddPicture("Sheet1", "A2", "image.png", nil); err != nil {
fmt.Println(err)
}
// Insert a picture to worksheet with scaling.
if err := f.AddPicture("Sheet1", "D2", "image.jpg",
&excelize.GraphicOptions{ScaleX: 0.5, ScaleY: 0.5}); err != nil {
fmt.Println(err)
}
// Insert a picture offset in the cell with printing support.
enable, disable := true, false
if err := f.AddPicture("Sheet1", "H2", "image.gif",
&excelize.GraphicOptions{
PrintObject: &enable,
LockAspectRatio: false,
OffsetX: 15,
OffsetY: 10,
Locked: &disable,
}); err != nil {
fmt.Println(err)
}
// Save the spreadsheet with the origin path.
if err = f.Save(); err != nil {
fmt.Println(err)
}
}
Contributing
Contributions are welcome! Open a pull request to fix a bug, or open an issue to discuss a new feature or change. XML is compliant with part 1 of the 5th edition of the ECMA-376 Standard for Office Open XML.
Licenses
This program is under the terms of the BSD 3-Clause License. See https://opensource.org/licenses/BSD-3-Clause.
The Excel logo is a trademark of Microsoft Corporation. This artwork is an adaptation.
gopher.{ai,svg,png} was created by Takuya Ueda. Licensed under the Creative Commons 3.0 Attributions license.
Top Related Projects
Go language library for reading and writing Microsoft Excel™ (XLAM / XLSM / XLSX / XLTM / XLTX) spreadsheets
Convert designs to code with AI
Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.
Try Visual Copilot