Skip to main content

DHTMLX Spreadsheet. Localization example

This demo shows how to localize the DHTMLX Spreadsheet interface by registering custom locales with dhx.i18n.setLocale() and recreating the component when the selected language changes.

Live example

const locale = {
    // English locale
    en: {
        // Toolbar
        undo: "Undo",
        redo: "Redo",

        textColor: "Text color",
        backgroundColor: "Background color",

        bold: "Bold",
        italic: "Italic",
        underline: "Underline",
        strikethrough: "Strikethrough",

        link: "Link",

        halign: "Horizontal align",
        valign: "Vertical align",
        left: "Left",
        right: "Right",
        center: "Center",
        top: "Top",
        bottom: "Bottom",
        multiline: "Text wrapping",
        clip: "Clip",
        wrap: "Wrap",
        merge: "Merge",
        unmerge: "Unmerge",

        lockCell: "Lock cell",
        unlockCell: "Unlock cell",

        clear: "Clear",
        clearValue: "Clear value",
        clearStyles: "Clear styles",
        clearAll: "Clear all",

        columns: "Columns",
        rows: "Rows",
        addColumn: "Add column",
        removeColumn: "Remove column {col}",
        removeColumns: "Remove columns {col}",
        freezeToCol: "Freeze up to column {col}",
        unfreezeCols: "Unfreeze columns",
        hideCol: "Hide column {col}",
        hideCols: "Hide columns {col}",
        showCols: "Show columns",
        fitToData: "Fit to data",
        addRow: "Add row",
        removeRow: "Remove row {row}",
        removeRow: "Remove rows {row}",
        freezeToRow: "Freeze up to row {row}",
        unfreezeRows: "Unfreeze rows",
        hideRow: "Hide row {row}",
        hideRows: "Hide rows {row}",
        showRows: "Show rows",

        format: "Format",
        common: "Common",
        number: "Number",
        currency: "Currency",
        percent: "Percent",
        text: "Text",
        date: "Date",
        time: "Time",

        filter: "Filter",

        help: "Help",

        // Tabbar
        deleteSheet: "Delete",
        renameSheet: "Rename",

        // Menu
        file: "File",
        import: "Import",
        export: "Export",
        downloadAs: "Download as...",
        importAs: "Import as...",

        data: "Data",
        validation: "Data validation",
        search: "Search",
        sort: "Sort",
        ascSort: "Sort A to Z",
        descSort: "Sort Z to A",

        //Actions
        copy: "Copy",
        edit: "Edit",
        insert: "Insert",
        remove: "Remove",
        linkCopied: "Link copied to clipboard",

        //Filter 
        e: "Is empty",
        ne: "Is not empty",
        tc: "Text contains",
        tdc: "Text doesn't contain",
        ts: "Text starts with",
        te: "Text ends with",
        tex: "Text is exactly",
        d: "Date is",
        db: "Date is before",
        da: "Date is after",
        gt: "Greater than",
        geq: "Greater or equal to",
        lt: "Less than",
        leq: "Less or equal to",
        eq: "Is equal to",
        neq: "Is not equal to",
        ib: "Is between",
        inb: "Is not between",

        none: "None",
        empty: "Empty",
        value: "Value",
        values: "By values",
        condition: "By condition",
        and: "And",

        // Buttons
        cancel: "Cancel",
        save: "Save",
        removeValidation: "Remove validation",
        selectAll: "Select all",
        unselectAll: "Unselect all",
        apply: "Apply",
        ok: "Ok",

        // Messages
        renameSheetAlert: "A sheet with the name $name already exists. Please enter another name. ",
        alertTitle: "There was a problem!",
        mergeAlertMessage: "You can't $action a range containing merges!",
        spanMergeAlert: "You can't merge frozen and non-frozen cells!",
        dontShowAgain: "Don't show again",
        spanPasteError: "You can't paste merges that cross the boundary of a frozen region",
        spanMergeLockedError: "You can't merge locked cells!",
        spanUnmergeLockedError: "You can't unmerge locked cells!",
    },
    // German locale
    de: {
        // Symbolleiste
        undo: "Rückgängig",
        redo: "Wiederholen",

        textColor: "Textfarbe",
        backgroundColor: "Hintergrundfarbe",

        bold: "Fett",
        italic: "Kursiv",
        underline: "Unterstreichen",
        strikethrough: "Durchgestrichen",

        link: "Verknüpfung",

        halign: "Horizontal ausrichten",
        valign: "Vertikal ausrichten",
        left: "Links",
        right: "Rechts",
        center: "Zentrum",
        top: "Oben",
        bottom: "Unten",
        multiline: "Textumbruch",
        clip: "Klemme",
        wrap: "Wickeln",
        merge: "Verschmelzen",
        unmerge: "Zusammenführung aufheben",

        lockCell: "Zelle sperren",
        unlockCell: "Zelle entsperren",

        clear: "Löschen",
        clearValue: "Wert löschen",
        clearStyles: "Stile löschen",
        clearAll: "Alles löschen",

        columns: "Kolumnen",
        rows: "Reihen",
        addColumn: "Spalte hinzufügen",
        removeColumn: "Spalte {col} entfernen",
        removeColumns: "Spalten {col} entfernen",
        freezeToCol: "Bis zur Spalte {col} fixieren",
        unfreezeCols: "Spalten freigeben",
        hideCol: "Spalte {col} ausblenden",
        hideCols: "Spalten {col} ausblenden",
        showCols: "Spalten anzeigen",
        fitToData: "An Daten anpassen",
        addRow: "Zeile hinzufügen",
        removeRow: "Zeile {row} entfernen",
        removeRows: "Zeilen entfernen {row}",
        freezeToRow: "Bis Zeile {row} einfrieren",
        unfreezeRows: "Zeilen freigeben",
        hideRow: "Zeile {row} ausblenden",
        hideRows: "Zeilen {row} ausblenden",
        showRows: "Zeilen anzeigen",

        format: "Format",
        common: "Allgemein",
        number: "Zahlenformat",
        currency: "Currency",
        percent: "Prozent",
        text: "Text",
        date: "Datum",
        time: "Zeit",

        filter: "Filter",

        help: "Hilfe",

        // Tabbar
        deleteSheet: "Löschen",
        renameSheet: "Umbenennen",

        // Menü
        file: "Datei",
        import: "Importieren",
        export: "Exportieren",
        downloadAs: "Speichern wie",
        importAs: "Importieren als",

        data: "Daten",
        validation: "Validierung der daten",
        search: "Suche",
        sort: "Sortieren",
        ascSort: "A nach Z sortieren",
        descSort: "Z nach A sortieren",

        copy: "Kopieren",
        edit: "Bearbeiten",
        insert: "Einfügen",
        remove: "Entfernen",
        linkCopied: "Link in die Zwischenablage kopiert",

        //Filter 
        e: "Ist leer",
        ne: "Ist nicht leer",
        tc: "Text enthält",
        tdc: "Text enthält nicht",
        ts: "Text beginnt mit",
        te: "Text endet mit",
        tex: "Text ist genau",
        d: "Datum ist",
        db: "Datum ist vor",
        da: "Datum ist nach",
        gt: "Größer als",
        geq: "Größer oder gleich",
        lt: "Weniger als",
        leq: "Weniger oder gleich",
        eq: "Ist gleich",
        neq: "Ist ungleich zu",
        ib: "Ist zwischen",
        inb: "Ist nicht dazwischen",

        none: "Keiner",
        empty: "Leer",
        value: "Wert",
        values: "Nach Werten",
        condition: "Nach Zustand",
        and: "Und",

        // Buttons
        cancel: "Absagen",
        save: "Speichern",
        removeValidation: "Validierung entfernen",
        selectAll: "Wählen Sie Alle",
        unselectAll: "Alles wiederufen",
        apply: "Sich bewerben",
        ok: "Ok",

        // Messages
        renameSheetAlert: "Ein Blatt mit dem Namen $name existiert bereits. Bitte geben Sie einen anderen Namen ein. ",
        alertTitle: "Es gab ein Problem!",
        mergeAlertMessage: "Sie können einen Bereich, der Merges enthält, nicht $action!",
        spanMergeAlert: "Sie können eingefrorene und nicht eingefrorene Zellen nicht zusammenführen!",
        spanPasteError: "Sie können keine Zusammenführungen einfügen, die die Grenze einer eingefrorenen Region überschreiten",
        spanMergeLockedError: "Sie können keine gesperrten Zellen zusammenführen!",
        spanUnmergeLockedError: "Sie können gesperrte Zellen nicht trennen!",
    }
};

let spreadsheet;

function create(lang) {
    if (spreadsheet) spreadsheet.destructor();
    spreadsheet = new dhx.Spreadsheet("spreadsheet", {
        formats: [
            {
                id: "currency",
                name: !lang || lang === "english" ? "currency" : "Währung",
                mask: "[$р.]#,##0.00"
            }
        ],
        menu: true
    });
    spreadsheet.parse(dataset);
}
create();

document.querySelector(".dhx_sample-controls").addEventListener("change", event => {
    switch (event.target.id) {
        case "english":
            dhx.i18n.setLocale("spreadsheet", locale["en"]);
            dhx.i18n.setLocale("formulas", formulas["en"]);
            create(event.target.id);
            break;
        case "deutsch":
            dhx.i18n.setLocale("spreadsheet", locale["de"]);
            dhx.i18n.setLocale("formulas", formulas["de"]);
            create(event.target.id);
            break;
    }
});

<!-- auxiliary controls for interacting with the sample -->
<link rel="stylesheet" href="https://snippet.dhtmlx.com/codebase/assets/css/auxiliary_controls.css" />
<section class="dhx_sample-controls">
    <label class="dhx_form-group dhx_radiobutton dhx_form-group--inline dhx_form-group--no-message-holder dhx_form-group dhx_sample-input__wrapper--pl-16">
        <input type="radio" checked name="lang" id="english" class="dhx_radiobutton__input" />
        <span class="dhx_radiobutton__visual-input"></span>
        <span class="dhx_label">English </span>
    </label>
    <label class="dhx_form-group dhx_radiobutton dhx_form-group--inline dhx_form-group--no-message-holder dhx_sample-input__wrapper--pl-16">
        <input type="radio" name="lang" id="deutsch" class="dhx_radiobutton__input" />
        <span class="dhx_radiobutton__visual-input"></span>
        <span class="dhx_label">Deutsch</span>
    </label>
</section>

<!-- component container -->
<div id="spreadsheet" style="height: calc(100% - 60px); width: 100%;"></div>

<script>
// Localized formula tooltips with parameter descriptions by language (e.g., 'de' for German).
    const formulas = {
        en: {
            SUM: [
                ["Number1", "Required. The first value to sum."],
                ["Number2", "Optional. The second value to sum."],
                ["Number3", "Optional. The third value to sum."],
            ],
            AVERAGE: [
                ["Number1", "Required. A number or cell reference that refers to numeric values."],
                ["Number2", "Optional. A number or cell reference that refers to numeric values."],
            ],
            AVERAGEA: [
                ["Value1", "Required. A value or reference to a value that can be evaluated as a number."],
                ["Value2", "Optional. A value or reference to a value that can be evaluated as a number."],
            ],
            COUNT: [
                ["Value1", "Required. An item, cell reference, or range."],
                ["Value2", "Optional. An item, cell reference, or range."],
            ],
            COUNTA: [
                ["Value1", "Required. An item, cell reference, or range."],
                ["Value2", "Optional. An item, cell reference, or range."],
            ],
            MIN: [
                ["Number1", "Required. Number, reference to numeric value, or range that contains numeric values."],
                ["Number2", "Optional. Number, reference to numeric value, or range that contains numeric values."],
            ],
            MAX: [
                ["Number1", "Required. Number, reference to numeric value, or range that contains numeric values."],
                ["Number2", "Optional. Number, reference to numeric value, or range that contains numeric values."],
            ],
            SQRT: [["Number", "Required. The number to get the square root of."]],
            POWER: [
                ["Number", "Required. Number to raise to a power."],
                ["Power", "Required. Power to raise number to (the exponent)."],
            ],
            LOG: [
                ["Number", "Required. Number for which you want the logarithm."],
                ["Base", "Optional. Base of the logarithm. Defaults to 10."],
            ],
            EXP: [["Number", "Required. The power that e is raised to."]],
            PRODUCT: [
                ["Number1", "Required. The first number or range to multiply."],
                ["Number2", "Optional. The second number or range to multiply."],
            ],
            SUMPRODUCT: [
                ["Array1", "Required. The first array or range to multiply, then add."],
                ["Array2", "Optional. The second array or range to multiply, then add."],
            ],
            ABS: [["Number", "Required. The number to get the absolute value of."]],
            RAND: [],
            RANDBETWEEN: [
                ["Bottom", "Required. An integer representing the lower value of the range."],
                ["Top", "Required. An integer representing the upper value of the range."],
            ],
            ROUND: [
                ["Number", "Required. The number to round."],
                ["Num_digits", "Required. The place at which number should be rounded."],
            ],
            ROUNDUP: [
                ["Number", "Required. The number to round up."],
                ["Num_digits", "Required. The place at which number should be rounded."],
            ],
            ROUNDDOWN: [
                ["Number", "Required. The number to round down."],
                ["Num_digits", "Required. The place at which number should be rounded."],
            ],
            INT: [["Number", "Required. The number from which you want an integer."]],
            CEILING: [
                ["Number", "Required. The number that should be rounded."],
                ["Significance", "Required. The multiple to use when rounding."],
            ],
            FLOOR: [
                ["Number", "Required. The number that should be rounded."],
                ["Significance", "Required. The multiple to use when rounding."],
            ],
            CONCATENATE: [
                ["Text1", "Required. The first text value to join together."],
                ["Text2", "Required. The second text value to join together."],
                ["Text3", "Optional. The third text value to join together."],
            ],
            MID: [
                ["Text", "Required. The text to extract from."],
                ["Start_num", "Required. The location of the first character to extract."],
                ["Num_chars", "Required. The number of characters to extract."],
            ],
            LEFT: [
                ["Text", "Required. The text from which to extract characters."],
                ["Num_chars", "Optional. The number of characters to extract, starting on the left side of text. Default = 1."],
            ],
            RIGHT: [
                ["Text", "Required. The text from which to extract characters on the right."],
                ["Num_chars", "Optional. The number of characters to extract, starting on the right. Optional, default = 1."],
            ],
            LOWER: [["Text", "Required. The text that should be converted to lower case."]],
            UPPER: [["Text", "Required. The text thatto convert to upper case."]],
            PROPER: [["Text", "Required. The text that should be converted to proper case."]],
            TRIM: [["Text", "Required. The text from which to remove extra space."]],
            LEN: [["Text", "Required. The text for which to calculate length."]],
            SEARCH: [
                ["Find_text", "Required. The substring to find."],
                ["Within_text", "Required. The text to search within."],
                ["Start_num", "Optional. Starting position. Optional, defaults to 1."],
            ],
            FIND: [
                ["Find_text", "Required. The substring to find."],
                ["Within_text", "Required. The text to search within."],
                ["Start_num", "Optional. The starting position in the text to search. Optional, defaults to 1."],
            ],
            REPLACE: [
                ["Old_text", "Required. The text to replace."],
                ["Start_num", "Required. The starting location in the text to search."],
                ["Num_chars", "Required. The number of characters to replace."],
                ["New_text", "Required. The text to replace old_text with."],
            ],
            SUBSTITUTE: [
                ["Text", "Required. The text to change."],
                ["Old_text", "Required. The text to replace."],
                ["New_text", "Required. The text to replace with."],
                ["Instance", "Optional. The instance to replace. If not supplied, all instances are replaced."],
            ],
            NOW: [],
            DATE: [
                ["Year", "Required. Number for year."],
                ["Month", "Required. Number for month."],
                ["Day", "Required. Number for day."],
            ],
            TIME: [
                ["Hour", "Required. The hour for the time you wish to create."],
                ["Minute", "Required. The minute for the time you wish to create."],
                ["Second", "Required. The second for the time you wish to create."],
            ],
            YEAR: [["Date", "Required. A valid Excel date."]],
            MONTH: [["Serial_number", "Required. A valid Excel date."]],
            DAY: [["Date", "Required. A valid Excel date."]],
            HOUR: [["Serial_number", "Required. A valid Excel time."]],
            MINUTE: [["Serial_number", "Required. A valid date or time."]],
            SECOND: [["Serial_number", "Required. A valid time in a format Excel recognizes."]],
            DATEDIF: [
                ["Start_date", "Required. Start date in Excel date serial number format."],
                ["End_date", "Required. End date in Excel date serial number format."],
                ["Unit", "Required. The time unit to use (years, months, or days)."],
            ],
            LOOKUP: [
                ["Lookup_value", "Required. The value to search for."],
                ["Lookup_vector", "Required. The one-row, or one-column range to search."],
                ["Result_vector", "Optional. The one-row, or one-column range of results."],
            ],
            HLOOKUP: [
                ["Lookup_value", "Required. The value to look up."],
                ["Table_array", "Required. The table from which to retrieve data."],
                ["Row_index", "Required. The row number from which to retrieve data."],
                ["Range_lookup", "Optional. A Boolean to indicate exact match or approximate match. Default = TRUE = approximate match."],
            ],
            VLOOKUP: [
                ["Lookup_value", "Required. The value to look for in the first column of a table."],
                ["Table_array", "Required. The table from which to retrieve a value."],
                ["Column_index_num", "Required. The column in the table from which to retrieve a value."],
                ["Range_lookup", "Optional. TRUE = approximate match (default). FALSE = exact match."],
            ],
            XLOOKUP: [
                ["Lookup", "Required. The lookup value."],
                ["Lookup_array", "Required. The array or range to search."],
                ["Return_array", "Required. The array or range to return."],
                ["Not_found", "Optional. Value to return if no match found."],
                ["Match_mode", "Optional. 0 = exact match (default), -1 = exact match or next smallest, 1 = exact match or next larger, 2 = wildcard match."],
                ["Search_mode", "Optional. 1 = search from first (default), -1 = search from last, 2 = binary search ascending, -2 = binary search descending."],
            ],
            INDEX: [
                ["Array", "Required. A range of cells, or an array constant."],
                ["Row_num", "Required. The row position in the reference or array."],
                ["Col_num", "Optional. The column position in the reference or array."],
                ["Area_num", "Optional. The range in reference that should be used."],
            ],
            MATCH: [
                ["Lookup_value", "Required. The value to match in lookup_array."],
                ["Lookup_array", "Required. A range of cells or an array reference."],
                ["Match_type", "Optional. 1 = exact or next smallest (default), 0 = exact match, -1 = exact or next largest."],
            ],
            XMATCH: [
                ["Lookup_value", "Required. The lookup value."],
                ["Lookup_array", "Required. The array or range to search."],
                ["Match_mode", "Optional. 0 = exact match (default), -1 = exact match or next smallest, 1 = exact match or next larger, 2 = wildcard match."],
                ["Search_mode", "Optional. 1 = search from first (default), -1 = search from last, 2 = binary search ascending, -2 = binary search descending."],
            ],
            CHOOSE: [
                ["Index_num", "Required. The value to choose. A number between 1 and 254."],
                ["Value1", "Required. The first value from which to choose."],
                ["Value2", "Optional. The second value from which to choose."],
            ],
            ISBLANK: [["Value", "Required. The value to check."]],
            ISBINARY: [["Value", "Required. The value to check."]],
            ISEVEN: [["Value", "Required. The numeric value to check."]],
            ISODD: [["Value", "Required. The numeric value to check."]],
            ISNONTEXT: [["Value", "Required. The value to check."]],
            ISNUMBER: [["Value", "Required. The value to check."]],
            ISTEXT: [["Value", "Required. The value to check."]],
            N: [["Value", "Required. The value to convert to a number."]],
            IF: [
                ["Logical_test", "Required. A value or logical expression that can be evaluated as TRUE or FALSE."],
                ["Value_if_true", "Optional. The value to return when logical_test evaluates to TRUE."],
                ["Value_if_false", "Optional. The value to return when logical_test evaluates to FALSE."],
            ],
            AND: [
                ["Logical1", "Required. The first condition or logical value to evaluate."],
                ["Logical2", "Optional. The second condition or logical value to evaluate."],
            ],
            NOT: [["Logical", "Required. A value or logical expression that can be evaluated as TRUE or FALSE."]],
            OR: [
                ["Logical1", "Required. The first condition or logical value to evaluate."],
                ["Logical2", "Optional. The second condition or logical value to evaluate."],
            ],
            FALSE: [],
            TRUE: [],
            ACOS: [["Number", "Required. The value to get the inverse cosine of. The number must be between -1 and 1 inclusive."]],
            ACOSH: [["Number", "Required. Any real number equal to or greater than 1."]],
            ACOT: [["Number", "Required. Number is the cotangent of the angle you want. This must be a real number."]],
            ACOTH: [["Number", "Required. The absolute value of Number must be greater than 1."]],
            ADD: [
                ["Number1", "Required. The first value to sum."],
                ["Number2", "Required. The second value to sum."],
            ],
            ARABIC: [["Roman_text", "Required. The Roman numeral in text that you want to convert."]],
            ASIN: [["Number", "Required. The value to get the inverse sine of. The number must be between -1 and 1 inclusive."]],
            ASINH: [["Number", "Required. Any real number."]],
            ATAN: [["Number", "Required. The value to get the inverse tangent of."]],
            ATAN2: [
                ["X_num", "Required. The x coordinate of the input point."],
                ["Y_num", "Required. The y coordinate of the input point."],
            ],
            ATANH: [["Number", "Required. Any real number between 1 and -1."]],
            AVEDEV: [
                ["Number1", "Required. First value or reference."],
                ["Number2", "Optional. Second value or reference."],
            ],
            BASE: [
                ["Number", "Required. The number to convert to a given base."],
                ["Radix", "Required. The base to convert to."],
                ["Min_length", "Optional. The minimum string length to return, achieved by padding with zeros."],
            ],
            BINOMDIST: [
                ["Number_s", "Required. The number of successes."],
                ["Trials", "Required. The number of independent trials."],
                ["Probability_s", "Required. The probability of success on each trial."],
                ["Cumulative", "Required. TRUE = cumulative distribution function, FALSE=probability mass function."],
            ],
            "BINOM.INV": [
                ["Trials", "Required. The number of Bernoulli trials."],
                ["Probability_s", "Required. The probability of a success on each trial."],
                ["Alpha", "Required. The criterion value."],
            ],
            "BINOM.DIST.RANGE": [
                ["Trials", "Required. The number of independent trials. Must be greater than or equal to 0."],
                ["Probability_s", "Required. The probability of success in each trial. Must be greater than or equal to 0 and less than or equal to 1."],
                ["Number_s", "Required. The number of successes in trials. Must be greater than or equal to 0 and less than or equal to Trials."],
                ["Number_s2", "Optional. If provided, returns the probability that the number of successful trials will fall between Number_s and number_s2. Must be greater than or equal to Number_s and less than or equal to Trials."],
            ],
            "BINOM.DIST": [
                ["Number_s", "Required. The number of successes."],
                ["Trials", "Required. The number of independent trials."],
                ["Probability_s", "Required. The probability of success on each trial."],
                ["Cumulative", "Required. TRUE = cumulative distribution function, FALSE=probability mass function."],
            ],
            BITAND: [
                ["Number1", "Required. A positive decimal number."],
                ["Number2", "Required. A positive decimal number."],
            ],
            BITLSHIFT: [
                ["Number", "Required. The number to be bit shifted."],
                ["Shift_amount", "Required. The amount of bits to shift, if negative shifts bits to the right instead."],
            ],
            BITOR: [
                ["Number1", "Required. A positive decimal number."],
                ["Number2", "Required. A positive decimal number."],
            ],
            BITRSHIFT: [
                ["Number", "Required. The number to be bit shifted."],
                ["Shift_amount", "Required. The amount of bits to shift to the right, if negative shifts bits to the left instead."],
            ],
            BITXOR: [
                ["Number1", "Required. A positive decimal number."],
                ["Number2", "Required. A positive decimal number."],
            ],
            COMBIN: [
                ["Number", "Required. The total number of items."],
                ["Number_chosen", "Required. The number of items in each combination."],
            ],
            COMBINA: [
                ["Number", "Required. The total number of items."],
                ["Number_chosen", "Required. The number of items in each combination."],
            ],
            COMPLEX: [
                ["Real_num", "Required. The real number."],
                ["I_num", "Required. The imaginary number."],
                ["Suffix", 'Optional. The suffix, either "i" or "j".'],
            ],
            CORREL: [
                ["Array1", "Required. A range of cell values."],
                ["Array2", "Required. A second range of cell values."],
            ],
            COS: [["Number", "Required. The angle in radians for which you want the cosine."]],
            COSH: [["Number", "Required. The hyperbolic angle."]],
            COT: [["Number", "Required. The angle provided in radians."]],
            COTH: [["Number", "Required."]],
            COUNTBLANK: [["Range", "Required. The range in which to count blank cells."]],
            COVAR: [
                ["Array1", "Required. The first cell range of integers."],
                ["Array2", "Required. The second cell range of integers."],
            ],
            "COVARIANCE.P": [
                ["Array1", "Required. The first cell range of integers."],
                ["Array2", "Required. The second cell range of integers."],
            ],
            "COVARIANCE.S": [
                ["Array1", "Required. The first cell range of integers."],
                ["Array2", "Required. The second cell range of integers."],
            ],
            CSC: [["Number", "Required. The angle provided in radians."]],
            CSCH: [["Number", "Required."]],
            DEC2BIN: [
                ["Number", "Required. The decimal number you want to convert to binary."],
                ["Places", "Optional. Pads the resulting binary number with zeros up to the specified number of digits. If omitted returns the least number of characters required to represent the number."],
            ],
            DEC2HEX: [
                ["Number", "Required. The decimal number you want to convert to hexadecimal."],
                ["Places", "Optional. Pads the resulting number with zeros up to the specified number of digits. If omitted returns the least number of characters required to represent the number."],
            ],
            DEC2OCT: [
                ["Number", "Required. The decimal number you want to convert to octal."],
                ["Places", "Optional. Pads the resulting octal number with zeros up to the specified number of digits. If omitted returns the least number of characters required to represent the number."],
            ],
            DECIMAL: [
                ["Number", "Required. A text string representing a number."],
                ["Radix", "Required. The base of the number to be converted, an integer between 2-36."],
            ],
            DEGREES: [["Angle", "Required. Angle in radians that you want to convert to degrees."]],
            DELTA: [
                ["Number1", "Required. The first number."],
                ["Number2", "Optional. The second number."],
            ],
            DEVSQ: [
                ["Number1", "Required. First value or reference."],
                ["Number2", "Optional. Second value or reference."],
            ],
            DIVIDE: [
                ["Number1", "Required. The number we are dividing."],
                ["Number2", "Required. The number by which we divide."],
            ],
            EQ: [
                ["Number1", "Required. First value or reference."],
                ["Number2", "Required. Second value or reference."],
            ],
            ERF: [
                ["Lower_limit", "Required. The lower bound for integrating ERF."],
                ["Upper_limit", "Optional. The upper bound for integrating ERF. If omitted, ERF integrates between zero and lower_limit."],
            ],
            ERFC: [["X", "Required. The lower bound for integrating ERFC."]],
            EVEN: [["Number", "Required. The number to round up to an even integer."]],
            FACT: [["Number", "Required. The number to get the factorial of."]],
            FACTDOUBLE: [["Number", "Required. A number greater than or equal to -1."]],
            FISHER: [["X", "Required. A numeric value for which you want the transformation."]],
            FISHERINV: [["Y", "Required. The value for which you want to perform the inverse of the transformation."]],
            GAMMA: [["Number", "Required. Returns a number."]],
            GCD: [
                ["Number1", "Required. The first number."],
                ["Number2", "Optional. The second number."],
            ],
            GEOMEAN: [
                ["Number1", "Required. First value or reference."],
                ["Number2", "Optional. Second value or reference."],
            ],
            GESTEP: [
                ["Number", "Required. The value to test against step."],
                ["Step", "Optional. The threshold value. If you omit a value for step, GESTEP uses zero."],
            ],
            GT: [
                ["Number1", "Required. First value or reference."],
                ["Number2", "Required. Second value or reference."],
            ],
            GTE: [
                ["Number1", "Required. First value or reference."],
                ["Number2", "Required. Second value or reference."],
            ],
            HARMEAN: [
                ["Number1", "Required. First value or reference."],
                ["Number2", "Optional. Second value or reference."],
            ],
            HEX2BIN: [
                ["Number", "Required. The hexadecimal number you want to convert to binary."],
                ["Places", "Optional. Pads the resulting binary number with zeros up to the specified number of digits. If omitted returns the least number of characters required to represent the number."],
            ],
            HEX2DEC: [["Number", "Required. The hexadecimal number you want to convert to decimal."]],
            HEX2OCT: [
                ["Number", "Required. The hexadecimal number you want to convert to octal."],
                ["Places", "Optional. Pads the resulting binary number with zeros up to the specified number of digits. If omitted returns the least number of characters required to represent the number."],
            ],
            IMABS: [["Inumber", "Required. A complex number."]],
            IMAGINARY: [["Inumber", "Required. A complex number."]],
            IMCONJUGATE: [["Inumber", "Required. A complex number for which you want the conjugate."]],
            IMCOS: [["Inumber", "Required. A complex number for which you want the cosine."]],
            IMCOSH: [["Inumber", "Required. A complex number for which you want the hyperbolic cosine."]],
            IMCOT: [],
            IMCSC: [["Inumber", "Required. A complex number for which you want the cosecant."]],
            IMCSCH: [["Inumber", "Required. A complex number for which you want the hyperbolic cosecant."]],
            IMDIV: [
                ["Inumber1", "Required. The complex numerator or dividend."],
                ["Inumber2", "Required. The complex denominator or divisor."],
            ],
            IMEXP: [["Inumber", "Required. A complex number for which you want the exponential."]],
            IMLN: [["Inumber", "Required. A complex number for which you want the natural logarithm."]],
            IMPOWER: [
                ["Inumber", "Required. A complex number."],
                ["Number", "Required. Power to raise number."],
            ],
            IMPRODUCT: [
                ["Inumber1", "Required. Complex number 1."],
                ["Inumber2", "Optional. Complex number 2."],
            ],
            IMREAL: [["Inumber", "Required. A complex number."]],
            IMSEC: [["Inumber", "Required. A complex number for which you want the secant."]],
            IMSECH: [["Inumber", "Required. A complex number for which you want the hyperbolic secant."]],
            IMSIN: [["Inumber", "Required. A complex number for which you want the sine."]],
            IMSINH: [["Inumber", "Required. A complex number for which you want the hyperbolic sine."]],
            IMSQRT: [["Inumber", "Required. A complex number for which you want the square root."]],
            IMSUB: [
                ["Inumber1", "Required. Complex number 1."],
                ["Inumber2", "Required. Complex number 2."],
            ],
            IMSUM: [
                ["Inumber1", "Required. Complex number 1."],
                ["Inumber2", "Optional. Complex number 2."],
            ],
            IMTAN: [["Inumber", "Required. A complex number for which you want the tangent."]],
            LARGE: [
                ["Array", "Required. An array or range of numeric values."],
                ["K", "Required. Position as an integer, where 1 corresponds to the largest value."],
            ],
            LN: [["Number", "Required. A number to take the natural logarithm of."]],
            LOG10: [["Number", "Required. Number for which you want the logarithm."]],
            LT: [
                ["Number1", "Required. First value or reference."],
                ["Number2", "Required. Second value or reference."],
            ],
            LTE: [
                ["Number1", "Required. First value or reference."],
                ["Number2", "Required. Second value or reference."],
            ],
            MEDIAN: [
                ["Number1", "Required. A number or cell reference that refers to numeric values."],
                ["Number2", "Optional. A number or cell reference that refers to numeric values."],
            ],
            MINUS: [
                ["Number1", "Required. The number from which we subtract."],
                ["Number2", "Required. The number by which we subtract."],
            ],
            MOD: [
                ["Number", "Required. The number to be divided."],
                ["Divisor", "Required. The number to divide with."],
            ],
            MROUND: [
                ["Number", "Required. The number that should be rounded."],
                ["Significance", "Required. The multiple to use when rounding."],
            ],
            MULTINOMIAL: [["Number1, number2, ...", "Required. Number1 is required, subsequent numbers are optional. 1 to 255 values for which you want the multinomial."]],
            MULTIPLY: [
                ["Number1", "Required. The number to multiply."],
                ["Number2", "Required. The number to multiply by."],
            ],
            NE: [
                ["Number1", "Required. First value or reference."],
                ["Number2", "Required. Second value or reference."],
            ],
            OCT2BIN: [
                [
                    "Number",
                    "Required. The octal number you want to convert. Number may not contain more than 10 characters. The most significant bit of number is the sign bit. The remaining 29 bits are magnitude bits. Negative numbers are represented using two's-complement notation.",
                ],
                ["Places", "Optional. The number of characters to use. If places is omitted, OCT2BIN uses the minimum number of characters necessary. Places is useful for padding the return value with leading 0s (zeros)."],
            ],
            OCT2DEC: [
                [
                    "Number",
                    "Required. The octal number you want to convert. Number may not contain more than 10 octal characters (30 bits). The most significant bit of number is the sign bit. The remaining 29 bits are magnitude bits. Negative numbers are represented using two's-complement notation.",
                ],
            ],
            OCT2HEX: [
                [
                    "Number",
                    "Required. The octal number you want to convert. Number may not contain more than 10 octal characters (30 bits). The most significant bit of number is the sign bit. The remaining 29 bits are magnitude bits. Negative numbers are represented using two's-complement notation.",
                ],
                ["Places", "Optional. The number of characters to use. If places is omitted, OCT2HEX uses the minimum number of characters necessary. Places is useful for padding the return value with leading 0s (zeros)."],
            ],
            ODD: [["Number", "Required. The number to round up to an odd integer."]],
            PERCENTILE: [
                ["Array", "Required. Data values."],
                ["K", "Required. Number representing kth percentile."],
            ],
            "PERCENTILE.INC": [
                ["Array", "Required. Data values."],
                ["K", "Required. Number representing kth percentile."],
            ],
            "PERCENTILE.EXC": [
                ["Array", "Required. Data values."],
                ["K", "Required. A value between 0 and 1 that represents the k:th percentile."],
            ],
            PERMUT: [
                ["Number", "Required. The total number of items."],
                ["Number_chosen", "Required. The number of items in each combination."],
            ],
            PI: [],
            POW: [
                ["Number", "Required. Number to raise to a power."],
                ["Power", "Required. Power to raise number to (the exponent)."],
            ],
            QUARTILE: [
                ["Array", "Required. A reference containing data to analyze."],
                ["Quart", "Required. The quartile value to return."],
            ],
            "QUARTILE.INC": [
                ["Array", "Required. A reference containing data to analyze."],
                ["Quart", "Required. The quartile value to return."],
            ],
            "QUARTILE.EXC": [
                ["Array", "Required. A reference containing data to analyze."],
                ["Quart", "Required. The quartile value to return, 1-3."],
            ],
            QUOTIENT: [
                ["Numerator", "Required. The number to be divided."],
                ["Denominator", "Required. The number to divide by."],
            ],
            RADIANS: [["Angle", "Required. Angle in degrees to convert to radians."]],
            ROMAN: [
                ["Number", "Required. Number (in Arabic numeral) you want to convert to Roman numeral."],
                ["Form", "Optional. The type of Roman numeral you want."],
            ],
            SEC: [["Number", "Required. The angle in radians for which you want the secant."]],
            SECH: [],
            SIGN: [["Number", "Required. The number to get the sign of."]],
            SIN: [["Number", "Required. The angle in radians for which you want the sine."]],
            SINH: [["Number", "Required. The hyperbolic angle."]],
            SMALL: [
                ["Array", "Required. An array or range of numeric values."],
                ["K", "Required. Position as an integer, where 1 corresponds to the smallest value."],
            ],
            SQRTPI: [["Number", "Required. The number by which pi is multiplied."]],
            STDEV: [
                ["Number1", "Required. First number or reference in the sample."],
                ["Number2", "Optional. Second number or reference."],
            ],
            "STDEV.S": [
                ["Number1", "Required. First number or reference in the sample."],
                ["Number2", "Optional. Second number or reference."],
            ],
            "STDEV.P": [
                ["Number1", "Required. First number or reference in the sample."],
                ["Number2", "Optional. Second number or reference."],
            ],
            STDEVA: [
                ["Number1", "Required. First number or reference in the sample."],
                ["Number2", "Optional. Second number or reference."],
            ],
            STDEVP: [
                ["Number1", "Required. First number or reference in the sample."],
                ["Number2", "Optional. Second number or reference."],
            ],
            STDEVPA: [
                ["Number1", "Required. First number or reference in the sample."],
                ["Number2", "Optional. Second number or reference."],
            ],
            STEYX: [
                ["Known_y's", "Required. An array or range of dependent data points."],
                ["Known_x's", "Required. An array or range of independent data points."],
            ],
            SUBTOTAL: [
                ["Function_num", "Required. A number that specifies which function to use in calculating subtotals within a list. See table below for full list."],
                ["Ref1", "Required. A named range or reference to subtotal."],
                ["Ref2", "Optional. A named range or reference to subtotal."],
            ],
            SUMSQ: [
                ["Number1", "Required. The first argument containing numeric values."],
                ["Number2", "Optional. The first argument containing numeric values."],
            ],
            SUMX2MY2: [
                ["Array_x", "Required. The first range or array containing numeric values."],
                ["Array_y", "Required. The second range or array containing numeric values."],
            ],
            SUMX2PY2: [
                ["Array_x", "Required. The first range or array containing numeric values."],
                ["Array_y", "Required. The second range or array containing numeric values."],
            ],
            SUMXMY2: [
                ["Array_x", "Required. The first range or array containing numeric values."],
                ["Array_y", "Required. The second range or array containing numeric values."],
            ],
            TAN: [["Number", "Required. The angle in radians for which you want the tangent."]],
            TANH: [["Number", "Required. Any real number."]],
            TRUNC: [
                ["Number", "Required. The number to truncate."],
                ["Num_digits", "Optional. The precision of the truncation (default is 0)."],
            ],
            VAR: [
                ["Number1", "Required. First number or reference."],
                ["Number2", "Optional. Second number or reference."],
            ],
            "VAR.S": [
                ["Number1", "Required. First number or reference."],
                ["Number2", "Optional. Second number or reference."],
            ],
            "VAR.P": [
                ["Number1", "Required. First number or reference."],
                ["Number2", "Optional. Second number or reference."],
            ],
            VARA: [
                ["Number1", "Required. First number or reference."],
                ["Number2", "Optional. Second number or reference."],
            ],
            VARP: [
                ["Number1", "Required. First number or reference."],
                ["Number2", "Optional. Second number or reference."],
            ],
            VARPA: [
                ["Number1", "Required. First number or reference."],
                ["Number2", "Optional. Second number or reference."],
            ],
            WEIBULL: [
                ["X", "Required. The value at which to evaluate the function."],
                ["Alpha", "Required. A parameter to the distribution."],
                ["Beta", "Required. A parameter to the distribution."],
                ["Cumulative", "Required. Determines the form of the function."],
            ],
            "WEIBULL.DIST": [
                ["X", "Required. The value at which to evaluate the function."],
                ["Alpha", "Required. A parameter to the distribution."],
                ["Beta", "Required. A parameter to the distribution."],
                ["Cumulative", "Required. Determines the form of the function."],
            ],
            CHAR: [["Number", "Required. A number between 1 and 255."]],
            CLEAN: [["Text", "Required. The text to clean."]],
            CODE: [["Text", "Required. The text for which you want a numeric code."]],
            EXACT: [
                ["Text1", "Required. The first text string to compare."],
                ["Text2", "Required. The second text string to compare."],
            ],
            FIXED: [
                ["Number", "Required. The number to round and format."],
                ["Decimals", "Optional. Number of decimals to use. Default is 2."],
                ["No_commas", "Optional. Suppress commas. TRUE = no commas, FALSE = commas. Default is FALSE."],
            ],
            NUMBERVALUE: [
                ["Text", "Required. The text to convert to a number."],
                ["Decimal_separator", "Optional. The character for decimal values."],
                ["Group_separator", "Optional. The character for grouping by thousands."],
            ],
            REGEXEXTRACT: [
                ["Text", "Required. The input text."],
                ["Regular_expression", "Required. The first part of text that matches this expression will be returned."],
            ],
            REGEXMATCH: [
                ["Text", "Required. The text to be tested against the regular expression."],
                ["Regular_expression", "Required. The regular expression to test the text against."],
            ],
            REGEXREPLACE: [
                ["Text", "Required. The text, a part of which will be replaced."],
                ["Regular_expression", "Required. The regular expression. All matching instances in text will be replaced."],
                ["Replacement", "Required. The text which will be inserted into the original text."],
            ],
            REPT: [
                ["Text", "Required. The text to repeat."],
                ["Number_times", "Required. The number of times to repeat text."],
            ],
            T: [["Value", "Required. The value to return as text."]],
            JOIN: [["Text1, text2, ..."], ["Text you want to combine"]],
            ARRAYTOTEXT: [
                ["Array", "Required. The array or range to convert to text."],
                ["Format", "Optional. Output format. 0 = concise (default), and 1 = strict."],
            ],
            DATEVALUE: [["Date_text", "Required. A valid date in text format."]],
            DAYS: [
                ["End_date", "Required. The end date."],
                ["Start_date", "Required. The start date."],
            ],
            DAYS360: [
                ["Start_date", "Required. The start date."],
                ["End_date", "Required. The end date."],
                ["Method", "Optional. Day count method. FALSE (default) = US method, TRUE = European method."],
            ],
            EDATE: [
                ["Start_date", "Required. Start date as a valid Excel date."],
                ["Months", "Required. Number of months before or after start_date."],
            ],
            EOMONTH: [
                ["Start_date", "Required. A date that represents the start date in a valid Excel serial number format."],
                ["Months", "Required. The number of months before or after start_date."],
            ],
            ISOWEEKNUM: [["Date", "Required. A valid Excel date in serial number format."]],
            NETWORKDAYS: [
                ["Start_date", "Required. The start date."],
                ["End_date", "Required. The end date."],
                ["Holidays", "Optional. A list of non-work days as dates."],
            ],
            "NETWORKDAYS.INTL": [
                ["Start_date", "Required. The start date."],
                ["End_date", "Required. The end date."],
                ["Weekend", "Optional. Setting for which days of the week should be considered weekends."],
                ["Holidays", "Optional. A reference to dates that should be considered non-work days."],
            ],
            TIMEVALUE: [["Time_text", "Required. A date and/or time in a text format recognized by Excel."]],
            WEEKNUM: [
                ["Serial_num", "Required. A valid Excel date in serial number format."],
                ["Return_type", "Optional. The day the week begins. Default is 1."],
            ],
            WEEKDAY: [
                ["Serial_number", "Required. The date for which you want to get the day of week."],
                ["Return_type", "Optional. A number representing day of week mapping scheme. Default is 1."],
            ],
            WORKDAY: [
                ["Start_date", "Required. The date from which to start."],
                ["Days", "Required. The working days before or after start_date."],
                ["Holidays", "Optional. A list dates that should be considered non-work days."],
            ],
            "WORKDAY.INTL": [
                ["Start_date", "Required. The start date."],
                ["Days", "Required. The end date."],
                ["Weekend", "Optional. Setting for which days of the week should be considered weekends."],
                ["Holidays", "Optional. A list of one or more dates that should be considered non-work days."],
            ],
            YEARFRAC: [
                ["Start_date", "Required. The start date."],
                ["End_date", "Required. The end date."],
                ["Basis", "Optional. The type of day count basis to use (see below)."],
            ],
            ACCRINT: [
                ["Id", "Required. Issue date of the security."],
                ["Fd", "Required. First interest date of security."],
                ["Sd", "Required. Settlement date of security."],
                ["Rate", "Required. Interest rate of security."],
                ["Par", "Required. Par value of security."],
                ["Freq", "Required. Coupon payments per year (annual = 1, semiannual = 2; quarterly = 4)."],
                ["Basis", "Optional. Day count basis (see below, default =0)."],
                ["Calc", "Optional. Calculation method (see below, default = TRUE)."],
            ],
            PMT: [
                ["Rate", "Required. The interest rate for the loan."],
                ["Nper", "Required. The total number of payments for the loan."],
                ["Pv", "Required. The present value, or total value of all loan payments now."],
                ["Fv", "Optional. The future value, or a cash balance you want after the last payment is made. Defaults to 0 (zero)."],
                ["Type", "Optional. When payments are due. 0 = end of period. 1 = beginning of period. Default is 0."],
            ],
            FV: [
                ["Rate", "Required. The interest rate per period."],
                ["Nper", "Required. The total number of payment periods."],
                ["Pmt", "Required. The payment made each period. Must be entered as a negative number."],
                ["Pv", "Optional. The present value of future payments. If omitted, assumed to be zero. Must be entered as a negative number."],
                ["Type", "Optional. When payments are due. 0 = end of period, 1 = beginning of period. Default is 0."],
            ],
            DB: [
                ["Cost", "Required. Initial cost of asset."],
                ["Salvage", "Required. Asset value at the end of the depreciation."],
                ["Life", "Required. Periods over which asset is depreciated."],
                ["Period", "Required. Period to calculation depreciation for."],
                ["Month", "Optional. Number of months in the first year. Defaults to 12."],
            ],
            DDB: [
                ["Cost", "Required. Initial cost of asset."],
                ["Salvage", "Required. Asset value at the end of the depreciation."],
                ["Life", "Required. Periods over which asset is depreciated."],
                ["Period", "Required. Period to calculation depreciation for."],
                ["Factor", "Optional. Rate at which the balance declines. If omitted, defaults to 2."],
            ],
            DOLLAR: [
                ["Number", "Required. The number to convert."],
                ["Decimals", "Required. The number of digits to the right of the decimal point. Default is 2."],
            ],
            DOLLARDE: [
                ["Fractional_dollar", "Required. Dollar component in special fractional notation."],
                ["Fraction", "Required. The denominator in the fractional unit. 8 = 1/8, 16 = 1/16, 32 = 1/32, etc."],
            ],
            DOLLARFR: [
                ["Decimal_dollar", "Required. Pricing as a normal decimal number."],
                ["Fraction", "Required. The denominator in the fractional unit. 8 = 1/8, 16 = 1/16, 32 = 1/32, etc."],
            ],
            EFFECT: [
                ["Nominal_rate", "Required. The nominal or stated interest rate."],
                ["Npery", "Required. Number of compounding periods per year."],
            ],
            FVSCHEDULE: [
                ["Principal", "Required. The initial investment sum."],
                ["Schedule", "Required. Schedule of interest rates, provided as range or array."],
            ],
            IRR: [
                ["Values", "Required. Array or reference to cells that contain values."],
                ["Guess", "Optional. An estimate for expected IRR. Default is .1 (10%)."],
            ],
            IPMT: [
                ["Rate", "Required. The interest rate per period."],
                ["Per", "Required. The payment period of interest."],
                ["Nper", "Required. The total number of payment periods."],
                ["Pv", "Required. The present value, or total value of all payments now."],
                ["Fv", "Optional. The cash balance desired after last payment is made. Defaults to 0."],
                ["Type", "Optional. When payments are due. 0 = end of period. 1 = beginning of period. Default is 0."],
            ],
            ISPMT: [
                ["Rate", "Required. Interest rate."],
                ["Per", "Required. Period (starts with zero, not 1)."],
                ["Nper", "Required. Number of periods."],
                ["Pv", "Required. Present value."],
            ],
            NPV: [
                ["Rate", "Required. Discount rate over one period."],
                ["Value1", "Required. First value(s) representing cash flows."],
                ["Value2", "Optional. Second value(s) representing cash flows."],
            ],
            NOMINAL: [
                ["Effect_rate", "Required. The effective annual interest rate."],
                ["Npery", "Required. Number of compounding periods per year."],
            ],
            NPER: [
                ["Rate", "Required. The interest rate per period."],
                ["Pmt", "Required. The payment made each period."],
                ["Pv", "Required. The present value, or total value of all payments now."],
                ["Fv", "Optional. The future value, or a cash balance you want after the last payment is made. Defaults to 0."],
                ["Type", "Optional. When payments are due. 0 = end of period. 1 = beginning of period. Default is 0."],
            ],
            PDURATION: [
                ["Rate", "Required. Interest rate per period."],
                ["Pv", "Required. Present value of the investment."],
                ["Fv", "Required. Future value of the investment."],
            ],
            PPMT: [
                ["Rate", "Required. The interest rate per period."],
                ["Per", "Required. The payment period of interest."],
                ["Nper", "Required. The total number of payments for the loan."],
                ["Pv", "Required. The present value, or total value of all payments now."],
                ["Fv", "Optional. The cash balance desired after last payment is made. Defaults to 0."],
                ["Type", "Optional. When payments are due. 0 = end of period. 1 = beginning of period. Default is 0."],
            ],
            PV: [
                ["Rate", "Required. The interest rate per period."],
                ["Nper", "Required. The number of payment periods."],
                ["Pmt", "Required. The payment made each period."],
                ["Fv", "Optional. Future value. If omitted, defaults to zero."],
                ["Type", "Optional. Payment type, 0 = end of period, 1 = beginning of period. Default is 0."],
            ],
            SYD: [
                ["Cost", "Required. Initial cost of asset."],
                ["Salvage", "Required. Asset value at the end of the depreciation."],
                ["Life", "Required. Periods over which asset is depreciated."],
                ["Period", "Required. Period to calculation depreciation for."],
            ],
            TBILLPRICE: [
                ["Settlement", "Required. Settlement date of the security."],
                ["Maturity", "Required. Maturity date of the security."],
                ["Discount", "Required. The discount rate for the security."],
            ],
            TBILLYIELD: [
                ["Settlement", "Required. Settlement date of the security."],
                ["Maturity", "Required. Maturity date of the security."],
                ["Price", "Required. Price per $100."],
            ],
        },
        de: {
            SUM: [
                ["Zahl1", "Erforderlich. Der erste zu summierende Wert."],
                ["Zahl2", "Optional. Der zweite zu summierende Wert."],
                ["Zahl3", "Optional. Der dritte zu summierende Wert."],
            ],
            AVERAGE: [
                ["Zahl1", "Erforderlich. Eine Zahl oder ein Zellbezug, der auf numerische Werte verweist."],
                ["Zahl2", "Optional. Eine Zahl oder ein Zellbezug, der auf numerische Werte verweist."],
            ],
            AVERAGEA: [
                ["Wert1", "Erforderlich. Ein Wert oder ein Bezug zu einem Wert, der als Zahl ausgewertet werden kann."],
                ["Wert2", "Optional. Ein Wert oder ein Bezug zu einem Wert, der als Zahl ausgewertet werden kann."],
            ],
            COUNT: [
                ["Wert1", "Erforderlich. Ein Element, Zellbezug oder Bereich."],
                ["Wert2", "Optional. Ein Element, Zellbezug oder Bereich."],
            ],
            COUNTA: [
                ["Wert1", "Erforderlich. Ein Element, Zellbezug oder Bereich."],
                ["Wert2", "Optional. Ein Element, Zellbezug oder Bereich."],
            ],
            MIN: [
                ["Zahl1", "Erforderlich. Zahl, Bezug zu einem numerischen Wert oder Bereich, der numerische Werte enthält."],
                ["Zahl2", "Optional. Zahl, Bezug zu einem numerischen Wert oder Bereich, der numerische Werte enthält."],
            ],
            MAX: [
                ["Zahl1", "Erforderlich. Zahl, Bezug zu einem numerischen Wert oder Bereich, der numerische Werte enthält."],
                ["Zahl2", "Optional. Zahl, Bezug zu einem numerischen Wert oder Bereich, der numerische Werte enthält."],
            ],
            SQRT: [["Zahl", "Erforderlich. Die Zahl, von der die Quadratwurzel berechnet werden soll."]],
            POWER: [
                ["Zahl", "Erforderlich. Zahl, die potenziert werden soll."],
                ["Potenz", "Erforderlich. Potenz, auf die die Zahl erhöht wird (der Exponent)."],
            ],
            LOG: [
                ["Zahl", "Erforderlich. Zahl, für die der Logarithmus berechnet werden soll."],
                ["Basis", "Optional. Basis des Logarithmus. Standard ist 10."],
            ],
            EXP: [["Zahl", "Erforderlich. Die Potenz, auf die die Euler-Zahl e erhöht wird."]],
            PRODUCT: [
                ["Zahl1", "Erforderlich. Die erste Zahl oder der Bereich, der multipliziert werden soll."],
                ["Zahl2", "Optional. Die zweite Zahl oder der Bereich, der multipliziert werden soll."],
            ],
            SUMPRODUCT: [
                ["Array1", "Erforderlich. Das erste Array oder der Bereich, der multipliziert und dann addiert wird."],
                ["Array2", "Optional. Das zweite Array oder der Bereich, der multipliziert und dann addiert wird."],
            ],
            ABS: [["Zahl", "Erforderlich. Die Zahl, von der der Absolutwert berechnet werden soll."]],
            RAND: [],
            RANDBETWEEN: [
                ["UntereGrenze", "Erforderlich. Eine Ganzzahl, die den unteren Wert des Bereichs darstellt."],
                ["ObereGrenze", "Erforderlich. Eine Ganzzahl, die den oberen Wert des Bereichs darstellt."],
            ],
            ROUND: [
                ["Zahl", "Erforderlich. Die zu rundende Zahl."],
                ["AnzahlStellen", "Erforderlich. Die Stelle, an der die Zahl gerundet werden soll."],
            ],
            ROUNDUP: [
                ["Zahl", "Erforderlich. Die aufzurundende Zahl."],
                ["AnzahlStellen", "Erforderlich. Die Stelle, an der die Zahl gerundet werden soll."],
            ],
            ROUNDDOWN: [
                ["Zahl", "Erforderlich. Die abzurundende Zahl."],
                ["AnzahlStellen", "Erforderlich. Die Stelle, an der die Zahl gerundet werden soll."],
            ],
            INT: [["Zahl", "Erforderlich. Die Zahl, von der eine Ganzzahl berechnet werden soll."]],
            CEILING: [
                ["Zahl", "Erforderlich. Die zu rundende Zahl."],
                ["Schrittweite", "Erforderlich. Das Vielfache, das beim Runden verwendet werden soll."],
            ],
            FLOOR: [
                ["Zahl", "Erforderlich. Die zu rundende Zahl."],
                ["Schrittweite", "Erforderlich. Das Vielfache, das beim Runden verwendet werden soll."],
            ],
            CONCATENATE: [
                ["Text1", "Erforderlich. Der erste Textwert, der zusammengeführt werden soll."],
                ["Text2", "Erforderlich. Der zweite Textwert, der zusammengeführt werden soll."],
                ["Text3", "Optional. Der dritte Textwert, der zusammengeführt werden soll."],
            ],
            MID: [
                ["Text", "Erforderlich. Der Text, aus dem extrahiert werden soll."],
                ["Startposition", "Erforderlich. Die Position des ersten zu extrahierenden Zeichens."],
                ["AnzahlZeichen", "Erforderlich. Die Anzahl der zu extrahierenden Zeichen."],
            ],
            LEFT: [
                ["Text", "Erforderlich. Der Text, aus dem Zeichen extrahiert werden sollen."],
                ["AnzahlZeichen", "Optional. Die Anzahl der Zeichen, die von links extrahiert werden sollen. Standard = 1."],
            ],
            RIGHT: [
                ["Text", "Erforderlich. Der Text, aus dem Zeichen rechts extrahiert werden sollen."],
                ["AnzahlZeichen", "Optional. Die Anzahl der Zeichen, die von rechts extrahiert werden sollen. Standard = 1."],
            ],
            LOWER: [["Text", "Erforderlich. Der Text, der in Kleinbuchstaben umgewandelt werden soll."]],
            UPPER: [["Text", "Erforderlich. Der Text, der in Großbuchstaben umgewandelt werden soll."]],
            PROPER: [["Text", "Erforderlich. Der Text, der in die korrekte Groß-/Kleinschreibung umgewandelt werden soll."]],
            TRIM: [["Text", "Erforderlich. Der Text, aus dem überflüssige Leerzeichen entfernt werden sollen."]],
            LEN: [["Text", "Erforderlich. Der Text, für den die Länge berechnet werden soll."]],
            SEARCH: [
                ["Suchtext", "Erforderlich. Der zu findende Teilstring."],
                ["InText", "Erforderlich. Der Text, in dem gesucht werden soll."],
                ["Startposition", "Optional. Startposition. Standard ist 1."],
            ],
            FIND: [
                ["Suchtext", "Erforderlich. Der zu findende Teilstring."],
                ["InText", "Erforderlich. Der Text, in dem gesucht werden soll."],
                ["Startposition", "Optional. Die Startposition im Text für die Suche. Standard ist 1."],
            ],
            REPLACE: [
                ["AlterText", "Erforderlich. Der zu ersetzende Text."],
                ["Startposition", "Erforderlich. Die Startposition im Text für die Suche."],
                ["AnzahlZeichen", "Erforderlich. Die Anzahl der zu ersetzenden Zeichen."],
                ["NeuerText", "Erforderlich. Der Text, mit dem der alte Text ersetzt werden soll."],
            ],
            SUBSTITUTE: [
                ["Text", "Erforderlich. Der zu ändernde Text."],
                ["AlterText", "Erforderlich. Der zu ersetzende Text."],
                ["NeuerText", "Erforderlich. Der Text, mit dem ersetzt werden soll."],
                ["Instanz", "Optional. Die zu ersetzende Instanz. Wenn nicht angegeben, werden alle Instanzen ersetzt."],
            ],
            NOW: [],
            DATE: [
                ["Jahr", "Erforderlich. Zahl für das Jahr."],
                ["Monat", "Erforderlich. Zahl für den Monat."],
                ["Tag", "Erforderlich. Zahl für den Tag."],
            ],
            TIME: [
                ["Stunde", "Erforderlich. Die Stunde für die zu erstellende Zeit."],
                ["Minute", "Erforderlich. Die Minute für die zu erstellende Zeit."],
                ["Sekunde", "Erforderlich. Die Sekunde für die zu erstellende Zeit."],
            ],
            YEAR: [["Datum", "Erforderlich. Ein gültiges Excel-Datum."]],
            MONTH: [["Seriennummer", "Erforderlich. Ein gültiges Excel-Datum."]],
            DAY: [["Datum", "Erforderlich. Ein gültiges Excel-Datum."]],
            HOUR: [["Seriennummer", "Erforderlich. Eine gültige Excel-Zeit."]],
            MINUTE: [["Seriennummer", "Erforderlich. Ein gültiges Datum oder eine gültige Zeit."]],
            SECOND: [["Seriennummer", "Erforderlich. Eine gültige Zeit in einem von Excel erkannten Format."]],
            DATEDIF: [
                ["Startdatum", "Erforderlich. Startdatum im Excel-Datumsseriennummernformat."],
                ["Enddatum", "Erforderlich. Enddatum im Excel-Datumsseriennummernformat."],
                ["Einheit", "Erforderlich. Die zu verwendende Zeiteinheit (Jahre, Monate oder Tage)."],
            ],
            LOOKUP: [
                ["Suchwert", "Erforderlich. Der zu suchende Wert."],
                ["Suchvektor", "Erforderlich. Der einzeilige oder einspaltige Bereich, in dem gesucht wird."],
                ["Ergebnisvektor", "Optional. Der einzeilige oder einspaltige Bereich der Ergebnisse."],
            ],
            HLOOKUP: [
                ["Suchwert", "Erforderlich. Der zu suchende Wert."],
                ["Tabellenarray", "Erforderlich. Die Tabelle, aus der Daten abgerufen werden sollen."],
                ["Zeilenindex", "Erforderlich. Die Zeilennummer, aus der Daten abgerufen werden sollen."],
                ["Bereichssuche", "Optional. Ein Boolean-Wert, der eine exakte oder ungefähre Übereinstimmung angibt. Standard = WAHR = ungefähre Übereinstimmung."],
            ],
            VLOOKUP: [
                ["Suchwert", "Erforderlich. Der Wert, der in der ersten Spalte einer Tabelle gesucht werden soll."],
                ["Tabellenarray", "Erforderlich. Die Tabelle, aus der ein Wert abgerufen werden soll."],
                ["Spaltenindex", "Erforderlich. Die Spalte in der Tabelle, aus der ein Wert abgerufen werden soll."],
                ["Bereichssuche", "Optional. WAHR = ungefähre Übereinstimmung (Standard). FALSCH = exakte Übereinstimmung."],
            ],
            XLOOKUP: [
                ["Suchwert", "Erforderlich. Der Suchwert."],
                ["Sucharray", "Erforderlich. Das Array oder der Bereich, in dem gesucht werden soll."],
                ["Ergebnisarray", "Erforderlich. Das Array oder der Bereich, der zurückgegeben werden soll."],
                ["NichtGefunden", "Optional. Wert, der zurückgegeben wird, wenn keine Übereinstimmung gefunden wird."],
                ["Übereinstimmungsmodus", "Optional. 0 = exakte Übereinstimmung (Standard), -1 = exakte Übereinstimmung oder nächster kleinerer Wert, 1 = exakte Übereinstimmung oder nächster größerer Wert, 2 = Platzhalterübereinstimmung."],
                ["Suchmodus", "Optional. 1 = Suche ab dem ersten (Standard), -1 = Suche ab dem letzten, 2 = binäre Suche aufsteigend, -2 = binäre Suche absteigend."],
            ],
            INDEX: [
                ["Array", "Erforderlich. Ein Zellbereich oder eine Array-Konstante."],
                ["Zeilennummer", "Erforderlich. Die Zeilenposition im Bezug oder Array."],
                ["Spaltennummer", "Optional. Die Spaltenposition im Bezug oder Array."],
                ["Bereichsnummer", "Optional. Der Bereich im Bezug, der verwendet werden soll."],
            ],
            MATCH: [
                ["Suchwert", "Erforderlich. Der Wert, der im Sucharray abgeglichen werden soll."],
                ["Sucharray", "Erforderlich. Ein Zellbereich oder ein Array-Bezug."],
                ["Übereinstimmungstyp", "Optional. 1 = exakt oder nächster kleinerer Wert (Standard), 0 = exakte Übereinstimmung, -1 = exakt oder nächster größerer Wert."],
            ],
            XMATCH: [
                ["Suchwert", "Erforderlich. Der Suchwert."],
                ["Sucharray", "Erforderlich. Das Array oder der Bereich, in dem gesucht werden soll."],
                ["Übereinstimmungsmodus", "Optional. 0 = exakte Übereinstimmung (Standard), -1 = exakte Übereinstimmung oder nächster kleinerer Wert, 1 = exakte Übereinstimmung oder nächster größerer Wert, 2 = Platzhalterübereinstimmung."],
                ["Suchmodus", "Optional. 1 = Suche ab dem ersten (Standard), -1 = Suche ab dem letzten, 2 = binäre Suche aufsteigend, -2 = binäre Suche absteigend."],
            ],
            CHOOSE: [
                ["Indexnummer", "Erforderlich. Der auszuwählende Wert. Eine Zahl zwischen 1 und 254."],
                ["Wert1", "Erforderlich. Der erste Wert, aus dem ausgewählt werden soll."],
                ["Wert2", "Optional. Der zweite Wert, aus dem ausgewählt werden soll."],
            ],
            ISBLANK: [["Wert", "Erforderlich. Der zu überprüfende Wert."]],
            ISBINARY: [["Wert", "Erforderlich. Der zu überprüfende Wert."]],
            ISEVEN: [["Wert", "Erforderlich. Der numerische Wert, der überprüft werden soll."]],
            ISODD: [["Wert", "Erforderlich. Der numerische Wert, der überprüft werden soll."]],
            ISNONTEXT: [["Wert", "Erforderlich. Der zu überprüfende Wert."]],
            ISNUMBER: [["Wert", "Erforderlich. Der zu überprüfende Wert."]],
            ISTEXT: [["Wert", "Erforderlich. Der zu überprüfende Wert."]],
            N: [["Wert", "Erforderlich. Der Wert, der in eine Zahl umgewandelt werden soll."]],
            IF: [
                ["LogischerTest", "Erforderlich. Ein Wert oder logischer Ausdruck, der als WAHR oder FALSCH ausgewertet werden kann."],
                ["WertWennWahr", "Optional. Der Wert, der zurückgegeben wird, wenn der logische Test WAHR ergibt."],
                ["WertWennFalsch", "Optional. Der Wert, der zurückgegeben wird, wenn der logische Test FALSCH ergibt."],
            ],
            AND: [
                ["Logisch1", "Erforderlich. Die erste Bedingung oder der logische Wert, der ausgewertet werden soll."],
                ["Logisch2", "Optional. Die zweite Bedingung oder der logische Wert, der ausgewertet werden soll."],
            ],
            NOT: [["Logisch", "Erforderlich. Ein Wert oder logischer Ausdruck, der als WAHR oder FALSCH ausgewertet werden kann."]],
            OR: [
                ["Logisch1", "Erforderlich. Die erste Bedingung oder der logische Wert, der ausgewertet werden soll."],
                ["Logisch2", "Optional. Die zweite Bedingung oder der logische Wert, der ausgewertet werden soll."],
            ],
            FALSE: [],
            TRUE: [],
            ACOS: [["Zahl", "Erforderlich. Der Wert, von dem der inverse Kosinus berechnet werden soll. Die Zahl muss zwischen -1 und 1 liegen."]],
            ACOSH: [["Zahl", "Erforderlich. Eine reelle Zahl, die gleich oder größer als 1 ist."]],
            ACOT: [["Zahl", "Erforderlich. Die Zahl ist der Kotangens des gewünschten Winkels. Muss eine reelle Zahl sein."]],
            ACOTH: [["Zahl", "Erforderlich. Der Absolutwert der Zahl muss größer als 1 sein."]],
            ADD: [
                ["Zahl1", "Erforderlich. Der erste zu summierende Wert."],
                ["Zahl2", "Erforderlich. Der zweite zu summierende Wert."],
            ],
            ARABIC: [["RömischerText", "Erforderlich. Die römische Zahl in Textform, die konvertiert werden soll."]],
            ASIN: [["Zahl", "Erforderlich. Der Wert, von dem der inverse Sinus berechnet werden soll. Die Zahl muss zwischen -1 und 1 liegen."]],
            ASINH: [["Zahl", "Erforderlich. Eine beliebige reelle Zahl."]],
            ATAN: [["Zahl", "Erforderlich. Der Wert, von dem der inverse Tangens berechnet werden soll."]],
            ATAN2: [
                ["X_Zahl", "Erforderlich. Die x-Koordinate des Eingabepunkts."],
                ["Y_Zahl", "Erforderlich. Die y-Koordinate des Eingabepunkts."],
            ],
            ATANH: [["Zahl", "Erforderlich. Eine reelle Zahl zwischen 1 und -1."]],
            AVEDEV: [
                ["Zahl1", "Erforderlich. Erster Wert oder Bezug."],
                ["Zahl2", "Optional. Zweiter Wert oder Bezug."],
            ],
            BASE: [
                ["Zahl", "Erforderlich. Die Zahl, die in eine gegebene Basis konvertiert werden soll."],
                ["Radix", "Erforderlich. Die Basis, in die konvertiert werden soll."],
                ["MinLänge", "Optional. Die minimale Zeichenfolgenlänge, die durch Auffüllen mit Nullen erreicht wird."],
            ],
            BINOMDIST: [
                ["AnzahlErfolge", "Erforderlich. Die Anzahl der Erfolge."],
                ["Versuche", "Erforderlich. Die Anzahl der unabhängigen Versuche."],
                ["Erfolgswahrscheinlichkeit", "Erforderlich. Die Erfolgswahrscheinlichkeit bei jedem Versuch."],
                ["Kumulativ", "Erforderlich. WAHR = kumulative Verteilungsfunktion, FALSCH = Wahrscheinlichkeitsdichtefunktion."],
            ],
            "BINOM.INV": [
                ["Versuche", "Erforderlich. Die Anzahl der Bernoulli-Versuche."],
                ["Erfolgswahrscheinlichkeit", "Erforderlich. Die Wahrscheinlichkeit eines Erfolgs bei jedem Versuch."],
                ["Alpha", "Erforderlich. Der Kriteriumswert."],
            ],
            "BINOM.DIST.RANGE": [
                ["Versuche", "Erforderlich. Die Anzahl der unabhängigen Versuche. Muss größer oder gleich 0 sein."],
                ["Erfolgswahrscheinlichkeit", "Erforderlich. Die Erfolgswahrscheinlichkeit bei jedem Versuch. Muss größer oder gleich 0 und kleiner oder gleich 1 sein."],
                ["AnzahlErfolge", "Erforderlich. Die Anzahl der Erfolge in den Versuchen. Muss größer oder gleich 0 und kleiner oder gleich der Anzahl der Versuche sein."],
                [
                    "AnzahlErfolge2",
                    ".Concurrent. Falls angegeben, wird die Wahrscheinlichkeit zurückgegeben, dass die Anzahl der erfolgreichen Versuche zwischen AnzahlErfolge und AnzahlErfolge2 liegt. Muss größer oder gleich AnzahlErfolge und kleiner oder gleich Versuche sein.",
                ],
            ],
            "BINOM.DIST": [
                ["AnzahlErfolge", "Erforderlich. Die Anzahl der Erfolge."],
                ["Versuche", "Erforderlich. Die Anzahl der unabhängigen Versuche."],
                ["Erfolgswahrscheinlichkeit", "Erforderlich. Die Erfolgswahrscheinlichkeit bei jedem Versuch."],
                ["Kumulativ", "Erforderlich. WAHR = kumulative Verteilungsfunktion, FALSCH = Wahrscheinlichkeitsdichtefunktion."],
            ],
            BITAND: [
                ["Zahl1", "Erforderlich. Eine positive Dezimalzahl."],
                ["Zahl2", "Erforderlich. Eine positive Dezimalzahl."],
            ],
            BITLSHIFT: [
                ["Zahl", "Erforderlich. Die Zahl, die bitweise verschoben werden soll."],
                ["Verschiebung", "Erforderlich. Die Anzahl der Bits, um die verschoben wird. Bei negativem Wert wird nach rechts verschoben."],
            ],
            BITOR: [
                ["Zahl1", "Erforderlich. Eine positive Dezimalzahl."],
                ["Zahl2", "Erforderlich. Eine positive Dezimalzahl."],
            ],
            BITRSHIFT: [
                ["Zahl", "Erforderlich. Die Zahl, die bitweise verschoben werden soll."],
                ["Verschiebung", "Erforderlich. Die Anzahl der Bits, um die nach rechts verschoben wird. Bei negativem Wert wird nach links verschoben."],
            ],
            BITXOR: [
                ["Zahl1", "Erforderlich. Eine positive Dezimalzahl."],
                ["Zahl2", "Erforderlich. Eine positive Dezimalzahl."],
            ],
            COMBIN: [
                ["Zahl", "Erforderlich. Die Gesamtzahl der Elemente."],
                ["AusgewählteZahl", "Erforderlich. Die Anzahl der Elemente in jeder Kombination."],
            ],
            COMBINA: [
                ["Zahl", "Erforderlich. Die Gesamtzahl der Elemente."],
                ["AusgewählteZahl", "Erforderlich. Die Anzahl der Elemente in jeder Kombination."],
            ],
            COMPLEX: [
                ["Realteil", "Erforderlich. Die reelle Zahl."],
                ["Imaginärteil", "Erforderlich. Die imaginäre Zahl."],
                ["Suffix", 'Optional. Das Suffix, entweder "i" oder "j".'],
            ],
            CORREL: [
                ["Array1", "Erforderlich. Ein Bereich von Zellwerten."],
                ["Array2", "Erforderlich. Ein zweiter Bereich von Zellwerten."],
            ],
            COS: [["Zahl", "Erforderlich. Der Winkel in Radiant, für den der Kosinus berechnet werden soll."]],
            COSH: [["Zahl", "Erforderlich. Der hyperbolische Winkel."]],
            COT: [["Zahl", "Erforderlich. Der Winkel in Radiant."]],
            COTH: [["Zahl", "Erforderlich."]],
            COUNTBLANK: [["Bereich", "Erforderlich. Der Bereich, in dem leere Zellen gezählt werden sollen."]],
            COVAR: [
                ["Array1", "Erforderlich. Der erste Zellbereich von Ganzzahlen."],
                ["Array2", "Erforderlich. Der zweite Zellbereich von Ganzzahlen."],
            ],
            "COVARIANCE.P": [
                ["Array1", "Erforderlich. Der erste Zellbereich von Ganzzahlen."],
                ["Array2", "Erforderlich. Der zweite Zellbereich von Ganzzahlen."],
            ],
            "COVARIANCE.S": [
                ["Array1", "Erforderlich. Der erste Zellbereich von Ganzzahlen."],
                ["Array2", "Erforderlich. Der zweite Zellbereich von Ganzzahlen."],
            ],
            CSC: [["Zahl", "Erforderlich. Der Winkel in Radiant."]],
            CSCH: [["Zahl", "Erforderlich."]],
            DEC2BIN: [
                ["Zahl", "Erforderlich. Die Dezimalzahl, die in Binärzahl konvertiert werden soll."],
                ["Stellen", "Optional. Füllt die resultierende Binärzahl mit Nullen bis zur angegebenen Anzahl von Stellen auf. Wenn weggelassen, wird die minimale Anzahl von Zeichen verwendet."],
            ],
            DEC2HEX: [
                ["Zahl", "Erforderlich. Die Dezimalzahl, die in Hexadezimalzahl konvertiert werden soll."],
                ["Stellen", "Optional. Füllt die resultierende Hexadezimalzahl mit Nullen bis zur angegebenen Anzahl von Stellen auf. Wenn weggelassen, wird die minimale Anzahl von Zeichen verwendet."],
            ],
            DEC2OCT: [
                ["Zahl", "Erforderlich. Die Dezimalzahl, die in Oktalzahl konvertiert werden soll."],
                ["Stellen", "Optional. Füllt die resultierende Oktalzahl mit Nullen bis zur angegebenen Anzahl von Stellen auf. Wenn weggelassen, wird die minimale Anzahl von Zeichen verwendet."],
            ],
            DECIMAL: [
                ["Zahl", "Erforderlich. Eine Textzeichenfolge, die eine Zahl darstellt."],
                ["Radix", "Erforderlich. Die Basis der zu konvertierenden Zahl, eine Ganzzahl zwischen 2 und 36."],
            ],
            DEGREES: [["Winkel", "Erforderlich. Winkel in Radiant, der in Grad umgewandelt werden soll."]],
            DELTA: [
                ["Zahl1", "Erforderlich. Die erste Zahl."],
                ["Zahl2", "Optional. Die zweite Zahl."],
            ],
            DEVSQ: [
                ["Zahl1", "Erforderlich. Erster Wert oder Bezug."],
                ["Zahl2", "Optional. Zweiter Wert oder Bezug."],
            ],
            DIVIDE: [
                ["Zahl1", "Erforderlich. Die zu dividierende Zahl."],
                ["Zahl2", "Erforderlich. Die Zahl, durch die dividiert wird."],
            ],
            EQ: [
                ["Zahl1", "Erforderlich. Erster Wert oder Bezug."],
                ["Zahl2", "Erforderlich. Zweiter Wert oder Bezug."],
            ],
            ERF: [
                ["UntereGrenze", "Erforderlich. Die untere Grenze für die Integration von ERF."],
                ["ObereGrenze", "Optional. Die obere Grenze für die Integration von ERF. Wenn weggelassen, integriert ERF zwischen Null und der unteren Grenze."],
            ],
            ERFC: [["X", "Erforderlich. Die untere Grenze für die Integration von ERFC."]],
            EVEN: [["Zahl", "Erforderlich. Die Zahl, die auf eine gerade Ganzzahl aufgerundet werden soll."]],
            FACT: [["Zahl", "Erforderlich. Die Zahl, von der die Faktorielle berechnet werden soll."]],
            FACTDOUBLE: [["Zahl", "Erforderlich. Eine Zahl größer oder gleich -1."]],
            FISHER: [["X", "Erforderlich. Ein numerischer Wert, für den die Transformation berechnet werden soll."]],
            FISHERINV: [["Y", "Erforderlich. Der Wert, für den die Inverse der Transformation durchgeführt werden soll."]],
            GAMMA: [["Zahl", "Erforderlich. Gibt eine Zahl zurück."]],
            GCD: [
                ["Zahl1", "Erforderlich. Die erste Zahl."],
                ["Zahl2", "Optional. Die zweite Zahl."],
            ],
            GEOMEAN: [
                ["Zahl1", "Erforderlich. Erster Wert oder Bezug."],
                ["Zahl2", "Optional. Zweiter Wert oder Bezug."],
            ],
            GESTEP: [
                ["Zahl", "Erforderlich. Der Wert, der gegen den Schritt getestet werden soll."],
                ["Schritt", "Optional. Der Schwellenwert. Wenn kein Wert für Schritt angegeben wird, verwendet GESTEP Null."],
            ],
            GT: [
                ["Zahl1", "Erforderlich. Erster Wert oder Bezug."],
                ["Zahl2", "Erforderlich. Zweiter Wert oder Bezug."],
            ],
            GTE: [
                ["Zahl1", "Erforderlich. Erster Wert oder Bezug."],
                ["Zahl2", "Erforderlich. Zweiter Wert oder Bezug."],
            ],
            HARMEAN: [
                ["Zahl1", "Erforderlich. Erster Wert oder Bezug."],
                ["Zahl2", "Optional. Zweiter Wert oder Bezug."],
            ],
            HEX2BIN: [
                ["Zahl", "Erforderlich. Die Hexadezimalzahl, die in Binärzahl konvertiert werden soll."],
                ["Stellen", "Optional. Füllt die resultierende Binärzahl mit Nullen bis zur angegebenen Anzahl von Stellen auf. Wenn weggelassen, wird die minimale Anzahl von Zeichen verwendet."],
            ],
            HEX2DEC: [["Zahl", "Erforderlich. Die Hexadezimalzahl, die in Dezimalzahl konvertiert werden soll."]],
            HEX2OCT: [
                ["Zahl", "Erforderlich. Die Hexadezimalzahl, die in Oktalzahl konvertiert werden soll."],
                ["Stellen", "Optional. Füllt die resultierende Oktalzahl mit Nullen bis zur angegebenen Anzahl von Stellen auf. Wenn weggelassen, wird die minimale Anzahl von Zeichen verwendet."],
            ],
            IMABS: [["KomplexeZahl", "Erforderlich. Eine komplexe Zahl."]],
            IMAGINARY: [["KomplexeZahl", "Erforderlich. Eine komplexe Zahl."]],
            IMCONJUGATE: [["KomplexeZahl", "Erforderlich. Eine komplexe Zahl, für die die Konjugierte berechnet werden soll."]],
            IMCOS: [["KomplexeZahl", "Erforderlich. Eine komplexe Zahl, für die der Kosinus berechnet werden soll."]],
            IMCOSH: [["KomplexeZahl", "Erforderlich. Eine komplexe Zahl, für die der hyperbolische Kosinus berechnet werden soll."]],
            IMCOT: [],
            IMCSC: [["KomplexeZahl", "Erforderlich. Eine komplexe Zahl, für die der Kosekans berechnet werden soll."]],
            IMCSCH: [["KomplexeZahl", "Erforderlich. Eine komplexe Zahl, für die der hyperbolische Kosekans berechnet werden soll."]],
            IMDIV: [
                ["KomplexeZahl1", "Erforderlich. Der komplexe Zähler oder Dividend."],
                ["KomplexeZahl2", "Erforderlich. Der komplexe Nenner oder Divisor."],
            ],
            IMEXP: [["KomplexeZahl", "Erforderlich. Eine komplexe Zahl, für die die Exponentialfunktion berechnet werden soll."]],
            IMLN: [["KomplexeZahl", "Erforderlich. Eine komplexe Zahl, für die der natürliche Logarithmus berechnet werden soll."]],
            IMPOWER: [
                ["KomplexeZahl", "Erforderlich. Eine komplexe Zahl."],
                ["Zahl", "Erforderlich. Potenz, auf die die Zahl erhöht wird."],
            ],
            IMPRODUCT: [
                ["KomplexeZahl1", "Erforderlich. Komplexe Zahl 1."],
                ["KomplexeZahl2", "Optional. Komplexe Zahl 2."],
            ],
            IMREAL: [["KomplexeZahl", "Erforderlich. Eine komplexe Zahl."]],
            IMSEC: [["KomplexeZahl", "Erforderlich. Eine komplexe Zahl, für die der Sekans berechnet werden soll."]],
            IMSECH: [["KomplexeZahl", "Erforderlich. Eine komplexe Zahl, für die der hyperbolische Sekans berechnet werden soll."]],
            IMSIN: [["KomplexeZahl", "Erforderlich. Eine komplexe Zahl, für die der Sinus berechnet werden soll."]],
            IMSINH: [["KomplexeZahl", "Erforderlich. Eine komplexe Zahl, für die der hyperbolische Sinus berechnet werden soll."]],
            IMSQRT: [["KomplexeZahl", "Erforderlich. Eine komplexe Zahl, für die die Quadratwurzel berechnet werden soll."]],
            IMSUB: [
                ["KomplexeZahl1", "Erforderlich. Komplexe Zahl 1."],
                ["KomplexeZahl2", "Erforderlich. Komplexe Zahl 2."],
            ],
            IMSUM: [
                ["KomplexeZahl1", "Erforderlich. Komplexe Zahl 1."],
                ["KomplexeZahl2", "Optional. Komplexe Zahl 2."],
            ],
            IMTAN: [["KomplexeZahl", "Erforderlich. Eine komplexe Zahl, für die der Tangens berechnet werden soll."]],
            LARGE: [
                ["Array", "Erforderlich. Ein Array oder Bereich von numerischen Werten."],
                ["K", "Erforderlich. Position als Ganzzahl, wobei 1 dem größten Wert entspricht."],
            ],
            LN: [["Zahl", "Erforderlich. Eine Zahl, von der der natürliche Logarithmus berechnet werden soll."]],
            LOG10: [["Zahl", "Erforderlich. Zahl, für die der Logarithmus berechnet werden soll."]],
            LT: [
                ["Zahl1", "Erforderlich. Erster Wert oder Bezug."],
                ["Zahl2", "Erforderlich. Zweiter Wert oder Bezug."],
            ],
            LTE: [
                ["Zahl1", "Erforderlich. Erster Wert oder Bezug."],
                ["Zahl2", "Erforderlich. Zweiter Wert oder Bezug."],
            ],
            MEDIAN: [
                ["Zahl1", "Erforderlich. Eine Zahl oder ein Zellbezug, der auf numerische Werte verweist."],
                ["Zahl2", "Optional. Eine Zahl oder ein Zellbezug, der auf numerische Werte verweist."],
            ],
            MINUS: [
                ["Zahl1", "Erforderlich. Die Zahl, von der subtrahiert wird."],
                ["Zahl2", "Erforderlich. Die Zahl, mit der subtrahiert wird."],
            ],
            MOD: [
                ["Zahl", "Erforderlich. Die zu dividierende Zahl."],
                ["Divisor", "Erforderlich. Die Zahl, durch die dividiert wird."],
            ],
            MROUND: [
                ["Zahl", "Erforderlich. Die zu rundende Zahl."],
                ["Schrittweite", "Erforderlich. Das Vielfache, das beim Runden verwendet werden soll."],
            ],
            MULTINOMIAL: [["Zahl1, Zahl2, ...", "Erforderlich. Zahl1 ist erforderlich, nachfolgende Zahlen sind optional. 1 bis 255 Werte, für die der Multinomialkoeffizient berechnet werden soll."]],
            MULTIPLY: [
                ["Zahl1", "Erforderlich. Die zu multiplizierende Zahl."],
                ["Zahl2", "Erforderlich. Die Zahl, mit der multipliziert wird."],
            ],
            NE: [
                ["Zahl1", "Erforderlich. Erster Wert oder Bezug."],
                ["Zahl2", "Erforderlich. Zweiter Wert oder Bezug."],
            ],
            OCT2BIN: [
                [
                    "Zahl",
                    "Erforderlich. Die Oktalzahl, die konvertiert werden soll. Die Zahl darf nicht mehr als 10 Zeichen enthalten. Das höchstwertige Bit der Zahl ist das Vorzeichenbit. Die restlichen 29 Bits sind Größenbits. Negative Zahlen werden in Zweierkomplement-Darstellung angegeben.",
                ],
                [
                    "Stellen",
                    "Optional. Die Anzahl der zu verwendenden Zeichen. Wenn Stellen weggelassen wird, verwendet OCT2BIN die minimale Anzahl notwendiger Zeichen. Stellen ist nützlich, um den Rückgabewert mit führenden Nullen aufzufüllen.",
                ],
            ],
            OCT2DEC: [
                [
                    "Zahl",
                    "Erforderlich. Die Oktalzahl, die konvertiert werden soll. Die Zahl darf nicht mehr als 10 Oktalzeichen (30 Bits) enthalten. Das höchstwertige Bit der Zahl ist das Vorzeichenbit. Die restlichen 29 Bits sind Größenbits. Negative Zahlen werden in Zweierkomplement-Darstellung angegeben.",
                ],
            ],
            OCT2HEX: [
                [
                    "Zahl",
                    "Erforderlich. Die Oktalzahl, die konvertiert werden soll. Die Zahl darf nicht mehr als 10 Oktalzeichen (30 Bits) enthalten. Das höchstwertige Bit der Zahl ist das Vorzeichenbit. Die restlichen 29 Bits sind Größenbits. Negative Zahlen werden in Zweierkomplement-Darstellung angegeben.",
                ],
                [
                    "Stellen",
                    "Optional. Die Anzahl der zu verwendenden Zeichen. Wenn Stellen weggelassen wird, verwendet OCT2HEX die minimale Anzahl notwendiger Zeichen. Stellen ist nützlich, um den Rückgabewert mit führenden Nullen aufzufüllen.",
                ],
            ],
            ODD: [["Zahl", "Erforderlich. Die Zahl, die auf eine ungerade Ganzzahl aufgerundet werden soll."]],
            PERCENTILE: [
                ["Array", "Erforderlich. Datenwerte."],
                ["K", "Erforderlich. Zahl, die das k-te Perzentil darstellt."],
            ],
            "PERCENTILE.INC": [
                ["Array", "Erforderlich. Datenwerte."],
                ["K", "Erforderlich. Zahl, die das k-te Perzentil darstellt."],
            ],
            "PERCENTILE.EXC": [
                ["Array", "Erforderlich. Datenwerte."],
                ["K", "Erforderlich. Ein Wert zwischen 0 und 1, der das k-te Perzentil darstellt."],
            ],
            PERMUT: [
                ["Zahl", "Erforderlich. Die Gesamtzahl der Elemente."],
                ["AusgewählteZahl", "Erforderlich. Die Anzahl der Elemente in jeder Permutation."],
            ],
            PI: [],
            POW: [
                ["Zahl", "Erforderlich. Zahl, die potenziert werden soll."],
                ["Potenz", "Erforderlich. Potenz, auf die die Zahl erhöht wird (der Exponent)."],
            ],
            QUARTILE: [
                ["Array", "Erforderlich. Ein Bezug, der Daten für die Analyse enthält."],
                ["Quartil", "Erforderlich. Der zurückzugebende Quartilswert."],
            ],
            "QUARTILE.INC": [
                ["Array", "Erforderlich. Ein Bezug, der Daten für die Analyse enthält."],
                ["Quartil", "Erforderlich. Der zurückzugebende Quartilswert."],
            ],
            "QUARTILE.EXC": [
                ["Array", "Erforderlich. Ein Bezug, der Daten für die Analyse enthält."],
                ["Quartil", "Erforderlich. Der zurückzugebende Quartilswert, 1-3."],
            ],
            QUOTIENT: [
                ["Zähler", "Erforderlich. Die zu dividierende Zahl."],
                ["Nenner", "Erforderlich. Die Zahl, durch die dividiert wird."],
            ],
            RADIANS: [["Winkel", "Erforderlich. Winkel in Grad, der in Radiant umgewandelt werden soll."]],
            ROMAN: [
                ["Zahl", "Erforderlich. Zahl (in arabischen Ziffern), die in römische Ziffern konvertiert werden soll."],
                ["Form", "Optional. Die Art der römischen Ziffer, die gewünscht wird."],
            ],
            SEC: [["Zahl", "Erforderlich. Der Winkel in Radiant, für den der Sekans berechnet werden soll."]],
            SECH: [],
            SIGN: [["Zahl", "Erforderlich. Die Zahl, von der das Vorzeichen berechnet werden soll."]],
            SIN: [["Zahl", "Erforderlich. Der Winkel in Radiant, für den der Sinus berechnet werden soll."]],
            SINH: [["Zahl", "Erforderlich. Der hyperbolische Winkel."]],
            SMALL: [
                ["Array", "Erforderlich. Ein Array oder Bereich von numerischen Werten."],
                ["K", "Erforderlich. Position als Ganzzahl, wobei 1 dem kleinsten Wert entspricht."],
            ],
            SQRTPI: [["Zahl", "Erforderlich. Die Zahl, mit der Pi multipliziert wird."]],
            STDEV: [
                ["Zahl1", "Erforderlich. Erste Zahl oder Bezug in der Stichprobe."],
                ["Zahl2", "Optional. Zweite Zahl oder Bezug."],
            ],
            "STDEV.S": [
                ["Zahl1", "Erforderlich. Erste Zahl oder Bezug in der Stichprobe."],
                ["Zahl2", "Optional. Zweite Zahl oder Bezug."],
            ],
            "STDEV.P": [
                ["Zahl1", "Erforderlich. Erste Zahl oder Bezug in der Stichprobe."],
                ["Zahl2", "Optional. Zweite Zahl oder Bezug."],
            ],
            STDEVA: [
                ["Zahl1", "Erforderlich. Erste Zahl oder Bezug in der Stichprobe."],
                ["Zahl2", "Optional. Zweite Zahl oder Bezug."],
            ],
            STDEVP: [
                ["Zahl1", "Erforderlich. Erste Zahl oder Bezug in der Stichprobe."],
                ["Zahl2", "Optional. Zweite Zahl oder Bezug."],
            ],
            STDEVPA: [
                ["Zahl1", "Erforderlich. Erste Zahl oder Bezug in der Stichprobe."],
                ["Zahl2", "Optional. Zweite Zahl oder Bezug."],
            ],
            STEYX: [
                ["BekannteY", "Erforderlich. Ein Array oder Bereich von abhängigen Datenpunkten."],
                ["BekannteX", "Erforderlich. Ein Array oder Bereich von unabhängigen Datenpunkten."],
            ],
            SUBTOTAL: [
                ["Funktionsnummer", "Erforderlich. Eine Zahl, die angibt, welche Funktion zur Berechnung von Zwischensummen in einer Liste verwendet werden soll. Siehe Tabelle unten für die vollständige Liste."],
                ["Bez1", "Erforderlich. Ein benannter Bereich oder Bezug für die Zwischensumme."],
                ["Bez2", "Optional. Ein benannter Bereich oder Bezug für die Zwischensumme."],
            ],
            SUMSQ: [
                ["Zahl1", "Erforderlich. Das erste Argument, das numerische Werte enthält."],
                ["Zahl2", "Optional. Das zweite Argument, das numerische Werte enthält."],
            ],
            SUMX2MY2: [
                ["ArrayX", "Erforderlich. Der erste Bereich oder Array, der numerische Werte enthält."],
                ["ArrayY", "Erforderlich. Der zweite Bereich oder Array, der numerische Werte enthält."],
            ],
            SUMX2PY2: [
                ["ArrayX", "Erforderlich. Der erste Bereich oder Array, der numerische Werte enthält."],
                ["ArrayY", "Erforderlich. Der zweite Bereich oder Array, der numerische Werte enthält."],
            ],
            SUMXMY2: [
                ["ArrayX", "Erforderlich. Der erste Bereich oder Array, der numerische Werte enthält."],
                ["ArrayY", "Erforderlich. Der zweite Bereich oder Array, der numerische Werte enthält."],
            ],
            TAN: [["Zahl", "Erforderlich. Der Winkel in Radiant, für den der Tangens berechnet werden soll."]],
            TANH: [["Zahl", "Erforderlich. Eine beliebige reelle Zahl."]],
            TRUNC: [
                ["Zahl", "Erforderlich. Die zu kürzende Zahl."],
                ["AnzahlStellen", "Optional. Die Präzision der Kürzung (Standard ist 0)."],
            ],
            VAR: [
                ["Zahl1", "Erforderlich. Erste Zahl oder Bezug."],
                ["Zahl2", "Optional. Zweite Zahl oder Bezug."],
            ],
            "VAR.S": [
                ["Zahl1", "Erforderlich. Erste Zahl oder Bezug."],
                ["Zahl2", "Optional. Zweite Zahl oder Bezug."],
            ],
            "VAR.P": [
                ["Zahl1", "Erforderlich. Erste Zahl oder Bezug."],
                ["Zahl2", "Optional. Zweite Zahl oder Bezug."],
            ],
            VARA: [
                ["Zahl1", "Erforderlich. Erste Zahl oder Bezug."],
                ["Zahl2", "Optional. Zweite Zahl oder Bezug."],
            ],
            VARP: [
                ["Zahl1", "Erforderlich. Erste Zahl oder Bezug."],
                ["Zahl2", "Optional. Zweite Zahl oder Bezug."],
            ],
            VARPA: [
                ["Zahl1", "Erforderlich. Erste Zahl oder Bezug."],
                ["Zahl2", "Optional. Zweite Zahl oder Bezug."],
            ],
            WEIBULL: [
                ["X", "Erforderlich. Der Wert, an dem die Funktion ausgewertet werden soll."],
                ["Alpha", "Erforderlich. Ein Parameter der Verteilung."],
                ["Beta", "Erforderlich. Ein Parameter der Verteilung."],
                ["Kumulativ", "Erforderlich. Bestimmt die Form der Funktion."],
            ],
            "WEIBULL.DIST": [
                ["X", "Erforderlich. Der Wert, an dem die Funktion ausgewertet werden soll."],
                ["Alpha", "Erforderlich. Ein Parameter der Verteilung."],
                ["Beta", "Erforderlich. Ein Parameter der Verteilung."],
                ["Kumulativ", "Erforderlich. Bestimmt die Form der Funktion."],
            ],
            CHAR: [["Zahl", "Erforderlich. Eine Zahl zwischen 1 und 255."]],
            CLEAN: [["Text", "Erforderlich. Der zu bereinigende Text."]],
            CODE: [["Text", "Erforderlich. Der Text, für den ein numerischer Code gewünscht wird."]],
            EXACT: [
                ["Text1", "Erforderlich. Die erste zu vergleichende Textzeichenfolge."],
                ["Text2", "Erforderlich. Die zweite zu vergleichende Textzeichenfolge."],
            ],
            FIXED: [
                ["Zahl", "Erforderlich. Die zu rundende und zu formatierende Zahl."],
                ["Dezimalstellen", "Optional. Anzahl der zu verwendenden Dezimalstellen. Standard ist 2."],
                ["KeineKommas", "Optional. Kommas unterdrücken. WAHR = keine Kommas, FALSCH = Kommas. Standard ist FALSCH."],
            ],
            NUMBERVALUE: [
                ["Text", "Erforderlich. Der Text, der in eine Zahl konvertiert werden soll."],
                ["Dezimaltrennzeichen", "Optional. Das Zeichen für Dezimalwerte."],
                ["Gruppentrennzeichen", "Optional. Das Zeichen für die Gruppierung nach Tausendern."],
            ],
            REGEXEXTRACT: [
                ["Text", "Erforderlich. Der Eingabetext."],
                ["RegulärerAusdruck", "Erforderlich. Der erste Teil des Textes, der mit diesem Ausdruck übereinstimmt, wird zurückgegeben."],
            ],
            REGEXMATCH: [
                ["Text", "Erforderlich. Der Text, der gegen den regulären Ausdruck getestet werden soll."],
                ["RegulärerAusdruck", "Erforderlich. Der reguläre Ausdruck, gegen den der Text getestet wird."],
            ],
            REGEXREPLACE: [
                ["Text", "Erforderlich. Der Text, von dem ein Teil ersetzt wird."],
                ["RegulärerAusdruck", "Erforderlich. Der reguläre Ausdruck. Alle übereinstimmenden Instanzen im Text werden ersetzt."],
                ["Ersatz", "Erforderlich. Der Text, der in den Originaltext eingefügt wird."],
            ],
            REPT: [
                ["Text", "Erforderlich. Der zu wiederholende Text."],
                ["AnzahlWiederholungen", "Erforderlich. Die Anzahl der Wiederholungen des Textes."],
            ],
            T: [["Wert", "Erforderlich. Der Wert, der als Text zurückgegeben werden soll."]],
            JOIN: [["Text1, Text2, ...", "Erforderlich. Text, der kombiniert werden soll."]],
            ARRAYTOTEXT: [
                ["Array", "Erforderlich. Das Array oder der Bereich, der in Text konvertiert werden soll."],
                ["Format", "Optional. Ausgabeformat. 0 = präzise (Standard), 1 = strikt."],
            ],
            DATEVALUE: [["Datumstext", "Erforderlich. Ein gültiges Datum im Textformat."]],
            DAYS: [
                ["Enddatum", "Erforderlich. Das Enddatum."],
                ["Startdatum", "Erforderlich. Das Startdatum."],
            ],
            DAYS360: [
                ["Startdatum", "Erforderlich. Das Startdatum."],
                ["Enddatum", "Erforderlich. Das Enddatum."],
                ["Methode", "Optional. Zähltagemethode. FALSCH (Standard) = US-Methode, WAHR = Europäische Methode."],
            ],
            EDATE: [
                ["Startdatum", "Erforderlich. Startdatum als gültiges Excel-Datum."],
                ["Monate", "Erforderlich. Anzahl der Monate vor oder nach dem Startdatum."],
            ],
            EOMONTH: [
                ["Startdatum", "Erforderlich. Ein Datum, das das Startdatum im gültigen Excel-Seriennummernformat darstellt."],
                ["Monate", "Erforderlich. Die Anzahl der Monate vor oder nach dem Startdatum."],
            ],
            ISOWEEKNUM: [["Datum", "Erforderlich. Ein gültiges Excel-Datum im Seriennummernformat."]],
            NETWORKDAYS: [
                ["Startdatum", "Erforderlich. Das Startdatum."],
                ["Enddatum", "Erforderlich. Das Enddatum."],
                ["Feiertage", "Optional. Eine Liste von Nicht-Arbeitstagen als Datum."],
            ],
            "NETWORKDAYS.INTL": [
                ["Startdatum", "Erforderlich. Das Startdatum."],
                ["Enddatum", "Erforderlich. Das Enddatum."],
                ["Wochenende", "Optional. Einstellung, welche Tage der Woche als Wochenende gelten sollen."],
                ["Feiertage", "Optional. Ein Bezug auf Daten, die als Nicht-Arbeitstage gelten sollen."],
            ],
            TIMEVALUE: [["Zeittext", "Erforderlich. Ein Datum und/oder eine Zeit in einem von Excel erkannten Textformat."]],
            WEEKNUM: [
                ["Seriennummer", "Erforderlich. Ein gültiges Excel-Datum im Seriennummernformat."],
                ["Rückgabetyp", "Optional. Der Tag, an dem die Woche beginnt. Standard ist 1."],
            ],
            WEEKDAY: [
                ["Seriennummer", "Erforderlich. Das Datum, für das der Wochentag ermittelt werden soll."],
                ["Rückgabetyp", "Optional. Eine Zahl, die das Zuordnungsschema für Wochentage angibt. Standard ist 1."],
            ],
            WORKDAY: [
                ["Startdatum", "Erforderlich. Das Datum, von dem aus gestartet wird."],
                ["Tage", "Erforderlich. Die Arbeitstage vor oder nach dem Startdatum."],
                ["Feiertage", "Optional. Eine Liste von Daten, die als Nicht-Arbeitstage gelten sollen."],
            ],
            "WORKDAY.INTL": [
                ["Startdatum", "Erforderlich. Das Startdatum."],
                ["Tage", "Erforderlich. Das Enddatum."],
                ["Wochenende", "Optional. Einstellung, welche Tage der Woche als Wochenende gelten sollen."],
                ["Feiertage", "Optional. Eine Liste von ein oder mehr Daten, die als Nicht-Arbeitstage gelten sollen."],
            ],
            YEARFRAC: [
                ["Startdatum", "Erforderlich. Das Startdatum."],
                ["Enddatum", "Erforderlich. Das Enddatum."],
                ["Basis", "Optional. Die Art der Zähltagebasis, die verwendet werden soll (siehe unten)."],
            ],
            ACCRINT: [
                ["Ausgabedatum", "Erforderlich. Ausgabedatum des Wertpapiers."],
                ["ErstesZinsdatum", "Erforderlich. Erstes Zinsdatum des Wertpapiers."],
                ["Abrechnungsdatum", "Erforderlich. Abrechnungsdatum des Wertpapiers."],
                ["Zinssatz", "Erforderlich. Zinssatz des Wertpapiers."],
                ["Nennwert", "Erforderlich. Nennwert des Wertpapiers."],
                ["Häufigkeit", "Erforderlich. Kuponzahlungen pro Jahr (jährlich = 1, halbjährlich = 2; vierteljährlich = 4)."],
                ["Basis", "Optional. Zähltagebasis (siehe unten, Standard = 0)."],
                ["Berechnung", "Optional. Berechnungsmethode (siehe unten, Standard = WAHR)."],
            ],
            PMT: [
                ["Zinssatz", "Erforderlich. Der Zinssatz für das Darlehen."],
                ["AnzahlZahlungen", "Erforderlich. Die Gesamtzahl der Zahlungen für das Darlehen."],
                ["Barwert", "Erforderlich. Der Barwert oder Gesamtwert aller Darlehenszahlungen jetzt."],
                ["Zukunftswert", "Optional. Der Zukunftswert oder ein gewünschter Kassenbestand nach der letzten Zahlung. Standard ist 0 (Null)."],
                ["Typ", "Optional. Wann Zahlungen fällig sind. 0 = Ende des Zeitraums. 1 = Anfang des Zeitraums. Standard ist 0."],
            ],
            FV: [
                ["Zinssatz", "Erforderlich. Der Zinssatz pro Periode."],
                ["AnzahlZahlungen", "Erforderlich. Die Gesamtzahl der Zahlungsperioden."],
                ["Zahlung", "Erforderlich. Die in jeder Periode geleistete Zahlung. Muss als negative Zahl eingegeben werden."],
                ["Barwert", "Optional. Der Barwert zukünftiger Zahlungen. Wenn weggelassen, wird Null angenommen. Muss als negative Zahl eingegeben werden."],
                ["Typ", "Optional. Wann Zahlungen fällig sind. 0 = Ende des Zeitraums, 1 = Anfang des Zeitraums. Standard ist 0."],
            ],
            DB: [
                ["Anschaffungskosten", "Erforderlich. Anschaffungskosten des Vermögenswerts."],
                ["Restwert", "Erforderlich. Wert des Vermögenswerts am Ende der Abschreibung."],
                ["Nutzungsdauer", "Erforderlich. Perioden, über die der Vermögenswert abgeschrieben wird."],
                ["Periode", "Erforderlich. Periode, für die die Abschreibung berechnet werden soll."],
                ["Monat", "Optional. Anzahl der Monate im ersten Jahr. Standard ist 12."],
            ],
            DDB: [
                ["Anschaffungskosten", "Erforderlich. Anschaffungskosten des Vermögenswerts."],
                ["Restwert", "Erforderlich. Wert des Vermögenswerts am Ende der Abschreibung."],
                ["Nutzungsdauer", "Erforderlich. Perioden, über die der Vermögenswert abgeschrieben wird."],
                ["Periode", "Erforderlich. Periode, für die die Abschreibung berechnet werden soll."],
                ["Faktor", "Optional. Rate, mit der der Saldo abnimmt. Wenn weggelassen, Standard ist 2."],
            ],
            DOLLAR: [
                ["Zahl", "Erforderlich. Die zu konvertierende Zahl."],
                ["Dezimalstellen", "Erforderlich. Die Anzahl der Stellen rechts vom Dezimalpunkt. Standard ist 2."],
            ],
            DOLLARDE: [
                ["Bruchdollar", "Erforderlich. Dollar-Komponente in spezieller Bruchnotation."],
                ["Bruch", "Erforderlich. Der Nenner in der Brucheinheit. 8 = 1/8, 16 = 1/16, 32 = 1/32, etc."],
            ],
            DOLLARFR: [
                ["Dezimaldollar", "Erforderlich. Preisangabe als normale Dezimalzahl."],
                ["Bruch", "Erforderlich. Der Nenner in der Brucheinheit. 8 = 1/8, 16 = 1/16, 32 = 1/32, etc."],
            ],
            EFFECT: [
                ["Nominalzinssatz", "Erforderlich. Der nominale oder angegebene Zinssatz."],
                ["AnzahlPerioden", "Erforderlich. Anzahl der Zinsperioden pro Jahr."],
            ],
            FVSCHEDULE: [
                ["Kapital", "Erforderlich. Die anfängliche Investitionssumme."],
                ["Plan", "Erforderlich. Plan der Zinssätze, bereitgestellt als Bereich oder Array."],
            ],
            IRR: [
                ["Werte", "Erforderlich. Array oder Bezug auf Zellen, die Werte enthalten."],
                ["Schätzung", "Optional. Eine Schätzung für den erwarteten IRR. Standard ist 0,1 (10%)."],
            ],
            IPMT: [
                ["Zinssatz", "Erforderlich. Der Zinssatz pro Periode."],
                ["Periode", "Erforderlich. Die Zahlungsperiode der Zinsen."],
                ["AnzahlZahlungen", "Erforderlich. Die Gesamtzahl der Zahlungsperioden."],
                ["Barwert", "Erforderlich. Der Barwert oder Gesamtwert aller Zahlungen jetzt."],
                ["Zukunftswert", "Optional. Der gewünschte Kassenbestand nach der letzten Zahlung. Standard ist 0."],
                ["Typ", "Optional. Wann Zahlungen fällig sind. 0 = Ende des Zeitraums. 1 = Anfang des Zeitraums. Standard ist 0."],
            ],
            ISPMT: [
                ["Zinssatz", "Erforderlich. Zinssatz."],
                ["Periode", "Erforderlich. Periode (beginnt mit Null, nicht 1)."],
                ["AnzahlZahlungen", "Erforderlich. Anzahl der Perioden."],
                ["Barwert", "Erforderlich. Barwert."],
            ],
            NPV: [
                ["Zinssatz", "Erforderlich. Diskontierungssatz über eine Periode."],
                ["Wert1", "Erforderlich. Erster Wert(e), der/die Cashflows repräsentiert."],
                ["Wert2", "Optional. Zweiter Wert(e), der/die Cashflows repräsentiert."],
            ],
            NOMINAL: [
                ["Effektivzinssatz", "Erforderlich. Der effektive jährliche Zinssatz."],
                ["AnzahlPerioden", "Erforderlich. Anzahl der Zinsperioden pro Jahr."],
            ],
            NPER: [
                ["Zinssatz", "Erforderlich. Der Zinssatz pro Periode."],
                ["Zahlung", "Erforderlich. Die in jeder Periode geleistete Zahlung."],
                ["Barwert", "Erforderlich. Der Barwert oder Gesamtwert aller Zahlungen jetzt."],
                ["Zukunftswert", "Optional. Der Zukunftswert oder ein gewünschter Kassenbestand nach der letzten Zahlung. Standard ist 0."],
                ["Typ", "Optional. Wann Zahlungen fällig sind. 0 = Ende des Zeitraums. 1 = Anfang des Zeitraums. Standard ist 0."],
            ],
            PDURATION: [
                ["Zinssatz", "Erforderlich. Zinssatz pro Periode."],
                ["Barwert", "Erforderlich. Barwert der Investition."],
                ["Zukunftswert", "Erforderlich. Zukunftswert der Investition."],
            ],
            PPMT: [
                ["Zinssatz", "Erforderlich. Der Zinssatz pro Periode."],
                ["Periode", "Erforderlich. Die Zahlungsperiode der Zinsen."],
                ["AnzahlZahlungen", "Erforderlich. Die Gesamtzahl der Zahlungen für das Darlehen."],
                ["Barwert", "Erforderlich. Der Barwert oder Gesamtwert aller Zahlungen jetzt."],
                ["Zukunftswert", "Optional. Der gewünschte Kassenbestand nach der letzten Zahlung. Standard ist 0."],
                ["Typ", "Optional. Wann Zahlungen fällig sind. 0 = Ende des Zeitraums. 1 = Anfang des Zeitraums. Standard ist 0."],
            ],
            PV: [
                ["Zinssatz", "Erforderlich. Der Zinssatz pro Periode."],
                ["AnzahlZahlungen", "Erforderlich. Die Anzahl der Zahlungsperioden."],
                ["Zahlung", "Erforderlich. Die in jeder Periode geleistete Zahlung."],
                ["Zukunftswert", "Optional. Zukunftswert. Wenn weggelassen, Standard ist Null."],
                ["Typ", "Optional. Zahlungstyp, 0 = Ende des Zeitraums, 1 = Anfang des Zeitraums. Standard ist 0."],
            ],
            SYD: [
                ["Anschaffungskosten", "Erforderlich. Anschaffungskosten des Vermögenswerts."],
                ["Restwert", "Erforderlich. Wert des Vermögenswerts am Ende der Abschreibung."],
                ["Nutzungsdauer", "Erforderlich. Perioden, über die der Vermögenswert abgeschrieben wird."],
                ["Periode", "Erforderlich. Periode, für die die Abschreibung berechnet werden soll."],
            ],
            TBILLPRICE: [
                ["Abrechnungsdatum", "Erforderlich. Abrechnungsdatum des Wertpapiers."],
                ["Fälligkeitsdatum", "Erforderlich. Fälligkeitsdatum des Wertpapiers."],
                ["Diskontsatz", "Erforderlich. Der Diskontsatz für das Wertpapier."],
            ],
            TBILLYIELD: [
                ["Abrechnungsdatum", "Erforderlich. Abrechnungsdatum des Wertpapiers."],
                ["Fälligkeitsdatum", "Erforderlich. Fälligkeitsdatum des Wertpapiers."],
                ["Preis", "Erforderlich. Preis pro 100 $."],
            ],
        },
    };

    const dataset = {
        styles: {
            bold: {
                "font-weight": "bold",
            },
            right: {
                "justify-content": "flex-end",
                "text-align": "right",
            },
        },
        data: [
            { cell: "a1", value: "Country", css: "bold" },
            { cell: "b1", value: "Product", css: "bold" },
            { cell: "c1", value: "Price", css: "right bold" },
            { cell: "d1", value: "Amount", css: "right bold" },
            { cell: "e1", value: "Total Price", css: "right bold" },

            { cell: "a2", value: "Ecuador" },
            { cell: "b2", value: "Banana" },
            { cell: "c2", value: 6.68, format: "currency" },
            { cell: "d2", value: 430 },
            { cell: "e2", value: 2872.4, format: "currency" },

            { cell: "a3", value: "Belarus" },
            { cell: "b3", value: "Apple" },
            { cell: "c3", value: 3.75, format: "currency" },
            { cell: "d3", value: 600 },
            { cell: "e3", value: 2250, format: "currency" },

            { cell: "a4", value: "Peru" },
            { cell: "b4", value: "Grapes" },
            { cell: "c4", value: 7.69, format: "currency" },
            { cell: "d4", value: 740 },
            { cell: "e4", value: 5690.6, format: "currency" },

            { cell: "a5", value: "Egypt" },
            { cell: "b5", value: "Orange" },
            { cell: "c5", value: 5.86, format: "currency" },
            { cell: "d5", value: 560 },
            { cell: "e5", value: 3281.6, format: "currency" },

            { cell: "a6", value: "South Africa" },
            { cell: "b6", value: "Grapefruit" },
            { cell: "c6", value: 8.58, format: "currency" },
            { cell: "d6", value: 800 },
            { cell: "e6", value: 6864, format: "currency" },

            { cell: "a7", value: "Spain" },
            { cell: "b7", value: "Lemon" },
            { cell: "c7", value: 9.12, format: "currency" },
            { cell: "d7", value: 650 },
            { cell: "e7", value: 5928, format: "currency" },

            { cell: "a8", value: "Iran" },
            { cell: "b8", value: "Pomegranate" },
            { cell: "c8", value: 9.67, format: "currency" },
            { cell: "d8", value: 300 },
            { cell: "e8", value: 2901, format: "currency" },
        ],
    };
</script>

Applications deployed internationally need their UI elements, including toolbar labels, menu items, dialog buttons, and error messages, translated into the user's language. Full localization support means the spreadsheet component integrates seamlessly into multi-language products without hardcoded English strings.

This example defines translation maps for both Spreadsheet UI labels and formula descriptions. When the user switches between the English and German radio buttons, the sample calls dhx.i18n.setLocale("spreadsheet", ...), dhx.i18n.setLocale("formulas", ...), and then recreates the Spreadsheet instance so the updated language is applied throughout the UI.

Solution overview

  1. Define translation objects for Spreadsheet labels and formulas
  2. Call dhx.i18n.setLocale("spreadsheet", localeObject) for the selected language
  3. Call dhx.i18n.setLocale("formulas", formulasLocale) to localize formula descriptions
  4. Recreate the Spreadsheet instance so the selected language is rendered in the UI

Key points

  • Recreation flow: The sample reapplies localization by destroying and recreating the Spreadsheet instance after the language changes
  • Complete coverage: The locale object includes translations for toolbar, menu, filter, buttons, and messages to avoid mixed-language UI
  • Formula descriptions: A separate "formulas" locale controls the parameter descriptions shown in formula tooltips

API reference

Additional resources