Excelize

https://github.com/xuri/excelize-doc
Admin
Excelize is a library for reading and writing Microsoft Excel™ (XLSX) files with Go, offering...
Tokens:197,993
Snippets:1,084
Trust Score:8.3
License:MIT
Update:1 week ago
Show doc for...
Tokens:
Raw
### Install Excelize with go get

Source: https://github.com/xuri/excelize-doc/blob/master/en/base/installation.md

Installs the Excelize library. The first command installs the legacy version, while the second installs the v2 version for Go Modules users.

```bash
go get github.com/xuri/excelize
```

```bash
go get github.com/xuri/excelize/v2
```

--------------------------------

### SetAppProps usage example

Source: https://github.com/xuri/excelize-doc/blob/master/en/workbook.md

Example of setting application properties, including the application name, security level, company, and version.

```go
err := f.SetAppProps(&excelize.AppProperties{
    Application:       "Microsoft Excel",
    ScaleCrop:         true,
    DocSecurity:       3,
    Company:           "Company Name",
    LinksUpToDate:     true,
    HyperlinksChanged: true,
    AppVersion:        "16.0000",
})
```

--------------------------------

### GetSheetMap usage example

Source: https://github.com/xuri/excelize-doc/blob/master/en/sheet.md

This example opens a workbook, defers closing it, and iterates over the sheet map to print each sheet index and name.

```go
f, err := excelize.OpenFile("Book1.xlsx")
if err != nil {
    return
}
defer func() {
    if err := f.Close(); err != nil {
        fmt.Println(err)
    }
}()
for index, name := range f.GetSheetMap() {
    fmt.Println(index, name)
}
```

--------------------------------

### SetColStyle example

Source: https://github.com/xuri/excelize-doc/blob/master/en/stream.md

Example call to set style of column H. Must be called before SetRow.

```go
err := sw.SetColStyle(8, 8, style)
```

--------------------------------

### GetRowVisible example

Source: https://github.com/xuri/excelize-doc/blob/master/en/sheet.md

This example retrieves the visibility of row 2 in Sheet1.

```go
visible, err := f.GetRowVisible("Sheet1", 2)
```

--------------------------------

### Add grouped sparkline example

Source: https://github.com/xuri/excelize-doc/blob/master/en/sparklines.md

Example of adding a grouped sparkline to three locations with markers enabled. Changes apply to all three sparklines.

```go
err := f.AddSparkline("Sheet1", &excelize.SparklineOptions{
    Location: []string{"A1", "A2", "A3"},
    Range:    []string{"Sheet2!A1:J1", "Sheet2!A2:J2", "Sheet2!A3:J3"},
    Markers:  true,
})
```

--------------------------------

### Set document properties example with all fields

Source: https://github.com/xuri/excelize-doc/blob/master/en/workbook.md

Example of setting document core properties with all available fields. The Created and Modified fields must be in ISO 8601 UTC format. The Revision and Version fields are set by the user or application.

```go
err := f.SetDocProps(&excelize.DocProperties{
    Category:       "category",
    ContentStatus:  "Draft",
    Created:        "2019-06-04T22:00:10Z",
    Creator:        "Go Excelize",
    Description:    "This file created by Go Excelize",
    Identifier:     "xlsx",
    Keywords:       "Spreadsheet",
    LastModifiedBy: "Go Author",
    Modified:       "2019-06-04T22:00:10Z",
    Revision:       "0",
    Subject:        "Test Subject",
    Title:          "Test Title",
    Language:       "en-US",
    Version:        "1.0.0",
})
```

--------------------------------

### GetCols usage example

Source: https://github.com/xuri/excelize-doc/blob/master/en/cell.md

Example that gets and traverses all cell values by columns on a worksheet named 'Sheet1'. It prints each cell value followed by a tab, and prints a newline after each column.

```go
cols, err := f.GetCols("Sheet1")
if err != nil {
    fmt.Println(err)
    return
}
for _, col := range cols {
    for _, rowCell := range col {
        fmt.Print(rowCell, "\t")
    }
    fmt.Println()
}
```

--------------------------------

### Example: Using GetBaseColor and ThemeColor to read cell rich text colors

Source: https://github.com/xuri/excelize-doc/blob/master/en/utils.md

Complete Go example that opens a workbook, reads rich text from a cell, and prints each run's text and computed hex color. It uses GetBaseColor to resolve the base color and ThemeColor to apply the tint, then trims the 'FF' prefix from the result.

```go
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() {
        if err := f.Close(); err != nil {
            fmt.Println(err)
        }
    }()
    runs, err := f.GetCellRichText("Sheet1", "A1")
    if err != nil {
        fmt.Println(err)
        return
    }
    for _, run := range runs {
        var hexColor string
        if run.Font != nil {
            baseColor := f.GetBaseColor(run.Font.Color, run.Font.ColorIndexed, run.Font.ColorTheme)
            hexColor = strings.TrimPrefix(excelize.ThemeColor(baseColor, run.Font.ColorTint), "FF")
        }
        fmt.Printf("text: %s, color: %s\r\n", run.Text, hexColor)
    }
}
```

--------------------------------

### AddVBAProject usage example

Source: https://github.com/xuri/excelize-doc/blob/master/en/utils.md

Example of setting a sheet code name, reading a vbaProject.bin file, adding it to the workbook, and saving as macros.xlsm. Requires the file extension to be .xlsm or .xltm.

```go
codeName := "Sheet1"
if err := f.SetSheetProps("Sheet1", &excelize.SheetPropsOptions{
    CodeName: &codeName,
}); err != nil {
    fmt.Println(err)
    return
}
file, err := os.ReadFile("vbaProject.bin")
if err != nil {
    fmt.Println(err)
    return
}
if err := f.AddVBAProject(file); err != nil {
    fmt.Println(err)
    return
}
if err := f.SaveAs("macros.xlsm"); err != nil {
    fmt.Println(err)
    return
}
```

--------------------------------

### SplitCellName example

Source: https://github.com/xuri/excelize-doc/blob/master/en/utils.md

Example call to SplitCellName with "AK74", returning "AK", 74, and nil.

```go
excelize.SplitCellName("AK74") // return "AK", 74, nil
```

--------------------------------

### GetRowHeight example

Source: https://github.com/xuri/excelize-doc/blob/master/en/sheet.md

This example retrieves the height of the first row in Sheet1.

```go
height, err := f.GetRowHeight("Sheet1", 1)
```

--------------------------------

### Filter expression examples

Source: https://github.com/xuri/excelize-doc/blob/master/en/utils.md

Shows example expressions using comparison operators and the and/or operators.

```text
x <  2000
x >  2000
x == 2000
x >  2000 and x <  5000
x == 2000 or  x == 5000
```

--------------------------------

### SetColOutlineLevel example

Source: https://github.com/xuri/excelize-doc/blob/master/en/stream.md

Example call to set outline level of column D to 2. Must be called before SetRow.

```go
err := sw.SetColOutlineLevel(4, 2)
```

--------------------------------

### AddTable example: simple table

Source: https://github.com/xuri/excelize-doc/blob/master/en/utils.md

Creates a table of A1:D5 on Sheet1 without format settings.

```go
err := f.AddTable("Sheet1", &excelize.Table{Range: "A1:D5"})
```

--------------------------------

### ColumnNameToNumber example

Source: https://github.com/xuri/excelize-doc/blob/master/en/utils.md

Example call to ColumnNameToNumber with "AK", returning 37 and nil.

```go
excelize.ColumnNameToNumber("AK") // returns 37, nil
```

--------------------------------

### AddTable example: table with format set

Source: https://github.com/xuri/excelize-doc/blob/master/en/utils.md

Creates a table of F2:H6 on Sheet2 with a name, style, and display options. Note that the table must be at least two lines including the header, header cells must contain unique strings, and multiple tables cannot intersect.

```go
disable := false
err := f.AddTable("Sheet2", &excelize.Table{
    Range:             "F2:H6",
    Name:              "table",
    StyleName:         "TableStyleMedium2",
    ShowFirstColumn:   true,
    ShowLastColumn:    true,
    ShowRowStripes:    &disable,
    ShowColumnStripes: true,
})
```

--------------------------------

### SetCellFormula example 7: table formula

Source: https://github.com/xuri/excelize-doc/blob/master/en/cell.md

Complete example that creates a workbook, adds a table, and sets a table formula =SUM(Table1[[A]:[B]]) for cell C2 on Sheet1, then saves as Book1.xlsx.

```go
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{}{{"A", "B", "C"}, {1, 2}} {
        if err := f.SetSheetRow("Sheet1", fmt.Sprintf("A%d", idx+1), &row); err != nil {
            fmt.Println(err)
            return
        }
    }
    if err := f.AddTable("Sheet1",
        &excelize.Table{
            Range:     "A1:C2",
            Name:      "Table1",
            StyleName: "TableStyleMedium2",
        }); err != nil {
        fmt.Println(err)
        return
    }
    formulaType := excelize.STCellFormulaTypeDataTable
    if err := f.SetCellFormula("Sheet1", "C2", "SUM(Table1[[A]:[B]])",
        excelize.FormulaOpts{Type: &formulaType}); err != nil {
        fmt.Println(err)
        return
    }
    if err := f.SaveAs("Book1.xlsx"); err != nil {
        fmt.Println(err)
    }
}
```

--------------------------------

### SetConditionalFormat example with cell type

Source: https://github.com/xuri/excelize-doc/blob/master/en/utils.md

Example call to SetConditionalFormat using the cell type with a symbolic criteria '>' and a numeric value. The Value property can also be a cell reference.

```go
err := f.SetConditionalFormat("Sheet1", "D1:D10",
    []excelize.ConditionalFormatOptions{
        {
            Type:     "cell",
            Criteria: ">",
            Format:   &format,
            Value:    "6",
        },
    },
)
```

--------------------------------

### SetPanes example: unfreeze and remove all panes

Source: https://github.com/xuri/excelize-doc/blob/master/en/utils.md

Unfreezes and removes all panes on Sheet1 by setting Freeze: false and Split: false.

```go
err := f.SetPanes("Sheet1", &excelize.Panes{Freeze: false, Split: false})
```

--------------------------------

### Create conditional style and apply cell format

Source: https://github.com/xuri/excelize-doc/blob/master/en/utils.md

Creates a conditional style with NewConditionalStyle and applies it to a cell-based conditional format. The style uses a dark red font and light red fill. The example shows error handling with fmt.Println.

```go
format, err := f.NewConditionalStyle(
    &excelize.Style{
        Font: &excelize.Font{Color: "9A0511"},
        Fill: excelize.Fill{
            Type: "pattern", Color: []string{"FEC7CE"}, Pattern: 1,
        },
    },
)
if err != nil {
    fmt.Println(err)
}
err = f.SetConditionalFormat("Sheet1", "D1:D10",
    []excelize.ConditionalFormatOptions{
        {Type: "cell", Criteria: ">", Format: &format, Value: "6"},
    },
)
```

--------------------------------

### SetPanes example: create split panes

Source: https://github.com/xuri/excelize-doc/blob/master/en/utils.md

Creates split panes in Sheet1 and sets the active cell on Sheet1!J60. Uses Split: true, XSplit: 3270, YSplit: 1800, TopLeftCell: "N57", ActivePane: "bottomLeft", and multiple selections.

```go
err := f.SetPanes("Sheet1", &excelize.Panes{
    Split:       true,
    XSplit:      3270,
    YSplit:      1800,
    TopLeftCell: "N57",
    ActivePane:  "bottomLeft",
    Selection: []excelize.Selection{
        {SQRef: "I36", ActiveCell: "I36"},
        {SQRef: "G33", ActiveCell: "G33", Pane: "topRight"},
        {SQRef: "J60", ActiveCell: "J60", Pane: "bottomLeft"},
        {SQRef: "O60", ActiveCell: "O60", Pane: "bottomRight"},
    },
})
```

--------------------------------

### Filter data in an auto filter

Source: https://github.com/xuri/excelize-doc/blob/master/en/utils.md

Example 2: applies an auto filter with a filter condition on column B to exclude blank cells.

```go
err := f.AutoFilter("Sheet1", "A1:D4", []excelize.AutoFilterOptions{
    {Column: "B", Expression: "x != blanks"},
})
```

--------------------------------

### SetPanes example: freeze column A

Source: https://github.com/xuri/excelize-doc/blob/master/en/utils.md

Freezes column A in Sheet1 and sets the active cell to Sheet1!K16. Uses Freeze: true, XSplit: 1, TopLeftCell: "B1", ActivePane: "topRight", and a selection with SQRef "K16".

```go
err := f.SetPanes("Sheet1", &excelize.Panes{
    Freeze:      true,
    XSplit:      1,
    TopLeftCell: "B1",
    ActivePane:  "topRight",
    Selection: []excelize.Selection{
        {SQRef: "K16", ActiveCell: "K16", Pane: "topRight"},
    },
})
```

--------------------------------

### GetCellHyperLink usage example

Source: https://github.com/xuri/excelize-doc/blob/master/en/cell.md

Example of getting a hyperlink from cell H6 on worksheet 'Sheet1'.

```go
link, target, err := f.GetCellHyperLink("Sheet1", "H6")
```

--------------------------------

### Create Excel document with Excelize

Source: https://github.com/xuri/excelize-doc/blob/master/en/base/installation.md

Minimal Go example that creates a new spreadsheet, adds a sheet, sets cell values, sets the active sheet, and saves the file as Book1.xlsx.

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

--------------------------------

### GetMergeCells usage example

Source: https://github.com/xuri/excelize-doc/blob/master/en/cell.md

Gets all merged cells on Sheet1.

```go
mergeCells, err := f.GetMergeCells("Sheet1")
```

--------------------------------

### GetColOutlineLevel usage example

Source: https://github.com/xuri/excelize-doc/blob/master/en/sheet.md

Gets the outline level of column D in Sheet1.

```go
level, err := f.GetColOutlineLevel("Sheet1", "D")
```

--------------------------------

### SetPanes example: freeze rows 1 to 9

Source: https://github.com/xuri/excelize-doc/blob/master/en/utils.md

Freezes rows 1 to 9 in Sheet1 and sets the active cell ranges on Sheet1!A11:XFD11. Uses Freeze: true, YSplit: 9, TopLeftCell: "A34", ActivePane: "bottomLeft", and a selection with SQRef "A11:XFD11".

```go
err := f.SetPanes("Sheet1", &excelize.Panes{
    Freeze:      true,
    YSplit:      9,
    TopLeftCell: "A34",
    ActivePane:  "bottomLeft",
    Selection: []excelize.Selection{
        {SQRef: "A11:XFD11", ActiveCell: "A11", Pane: "bottomLeft"},
    },
})
```

--------------------------------

### InsertRows function and example

Source: https://github.com/xuri/excelize-doc/blob/master/en/sheet.md

Inserts new rows after the specified row number (starting from 1). Example inserts 2 rows before row 3 in Sheet1.

```go
func (f *File) InsertRows(sheet string, row, n int) error
```

```go
err := f.InsertRows("Sheet1", 3, 2)
```

--------------------------------

### AddTable example 1: create table A1:D5

Source: https://github.com/xuri/excelize-doc/blob/master/en/stream.md

Creates a table with range A1:D5 using default settings.

```go
err := sw.AddTable(&excelize.Table{Range: "A1:D5"})
```

--------------------------------

### GetRowOutlineLevel usage example

Source: https://github.com/xuri/excelize-doc/blob/master/en/sheet.md

Gets the outline level of row 2 in Sheet1.

```go
level, err := f.GetRowOutlineLevel("Sheet1", 2)
```

--------------------------------

### HTTP server example using OpenReader

Source: https://github.com/xuri/excelize-doc/blob/master/en/workbook.md

Complete Go program that handles file upload, opens it with OpenReader, adds a new worksheet, and sends the modified file as a download. The server listens on port 8090 and the endpoint is /process.

```go
package main

import (
    "fmt"
    "net/http"

    "github.com/xuri/excelize/v2"
)

func process(w http.ResponseWriter, req *http.Request) {
    file, _, err := req.FormFile("file")
    if err != nil {
        fmt.Fprint(w, err.Error())
        return
    }
    defer file.Close()
    f, err := excelize.OpenReader(file)
    if err != nil {
        fmt.Fprint(w, err.Error())
        return
    }
    f.Path = "Book1.xlsx"
    f.NewSheet("NewSheet")
    w.Header().Set("Content-Disposition", fmt.Sprintf("attachment; filename=%s", f.Path))
    w.Header().Set("Content-Type", req.Header.Get("Content-Type"))
    if err := f.Write(w); err != nil {
        fmt.Fprint(w, err.Error())
    }
}

func main() {
    http.HandleFunc("/process", process)
    http.ListenAndServe(":8090", nil)
}
```

--------------------------------

### SetSheetRow: Write array to row in Excelize

Source: https://github.com/xuri/excelize-doc/blob/master/en/sheet.md

Writes an array to a row starting at a specified cell. The function is concurrency safe. The example writes to row 6 starting at B6 on Sheet1.

```go
func (f *File) SetSheetRow(sheet, cell string, slice interface{}) error
```

```go
err := f.SetSheetRow("Sheet1", "B6", &[]interface{}{"1", nil, 2})
```

--------------------------------

### Write array to column B starting at B6

Source: https://github.com/xuri/excelize-doc/blob/master/en/sheet.md

Example call that writes an array to column B starting at cell B6 on "Sheet1". The slice includes a nil value to leave a cell empty.

```go
err := f.SetSheetCol("Sheet1", "B6", &[]interface{}{"1", nil, 2})
```

--------------------------------

### Create a line chart with Excelize in Go

Source: https://github.com/xuri/excelize-doc/blob/master/en/chart/line.md

This example creates a new Excel file, populates a worksheet with fruit sales data, and adds a line chart with three series. It sets smooth lines, chart title, legend position, plot area options, and handles blank cells as zero. The workbook is saved as Book1.xlsx.

```go
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
        }
        if err := f.SetSheetRow("Sheet1", cell, &row); err != nil {
            fmt.Println(err)
            return
        }
    }
    if err := f.AddChart("Sheet1", "E1", &excelize.Chart{
        Type: excelize.Line,
        Series: []excelize.ChartSeries{
            {
                Name:       "Sheet1!$A$2",
                Categories: "Sheet1!$B$1:$D$1",
                Values:     "Sheet1!$B$2:$D$2",
                Line: excelize.LineOptions{
                    Smooth: true,
                },
            },
            {
                Name:       "Sheet1!$A$3",
                Categories: "Sheet1!$B$1:$D$1",
                Values:     "Sheet1!$B$3:$D$3",
                Line: excelize.LineOptions{
                    Smooth: true,
                },
            },
            {
                Name:       "Sheet1!$A$4",
                Categories: "Sheet1!$B$1:$D$1",
                Values:     "Sheet1!$B$4:$D$4",
                Line: excelize.LineOptions{
                    Smooth: true,
                },
            },
        },
        Format: excelize.GraphicOptions{
            OffsetX: 15,
            OffsetY: 10,
        },
        Legend: excelize.ChartLegend{
            Position: "top",
        },
        Title: excelize.ChartTitle{
            Paragraph: []excelize.RichTextRun{
                {
                    Text: "Fruit Line Chart",
                },
            },
        },
        PlotArea: excelize.ChartPlotArea{
            ShowCatName:     false,
            ShowLeaderLines: false,
            ShowPercent:     true,
            ShowSerName:     true,
            ShowVal:         true,
        },
        ShowBlanksAs: "zero",
    }); err != nil {
        fmt.Println(err)
        return
    }
    // Save workbook
    if err := f.SaveAs("Book1.xlsx"); err != nil {
        fmt.Println(err)
    }
}
```

--------------------------------

### GetMergeCells without values usage example

Source: https://github.com/xuri/excelize-doc/blob/master/en/cell.md

Gets merged cells on Sheet1 without cell values, only range references.

```go
mergeCells, err := f.GetMergeCells("Sheet1", true)
```

--------------------------------

### AddPicture usage example with GraphicOptions

Source: https://github.com/xuri/excelize-doc/blob/master/en/image.md

Complete example that adds three pictures to a worksheet using AddPicture: a simple one, one with scaling and a location hyperlink, and one with offset, external hyperlink, print/lock options, and oneCell positioning. Demonstrates the optional parameters: AltText, PrintObject (default true), Locked (no effect unless sheet protected), LockAspectRatio (default false), AutoFit (default false), OffsetX/OffsetY (default 0), ScaleX/ScaleY (must be >0, two decimal places precision, default 1.0), Hyperlink, HyperlinkType (External or Location, Location starts with #), and Positioning (oneCell, twoCell, absolute).

```go
package main

import (
    "fmt"
    _ "image/gif"
    _ "image/jpeg"
    _ "image/png"

    "github.com/xuri/excelize/v2"
)

func main() {
    f := excelize.NewFile()
    defer func() {
        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)
        return
    }
    // Insert a picture scaling in the cell with location hyperlink.
    enable, disable := true, false
    if err := f.AddPicture("Sheet1", "D2", "image.jpg",
        &excelize.GraphicOptions{
            ScaleX:        0.5,
            ScaleY:        0.5,
            Hyperlink:     "#Sheet2!D8",
            HyperlinkType: "Location",
        },
    ); err != nil {
        fmt.Println(err)
        return
    }
    // Insert a picture offset in the cell with external hyperlink, printing and positioning support.
    if err := f.AddPicture("Sheet1", "H2", "image.gif",
        &excelize.GraphicOptions{
            OffsetX:         15,
            OffsetY:         10,
            Hyperlink:       "https://github.com/xuri/excelize",
            HyperlinkType:   "External",
            PrintObject:     &enable,
            LockAspectRatio: false,
            Locked:          &disable,
            Positioning:     "oneCell",
        },
    ); err != nil {
        fmt.Println(err)
        return
    }
    if err := f.SaveAs("Book1.xlsx"); err != nil {
        fmt.Println(err)
    }
}
```

--------------------------------

### Create Volume-High-Low-Close stock chart with excelize in Go

Source: https://github.com/xuri/excelize-doc/blob/master/en/chart/stockVolumeHighLowClose.md

This example creates a new Excel file, fills a worksheet with stock data, and adds a combined chart: a column chart for volume and a High-Low-Close stock chart. It uses excelize.Chart with Type excelize.Col and excelize.StockHighLowClose, sets custom number formats for axes, and saves the workbook as Book1.xlsx.

```go
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{}{
        {"Date", "Volume", "High", "Low", "Close"},
        {45593, 14864000, 431.94, 426.3, 426.59},
        {45590, 16899100, 432.52, 426.57, 428.15},
        {45589, 13581600, 425.98, 422.4, 424.73},
        {45588, 19654400, 431.08, 422.53, 424.6},
        {45587, 25482200, 430.58, 418.04, 427.51},
        {45586, 14206100, 418.96, 413.75, 418.78},
        {45583, 17145300, 419.65, 416.26, 418.16},
        {45582, 14820000, 422.5, 415.59, 416.72},
        {45581, 15508900, 416.36, 410.48, 416.12},
        {45580, 18900200, 422.48, 415.26, 418.74},
        {45579, 16653100, 424.04, 417.52, 419.14},
        {45576, 14144900, 417.13, 413.25, 416.32},
        {45575, 13848400, 417.35, 413.15, 415.84},
        {45574, 14974300, 420.38, 414.3, 417.46},
        {45573, 19229300, 415.66, 408.17, 414.71},
        {45572, 20919800, 417.11, 409, 409.54},
        {45569, 19169700, 419.75, 414.97, 416.06},
        {45568, 13686400, 419.55, 414.29, 416.54},
        {45567, 16582300, 422.82, 416.71, 417.13},
        {45566, 19092900, 428.48, 418.81, 420.69},
        {45565, 16807300, 430.42, 425.37, 430.3},
    } {
        cell, err := excelize.CoordinatesToCellName(1, idx+1)
        if err != nil {
            fmt.Println(err)
            return
        }
        if err := f.SetSheetRow("Sheet1", cell, &row); err != nil {
            fmt.Println(err)
            return
        }
    }
    if err := f.AddChart("Sheet1", "F1", &excelize.Chart{
        Type: excelize.Col,
        Series: []excelize.ChartSeries{
            {
                Name:       "Sheet1!$B$1",
                Categories: "Sheet1!$A$2:$A$22",
                Values:     "Sheet1!$B$2:$B$22",
            },
        },
        XAxis: excelize.ChartAxis{
            NumFmt: excelize.ChartNumFmt{CustomNumFmt: "d-mmm-yy"},
        },
        YAxis: excelize.ChartAxis{
            NumFmt: excelize.ChartNumFmt{CustomNumFmt: "#,##0"},
        },
        Title: excelize.ChartTitle{
            Paragraph: []excelize.RichTextRun{
                {
                    Text: "Volume-High-Low-Close Stock Chart",
                },
            },
        },
    }, &excelize.Chart{
        Type: excelize.StockHighLowClose,
        Series: []excelize.ChartSeries{
            {
                Name:       "Sheet1!$C$1",
                Categories: "Sheet1!$A$2:$A$22",
                Values:     "Sheet1!$C$2:$C$22",
            },
            {
                Name:       "Sheet1!$D$1",
                Categories: "Sheet1!$A$2:$A$22",
                Values:     "Sheet1!$D$2:$D$22",
            },
            {
                Name:       "Sheet1!$E$1",
                Categories: "Sheet1!$A$2:$A$22",
                Values:     "Sheet1!$E$2:$E$22",
            },
        },
        YAxis: excelize.ChartAxis{Secondary: true},
    }); err != nil {
        fmt.Println(err)
        return
    }
    // Save workbook
    if err := f.SaveAs("Book1.xlsx"); err != nil {
        fmt.Println(err)
    }
}
```

--------------------------------

### Create a pie chart with excelize in Go

Source: https://github.com/xuri/excelize-doc/blob/master/en/chart/pie.md

This example creates a new Excel file, writes a header row and a data row, and adds a pie chart to the sheet. The chart uses the Pie type, sets the series name to 'Amount', categories to 'Sheet1!$A$1:$C$1', and values to 'Sheet1!$A$2:$C$2'. It also sets the chart title to 'Fruit Pie Chart' and enables percentage display on the plot area. The workbook is saved as 'Book1.xlsx'.

```go
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{}{
        {"Apple", "Orange", "Pear"},
        {2, 3, 3},
    } {
        cell, err := excelize.CoordinatesToCellName(1, idx+1)
        if err != nil {
            fmt.Println(err)
            return
        }
        if err := f.SetSheetRow("Sheet1", cell, &row); err != nil {
            fmt.Println(err)
            return
        }
    }
    if err := f.AddChart("Sheet1", "E1", &excelize.Chart{
        Type: excelize.Pie,
        Series: []excelize.ChartSeries{
            {
                Name:       "Amount",
                Categories: "Sheet1!$A$1:$C$1",
                Values:     "Sheet1!$A$2:$C$2",
            },
        },
        Format: excelize.GraphicOptions{
            OffsetX: 15,
            OffsetY: 10,
        },
        Title: excelize.ChartTitle{
            Paragraph: []excelize.RichTextRun{
                {
                    Text: "Fruit Pie Chart",
                },
            },
        },
        PlotArea: excelize.ChartPlotArea{
            ShowPercent: true,
        },
    }); err != nil {
        fmt.Println(err)
        return
    }
    // Save workbook
    if err := f.SaveAs("Book1.xlsx"); err != nil {
        fmt.Println(err)
    }
}
```
Tokens:
Raw