Cellula

RichTextRun mappa direttamente le impostazioni dell'esecuzione rich text.

type RichTextRun struct {
    Font *Font
    Text string
}

È possibile passare HyperlinkOpts a SetCellHyperlink per impostare attributi facoltativi del collegamento ipertestuale (ad esempio testo da visualizzare e testo del suggerimento sullo schermo).

type HyperlinkOpts struct {
    Display *string
    Tooltip *string
}

È possibile passare FormulaOpts a SetCellFormula per utilizzare altri tipi di formula.

type FormulaOpts struct {
    Type *string // Tipo di formula
    Ref  *string // Riferimento alla formula condivisa
}

Imposta il valore della cella

func (f *File) SetCellValue(sheet, cell string, value interface{}) error

SetCellValue fornisce una funzione per impostare il valore di una cella. Questa funzione è sicura per la concorrenza. Le coordinate specificate non devono trovarsi nella prima riga della tabella, è possibile impostare un numero complesso con una stringa di testo. Di seguito vengono mostrati i tipi di dati supportati:

Tieni presente che il formato della data predefinito è m/d/yy h:mm del valore di tipo time.Time. È possibile impostare il formato dei numeri tramite la funzione SetCellStyle. Se è necessario impostare una data specializzata in Excel come il 0 gennaio 1900 o il 29 febbraio 1900, questi orari non possono essere rappresentati nel tipo di dati "time.Time" della lingua Go. Imposta il valore della cella come numero 0 o 60, quindi crea e associa lo stile del formato numero data-ora per la cella.

Imposta il valore booleano

func (f *File) SetCellBool(sheet, cell string, value bool) error

SetCellBool fornisce una funzione per impostare il valore del tipo bool di una cella in base al nome del foglio di lavoro, al riferimento di cella e al valore della cella.

Imposta il valore RAW

func (f *File) SetCellDefault(sheet, cell, value string) error

SetCellDefault fornisce una funzione per impostare il valore del tipo di stringa di una cella come formato predefinito senza eseguire l'escape della cella.

Imposta il valore intero

func (f *File) SetCellInt(sheet, cell string, value int64) error

SetCellInt fornisce una funzione per impostare il valore del tipo int64 di una cella in base al nome del foglio di lavoro, al riferimento di cella e al valore della cella specificati.

Imposta il valore intero senza segno

func (f *File) SetCellUint(sheet, cell string, value uint64) error

SetCellUint fornisce una funzione per impostare il valore del tipo di dati intero senza segno di una cella in base al nome del foglio di lavoro, al riferimento di cella e al valore della cella specificati.

Imposta il valore in virgola mobile

func (f *File) SetCellFloat(sheet, cell string, value float64, precision, bitSize int) error

SetCellFloat imposta un valore in virgola mobile in una cella. Il parametro precision specifica quante cifre decimali verranno visualizzate mentre -1 è un valore speciale che utilizzerà tutte le cifre decimali necessarie per rappresentare il numero. bitSize è 32 o 64 a seconda che per il valore sia stato originariamente utilizzato float32 o float64.

Imposta il valore della stringa

func (f *File) SetCellStr(sheet, cell, value string) error

SetCellStr fornisce una funzione per impostare il valore del tipo di stringa di una cella. Il numero totale di caratteri che una cella può contenere 32767 caratteri.

Imposta lo stile della cella

func (f *File) SetCellStyle(sheet, topLeftCell, bottomRightCell string, styleID int) error

SetCellStyle fornisce una funzione per aggiungere attributi di stile per le celle in base al nome del foglio di lavoro, al riferimento all'intervallo e all'ID di stile. Questa funzione è sicura per la concorrenza. Gli indici di stile possono essere ottenuti con la funzione NewStyle. Tieni presente che i bordi di tipo diagonalDown e diagonalUp devono utilizzare lo stesso colore nello stesso intervallo. SetCellStyle sovrascriverà gli stili esistenti per la cella, non aggiungerà o unirà lo stile con gli stili esistenti.

• Esempio 1, crea i bordi della cella D7 su Foglio1:

style, err := f.NewStyle(&excelize.Style{
    Border: []excelize.Border{
        {Type: "left", Color: "0000FF", Style: 3},
        {Type: "top", Color: "00FF00", Style: 4},
        {Type: "bottom", Color: "FFFF00", Style: 5},
        {Type: "right", Color: "FF0000", Style: 6},
        {Type: "diagonalDown", Color: "A020F0", Style: 8},
        {Type: "diagonalUp", Color: "A020F0", Style: 8},
    },
})
if err != nil {
    fmt.Println(err)
}
err = f.SetCellStyle("Foglio1", "D7", "D7", style)

I quattro bordi della cella D7 sono impostati con stili e colori diversi. Questo è legato ai parametri quando si chiama la funzione NewStyle. È necessario impostare stili diversi per fare riferimento alla documentazione di quel capitolo.

• Esempio 2, impostazione dello stile del gradiente per la cella del foglio di lavoro D7 denominata Foglio1:

style, err := f.NewStyle(&excelize.Style{
    Fill: excelize.Fill{Type: "gradient", Color: []string{"FFFFFF", "E0EBF5"}, Shading: 1},
})
if err != nil {
    fmt.Println(err)
}
err = f.SetCellStyle("Foglio1", "D7", "D7", style)

La cella D7 è impostata con il colore di riempimento dell'effetto sfumato. L'effetto di riempimento sfumato è correlato al parametro quando viene chiamata la funzione NewStyle. È necessario impostare stili diversi per fare riferimento alla documentazione di questo capitolo.

• Esempio 3, imposta un riempimento solido per la cella D7 denominata Foglio1:

style, err := f.NewStyle(&excelize.Style{
    Fill: excelize.Fill{Type: "pattern", Color: []string{"E0EBF5"}, Pattern: 1},
})
if err != nil {
    fmt.Println(err)
}
err = f.SetCellStyle("Foglio1", "D7", "D7", style)

La cella D7 è impostata con un riempimento solido.

• Esempio 4, imposta la spaziatura dei caratteri e l'angolo di rotazione per la cella D7 denominata Foglio1:

f.SetCellValue("Foglio1", "D7", "Stile")
style, err := f.NewStyle(&excelize.Style{
    Alignment: &excelize.Alignment{
        Horizontal:      "center",
        Indent:          1,
        JustifyLastLine: true,
        ReadingOrder:    0,
        RelativeIndent:  1,
        ShrinkToFit:     true,
        TextRotation:    45,
        Vertical:        "",
        WrapText:        true,
    },
})
if err != nil {
    fmt.Println(err)
}
err = f.SetCellStyle("Foglio1", "D7", "D7", style)

• Esempio 5, la data e l'ora in Excel sono rappresentate da numeri reali, ad esempio 2017/7/4 12:00:00 PM può essere rappresentato dal numero 42920.5. Imposta il formato dell'ora per la cella del foglio di lavoro D7 denominata Foglio1:

f.SetCellValue("Foglio1", "D7", 42920.5)
f.SetColWidth("Foglio1", "D", "D", 13)
style, err := f.NewStyle(&excelize.Style{NumFmt: 22})
if err != nil {
    fmt.Println(err)
}
err = f.SetCellStyle("Foglio1", "D7", "D7", style)

La cella D7 è impostata sul formato ora. Tieni presente che quando la larghezza della cella con il formato dell'ora applicato è troppo stretta per essere visualizzata completamente, verrà visualizzata come ####, puoi trascinare e rilasciare la larghezza della colonna o impostare la colonna sulla dimensione appropriata chiamando il comando Funzione SetColWidth per renderla visualizzazione normale.

• Esempio 6, impostazione del carattere, della dimensione del carattere, del colore e dello stile di inclinazione per la cella del foglio di lavoro D7 denominata Foglio1:

f.SetCellValue("Foglio1", "D7", "Excel")
style, err := f.NewStyle(&excelize.Style{
    Font: &excelize.Font{
        Bold:   true,
        Italic: true,
        Family: "Times New Roman",
        Size:   36,
        Color:  "777777",
    },
})
if err != nil {
    fmt.Println(err)
}
err = f.SetCellStyle("Foglio1", "D7", "D7", style)

• Esempio 7, bloccare e nascondere la cella del foglio di lavoro D7 denominata Foglio1:

style, err := f.NewStyle(&excelize.Style{
    Protection: &excelize.Protection{
        Hidden: true,
        Locked: true,
    },
})
if err != nil {
    fmt.Println(err)
}
err = f.SetCellStyle("Foglio1", "D7", "D7", style)

Per bloccare una cella o nascondere una formula, proteggere il foglio di lavoro. Nella scheda "Revisione", fai clic su "Proteggi foglio di lavoro".

Imposta collegamento ipertestuale

func (f *File) SetCellHyperLink(sheet, cell, link, linkType string, opts ...HyperlinkOpts) error

SetCellHyperLink fornisce una funzione per impostare i collegamenti ipertestuali delle celle in base al nome del foglio di lavoro e all'indirizzo URL del collegamento. LinkType definisce due tipi di collegamenti ipertestuali External per il sito Web o Location per spostarsi in una delle celle di questa cartella di lavoro. Il limite massimo di collegamenti ipertestuali in un foglio di lavoro è 65530. Questa funzione viene utilizzata solo per impostare il collegamento ipertestuale della cella e non influisce sul valore della cella. Se è necessario impostare il valore della cella, utilizzare le altre funzioni come SetCellStyle o SetSheetRow. Di seguito è riportato un esempio di collegamento esterno.

• Esempio 1, aggiunta di un collegamento esterno alla cella A3 del foglio di lavoro denominato Foglio1:

display, tooltip := "https://github.com/xuri/excelize", "Excelize su GitHub"
if err := f.SetCellHyperLink("Foglio1", "A3",
    "https://github.com/xuri/excelize", "External", excelize.HyperlinkOpts{
        Display: &display,
        Tooltip: &tooltip,
    }); err != nil {
    fmt.Println(err)
}
// Imposta il carattere e lo stile di sottolineatura per la cella
style, err := f.NewStyle(&excelize.Style{
    Font: &excelize.Font{Color: "1265BE", Underline: "single"},
})
if err != nil {
    fmt.Println(err)
}
err = f.SetCellStyle("Foglio1", "A3", "A3", style)

• Esempio 2, aggiunta di un collegamento di posizione interno alla cella A3 denominata Foglio1:

err := f.SetCellHyperLink("Foglio1", "A3", "Sheet1!A40", "Location")

Imposta il testo ricco di celle

func (f *File) SetCellRichText(sheet, cell string, runs []RichTextRun) error

SetCellRichText fornisce una funzione per impostare una cella con testo RTF in un determinato foglio di lavoro.

Ad esempio, imposta il testo RTF sulla cella A1 del foglio di lavoro denominato Foglio1:

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)
        }
    }()
    if err := f.SetSheetName("Sheet1", "Foglio1"); err != nil {
        fmt.Println(err)
        return
    }
    if err := f.SetRowHeight("Foglio1", 1, 35); err != nil {
        fmt.Println(err)
        return
    }
    if err := f.SetColWidth("Foglio1", "A", "A", 56); err != nil {
        fmt.Println(err)
        return
    }
    if err := f.SetCellRichText("Foglio1", "A1", []excelize.RichTextRun{
        {
            Text: "testo in grassetto",
            Font: &excelize.Font{
                Bold:   true,
                Color:  "2354E8",
                Family: "Times New Roman",
            },
        },
        {
            Text: " e ",
            Font: &excelize.Font{
                Family: "Times New Roman",
            },
        },
        {
            Text: "corsivo ",
            Font: &excelize.Font{
                Bold:   true,
                Color:  "E83723",
                Italic: true,
                Family: "Times New Roman",
            },
        },
        {
            Text: "con colore e famiglia di caratteri,",
            Font: &excelize.Font{
                Bold:   true,
                Color:  "2354E8",
                Family: "Times New Roman",
            },
        },
        {
            Text: "\r\ntesto di grandi dimensioni con ",
            Font: &excelize.Font{
                Size:  14,
                Color: "AD23E8",
            },
        },
        {
            Text: "sciopero",
            Font: &excelize.Font{
                Color:  "E89923",
                Strike: true,
            },
        },
        {
            Text: " apice",
            Font: &excelize.Font{
                Color:     "DBC21F",
                VertAlign: "superscript",
            },
        },
        {
            Text: " e ",
            Font: &excelize.Font{
                Size:      14,
                Color:     "AD23E8",
                VertAlign: "baseline",
            },
        },
        {
            Text: "sottolineato",
            Font: &excelize.Font{
                Color:     "23E833",
                Underline: "single",
            },
        },
        {
            Text: " subscript.",
            Font: &excelize.Font{
                Color:     "017505",
                VertAlign: "subscript",
            },
        },
    }); err != nil {
        fmt.Println(err)
        return
    }
    style, err := f.NewStyle(&excelize.Style{
        Alignment: &excelize.Alignment{
            WrapText: true,
        },
    })
    if err != nil {
        fmt.Println(err)
        return
    }
    if err := f.SetCellStyle("Foglio1", "A1", "A1", style); err != nil {
        fmt.Println(err)
        return
    }
    if err := f.SaveAs("Cartel1.xlsx"); err != nil {
        fmt.Println(err)
    }
}

Ottieni testo ricco di celle

func (f *File) GetCellRichText(sheet, cell string) ([]RichTextRun, error)

GetCellRichText fornisce una funzione per ottenere il rich text delle celle da un determinato foglio di lavoro.

Ottieni il valore della cella

func (f *File) GetCellValue(sheet, cell string, opts ...Options) (string, error)

GetCellValue fornisce una funzione per ottenere un valore formattato dalla cella in base al nome del foglio di lavoro e al riferimento alla cella nel foglio di calcolo. Il valore restituito viene convertito nel tipo string. Questa funzione è sicura per la concorrenza. Se il formato cella può essere applicato al valore di una cella, verrà restituito il valore applicato, altrimenti verrà restituito il valore originale. I valori di tutte le celle saranno gli stessi in un intervallo unito.

Ottieni il tipo di cella

func (f *File) GetCellType(sheet, cell string) (CellType, error)

GetCellType fornisce una funzione per ottenere il tipo di dati della cella in base al nome del foglio di lavoro e al riferimento alla cella nel file del foglio di calcolo.

Ottieni tutto il valore della cella in base alle colonne

func (f *File) GetCols(sheet string, opts ...Options) ([][]string, error)

GetCols ottiene il valore di tutte le celle per colonne nel foglio di lavoro in base al nome del foglio di lavoro specificato, restituito come array bidimensionale, dove il valore della cella viene convertito nel tipo string. Se il formato della cella può essere applicato al valore della cella, verrà utilizzato il valore applicato, altrimenti verrà utilizzato il valore originale.

Ad esempio, ottieni e attraversa il valore di tutte le celle per colonne su un foglio di lavoro denominato Foglio1:

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

Ottieni tutto il valore della cella per righe

func (f *File) GetRows(sheet string, opts ...Options) ([][]string, error)

GetRows restituisce tutte le righe in un foglio in base al nome del foglio di lavoro specificato, restituito come array bidimensionale, in cui il valore della cella viene convertito nel tipo string. Se il formato della cella può essere applicato al valore della cella, verrà utilizzato il valore applicato, altrimenti verrà utilizzato il valore originale. GetRows ha recuperato le righe con celle di valore o formula, le celle continuamente vuote nella coda di ciascuna riga verranno ignorate, quindi la lunghezza di ciascuna riga potrebbe essere incoerente.

Ad esempio, ottieni e attraversa il valore di tutte le celle per righe su un foglio di lavoro denominato Foglio1:

rows, err := f.GetRows("Foglio1")
if err != nil {
    fmt.Println(err)
    return
}
for _, row := range rows {
    for _, colCell := range row {
        fmt.Print(colCell, "\t")
    }
    fmt.Println()
}

Ottieni il collegamento ipertestuale

func (f *File) GetCellHyperLink(sheet, cell string) (bool, string, error)

GetCellHyperLink ottiene un collegamento ipertestuale di cella in base al nome del foglio di lavoro e al riferimento di cella specificati. Se la cella ha un collegamento ipertestuale, restituirà true e l'indirizzo del collegamento, altrimenti restituirà false e un indirizzo del collegamento vuoto.

Ad esempio, ottieni un collegamento ipertestuale a una cella H6 su un foglio di lavoro denominato Foglio1:

link, target, err := f.GetCellHyperLink("Foglio1", "H6")

Ottieni l'indice di stile

func (f *File) GetCellStyle(sheet, cell string) (int, error)

L'indice dello stile della cella si ottiene dal nome del foglio di lavoro e dal riferimento della cella specificati e l'indice ottenuto può essere utilizzato come parametro per chiamare la funzione SetCellStyle durante la copia dello stile della cella.

Unire le celle

func (f *File) MergeCell(sheet, topLeftCell, bottomRightCell string) error

MergeCell fornisce una funzione per unire le celle in base al riferimento all'intervallo e al nome del foglio specificati. L'unione delle celle mantiene solo il valore della cella in alto a sinistra e scarta gli altri valori. Ad esempio, unisci le celle nell'area D3:E9 su un foglio di lavoro denominato Foglio1:

err := f.MergeCell("Foglio1", "D3", "E9")

Se crei una cella unita che si sovrappone a un'altra cella unita esistente, le celle unite già esistenti verranno rimosse.

Separa le celle

func (f *File) UnmergeCell(sheet, topLeftCell, bottomRightCell string) error

UnmergeCell fornisce una funzione per separare un dato intervallo di riferimento. Ad esempio, separa l'area D3:E9 dal Foglio1:

err := f.UnmergeCell("Sheet1", "D3", "E9")

Attenzione: anche le aree sovrapposte verranno separate.

Ottieni unisci celle

GetMergeCells fornisce una funzione per ottenere tutte le celle unite da un foglio di lavoro specifico.

func (f *File) GetMergeCells(sheet string) ([]MergeCell, error)

Ottieni il valore della cella unita

func (m *MergeCell) GetCellValue() string

GetCellValue restituisce il valore della cella unita.

Ottieni il riferimento della cella in alto a sinistra dell'intervallo unito

func (m *MergeCell) GetStartAxis() string

GetStartAxis restituisce il riferimento di cella in alto a sinistra dell'intervallo unito, ad esempio: C2.

Ottieni il riferimento della cella in basso a destra dell'intervallo unito

func (m *MergeCell) GetEndAxis() string

GetEndAxis restituisce il riferimento di cella in basso a destra dell'intervallo unito, ad esempio: D4.

Ottieni celle di immagini

func (f *File) GetPictureCells(sheet string) ([]string, error)

GetPictureCells restituisce tutti i riferimenti alle celle dell'immagine in un foglio di lavoro con un nome di foglio di lavoro specifico.

Aggiungi un commento

func (f *File) AddComment(sheet string, comment Comment) error

AddComment fornisce il metodo per aggiungere commenti in un foglio in base all'indice del foglio di lavoro, alla cella e al formato impostato (come autore e testo). Tieni presente che la lunghezza massima dell'autore è 255 e la lunghezza massima del testo è 32512. Ad esempio, aggiungi un commento in Foglio1!$A$3:

err := f.AddComment("Foglio1", excelize.Comment{
    Cell:   "A3",
    Author: "Excelize",
    Paragraph: []excelize.RichTextRun{
        {Text: "Excelize: ", Font: &excelize.Font{Bold: true}},
        {Text: "Questo è un commento."},
    },
})

Ottieni commento

func (f *File) GetComments(sheet string) ([]Comment, error)

GetComments recupera tutti i commenti in un foglio di lavoro in base al nome del foglio di lavoro specificato.

Elimina commento

func (f *File) DeleteComment(sheet, cell string) error

EliminaComment fornisce il metodo per eliminare il commento in un foglio in base al nome del foglio di lavoro specificato. Ad esempio, elimina il commento in Foglio1!$A$30:

err := f.DeleteComment("Foglio1", "A30")

Aggiungi errori ignorati

func (f *File) AddIgnoredErrors(sheet, rangeRef string, ignoredErrorsType IgnoredErrorsType) error

AddIgnoredErrors fornisce il metodo per ignorare l'errore per un intervallo di celle. Ad esempio: ignora l'errore "numero memorizzato come testo" su Foglio1 per l'intervallo di celle D15 C18:D19:

err := f.AddIgnoredErrors("Foglio1", "D15 C18:D19", excelize.IgnoredErrorsNumberStoredAsText)

Imposta la formula della cella

func (f *File) SetCellFormula(sheet, cell, formula string, opts ...FormulaOpts) error

SetCellFormula fornisce una funzione per impostare la formula sulla cella in base al nome del foglio di lavoro specificato e alle impostazioni della formula della cella. Il risultato della cella della formula può essere calcolato quando il foglio di lavoro viene aperto dall'applicazione Office Excel oppure è possibile utilizzare la funzione CalcCellValue per ottenere anche il valore della cella calcolata. Se l'applicazione Excel non calcola automaticamente la formula quando la cartella di lavoro è stata aperta, chiamare UpdateLinkedValue dopo aver impostato le funzioni della formula della cella.

• Esempio 1, imposta la formula normale =SUM(A1,B1) per la cella A3 su Foglio1:

err := f.SetCellFormula("Foglio1", "A3", "SUM(A1,B1)")

• Esempio 2, imposta la formula 1;2;3 per un array costante verticale unidimensionale (array di colonne) per la cella A3 su Foglio1:

err := f.SetCellFormula("Foglio1", "A3", "{1;2;3}")

• Esempio 3, imposta la formula "a","b","c" di un array costante orizzontale unidimensionale (array di righe) per la cella A3 su Foglio1:

err := f.SetCellFormula("Foglio1", "A3", "{\"a\",\"b\",\"c\"}")

• Esempio 4, imposta la formula di matrice costante bidimensionale {1,2;"a","b"} per la cella A3 su Foglio1:

formulaType, ref := excelize.STCellFormulaTypeArray, "A3:A3"
err := f.SetCellFormula("Foglio1", "A3", "{1,2;\"a\",\"b\"}",
    excelize.FormulaOpts{Ref: &ref, Type: &formulaType})

• Esempio 5, imposta la formula matriciale dell'intervallo A1:A2 per la cella A3 su Foglio1:

formulaType, ref := excelize.STCellFormulaTypeArray, "A3:A3"
err := f.SetCellFormula("Foglio1", "A3", "A1:A2",
    excelize.FormulaOpts{Ref: &ref, Type: &formulaType})

• Esempio 6, imposta la formula condivisa =A1+B1 per le celle C1:C5 su Foglio1, C1 è la cella principale:

formulaType, ref := excelize.STCellFormulaTypeShared, "C1:C5"
err := f.SetCellFormula("Foglio1", "C1", "A1+B1",
    excelize.FormulaOpts{Ref: &ref, Type: &formulaType})

• Esempio 7, imposta la formula della tabella =SUM(Table1[[A]:[B]]) per la cella C2 su Foglio1:

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

Ottieni la formula cellulare

func (f *File) GetCellFormula(sheet, cell string) (string, error)

GetCellFormula fornisce una funzione per ottenere la formula dalla cella in base al nome del foglio di lavoro e al riferimento alla cella nel foglio di calcolo.

Calcola il valore della cella

func (f *File) CalcCellValue(sheet, cell string, opts ...Options) (string, error)

CalcCellValue fornisce una funzione per ottenere il valore della cella calcolato. Questa funzionalità è attualmente in fase di elaborazione. Il calcolo iterativo, l'intersezione implicita, l'intersezione esplicita, la formula di matrice, la formula di tabella e alcune altre formule non sono attualmente supportate.

Formule supportate: