Arbeitsmappe

Options definiert die Optionen zum Lesen und Schreiben von Tabellenkalkulationen.

type Options struct {
    MaxCalcIterations uint
    Password          string
    RawCellValue      bool
    UnzipSizeLimit    int64
    UnzipXMLSizeLimit int64
    ShortDatePattern  string
    LongDatePattern   string
    LongTimePattern   string
    CultureInfo       CultureName
}

MaxCalcIterations gibt die maximalen Iterationen für die iterative Berechnung an, der Standardwert ist 0.

Password gibt das Passwort der Tabellenkalkulation im Klartext an.

RawCellValue gibt an, ob das Zahlenformat für den Zellenwert angewendet oder der Rohwert abgerufen wird.

UnzipSizeLimit gibt die Entpack-Größenbeschränkung in Bytes beim Öffnen der Tabelle an. Dieser Wert sollte größer oder gleich UnzipXMLSizeLimit sein, die Standardgrößenbeschränkung beträgt 16GB.

UnzipXMLSizeLimit gibt das Speicherlimit beim Entpacken des Arbeitsblatts und der freigegebenen Stringtabelle in Bytes an. Arbeitsblatt-XML wird in das temporäre Systemverzeichnis extrahiert, wenn die Dateigröße diesen Wert überschreitet. Dieser Wert sollte kleiner oder gleich UnzipSizeLimit sein, der Standardeinstellung Wert ist 16MB.

ShortDatePattern gibt den Formatcode für kurze Datumszahlen an. In den Tabellenkalkulationsanwendungen zeigen Datumsformate Datums- und Uhrzeitseriennummern als Datumswerte an. Datumsformate, die mit einem Sternchen (*) beginnen, reagieren auf Änderungen der regionalen Datums- und Uhrzeiteinstellungen, die für das Betriebssystem angegeben sind. Formate ohne Sternchen werden von den Betriebssystemeinstellungen nicht beeinflusst. Das ShortDatePattern, das für verwendet wird, gibt Datumsformate an, die mit einem Sternchen beginnen.

LongDatePattern gibt den Formatcode für lange Datumszahlen an.

LongTimePattern gibt den Formatcode für Langzeitzahlen an.

CultureInfo gibt den Ländercode für die Anwendung des integrierten Zahlenformatcodes in der Sprache an, der sich auf die lokalen Spracheinstellungen des Systems auswirkt.

Erstellen einer Kalkulationstabelle

func NewFile(opts ...Options) *File

NewFile bietet eine Funktion zum Erstellen einer neuen Datei als Standardvorlage. Die neu erstellte Arbeitsmappe enthält standardmäßig ein Arbeitsblatt mit dem Namen Sheet1. Zum Beispiel:

Öffnen

func OpenFile(filename string, opts ...Options) (*File, error)

OpenFile nimmt den Namen einer Tabellenkalkulationsdatei an und gibt dafür eine aufgefüllte Tabellenkalkulationsdateistruktur zurück. Öffnen Sie beispielsweise eine Kalkulationstabelle mit Kennwortschutz:

f, err := excelize.OpenFile("Book1.xlsx", excelize.Options{Password: "password"})
if err != nil {
    return
}

Schließen Sie die Datei von Close(), nachdem Sie die Tabelle geöffnet haben.

Offener Datenstrom

func OpenReader(r io.Reader, opts ...Options) (*File, error)

OpenReader liest Datenstrom von io.Reader und gibt eine gefüllte Tabellenkalkulationsdatei zurück.

Erstellen Sie beispielsweise http-Server, um die Upload-Vorlage zu verarbeiten, und senden Sie dann eine Antwortdownloaddatei mit einem neuen Arbeitsblatt:

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

Test mit cURL:

curl --location --request GET 'http://127.0.0.1:8090/process' \
--form 'file=@/tmp/template.xltx' -O -J

Speichern

func (f *File) Save(opts ...Options) error

Save bietet eine Funktion zum Überschreiben der Tabellenkalkulationsdatei mit dem Ursprungspfad.

Speichern als

func (f *File) SaveAs(name string, opts ...Options) error

SaveAs bietet eine Funktion zum Erstellen oder Aktualisieren einer Tabellenkalkulationsdatei unter dem angegebenen Pfad.

Arbeitsmappe schließen

func (f *File) Close() error

Close schließt und bereinigt die geöffnete temporäre Datei für die Kalkulationstabelle.

Arbeitsblatt erstellen

func (f *File) NewSheet(sheet string) (int, error)

NewSheet bietet die Funktion zum Erstellen eines neuen Blatts, indem ein Arbeitsblattname angegeben wird, und gibt den Index der Blätter in der Arbeitsmappe (Spreadsheet) zurück, nachdem es angehängt wurde. Beachten Sie, dass beim Erstellen einer neuen Tabellenkalkulationsdatei das Standardarbeitsblatt mit dem Namen Sheet1 erstellt wird.

Arbeitsblatt löschen

func (f *File) DeleteSheet(sheet string) error

DeleteSheet bietet eine Funktion zum Löschen von Arbeitsblättern in einer Arbeitsmappe nach dem angegebenen Arbeitsblattnamen, bei den Blattnamen wird nicht zwischen Groß- und Kleinschreibung unterschieden. Verwenden Sie diese Methode mit Vorsicht, da sie sich auf Änderungen in Referenzen wie Formeln, Diagrammen usw. auswirkt. Wenn es einen referenzierten Wert des gelöschten Arbeitsblatts gibt, führt dies zu einem Dateifehler, wenn Sie es öffnen. Diese Funktion ist ungültig, wenn nur noch ein Arbeitsblatt übrig ist.

Arbeitsblatt kopieren

func (f *File) CopySheet(from, to int) error

CopySheet bietet eine Funktion zum Duplizieren eines Arbeitsblatts nach dem gegebenen Quell- und Zielarbeitsblattindex. Beachten Sie, dass derzeit keine doppelten Arbeitsmappen unterstützt werden, die Tabellen, Diagramme oder Bilder enthalten. Zum Beispiel:

// Sheet1 ist bereits vorhanden...
index, err := f.NewSheet("Sheet2")
if err != nil {
    fmt.Println(err)
    return
}
err := f.CopySheet(1, index)

Gruppenarbeitsblätter

func (f *File) GroupSheets(sheets []string) error

GroupSheets bietet eine Funktion zum Gruppieren von Arbeitsblättern nach bestimmten Arbeitsblattnamen. Gruppenarbeitsblätter müssen ein aktives Arbeitsblatt enthalten.

Gruppierung von Arbeitsblättern aufheben

func (f *File) UngroupSheets() error

UngroupSheets bietet eine Funktion zum Aufheben der Gruppierung von Arbeitsblättern.

Festlegen des Arbeitsblatthintergrunds

func (f *File) SetSheetBackground(sheet, picture string) error

SetSheetBackground bietet eine Funktion zum Festlegen eines Hintergrundbilds anhand des angegebenen Arbeitsblattnamens und Dateipfads. Unterstützte Bildtypen: BMP, EMF, EMZ, GIF, JPEG, JPG, PNG, SVG, TIF, TIFF, WMF und WMZ.

func (f *File) SetSheetBackgroundFromBytes(sheet, extension string, picture []byte) error

SetSheetBackgroundFromBytes bietet eine Funktion zum Festlegen des Hintergrundbilds anhand des angegebenen Arbeitsblattnamens, Erweiterungsnamens und der Bilddaten. Unterstützte Bildtypen: BMP, EMF, EMZ, GIF, JPEG, JPG, PNG, SVG, TIF, TIFF, WMF und WMZ.

Festlegen eines Standardarbeitsblatts

func (f *File) SetActiveSheet(index int)

SetActiveSheet bietet eine Funktion zum Festlegen des aktiven Standardblatts der Arbeitsmappe durch einen bestimmten Index. Beachten Sie, dass sich der aktive Index von der ID unterscheidet, die von der Funktion GetSheetMap zurückgegeben wird. Sie sollte größer oder gleich 0 und kleiner als die Gesamten der Arbeitsblattnummern sein.

Aktives Blattindex abrufen

func (f *File) GetActiveSheetIndex() int

GetActiveSheetIndex bietet eine Funktion zum Abrufen eines aktiven Arbeitsblatts der Arbeitsmappe. Wenn das aktive Blatt nicht gefunden wurde, wird die ganze Zahl 0 zurückgegeben.

Set-Arbeitsblatt sichtbar

func (f *File) SetSheetVisible(sheet string, visible bool, veryHidden ...bool) error

SetSheetVisible bietet eine Funktion zum Festlegen eines Arbeitsblatts, das durch den angegebenen Arbeitsblattnamen sichtbar ist. Eine Arbeitsmappe muss mindestens ein sichtbares Arbeitsblatt enthalten. Wenn das angegebene Arbeitsblatt aktiviert wurde, wird diese Einstellung ungültig. Der dritte optionale veryHidden-Parameter funktioniert nur, wenn visible false war.

Geben Sie beispielsweise Sheet1 aus:

err := f.SetSheetVisible("Sheet1", false)

Arbeitsblatt sichtbar machen

func (f *File) GetSheetVisible(sheet string) (bool, error)

GetSheetVisible bietet eine Funktion, mit der das Arbeitsblatt unter dem angegebenen Arbeitsblattnamen sichtbar gemacht wird. Erhalten Sie beispielsweise den sichtbaren Status von Sheet1:

visible, err := f.GetSheetVisible("Sheet1")

Festlegen von Blatteigenschaften

func (f *File) SetSheetProps(sheet string, opts *SheetPropsOptions) error

SetSheetProps bietet eine Funktion zum Festlegen von Arbeitsblatteigenschaften. Die Eigenschaften, die festgelegt werden können, sind:

Legen Sie beispielsweise fest, dass Arbeitsblattzeilen standardmäßig ausgeblendet sind:

f, enable := excelize.NewFile(), true
if err := f.SetSheetProps("Sheet1", &excelize.SheetPropsOptions{
    ZeroHeight: &enable,
}); err != nil {
    fmt.Println(err)
}
if err := f.SetRowVisible("Sheet1", 10, true); err != nil {
    fmt.Println(err)
}
f.SaveAs("Book1.xlsx")

Abrufen von Blatteigenschaften

func (f *File) GetSheetProps(sheet string) (SheetPropsOptions, error)

GetSheetProps bietet eine Funktion zum Abrufen von Arbeitsblatteigenschaften. Die Eigenschaften, die festgelegt werden können, sind:

Festlegen von Arbeitsblattansichtseigenschaften

func (f *File) SetSheetView(sheet string, viewIndex int, opts *ViewOptions) error

SetSheetView legt die Blattansichtseigenschaften fest. Der viewIndex darf negativ sein und wird dann rückwärts gezählt (-1 ist der letzte View).

Abrufen von Arbeitsblattansichtseigenschaften

func (f *File) GetSheetView(sheet string, viewIndex int) (ViewOptions, error)

GetSheetView ruft den Wert der Blattansichtseigenschaften ab. Der viewIndex darf negativ sein und wird dann rückwärts gezählt (-1 ist der letzte View).

Festlegen des Layouts der Arbeitsblattseite

func (f *File) SetPageLayout(sheet string, opts *PageLayoutOptions) error

SetPageLayout bietet eine Funktion zum Festlegen des Seitenlayouts von Arbeitsblättern. Verfügbare Optionen:

Size gibt die Papiergröße des Arbeitsblatts an, die Standardpapiergröße des Arbeitsblatts ist "Briefpapier (8,5 Zoll x 11 Zoll)". Das Folgende zeigt die Papiergröße, sortiert nach der Excelize-Indexnummer:

Orientation gibt die Arbeitsblattausrichtung an, die Standardausrichtung ist portrait. Die möglichen Werte für dieses Feld sind portrait und landscape.

FirstPageNumber gibt die erste gedruckte Seitenzahl an. Wenn kein Wert angegeben ist, wird "automatisch" angenommen.

AdjustTo spezifiziert die Druckskalierung. Dieses Attribut ist auf Werte zwischen 10 (10 %) und 400 (400 %) beschränkt. Diese Einstellung wird außer Kraft gesetzt, wenn FitToWidth und/oder FitToHeight verwendet werden.

FitToHeight gibt die Anzahl der vertikalen Seiten an, auf die angepasst werden soll.

FitToWidth gibt die Anzahl der horizontalen Seiten an, die angepasst werden sollen.

BlackAndWhite spezifiziert Schwarz-Weiß-Druck.

Legen Sie beispielsweise das Seitenlayout für Sheet1 mit Schwarzweißdruck, erste gedruckte Seitenzahl von 2, kleines A4-Querformatpapier (210 mm x 297 mm), 2 vertikale Seiten zum Anpassen und 2 horizontale Seiten zum Anpassen:

f := excelize.NewFile()
var (
    size                 = 10
    orientation          = "landscape"
    firstPageNumber uint = 2
    adjustTo        uint = 100
    fitToHeight          = 2
    fitToWidth           = 2
    blackAndWhite        = true
)
if err := f.SetPageLayout("Sheet1", &excelize.PageLayoutOptions{
    Size:            &size,
    Orientation:     &orientation,
    FirstPageNumber: &firstPageNumber,
    AdjustTo:        &adjustTo,
    FitToHeight:     &fitToHeight,
    FitToWidth:      &fitToWidth,
    BlackAndWhite:   &blackAndWhite,
}); err != nil {
    fmt.Println(err)
}

Abrufen des Layouts der Arbeitsblattseite

func (f *File) GetPageLayout(sheet string) (PageLayoutOptions, error)

GetPageLayout bietet eine Funktion zum Abrufen des Seitenlayouts des Arbeitsblatts.

Festlegen von Arbeitsblattseitenrändern

func (f *File) SetPageMargins(sheet string, opts *PageLayoutMarginsOptions) error

SetPageMargins bietet eine Funktion zum Festlegen der Seitenränder von Arbeitsblättern. Verfügbare Optionen:

Abrufen von Arbeitsblattseitenrändern

func (f *File) GetPageMargins(sheet string) (PageLayoutMarginsOptions, error)

GetPageMargins bietet eine Funktion zum Abrufen von Arbeitsblattseitenrändern.

Arbeitsmappeneigenschaften festlegen

func (f *File) SetWorkbookProps(opts *WorkbookPropsOptions) error

SetWorkbookProps bietet eine Funktion zum Festlegen von Arbeitsmappeneigenschaften. Verfügbare Optionen:

Arbeitsmappeneigenschaften abrufen

func (f *File) GetWorkbookProps() (WorkbookPropsOptions, error)

GetWorkbookProps bietet eine Funktion zum Abrufen von Arbeitsmappeneigenschaften.

Kopf- und Fußzeile einstellen

func (f *File) SetHeaderFooter(sheet string, opts *HeaderFooterOptions) error

SetHeaderFooter bietet eine Funktion zum Festlegen von Kopf- und Fußzeilen anhand des angegebenen Arbeitsblattnamens und der Steuerzeichen.

Kopf- und Fußzeilen werden in den folgenden Einstellungsfeldern angegeben:

Die folgenden Formatierungscodes können in Feldern mit 6 Zeichenfolgentypen verwendet werden: OddHeader, OddFooter, EvenHeader, EvenFooter, FirstFooter, FirstHeader

Zum Beispiel:

err := f.SetHeaderFooter("Sheet1", &excelize.HeaderFooterOptions{
    DifferentFirst:   true,
    DifferentOddEven: true,
    OddHeader:        "&R&P",
    OddFooter:        "&C&F",
    EvenHeader:       "&L&P",
    EvenFooter:       "&L&D&R&T",
    FirstHeader:      `&CCenter &"-,Bold"Bold&"-,Regular"HeaderU+000A&D`,
})

Dieses Beispiel zeigt:

• Die erste Seite hat eine eigene Kopf- und Fußzeile
• Ungerade und gerade nummerierte Seiten haben unterschiedliche Kopf- und Fußzeilen
• Aktuelle Seitenzahl im rechten Bereich der Überschriften für ungerade Seiten
• Der Dateiname der aktuellen Arbeitsmappe im mittleren Bereich der Fußzeilen für ungerade Seiten
• Aktuelle Seitenzahl im linken Bereich der Überschriften mit geraden Seiten
• Aktuelles Datum im linken Bereich und aktuelle Uhrzeit im rechten Bereich der Fußzeilen mit geraden Seiten
• Der Text "Center Bold Header" in der ersten Zeile des mittleren Abschnitts der ersten Seite und das Datum in der zweiten Zeile des mittleren Abschnitts derselben Seite
• Keine Fußzeile auf der ersten Seite

Definierter Name festlegen

func (f *File) SetDefinedName(definedName *DefinedName) error

SetDefinedName bietet eine Funktion zum Festlegen der definierten Namen der Arbeitsmappe oder des Arbeitsblatts. Wenn kein Bereich angegeben ist, ist der Standardbereich die Arbeitsmappe. Zum Beispiel:

err := f.SetDefinedName(&excelize.DefinedName{
    Name:     "Amount",
    RefersTo: "Sheet1!$A$2:$D$5",
    Comment:  "defined name comment",
    Scope:    "Sheet2",
})

Einstellungen für Druckbereich und Drucktitel für das Arbeitsblatt:

if err := f.SetDefinedName(&excelize.DefinedName{
    Name:     "_xlnm.Print_Area",
    RefersTo: "Sheet1!$A$1:$Z$100",
    Scope:    "Sheet1",
}); err != nil {
    fmt.Println(err)
}
if err := f.SetDefinedName(&excelize.DefinedName{
    Name:     "_xlnm.Print_Titles",
    RefersTo: "Sheet1!$A:$A,Sheet1!$1:$1",
    Scope:    "Sheet1",
}); err != nil {
    fmt.Println(err)
}

Definierten Namen abrufen

func (f *File) GetDefinedName() []DefinedName

GetDefinedName bietet eine Funktion zum Abrufen der definierten Namen der Arbeitsmappe oder des Arbeitsblatts.

Definierter Name löschen

func (f *File) DeleteDefinedName(definedName *DefinedName) error

DeleteDefinedName bietet eine Funktion zum Löschen der definierten Namen der Arbeitsmappe oder des Arbeitsblatts. Wenn kein Bereich angegeben ist, ist der Standardbereich die Arbeitsmappe. Zum Beispiel:

err := f.DeleteDefinedName(&excelize.DefinedName{
    Name:     "Amount",
    Scope:    "Sheet2",
})

Anwendungseigenschaften festlegen

func (f *File) SetAppProps(appProperties *AppProperties) error

SetAppProps bietet eine Funktion zum Festlegen von Dokumentanwendungseigenschaften. Folgende Eigenschaften können eingestellt werden:

Zum Beispiel:

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

Anwendungseigenschaften abrufen

func (f *File) GetAppProps() (*AppProperties, error)

GetAppProps bietet eine Funktion zum Abrufen von Dokumentanwendungseigenschaften.

Festlegen von Dokumenteigenschaften

func (f *File) SetDocProps(docProperties *DocProperties) error

SetDocProps bietet eine Funktion zum Festlegen der Eigenschaften des Dokumentkerns. Folgende Eigenschaften können festgelegt werden:

Zum Beispiel:

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

Abrufen von Dokumenteigenschaften

func (f *File) GetDocProps() (*DocProperties, error)

GetDocProps bietet eine Funktion zum Abrufen der Eigenschaften des Dokumentkerns.

Arbeitsbuch schützen

func (f *File) ProtectWorkbook(opts *WorkbookProtectionOptions) error

ProtectWorkbook bietet eine Funktion, um zu verhindern, dass andere Benutzer versehentlich oder absichtlich Daten in einer Arbeitsmappe ändern, verschieben oder löschen. Das optionale Feld AlgorithmName gibt den Hash-Algorithmus an, unterstützt XOR, MD4, MD5, SHA-1, SHA2-56, SHA-384 und SHA-512, wenn derzeit kein Hash-Algorithmus angegeben ist, wird der XOR-Algorithmus standardmäßig verwendet. Schützen Sie beispielsweise die Arbeitsmappe mit Schutzeinstellungen:

err := f.ProtectWorkbook(&excelize.WorkbookProtectionOptions{
    Password:      "password",
    LockStructure: true,
})

WorkbookProtectionOptions bildet die Einstellungen des Arbeitsmappenschutzes direkt ab.

type WorkbookProtectionOptions struct {
    AlgorithmName string
    Password      string
    LockStructure bool
    LockWindows   bool
}

Schutz der Arbeitsmappe aufheben

func (f *File) UnprotectWorkbook(password ...string) error

UnprotectWorkbook bietet eine Funktion zum Aufheben des Schutzes für Arbeitsmappen und gibt den optionalen Kennwortparameter an, um den Arbeitsmappenschutz mit Kennwortüberprüfung zu entfernen.