---
sourceDocument: Yokohama Erstellen oder ändern Sie Anwendungen
sourceDocumentLink: https://servicenow-prod.fluidtopics.net/r/de-DE/yokohama/application-development

 Release :

    - yokohama

ft:locale :

    - de-DE

ft:publication_title :

    - Yokohama Erstellen oder ändern Sie Anwendungen

ft:clusterId :

    - cadev

bundleId :

    - cadev

workflow :

    - Creator


---

Formeln für Spaltenwerte in Tabellen-Generator
==============================================

Formeln für Spaltenwerte in Tabellen-Generator {#ariaid-title1}
===============================================================

* Freigeben Version: Yokohama
* 
* Aktualisiert 30. Januar 2025
* 
* ![](https://www.servicenow.com/docs/portal-asset/ico-clock) 12 Minuten Lesedauer

Sie können eine vordefinierte Funktion verwenden und eine Formel erstellen, um den Wert einer Spalte zu berechnen, ohne ein Skript zu schreiben. Verwenden Sie eine vordefinierte Funktion, oder erstellen Sie eine geschachtelte Formel, indem Sie die vorhandenen vordefinierten Funktionen verwenden, um den Spaltenwerttyp zu berechnen.

Unterstützte Operatoren {#formulas-columns-table-builder__section_nq4_fld_g5b}
------------------------------------------------------------------------------

Die folgenden Vergleichsoperatoren werden nur für Zahlentypwerte unterstützt.

* = (Gleich)
* \<\> (Ungleich)
* \> (Größer als)
* \< (Weniger als)
* \>= (größer als oder gleich)
* \<= (kleiner als oder gleich)
{#formulas-columns-table-builder__ul_wg3_3ld_g5b}

Einfache mathematische Funktionen {#ariaid-title2}
--------------------------------------------------

Verwenden Sie einfache mathematische Funktionen, um grundlegende mathematische Berechnungen für Spalten mit numerischen Werten durchzuführen.

### DURCHSCHNITT {#simple-math-functions-table-builder__section_xmc_yfn_ytb}

gibt den Durchschnittswert der Argumente zurück.
{#simple-math-functions-table-builder__table_ckw_zfn_ytb__entry__3}

|                     Syntax                      |                     Eingabe                     |     Ausgabe      |
|-------------------------------------------------|-------------------------------------------------|------------------|
| AVERAGE(Argument 1, Argument 2, ... Argument n) | Numerischer Wert, Funktionsaufruf oder Variable | Numerischer Wert |
[ ]

{#simple-math-functions-table-builder__table_ckw_zfn_ytb}Beispiele:

* Funktion: AVERAGE(1,2,3)Das Ergebnis ist 2.

* Formel: AVERAGE(Length(first_name), Length(last_name))Das Ergebnis ist der Durchschnittswert der Anzahl der Zeichen in der Spalte „first_name" und „last_name".

{#simple-math-functions-table-builder__ul_y21_3tt_ytb}

### TEILEN {#simple-math-functions-table-builder__section_skl_l24_ytb}

Gibt den endgültigen Quotientenwert zurück, nachdem das erste Argument durch das nächste Argument geteilt wurde, bis die Funktion das letzte Argument erreicht.
{#simple-math-functions-table-builder__table_fdf_n24_ytb__entry__3}

|                    Syntax                     |                     Eingabe                     |     Ausgabe      |
|-----------------------------------------------|-------------------------------------------------|------------------|
| DIVIDE(Argument 1, Argument 2 ... Argument n) | Numerischer Wert, Funktionsaufruf oder Variable | Numerischer Wert |
[ ]

{#simple-math-functions-table-builder__table_fdf_n24_ytb}Beispiele:

* Funktion: DIVIDE(10,20, 0.25, 10)Das Ergebnis ist 0,2.

* Formel: DIVIDE(Length(full_name),2)Das Ergebnis ist die Anzahl der Zeichen in der Spalte „full_name" geteilt durch 2.

{#simple-math-functions-table-builder__ul_apt_qd5_ytb}

### INDEXMATCH {#simple-math-functions-table-builder__section_y2x_mfn_dwb}

Ruft den ersten Wert, der nicht NULL ist, aus dem angegebenen Satz von Argumenten ab.{#simple-math-functions-table-builder__table_lb3_qfn_dwb__entry__3}

|                       Syntax                        |                            Eingabe                             |     Ausgabe      |
|-----------------------------------------------------|----------------------------------------------------------------|------------------|
| INDEXMATCH(Argument 1, Argument 2 , ... Argument n) | Zeichenfolge, numerischer Wert, Funktionsaufruf oder Variable. | Numerischer Wert |
[ ]

{#simple-math-functions-table-builder__table_lb3_qfn_dwb}Beispiel:

Funktion: INDEXMATCH(""," ",2,"string")

Das Ergebnis ist 2.

### MAX {#simple-math-functions-table-builder__section_c5k_23n_ytb}

gibt den Höchstwert der angegebenen Argumente zurück.
{#simple-math-functions-table-builder__table_amb_g3n_ytb__entry__3}

|                   Syntax                    |                     Eingabe                     |     Ausgabe      |
|---------------------------------------------|-------------------------------------------------|------------------|
| MAX(Argument 1, Argument 2, ... Argument n) | Numerischer Wert, Funktionsaufruf oder Variable | Numerischer Wert |
[ ]

{#simple-math-functions-table-builder__table_amb_g3n_ytb}Beispiele:

* Funktion: MAX(1, -5, 20, 6)Das Ergebnis ist 20.

* Formel: MAX(Length(first_name), Length(last_name))Das Ergebnis ist die Anzahl der Zeichen in der Spalte „first_name" oder „last_name", je nachdem, welche die höchste ist.

{#simple-math-functions-table-builder__ul_lqm_svt_ytb}

### MIN {#simple-math-functions-table-builder__section_xv1_h24_ytb}

Gibt den kleinsten Wert der angegebenen Argumente zurück.
{#simple-math-functions-table-builder__table_kt3_324_ytb__entry__3}

|                   Syntax                    |                     Eingabe                     |     Ausgabe      |
|---------------------------------------------|-------------------------------------------------|------------------|
| MIN(Argument 1, Argument 2, ... Argument n) | Numerischer Wert, Funktionsaufruf oder Variable | Numerischer Wert |
[ ]

{#simple-math-functions-table-builder__table_kt3_324_ytb}Beispiele:

* Funktion: MIN(1, -5, 20, 6)Das Ergebnis ist -5.

* Formel: MIN(Length(first_name), Length(last_name))Das Ergebnis ist die Anzahl der Zeichen in der Spalte „first_name" oder „last_name", je nachdem, welche Zahl die niedrigste ist.

{#simple-math-functions-table-builder__ul_qws_nd5_ytb}

### MEHRFACH {#simple-math-functions-table-builder__section_nyn_qcn_ytb}

gibt den multiplizierten Gesamtwert der Argumente zurück.
{#simple-math-functions-table-builder__table_t4r_gdn_ytb__entry__3}

|                         Syntax                         |                     Eingabe                     |     Ausgabe      |
|--------------------------------------------------------|-------------------------------------------------|------------------|
| Multiplikator (Argument 1, Argument 2, ... Argument n) | Numerischer Wert, Funktionsaufruf oder Variable | Numerischer Wert |
[ ]

{#simple-math-functions-table-builder__table_t4r_gdn_ytb} Beispiele:

* Funktion: Multiplikator (12, 4) Das Ergebnis ist 48.

* Formel: Multiplikator (Reihenfolge, 2)Das Ergebnis ist der Wert der Reihenfolgenspalte multipliziert mit 2.

{#simple-math-functions-table-builder__ul_gsd_pf4_ytb}

### LEISTUNG {#simple-math-functions-table-builder__section_hcg_3kn_ytb}

gibt das Ergebnis des Basiswerts potenziert mit dem Exponentenwert zurück.
{#simple-math-functions-table-builder__table_e35_mkn_ytb__entry__3}

|            Syntax             |                                                                                 Eingabe                                                                                 | Ausgabe |
|-------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------|
| POWER(Argument 1, Argument 2) | Argument 1 ist die Basis und Argument 2 der Exponent. * Basis: Zahl oder Variable * Exponent: Zahl oder Variable {#simple-math-functions-table-builder__ul_elh_rkn_ytb} | Nummer  |
[ ]

{#simple-math-functions-table-builder__table_e35_mkn_ytb}Beispiele:

* Funktion: POWER(3,2)Das Ergebnis ist 9.

* Formel: LEISTUNG(LÄNGE(vollständiger_Name),2)Das Ergebnis ist die Anzahl der Zeichen in der Spalte „full_name" hoch 2.

{#simple-math-functions-table-builder__ul_ogq_tc5_ytb}

### SUBTRAKT {#simple-math-functions-table-builder__section_qs3_njn_ytb}

gibt den Ergebniswert zurück, nachdem das nächste verfügbare Argument schrittweise vom vorherigen Argument subtrahiert wurde, bis die Funktion das letzte Argument erreicht.
{#simple-math-functions-table-builder__table_elz_4jn_ytb__entry__3}

|                     Syntax                      |                     Eingabe                     |     Ausgabe      |
|-------------------------------------------------|-------------------------------------------------|------------------|
| SUBTRACT(Argument 1, Argument 2 ... Argument n) | Numerischer Wert, Funktionsaufruf oder Variable | Numerischer Wert |
[ ]

{#simple-math-functions-table-builder__table_elz_4jn_ytb}Beispiele:

* Funktion: SUBTRACT(1.15, 0.02, 0.45, -0.85) Das Ergebnis ist 1,53.

* Formel: SUBTRACT(Length(full_name), Length(first_name))Das Ergebnis ist die Anzahl der Zeichen aus der Spalte „full_name" minus die Anzahl der Zeichen aus der Spalte „first_name".

{#simple-math-functions-table-builder__ul_s3j_dc5_ytb}

### SUMME {#simple-math-functions-table-builder__section_u3v_p24_ytb}

gibt die Summe aller Argumente zurück.
{#simple-math-functions-table-builder__table_qtw_q24_ytb__entry__3}

|                   Syntax                   |                     Eingabe                     |     Ausgabe      |
|--------------------------------------------|-------------------------------------------------|------------------|
| SUM(argument 1,argument 2, ... argument n) | Numerischer Wert, Funktionsaufruf oder Variable | Numerischer Wert |
[ ]

{#simple-math-functions-table-builder__table_qtw_q24_ytb}Beispiele:

* Funktion: SUM(0.03, -0.02, 1)Das Ergebnis ist 1,01.

* Formel: SUM(Length(first_name), Length(last_name))Das Ergebnis ist die Gesamtzahl der Zeichen in der Spalte „first_name" plus die Gesamtzahl der Zeichen in der Spalte „last_name".

{#simple-math-functions-table-builder__ul_yl3_xd5_ytb}

### COUNTIF {#simple-math-functions-table-builder__section_vdh_xd4_dwb}

gibt die Anzahl der Argumente zurück, die den angegebenen Kriterien innerhalb des angegebenen Satzes von Argumenten entsprechen.{#simple-math-functions-table-builder__table_p1x_yd4_dwb__entry__3}

|                          Syntax                          |                                                                                                                                           Eingabe                                                                                                                                           |     Ausgabe      |
|----------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|------------------|
| COUNTIF(Argument 1, Argument 2, Argument n-1, Kriterium) | * Argument 1 ... Argument n: Zeichenfolge, numerischer Wert, Funktionsaufruf oder Variable. * Kriterien: Kriterien, die den angegebenen Satz von Argumenten bewerten. Zeichenfolge, numerischer Wert, Funktionsaufruf oder Variable. {#simple-math-functions-table-builder__ul_lqv_124_dwb} | Numerischer Wert |
[ ]

{#simple-math-functions-table-builder__table_p1x_yd4_dwb}Beispiel:

Funktion: COUNTIF(2,3,2,"string",2)

Das Ergebnis ist 2.

### MODUS {#simple-math-functions-table-builder__section_ixn_r24_dwb}

Gibt den sich am häufigsten wiederholenden Wert im angegebenen Satz von Argumenten zurück.{#simple-math-functions-table-builder__table_mz2_1f4_dwb__entry__3}

|                   Syntax                    |                     Eingabe                     |     Ausgabe      |
|---------------------------------------------|-------------------------------------------------|------------------|
| MODE(Argument 1,Argument 2, ... Argument n) | Numerischer Wert, Funktionsaufruf oder Variable | Numerischer Wert |
[ ]

{#simple-math-functions-table-builder__table_mz2_1f4_dwb}Beispiel:

Funktion: MODE(1, 2, 2, 3, 3, 3)

Das Ergebnis ist 3.

Zeichenfolgenfunktionen {#ariaid-title3}
----------------------------------------

Verwenden Sie Zeichenfolgenfunktionen, um Zeichenfolgen-Spaltenwerte neu zu formatieren oder Berechnungen darauf durchzuführen.

### VERKETTEN {#string-functions-table-builder__section_mjk_zkn_ytb}

verbindet eine oder mehrere Eingabezeichenfolgen zu einer einzigen Zeichenfolge.
{#string-functions-table-builder__table_ayq_bln_ytb__entry__3}

|                             Syntax                              |                   Eingabe                   |   Ausgabe    |
|-----------------------------------------------------------------|---------------------------------------------|--------------|
| CONCATENATE(Zeichenfolge 1, Zeichenfolge 2, ... Zeichenfolge n) | Zeichenfolge, Funktionsaufruf oder Variable | Zeichenfolge |
[ ]

{#string-functions-table-builder__table_ayq_bln_ytb}Beispiele:

* Funktion: CONCATENATE(first_name, ".", last_name, "@", LOWERCASE(example), ".com")Das Ergebnis ist der verkettete Wert\<first_name_value\> .\<last_name_value\> @example.com. In diesem Beispiel\<first_name_value\> und\<last_name_value\> sind Platzhalter.

* Funktion: CONCATENATE(first_name, " ", last_name)Das Ergebnis ist die verkettete Zeichenfolge aus dem Spaltenwert „first_name" und dem Spaltenwert „last_name", getrennt durch ein Leerzeichen.

{#string-functions-table-builder__ul_wfm_zc5_ytb}

### IST BLANK {#string-functions-table-builder__section_wlx_fjn_ytb}

findet Leerräume oder Leerwerte in der Zeichenfolge und gibt „wahr" zurück, wenn welche vorhanden sind.
{#string-functions-table-builder__table_jgr_3jn_ytb__entry__3}

|      Syntax       |        Eingabe         |       Ausgabe       |
|-------------------|------------------------|---------------------|
| ISBLANK(argument) | Zeichenfolge oder Wert | „true" oder „false" |
[ ]

{#string-functions-table-builder__table_jgr_3jn_ytb}Beispiele:

* Funktion: ISBLANK("example_string")Das Ergebnis ist „falsch".

* Funktion: ISBLANK(full_name)Das Ergebnis ist nur true, wenn in der Spalte „full_name" leere Stellen vorhanden sind. Andernfalls lautet das Ergebnis „falsch".

{#string-functions-table-builder__ul_uk5_xb5_ytb}

### LÄNGE {#string-functions-table-builder__section_wz5_pgn_ytb}

Gibt die Gesamtzahl der Zeichen in der Eingabezeichenfolge zurück.
{#string-functions-table-builder__table_sz1_sgn_ytb__entry__3}

|      Syntax      |                     Eingabe                      |     Ausgabe      |
|------------------|--------------------------------------------------|------------------|
| LENGTH(argument) | Zeichenfolgenwert, Funktionsaufruf oder Variable | Numerischer Wert |
[ ]

{#string-functions-table-builder__table_sz1_sgn_ytb}Beispiele:

* Funktion: Length("example_string")Das Ergebnis ist 14.

* Funktion: Length(full_name)Das Ergebnis ist die Gesamtzahl der Zeichen im Wert der Spalte „full_name".

{#string-functions-table-builder__ul_crp_c5t_ytb}

### KLEINBUCHSTABE {#string-functions-table-builder__section_ufr_sjn_ytb}

konvertiert die Eingabezeichenfolge in Kleinbuchstaben.
{#string-functions-table-builder__table_sc1_vjn_ytb__entry__3}

|       Syntax        |                   Eingabe                   |             Ausgabe             |
|---------------------|---------------------------------------------|---------------------------------|
| LOWERCASE(argument) | Zeichenfolge, Funktionsaufruf oder Variable | Zeichenfolge in Kleinbuchstaben |
[ ]

{#string-functions-table-builder__table_sc1_vjn_ytb}Beispiele:

* Funktion: LOWERCASE("ExamPle inpuT stRing")Das Ergebnis ist eine Beispiel-Eingabezeichenfolge.

* Funktion: LOWERCASE(sys_created_by)Das Ergebnis ist die Zeichenfolge in Kleinbuchstaben des Spaltenwerts „sys_created_by".

{#string-functions-table-builder__ul_dh4_gc5_ytb}

### ERSETZEN {#string-functions-table-builder__section_dfv_2hd_g5b}

Ersetzt die Zeichen in der Quellzeichenfolge durch die Zeichen in der Zielzeichenfolge.
{#string-functions-table-builder__table_efv_2hd_g5b__entry__3}

|                          Syntax                           |                                                                                                                     Eingabe                                                                                                                     |   Ausgabe    |
|-----------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------|
| REPLACE(source_string, target_string, replacement_string) | * source_string: Zeichenfolge, Funktionsaufruf oder Variable * target_string: Zeichenfolge, Funktionsaufruf oder Variable * „replacement_string": Zeichenfolge, Funktionsaufruf oder Variable {#string-functions-table-builder__ul_ffv_2hd_g5b} | Zeichenfolge |
[ ]

{#string-functions-table-builder__table_efv_2hd_g5b}Beispiele:

* Funktion: REPLACE("Peperoniwurst-Pizza", „Peperoniwurst", „Käse")Die Ergebniszeichenfolge ist „Käsepizza".

* Funktion: REPLACE("abe.tuter@example.com", "example", company_name)Die Ergebniszeichenfolge ist abe.tuter@\<company_name\> .com In diesem Beispiel\<company_name\> ist ein Platzhalter.

{#string-functions-table-builder__ul_gfv_2hd_g5b}

### TITLECASE {#string-functions-table-builder__section_zl3_l3n_ytb}

konvertiert die Eingabezeichenfolge in Groß- und Kleinbuchstaben.
{#string-functions-table-builder__table_hwc_r3n_ytb__entry__3}

|       Syntax        |                   Eingabe                   |                  Ausgabe                  |
|---------------------|---------------------------------------------|-------------------------------------------|
| TITLECASE(argument) | Zeichenfolge, Funktionsaufruf oder Variable | Zeichenfolge in Groß- und Kleinbuchstaben |
[ ]

{#string-functions-table-builder__table_hwc_r3n_ytb}Beispiele:

* Funktion: TITLECASE("example Zeichenfolge")Das Ergebnis ist Beispielzeichenfolge.

* Funktion: TITLECASE(full_name)Das Ergebnis ist der vollständige Namensspaltenwert in Groß-/Kleinschreibung.

{#string-functions-table-builder__ul_k1z_bb5_ytb}

### GRUNDBUCHSTABEN {#string-functions-table-builder__section_vqx_hgn_ytb}

konvertiert die Eingabezeichenfolge in Großbuchstaben.
{#string-functions-table-builder__table_epc_lgn_ytb__entry__3}

|       Syntax        |                     Eingabe                      |            Ausgabe             |
|---------------------|--------------------------------------------------|--------------------------------|
| UPPERCASE(argument) | Zeichenfolgenwert, Funktionsaufruf oder Variable | Zeichenfolge in Großbuchstaben |
[ ]

{#string-functions-table-builder__table_epc_lgn_ytb}Beispiele:

* Funktion: UPPERCASE("eXamPle sTring")Das Ergebnis ist EXAMPLE STRING.

* Funktion: UPPERCASE(state)Das Ergebnis ist der Wert der Statusspalte in Großbuchstaben.

{#string-functions-table-builder__ul_ilr_ltt_ytb}

### FINDEN {#string-functions-table-builder__section_krg_xgn_dwb}

Sucht nach dem ersten Vorkommen einer Teilzeichenfolge innerhalb einer Zeichenfolge und gibt die Position des ersten Vorkommens zurück.  
Hinweis:  
Bei dieser Funktion wird zwischen Groß- und Kleinschreibung unterschieden.
{#string-functions-table-builder__table_vvp_1hn_dwb__entry__3}

|                     Syntax                     |                                                                                                                                                            Eingabe                                                                                                                                                            |                                                           Ausgabe                                                           |
|------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------|
| FIND(search_string, source_string, from_index) | * search_string: Teilzeichenfolge, Funktionsaufruf oder Variable. * source_string: Hauptzeichenfolge, Funktionsaufruf oder Variable. * from_index: Indexposition in der Hauptzeichenfolge, ab der die Suche beginnen soll. Numerischer Wert, Funktionsaufruf oder Variable. {#string-functions-table-builder__ul_pdg_dhn_dwb} | Numerischer Wert (Ganzzahl). Wenn die Teilzeichenfolge nicht in der Hauptzeichenfolge vorhanden ist, wird -1 zurückgegeben. |
[ ]

{#string-functions-table-builder__table_vvp_1hn_dwb}Beispiel:

Funktion: FIND("Morgen", "Guten Morgen")

Das Ergebnis ist 5.

### SEARCH {#string-functions-table-builder__section_f4n_tc4_dwb}

Sucht nach einer Teilzeichenfolge innerhalb einer Zeichenfolge und gibt die Position des ersten Vorkommens der Teilzeichenfolge zurück.  
Hinweis:  
Bei dieser Funktion wird zwischen Groß- und Kleinschreibung unterschieden.
{#string-functions-table-builder__table_udg_zc4_dwb__entry__3}

|                      Syntax                      |                                                                                                                                                            Eingabe                                                                                                                                                            |                                                           Ausgabe                                                           |
|--------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------|
| SEARCH(search_string, source_string, from_index) | * search_string: Teilzeichenfolge, Funktionsaufruf oder Variable. * source_string: Hauptzeichenfolge, Funktionsaufruf oder Variable. * from_index: Indexposition in der Hauptzeichenfolge, ab der die Suche beginnen soll. Numerischer Wert, Funktionsaufruf oder Variable. {#string-functions-table-builder__ul_izl_cd4_dwb} | Numerischer Wert (Ganzzahl). Wenn die Teilzeichenfolge nicht in der Hauptzeichenfolge vorhanden ist, wird -1 zurückgegeben. |
[ ]

{#string-functions-table-builder__table_udg_zc4_dwb}Beispiele:

* SEARCH("Morgen", "Guten Morgen")Das Ergebnis ist 5.

* SEARCH(" World","Hello World! ")Das Ergebnis ist -1.

{#string-functions-table-builder__ul_pn1_3d4_dwb}

### SUBSTRING {#string-functions-table-builder__section_u5g_cqn_dwb}

Ruft eine Teilzeichenfolge aus einer Zeichenfolge an der angegebenen Indexposition und für die angegebene Länge ab.{#string-functions-table-builder__table_jjp_wb4_dwb__entry__3}

|                    Syntax                     |                                                                                                                                                           Eingabe                                                                                                                                                            |   Ausgabe    |
|-----------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------|
| SUBSTRING(source_string, start_index, length) | * source_string: Zeichenfolge, Funktionsaufruf oder Variable. * start_index: Position in der Zeichenfolge, aus der die Teilzeichenfolge extrahiert wird. Numerischer Wert, Funktionsaufruf oder Variable. * Länge: Länge der Teilzeichenfolge, die extrahiert werden soll. {#string-functions-table-builder__ul_gnx_bc4_dwb} | Zeichenfolge |
[ ]

{#string-functions-table-builder__table_jjp_wb4_dwb}Beispiel:

SUBSTRING("Hallo, Guten Morgen", 7, 4)

Die Ergebnisteilzeichenfolge ist „Gut".

Datums-/Uhrzeitfunktionen {#ariaid-title4}
------------------------------------------

Verwenden Sie Datums- und Uhrzeitfunktionen, um die Werte der Datums- und Uhrzeitspalte zu berechnen oder neu zu formatieren.

### NOW {#date-time-functions-table-builder__section_lqm_f3d_g5b}

Gibt das aktuelle Datum und die aktuelle Uhrzeit der Instanz im ISO-Format (JJJJ-MM-TT hh:mm:ss) zurück.
{#date-time-functions-table-builder__table_mqm_f3d_g5b__entry__3}

| Syntax |                        Eingabe                        |                      Ausgabe                       |
|--------|-------------------------------------------------------|----------------------------------------------------|
| NOW()  | Für diese Funktion sind keine Argumente erforderlich. | Aktuelles Datum und aktuelle Uhrzeit im ISO-Format |
[ ]

{#date-time-functions-table-builder__table_mqm_f3d_g5b}Beispiel:

Funktion: NOW()

Das Ergebnis sind das aktuelle Datum und die aktuelle Uhrzeit im ISO-Format.

### HEUTE {#date-time-functions-table-builder__section_a4f_dnn_dwb}

Gibt das aktuelle Datum mit Zeitversatz zum Tagesbeginn im ISO-Format in der UTC-Zeitzone zurück.{#date-time-functions-table-builder__table_mss_gnn_dwb__entry__3}

|  Syntax  |                        Eingabe                        |                            Ausgabe                             |
|----------|-------------------------------------------------------|----------------------------------------------------------------|
| HEUTE () | Für diese Funktion sind keine Argumente erforderlich. | Aktuelles Datum mit Zeitversatz zum Tagesbeginn im ISO-Format. |
[ ]

{#date-time-functions-table-builder__table_mss_gnn_dwb}Beispiel:

Funktion: HEUTE()

Das Ergebnis sind das aktuelle Datum und die Startzeit des Tages im ISO-Format.

### ZEITDIFF {#date-time-functions-table-builder__section_fkr_yjn_ytb}

Wertet die Zeitdifferenz zwischen zwei Datumsangaben aus.
{#date-time-functions-table-builder__table_vhc_1kn_ytb__entry__3}

|             Syntax             |                                 Eingabe                                  | Ausgabe |
|--------------------------------|--------------------------------------------------------------------------|---------|
| TIMEDIFF(Argument1, Argument2) | Datum im ISO-Format (JJJJ-MM-TT hh:mm:ss) als Zeichenfolge oder Variable | Dauer   |
[ ]

{#date-time-functions-table-builder__table_vhc_1kn_ytb}Beispiele:

* Funktion: TIMEDIFF("2021-05-02 9:10:12", "2021-04-07 6:2:23")Das Ergebnis ist 25 03:07:49.

* Formel: TIMEDIFF(sys_created_on, NOW())Das Ergebnis ist die Zeitdauerdifferenz zwischen dem Datum „sys_created_on" und dem aktuellen Datum des Systems.

{#date-time-functions-table-builder__ul_t2y_kc5_ytb}

### DATEDIF {#date-time-functions-table-builder__section_km1_13n_dwb}

Wertet die Differenz zwischen den beiden Datumsangaben in Tagen, Monaten oder Jahren aus.{#date-time-functions-table-builder__table_s4h_33n_dwb__entry__3}

|                       Syntax                        |                                                                                                                                                                                             Eingabe                                                                                                                                                                                              |                                   Ausgabe                                   |
|-----------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------|
| DATEDIF(start_date, end_date, date_difference_unit) | * start_date: Datum im ISO-Format (JJJJ-MM-TT oder JJJJ-MM-TT hh:mm:ss) als Zeichenfolge oder Variable. * end_date: Datum im ISO-Format (JJJJ-MM-TT oder JJJJ-MM-TT hh:mm:ss) als Zeichenfolge oder Variable. * date_difference_unit: Zeichenfolge und entweder „Y", „M" oder „D" in Kleinbuchstaben oder Großbuchstaben. Standard ist „D". {#date-time-functions-table-builder__ul_wz5_k3n_dwb} | Numerischer Dauerwert basierend auf der angegebenen Datumsdifferenzeinheit. |
[ ]

{#date-time-functions-table-builder__table_s4h_33n_dwb}Beispiel:

Funktion: DATEDIF("2021-05-02 9:10:12","2021-05-05 6:2:23 ","d")

Das Ergebnis ist 3.

### DATUM {#date-time-functions-table-builder__section_sn2_gdn_dwb}

Erstellt ein Datum aus den angegebenen einzelnen Jahres-, Monats- und Tageswerten. Das Erstellungsdatum liegt in der Zeitzone Coordinated Universal Time (UTC).{#date-time-functions-table-builder__table_ek1_jdn_dwb__entry__3}

|        Syntax        |                                                                                                  Eingabe                                                                                                   |                  Ausgabe                  |
|----------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-------------------------------------------|
| DATE(year,month,day) | * Jahr: Numerischer Wert, Variable oder Funktion. * Monat: Numerischer Wert, Variable oder Funktion. * Tag: Numerischer Wert, Variable oder Funktion. {#date-time-functions-table-builder__ul_rxg_4dn_dwb} | Datum im ISO-Format (JJJJ-MM-TT hh:mm:ss) |
[ ]

{#date-time-functions-table-builder__table_ek1_jdn_dwb}Beispiel:

Funktion: DATE(2021,5,2)

Das Ergebnis ist 02.05.2021 00:00:00.

### TAG {#date-time-functions-table-builder__section_kkg_zbn_dwb}

Ruft die numerische Tageskomponente ab dem angegebenen Datum ab.{#date-time-functions-table-builder__table_f1h_2cn_dwb__entry__3}

|  Syntax   |                                               Eingabe                                               |                             Ausgabe                              |
|-----------|-----------------------------------------------------------------------------------------------------|------------------------------------------------------------------|
| DAY(date) | Datum im ISO-Format (JJJJ-MM-TT oder JJJJ-MM-TT hh:mm:ss) als Zeichenfolge, Variable oder Funktion. | Numerischer Wert (Ganzzahl). Die Werte liegen zwischen 1 und 31. |
[ ]

{#date-time-functions-table-builder__table_f1h_2cn_dwb}Beispiele:

* Funktion: DAY("2021-05-029:10:12")Das Ergebnis ist 2.

* Funktion: DAY(NOW())Das Ergebnis ist die Tageskomponente des aktuellen Datums und der aktuellen Uhrzeit.

{#date-time-functions-table-builder__ul_z1q_wcn_dwb}

### MONAT {#date-time-functions-table-builder__section_uxz_cfp_dwb}

Ruft die numerische Monatskomponente ab dem angegebenen Datum ab.{#date-time-functions-table-builder__table_gr4_khp_dwb__entry__3}

|   Syntax    |                                             Eingabe                                             |                                       Ausgabe                                        |
|-------------|-------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------|
| MONTH(date) | date: Datum im ISO-Format (JJJJ-MM-TT oder JJJJ-MM-TT hh:mm:ss) als Zeichenfolge oder Variable. | Numerischer Wert (Ganzzahl). Die Werte liegen zwischen 1 (Januar) und 12 (Dezember). |
[ ]

{#date-time-functions-table-builder__table_gr4_khp_dwb}Beispiele:

* Funktion:MONTH("2021-05-02 9:10:12")Das Ergebnis ist 5.

* Funktion: DAY(NOW())Das Ergebnis ist die Monatskomponente des aktuellen Datums und der aktuellen Uhrzeit.

{#date-time-functions-table-builder__ul_wj5_thp_dwb}

### JAHR {#date-time-functions-table-builder__section_cpy_xym_dwb}

Ruft die Jahreskomponente ab dem angegebenen Datum ab.{#date-time-functions-table-builder__table_d3g_2zm_dwb__entry__3}

|   Syntax   |                                               Eingabe                                               |          Ausgabe          |
|------------|-----------------------------------------------------------------------------------------------------|---------------------------|
| YEAR(date) | Datum im ISO-Format (JJJJ-MM-TT oder JJJJ-MM-TT hh:mm:ss) als Zeichenfolge, Variable oder Funktion. | NumerischerWert (Integer) |
[ ]

{#date-time-functions-table-builder__table_d3g_2zm_dwb}Beispiele:

* Funktion: YEAR("2021-05-02 9:10:12")Das Ergebnis ist 2021.

* Funktion: YEAR(NOW())Das Ergebnis ist die Jahreskomponente des aktuellen Datums und der aktuellen Uhrzeit.

{#date-time-functions-table-builder__ul_mnv_4zm_dwb}

### WOCHENTAG {#date-time-functions-table-builder__section_x3r_qjn_dwb}

Gibt den numerischen Wochentag für das angegebene Datum zurück. Der Tagesbereich liegt zwischen 1 (Sonntag) und 7 (Samstag).{#date-time-functions-table-builder__table_acd_sjn_dwb__entry__3}

|    Syntax     |                                             Eingabe                                             |          Ausgabe          |
|---------------|-------------------------------------------------------------------------------------------------|---------------------------|
| WEEKDAY(date) | date: Datum im ISO-Format (JJJJ-MM-TT oder JJJJ-MM-TT hh:mm:ss) als Zeichenfolge oder Variable. | NumerischerWert (Integer) |
[ ]

{#date-time-functions-table-builder__table_acd_sjn_dwb}Beispiel:

Funktion: WEEKDAY("2021-05-02 9:10:12")

Das Ergebnis ist 1.

### TEXT {#date-time-functions-table-builder__section_emz_b1n_dwb}

Ruft die spezifischen Datumskomponenten in einem Datum im Zeichenfolgenformat ab.{#date-time-functions-table-builder__table_znr_d1n_dwb__entry__3}

|         Syntax          |                                                                                                                      Eingabe                                                                                                                      |   Ausgabe    |
|-------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------|
| TEXT(date, format_text) | * date: Datum im ISO-Format (JJJJ-MM-TT oder JJJJ-MM-TT hh:mm:ss) als Zeichenfolge, Variable. * format_text: Datumskomponenten als Zeichenfolge oder Variable, die extrahiert werden sollen. {#date-time-functions-table-builder__ul_lzb_n1n_dwb} | Zeichenfolge |
[ ]

{#date-time-functions-table-builder__table_znr_d1n_dwb}Beispiel:

TEXT("2022-08-17 9:10:12","jjjj-MM")

Das Ergebnis ist 2022--08.

### DATEVALUE {#date-time-functions-table-builder__section_qzy_3n4_dwb}

Konvertiert ein Datum im Textformat in ein Datum im ISO-Format.{#date-time-functions-table-builder__table_opb_d44_dwb__entry__3}

|        Syntax        |                                     Eingabe                                     |                           Ausgabe                           |
|----------------------|---------------------------------------------------------------------------------|-------------------------------------------------------------|
| DATEVALUE(date_text) | date_text: Das als Text gespeicherte Datum muss im Format JJJJ-MM-TT vorliegen. | Datum im ISO-Format (JJJJ-MM-TT hh:mm:ss) als Zeichenfolge. |
[ ]

{#date-time-functions-table-builder__table_opb_d44_dwb}Beispiel:

Funktion: DATEVALUE("2021-05-02")

Das Ergebnis ist 02.05.2021 00:00:00.

### WORKDAY {#date-time-functions-table-builder__section_cb3_ydn_dwb}

Gibt den nächsten Arbeitstag für das angegebene Eingabedatum zurück, indem die angegebenen Feiertage und Wochenenden vor oder nach der angegebenen n Anzahl von Tagen ausgeschlossen werden.{#date-time-functions-table-builder__table_zyw_b2n_dwb__entry__3}

|                               Syntax                               |                                                                                                                                                                                 Eingabe                                                                                                                                                                                 |                           Ausgabe                           |
|--------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-------------------------------------------------------------|
| WORKDAY(start_date, Tage, Feiertag 1, Feiertag 2, ..., Feiertag n) | * start_date: Datum im ISO-Format (JJJJ-MM-TT oder JJJJ-MM-TT hh:mm:ss) als Zeichenfolge oder Variable. * Tage: Anzahl der Tage als numerischer Wert, Zeichenfolge oder Funktion. * Feiertag 1... Feiertag n (optional): Datum im ISO-Format (JJJJ-MM-TT oder JJJJ-MM-TT hh:mm:ss) als Zeichenfolge oder Variable. {#date-time-functions-table-builder__ul_lhw_h2n_dwb} | Datum im ISO-Format (JJJJ-MM-TT hh:mm:ss) als Zeichenfolge. |
[ ]

{#date-time-functions-table-builder__table_zyw_b2n_dwb}Beispiel:

Funktion: WORKDAY("2022-08-17 9:10:12",2)

Das Ergebnis ist 19.08.2022 00:00:00.

### NETWORKDAYS {#date-time-functions-table-builder__section_trs_4f4_dwb}

Berechnet die Anzahl der Arbeitstage zwischen zwei Daten, indem Wochenenden und angegebene Feiertage ausgeschlossen werden. Die Anzahl der Arbeitstage enthält das Startdatum und das Enddatum.{#date-time-functions-table-builder__table_opy_qf4_dwb__entry__3}

|                                 Syntax                                 |                                                                                                                                                                                                      Eingabe                                                                                                                                                                                                      |          Ausgabe          |
|------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------------------------|
| NETWORKDAYS(start_date,end_date,feiertag 1,feiertag 2, ... Feiertag n) | * start_date: Datum im ISO-Format (JJJJ-MM-TT oder JJJJ-MM-TT hh:mm:ss) als Zeichenfolge oder Variable. * end_date: Datum im ISO-Format (JJJJ-MM-TT oder JJJJ-MM-TT hh:mm:ss) als Zeichenfolge oder Variable. * Feiertag 1, Feiertag 2, ... Feiertag n (optional): Liste der Feiertage, die bei der Berechnung der Arbeitstage ausgeschlossen werden sollen. {#date-time-functions-table-builder__ul_ilg_5f4_dwb} | NumerischerWert (Integer) |
[ ]

{#date-time-functions-table-builder__table_opy_qf4_dwb}Beispiel:

Funktion: NETWORKDAYS("2022-08-17 20:10:12","2022-08-19 9: 10:12")

Das Ergebnis ist 3.

Logische Funktionen {#ariaid-title5}
------------------------------------

Verwenden Sie logische Funktionen, um logische Vorgänge für Spaltenwerte auszuführen.

### UND {#logical-functions-table-builder__section_hh1_fln_ytb}

führt einen logischen AND-Vorgang für die Argumente aus.
{#logical-functions-table-builder__table_skg_224_ytb__entry__3}

|           Syntax            |                   Eingabe                   |       Ausgabe       |
|-----------------------------|---------------------------------------------|---------------------|
| AND(argument 1, argument 2) | Zeichenfolge, Funktionsaufruf oder Variable | „true" oder „false" |
[ ]

{#logical-functions-table-builder__table_skg_224_ytb}Beispiele:

* Funktion: AND(2\>3, 4\<5) Das Ergebnis ist „falsch".

* Formel: AND(Length(sys_created_by)\>25, Length(sys_updated_by)\>25)Das Ergebnis ist nur „true", wenn die Anzahl der Zeichen in den Spalten „sys_created_by" und „sys_updated_by" größer als 25 ist. Andernfalls lautet das Ergebnis „falsch".

{#logical-functions-table-builder__ul_oh3_kd5_ytb}

### IF {#logical-functions-table-builder__section_nk5_wgn_ytb}

führt die angegebenen Anweisungen basierend auf der booleschen Ausgabe des bedingten Ausdrucks aus.
{#logical-functions-table-builder__table_pt3_zgn_ytb__entry__3}

|                                     Syntax                                     |                                                                                                                                                                                                                                                                              Eingabe                                                                                                                                                                                                                                                                              |                                                           Ausgabe                                                           |
|--------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------|
| IF(\<conditional_expression\> ,\<do_this_when_true\> ,\<do this_when_false\> ) | * Conditional_expression: Logischer bedingter Ausdruck, Funktionsaufruf oder Variable Hinweis: Der logische Vergleich von Zeichenfolgen wird im bedingten Ausdruck nicht unterstützt. * do_dis_when_true: Zeichenfolge, numerischer Wert, Funktionsaufruf oder Variable, die zurückgegeben wird, wenn die Bedingung als „wahr" ausgewertet wird * do_dies_when_falsch: Zeichenfolge, numerischer Wert, Funktionsaufruf oder Variable, die zurückgegeben wird, wenn die Bedingung als „falsch" ausgewertet wird {#logical-functions-table-builder__ul_rl2_fhn_ytb} | Zeichenfolge, numerischer Wert, Funktionsaufruf oder Variable basierend auf der booleschen Ausgabe des bedingten Ausdrucks. |
[ ]

{#logical-functions-table-builder__table_pt3_zgn_ytb}Beispiele:

* Funktion: IF(number_of_incidents \>= 5, „Hoch", „Mittel")Wenn die Anzahl der Incidents größer als 5 ist, wird die Zeichenfolge „Hoch" zurückgegeben. In anderen Fällen wird die Zeichenfolge „Medium" zurückgegeben.

* Funktion: IF(LENDTH(full_name) \> 100, „Anzahl der Zeichen überschreitet Grenzwert", „Anzahl der Zeichen innerhalb des Grenzwerts")Wenn die Anzahl der Zeichen für die Spalte „full_name" über 100 liegt, wird die Zeichenfolge „Anzahl der Zeichen überschreitet Grenzwert" zurückgegeben. Andernfalls wird die Zeichenfolge „Anzahl der Zeichen innerhalb des Grenzwerts" zurückgegeben.

{#logical-functions-table-builder__ul_jhw_n5t_ytb}

### ODER {#logical-functions-table-builder__section_bxk_qhn_ytb}

führt einen logischen OR-Vorgang für die Argumente aus.
{#logical-functions-table-builder__table_nsw_shn_ytb__entry__3}

|           Syntax           |                      Eingabe                      |       Ausgabe       |
|----------------------------|---------------------------------------------------|---------------------|
| OR(argument 1, argument 2) | Bedingter Ausdruck, Funktionsaufruf oder Variable | „true" oder „false" |
[ ]

{#logical-functions-table-builder__table_nsw_shn_ytb}Beispiele:

* Funktion: OR(2\>3,4\<5) Das Ergebnis ist true.

* Formel: OR(Length(first_name)\>25, Length(last_name)\<25)Das Ergebnis ist „wahr", wenn die Anzahl der Zeichen in der Spalte „first_name" größer als 25 oder die Anzahl der Zeichen in der Spalte „last_name" kleiner als 25 ist. Andernfalls lautet das Ergebnis „falsch".

{#logical-functions-table-builder__ul_r3c_hvt_ytb}

### IFERROR {#logical-functions-table-builder__section_tmx_nln_dwb}

Wertet Ausdruck 1 aus und gibt den Wert von Ausdruck 1 zurück, wenn Ausdruck 1 keine Fehler enthält. Wenn bei der Auswertung von Ausdruck 1 ein Fehler auftritt, wird Ausdruck 2 ausgewertet und der Wert von Ausdruck 2 zurückgegeben. {#logical-functions-table-builder__table_wgl_rln_dwb__entry__3}

|              Syntax              |                                                                                                                                   Eingabe                                                                                                                                    |                                               Ausgabe                                               |
|----------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------|
| IFERROR (Ausdruck 1, Ausdruck 2) | * Ausdruck 1: Arithmetik, logischer Ausdruck, Funktionsaufruf, Zeichenfolge, numerischer Wert oder Variable. * Ausdruck 2: Arithmetik, logischer Ausdruck, Funktionsaufruf, Zeichenfolge, numerischer Wert oder Variable. {#logical-functions-table-builder__ul_b5r_tln_dwb} | Ergebnis von Ausdruck 1, wenn Ausdruck 1 keine Fehler enthält. Andernfalls Ergebnis von Ausdruck 2. |
[ ]

{#logical-functions-table-builder__table_wgl_rln_dwb}Beispiel:

Funktion: IFERROR( Multiplikator (snr_factor, Signal), Multiplikator (default_factor, Signal))

Wenn der Wert von „snr_factor" eine gültige Zahl ist, wird der multiplizierte Wert von „snr_factor" mit dem Signal zurückgegeben. Wenn der Wert von „snr_factor" keine gültige Zahl ist, wird der multiplizierte Wert des Werts von „default_factor" mit dem Signal zurückgegeben.