Werte
Ein Wert steht für Daten, die durch die Auswertung eines Ausdrucks erzeugt werden. In diesem Abschnitt werden die Arten der Werte in der M-Sprache beschrieben. Jede Art von Wert ist einer Literalsyntax zugeordnet. Dabei handelt es sich um eine Gruppe von Werten vom selben Typ, Operatoren, die für diese Werte definiert wurden, und einen intrinsischen Typ, der neu erstellten Werten zugeordnet wird.
| Art | Literal |
|---|---|
| NULL | null |
| Logisch | true false |
| Number | 0 1 -1 1.5 2.3e-5 |
| Time | #time(09,15,00) |
| Date | #date(2013,02,26) |
| DateTime | #datetime(2013,02,26, 09,15,00) |
| DateTimeZone | #datetimezone(2013,02,26, 09,15,00, 09,00) |
| Duration | #duration(0,1,30,0) |
| Text | "hello" |
| Binär (Binary) | #binary("AQID") |
| Liste | {1, 2, 3} |
| Datensatz | [ A = 1, B = 2 ] |
| Tabelle | #table({"X","Y"},{{0,1},{1,0}}) |
| Function | (x) => x + 1 |
| Typ | type { number } type table [ A = any, B = text ] |
In den folgenden Abschnitten werden alle Arten der Werte ausführlich behandelt. Typen und die Typzuordnung werden formell in Typen definiert. Funktionswerte werden in Funktionen definiert. In den folgenden Abschnitten werden die Operatoren für alle Arten von Werten definiert und Beispiele veranschaulicht. Die vollständige Definition der Operatorsemantik finden Sie unter Operatoren.
NULL
NULL-Werte werden verwendet, um das Fehlen eines Werts oder einen Wert mit unbestimmtem oder unbekanntem Zustand darzustellen. NULL-Werte werden mit dem Literal null geschrieben. Die folgenden Operatoren sind für NULL-Werte definiert:
| Operator | Ergebnis |
|---|---|
x > y |
Größer als |
x >= y |
Größer als oder gleich |
x < y |
Kleiner als |
x <= y |
Kleiner als oder gleich |
x = y |
Gleich |
x <> y |
Ungleich |
x ?? y |
Coalesce |
Der native Typ des Werts null ist der intrinsische Typ null.
Logik (Logical)
Logische Werte werden für boolesche Vorgänge verwendet, die die Werte TRUE oder FALSE aufweisen. Logische Werte werden mit den Literalen true und false geschrieben. Die folgenden Operatoren sind für logische Werte definiert:
| Operator | Ergebnis |
|---|---|
x > y |
Größer als |
x >= y |
Größer als oder gleich |
x < y |
Kleiner als |
x <= y |
Kleiner als oder gleich |
x = y |
Gleich |
x <> y |
Ungleich |
x or y |
Bedingtes logisches OR |
x ?? y |
Coalesce |
x and y |
Bedingtes logisches AND |
not x |
Logisches NOT |
Der native Typ der beiden logischen Werte (true und false) ist der intrinsische Typ logical.
Zahl
Zahlenwerte werden für numerische und arithmetische Vorgänge verwendet. Im Folgenden finden Sie Beispiele für Zahlenliterale:
3.14 // Fractional number
-1.5 // Fractional number
1.0e3 // Fractional number with exponent
123 // Whole number
1e3 // Whole number with exponent
0xff // Whole number in hex (255)
Eine Zahl wird mindestens mit einer Genauigkeit von Double dargestellt (kann aber mehr Genauigkeit beibehalten). Die Double-Darstellung entspricht dem IEEE 64-Bit-Standard für doppelte Genauigkeit für binäre Gleitkommaarithmetik gemäß der Definition im Standard [IEEE 754-2008]. (Die Double-Darstellung verfügt über einen dynamischen Bereich von ungefähr 5,0 × 10324 bis 1,7 × 10308 mit einer Genauigkeit von 15-16 Ziffern.)
Die folgenden speziellen Werte werden auch auchZahlenwerte betrachtet:
Positive null (+0) und negative null (-0): In den meisten Fällen verhält sich die positive und die negative null genau wie der einfache Wert null (0), jedoch unterscheiden bestimmte Vorgänge zwischen den beiden.
Positiv unendlich (
#infinity) und negativ unendlich (-#infinity): Unendlich ist das Ergebnis von Vorgängen wie das Teilen einer Zahl ungleich null (0) durch null (0).1.0 / 0.0ergibt beispielsweise positiv unendlich und-1.0 / 0.0negativ unendlich.Der Wert Not-a-Number (
#nan), der häufig als NaN abgekürzt wird: NaN-Werte werden durch ungültige Gleitkommavorgänge erzeugt, z. B. beim Teilen von null durch null.
Binäre mathematische Vorgänge werden mithilfe einer Genauigkeit durchgeführt. Die Genauigkeit bestimmt die Domäne, mit der die Operanden gerundet werden, und die Domäne, in der der Vorgang durchgeführt wird. Wenn keine explizit angegebene Genauigkeit vorliegt, werden solche Vorgänge mit doppelter Genauigkeit durchgeführt.
Wenn das Ergebnis eines mathematischen Vorgangs zu klein für das Zielformat ist, ist das Ergebnis des Vorgangs positiv oder negativ null.
Wenn das Ergebnis eines mathematischen Vorgangs zu groß für das Zielformat ist, ist das Ergebnis des Vorgangs positiv oder negativ unendlich.
Wenn ein mathematischer Vorgang ungültig ist, ist das Ergebnis des Vorgangs NaN.
Wenn einer der Operanden oder beide Operanden eines Gleitkommavorgangs NaN ergibt, ist das Ergebnis des Vorgangs NaN.
Die folgenden Operatoren sind für Zahlenwerte definiert:
| Operator | Ergebnis |
|---|---|
x > y |
Größer als |
x >= y |
Größer als oder gleich |
x < y |
Kleiner als |
x <= y |
Kleiner als oder gleich |
x = y |
Gleich |
x <> y |
Ungleich |
x + y |
Summe |
x - y |
Unterschied |
x * y |
Produkt |
x / y |
Quotient |
x ?? y |
Coalesce |
+x |
Unäres Plus |
-x |
Negation |
Der native Typ von Zahlenwerten ist der intrinsische Typ number.
Zeit
time-Werte speichern eine nicht transparente Darstellung der Uhrzeit. Die Zeit wird als Anzahl des Werts ticks since midnight codiert. Dabei wird die Anzahl der Ticks alle 100 Nanosekunden gezählt, die in einem Zeitraum von 24 Stunden verstrichen sind. Die maximale Anzahl von ticks since midnight entspricht 23:59:59.9999999 Stunden.
Obwohl es keine Literalsyntax für time-Werte gibt, stehen mehrere Standardbibliotheksfunktionen zur Verfügung, um sie zu erstellen. Die time-Werte können mit der intrinsischen Funktion #time erzeugt werden:
#time(hour, minute, second)
Folgendes muss gelten, da sonst ein Fehler mit dem Ursachencode Expression.Error ausgelöst wird:
0 ≤ Stunde ≤ 24
0 ≤ Minute ≤ 59
0 ≤ Sekunde ≤ 59
Außerdem müssen die Werte für Minuten und Sekunden „0“ (null) entsprechen, wenn der Wert für Stunden „24“ ist.
Die folgenden Operatoren sind für time-Werte definiert:
| Operator | Ergebnis |
|---|---|
x = y |
Gleich |
x <> y |
Ungleich |
x >= y |
Größer als oder gleich |
x > y |
Größer als |
x < y |
Kleiner als |
x <= y |
Kleiner als oder gleich |
x ?? y |
Coalesce |
Die folgenden Operatoren lassen zu, dass ein Operand oder beide Operanden ein Datum darstellen:
| Operator | Linker Operand | Rechter Operand | Bedeutung |
|---|---|---|---|
x + y |
time |
duration |
Date-Offset nach duration |
x + y |
duration |
time |
Date-Offset nach duration |
x - y |
time |
duration |
Date-Offset nach negierter duration |
x - y |
time |
time |
Duration zwischen dates |
x & y |
date |
time |
zusammengeführte datetime |
Der native Typ von time-Werten ist der intrinsische Typ time.
Datum
date-Werte speichern eine nicht transparente Darstellung eines spezifischen Tages. Ein Datum wird als Zahl des Werts days since epoch codiert. Der Wert beginnt am 1. Januar 0001 nach unserer Zeitrechnung im gregorianischen Kalender. Der maximale Wert für „days since epoch“ lautet „3652058“ und entspricht dem 31. Dezember 9999.
Obwohl es keine Literalsyntax für date-Werte gibt, stehen mehrere Standardbibliotheksfunktionen zur Verfügung, um sie zu erstellen. Die date-Werte können auch mit der intrinsischen Funktion #date erzeugt werden:
#date(year, month, day)
Folgendes muss gelten, da sonst ein Fehler mit dem Ursachencode Expression.Error ausgelöst wird:
1 ≤ Jahr ≤ 9999
1 ≤ Monat ≤ 12
1 ≤ Tag ≤ 31
Darüber hinaus muss der Tag für den jeweiligen Monat und das Jahr gültig sein.
Die folgenden Operatoren sind für date-Werte definiert:
| Operator | Ergebnis |
|---|---|
x = y |
Gleich |
x <> y |
Ungleich |
x >= y |
Größer als oder gleich |
x > y |
Größer als |
x < y |
Kleiner als |
x <= y |
Kleiner als oder gleich |
x ?? y |
Coalesce |
Die folgenden Operatoren lassen zu, dass ein Operand oder beide Operanden ein Datum darstellen:
| Operator | Linker Operand | Rechter Operand | Bedeutung |
|---|---|---|---|
x + y |
date |
duration |
Date-Offset nach duration |
x + y |
duration |
date |
Date-Offset nach duration |
x - y |
date |
duration |
Date-Offset nach negierter duration |
x - y |
date |
date |
Duration zwischen dates |
x & y |
date |
time |
zusammengeführte datetime |
Der native Typ von date-Werten ist der intrinsische Typ date.
DateTime
datetime-Werte enthalten sowohl ein Datum als auch eine Uhrzeit.
Obwohl es keine Literalsyntax für datetime-Werte gibt, stehen mehrere Standardbibliotheksfunktionen zur Verfügung, um sie zu erstellen. Die datetime-Werte können auch mit der intrinsischen Funktion #datetime erzeugt werden:
#datetime(year, month, day, hour, minute, second)
Folgendes muss gelten, da sonst ein Fehler mit dem Ursachencode „Expression.Error“ ausgelöst wird: 1 ≤ Jahr ≤ 9999
1 ≤ Monat ≤ 12
1 ≤ Tag ≤ 31
0 ≤ Stunde ≤ 23
0 ≤ Minute ≤ 59
0 ≤ Sekunde ≤ 59
Darüber hinaus muss der Tag für den jeweiligen Monat und das Jahr gültig sein.
Die folgenden Operatoren sind für datetime-Werte definiert:
| Operator | Ergebnis |
|---|---|
x = y |
Gleich |
x <> y |
Ungleich |
x >= y |
Größer als oder gleich |
x > y |
Größer als |
x < y |
Kleiner als |
x <= y |
Kleiner als oder gleich |
x ?? y |
Coalesce |
Die folgenden Operatoren lassen zu, dass ein Operand oder beide Operanden einen datetime-Wert darstellen:
| Operator | Linker Operand | Rechter Operand | Bedeutung |
|---|---|---|---|
x + y |
datetime |
duration |
Date-Offset nach duration |
x + y |
duration |
datetime |
Date-Offset nach duration |
x - y |
datetime |
duration |
Datetime-Offset nach negierter duration |
x - y |
datetime |
datetime |
Duration zwischen datetimes |
Der native Typ von datetime-Werten ist der intrinsische Typ datetime.
DatumZeitzone (DateTimeZone)
datetimezone-Werte enthalten einen datetime-Wert und einen Wert für die Zeitzone. Eine Zeitzone wird mit einem Wert für die Minutenabweichung von der koordinierten Weltzeit codiert. Dieser Wert entspricht der Anzahl der Minuten, um die der datetime-Wert von der koordinierten Weltzeit (UTC) abweichen sollte. Der Mindestwert für die Minutenabweichung von der koordinierten Weltzeit ist „-840“. Dieser Wert stellt eine UTC-Abweichung von „-14:00“ bzw. 14 Stunden vor UTC dar. Der Maximalwert für die Minutenabweichung von der koordinierten Weltzeit ist „840“. Dieser Wert stellt eine UTC-Abweichung von „14:00“ dar.
Obwohl es keine Literalsyntax für datetimezone-Werte gibt, stehen mehrere Standardbibliotheksfunktionen zur Verfügung, um sie zu erstellen. Die datetimezone-Werte können auch mit der intrinsischen Funktion #datetimezone erzeugt werden:
#datetimezone(
year, month, day,
hour, minute, second,
offset-hours, offset-minutes)
Folgendes muss gelten, da sonst ein Fehler mit dem Ursachencode Expression.Error ausgelöst wird:
1 ≤ Jahr ≤ 9999
1 ≤ Monat ≤ 12
1 ≤ Tag ≤ 31
0 ≤ Stunde ≤ 23
0 ≤ Minute ≤ 59
0 ≤ Sekunde ≤ 59
-14 ≤ Stundenabweichung ≤ 14
-59 ≤ Minutenabweichung ≤ 59
Darüber hinaus muss der Tag für den jeweiligen Monat und das Jahr gültig sein. Wenn die Stundenabweichung „14“ beträgt, muss die Minutenabweichung kleiner als oder gleich „0“ sein, und wenn die Stundenabweichung „-14“ beträgt, muss die Minutenabweichung größer als oder gleich „0“ sein.
Die folgenden Operatoren sind für datetimezone-Werte definiert:
| Operator | Ergebnis |
|---|---|
x = y |
Gleich |
x <> y |
Ungleich |
x >= y |
Größer als oder gleich |
x > y |
Größer als |
x < y |
Kleiner als |
x <= y |
Kleiner als oder gleich |
x ?? y |
Coalesce |
Die folgenden Operatoren lassen zu, dass ein Operand oder beide Operanden einen datetimezone-Wert darstellen:
| Operator | Linker Operand | Rechter Operand | Bedeutung |
|---|---|---|---|
x + y |
datetimezone |
duration |
Datetimezone-Offset nach duration |
x + y |
duration |
datetimezone |
Datetimezone-Offset nach duration |
x - y |
datetimezone |
duration |
Datetimezone-Offset nach negierter duration |
x - y |
datetimezone |
datetimezone |
Duration zwischen datetimezones |
Der native Typ von datetimezone-Werten ist der intrinsische Typ datetimezone.
Dauer
duration-Werte speichern eine nicht transparente Darstellung der Distanz zwischen zwei Punkten auf einer Zeitskala nach Ticks von 100 Nanosekunden. Der Wert einer Dauer kann entweder positiv oder negativ sein. Positive Werte stellen Zeitfortschritt vorwärts dar, und negative Werte stellen Zeitfortschritt rückwärts dar. Der Mindestwert für eine Dauer ist -9.223.372.036.854.775.808 Ticks. Dies entspricht 10.675.199 Tagen, 2 Stunden, 48 Minuten und 05,4775808 Sekunden in der Zeit zurück. Der Maximalwert für eine Dauer ist 9.223.372.036.854.775.807 Ticks. Dies entspricht 10.675.199 Tagen, 2 Stunden, 48 Minuten und 05,4775807 Sekunden in der Zeit vorwärts.
Obwohl es keine Literalsyntax für duration-Werte gibt, stehen mehrere Standardbibliotheksfunktionen zur Verfügung, um sie zu erstellen. Die duration-Werte können auch mit der intrinsischen Funktion #duration erzeugt werden:
#duration(0, 0, 0, 5.5) // 5.5 seconds
#duration(0, 0, 0, -5.5) // -5.5 seconds
#duration(0, 0, 5, 30) // 5.5 minutes
#duration(0, 0, 5, -30) // 4.5 minutes
#duration(0, 24, 0, 0) // 1 day
#duration(1, 0, 0, 0) // 1 day
Die folgenden Operatoren sind für duration-Werte definiert:
| Operator | Ergebnis |
|---|---|
x = y |
Gleich |
x <> y |
Ungleich |
x >= y |
Größer als oder gleich |
x > y |
Größer als |
x < y |
Kleiner als |
x <= y |
Kleiner als oder gleich |
x ?? y |
Coalesce |
Außerdem lassen die folgenden Operatoren zu, dass ein Operand oder beide Operanden einen duration-Wert darstellen:
| Operator | Linker Operand | Rechter Operand | Bedeutung |
|---|---|---|---|
x + y |
datetime |
duration |
Date-Offset nach duration |
x + y |
duration |
datetime |
Date-Offset nach duration |
x + y |
duration |
duration |
Summe der durations |
x - y |
datetime |
duration |
Datetime-Offset nach negierter duration |
x - y |
datetime |
datetime |
Duration zwischen datetimes |
x - y |
duration |
duration |
Differenz der durations |
x * y |
duration |
number |
N-fach duration |
x * y |
number |
duration |
N-fach duration |
x / y |
duration |
number |
Teil von duration |
Der native Typ von duration-Werten ist der intrinsische Typ duration.
Text
Textwerte stellen eine Sequenz aus Unicode-Zeichen dar. Textwerte verfügen über ein Literalformat entsprechend der folgenden Grammatik:
_text-literal:
" text-literal-charactersopt"
text-literal-characters:
text-literal-character text-literal-charactersopt
text-literal-character:
single-text-character
character-escape-sequence
double-quote-escape-sequence
single-text-character:
Beliebiges Zeichen außer " (U+0022) oder # (U+0023), gefolgt von ( (U+0028)
Escapesequenz mit doppelten Anführungszeichen:
"" (U+0022, U+0022)
Im Folgenden finden Sie ein Beispiel für einen Textwert:
"ABC" // the text value ABC
Die folgenden Operatoren sind für Textwerte definiert:
| Operator | Ergebnis |
|---|---|
x = y |
Gleich |
x <> y |
Ungleich |
x >= y |
Größer als oder gleich |
x > y |
Größer als |
x < y |
Kleiner als |
x <= y |
Kleiner als oder gleich |
x & y |
Verkettung |
x ?? y |
Coalesce |
Der native Typ von Textwerten ist der intrinsische Typ text.
Binär
Binärwerte stellen eine Sequenz von Bytes dar.
Obwohl es keine Literalsyntax für Binärwerte gibt, stehen mehrere Standardbibliotheksfunktionen zur Verfügung, um sie zu erstellen. Binärwerte können auch mit der intrinsischen Funktion #binary erzeugt werden.
Im folgenden Beispiel wird ein Binärwert aus einer Liste von Bytes erstellt:
#binary( {0x00, 0x01, 0x02, 0x03} )
Die folgenden Operatoren sind für Binärwerte definiert:
| Operator | Ergebnis |
|---|---|
x = y |
Gleich |
x <> y |
Ungleich |
x >= y |
Größer als oder gleich |
x > y |
Größer als |
x < y |
Kleiner als |
x <= y |
Kleiner als oder gleich |
x ?? y |
Coalesce |
Der native Typ von Binärwerten ist der intrinsische Typ binary.
Liste
Listenwerte sind Werte, die bei der Enumeration eine Sequenz von Werten erzeugt. Ein Wert, der von einer Liste erzeugt wird, kann einen beliebigen Wert enthalten, einschließlich einer Liste. Listen können wie folgt mithilfe der Initialisierungssyntax erstellt werden:
Listenausdruck:
{ item-listopt }
item-list:
item
item,item-list
item:
expression
expression..expression
Im folgenden Beispiel für eine list-expression (einen Listenausdruck) wird eine Liste mit drei Textwerten definiert: "A", "B" und "C".
{"A", "B", "C"}
Der Wert "A" ist das erste Element in der Liste, und der Wert "C" ist das letzte Element in der Liste.
- Die Elemente einer Liste werden erst ausgewertet, wenn auf sie zugegriffen wird.
- Obwohl Listenwerte, die mithilfe der Listensyntax erstellt wurden, Elemente gemäß der Reihenfolge in der Elementliste erzeugen, können von Bibliotheksfunktionen zurückgegebene Listen im Allgemeinen bei jeder Enumeration eine andere Gruppe oder eine andere Anzahl von Werten erzeugen.
Zum Einfügen einer Sequenz aus ganzen Zahlen in eine Liste kann das Format a..b verwendet werden:
{ 1, 5..9, 11 } // { 1, 5, 6, 7, 8, 9, 11 }
Die Anzahl der Elemente in einer Liste, die als Listenanzahl bezeichnet wird, kann mithilfe der Funktion List.Count ermittelt werden.
List.Count({true, false}) // 2
List.Count({}) // 0
Eine Liste kann effektiv eine unbegrenzte Anzahl von Elementen enthalten. List.Count ist für solche Listen nicht definiert und kann entweder einen Fehler auslösen oder wird nicht beendet.
Wenn eine Liste keine Elemente beinhaltet, handelt es sich um eine leere Liste. Eine leere Liste wird folgendermaßen geschrieben:
{} // empty list
Die folgenden Operatoren sind für Listen definiert:
| Operator | Ergebnis |
|---|---|
x = y |
Gleich |
x <> y |
Ungleich |
x & y |
Concatenate |
x ?? y |
Coalesce |
Beispiel:
{1, 2} & {3, 4, 5} // {1, 2, 3, 4, 5}
{1, 2} = {1, 2} // true
{2, 1} <> {1, 2} // true
Der native Typ von Listenwerten ist der intrinsische Typ list, der den Elementtyp any angibt.
Aufzeichnung (Record)
Datensatzwerte sind eine geordnete Sequenz von Feldern. Ein Feld besteht aus einem Feldnamen, bei dem es sich um einen Textwert handelt, der das Feld im Datensatz eindeutig identifiziert, und einen Feldwert. Der Feldwert kann einer beliebigen Art von Wert entsprechen, einschließlich Datensatzwerten. Datensätze können wie folgt mithilfe der Initialisierungssyntax erstellt werden:
Datensatzausdruck:
[field-listopt]
field-list:
Feld
field,field-list
field:
field-name=expression
field-name:
generalized-identifier
quoted-identifier
Im folgenden Beispiel wird ein Datensatz mit einem Feld namens x mit dem Wert 1 und einem Feld namens y mit dem Wert 2 erstellt.
[ x = 1, y = 2 ]
Im folgenden Beispiel wird ein Datensatz mit einem a-Feld namens „a“ mit einem geschachtelten Datensatzwert erstellt. Der geschachtelte Datensatz umfasst ein Feld namens b mit dem Wert 2.
[ a = [ b = 2 ] ]
Folgendes gilt beim Auswerten eines Datensatzausdrucks:
Der Ausdruck, der den einzelnen Feldnamen zugeordnet ist, wird zum Bestimmen des Werts des zugeordneten Felds verwendet.
Wenn der Ausdruck, der einem Feldnamen zugewiesen ist, bei der Auswertung einen Wert erzeugt, wird dieser der Wert des Felds im resultierenden Datensatz.
Wenn der Ausdruck, der einem Feldnamen zugewiesen ist, bei der Auswertung einen Fehler auslöst, wird die Auslösung des Fehlers mit dem Feld und dem ausgelösten Fehlerwert aufgezeichnet. Anschließender Zugriff auf dieses Feld löst den Fehler nochmal mit dem aufgezeichneten Fehlerwert aus.
Der Ausdruck wird in einer Umgebung ähnlich der übergeordneten Umgebung ausgewertet, nur entsprechen die zusammengeführten Werte den Werten der Felder des Datensatzes, mit Ausnahme des Werts, der initialisiert wird.
Ein Wert in einem Datensatz wird erst ausgewertet, wenn auf das entsprechende Feld zugegriffen wird.
Ein Wert in einem Datensatz wird maximal einmal ausgewertet.
Das Ergebnis des Ausdrucks ist ein Datensatzwert mit einem leeren Metadatensatz.
Die Reihenfolge der Felder im Datensatz wird anhand der Reihenfolge definiert, in der sie in record-initializer-expression angezeigt werden.
Jeder angegebene Feldname muss innerhalb des Datensatzes eindeutig sein, da sonst ein Fehler auftritt. Namen werden mit einem Ordinalvergleich verglichen.
[ x = 1, x = 2 ] // error: field names must be unique
[ X = 1, x = 2 ] // OK
Ein Datensatz ohne Felder wird als leerer Datensatz bezeichnet und wird wie folgt geschrieben:
[] // empty record
Obwohl die Reihenfolge der Felder eines Datensatzes für den Zugriff auf ein Feld oder das Vergleichen von zwei Datensätzen keine Bedeutung hat, ist sie in anderen Kontexten wichtig, z. B. wenn die Felder eines Datensatzes aufgelistet werden.
Die selben zwei Datensätze erzeugen unterschiedliche Ergebnisse, wenn die Felder abgerufen werden:
Record.FieldNames([ x = 1, y = 2 ]) // [ "x", "y" ]
Record.FieldNames([ y = 1, x = 2 ]) // [ "y", "x" ]
Die Anzahl der Felder in einem Datensatz kann mithilfe der Record.FieldCount-Funktion ermittelt werden. Beispiel:
Record.FieldCount([ x = 1, y = 2 }) // 2
Record.FieldCount([]) // 0
Neben der Verwendung der Datensatzinitialisierungssyntax [ ] können Datensätze auch aus einer Liste von Werten und einer Liste von Feldnamen oder einem Datensatztyp erstellt werden. Beispiel:
Record.FromList({1, 2}, {"a", "b"})
Das obige Beispiel entspricht dem folgenden:
[ a = 1, b = 2 ]
Die folgenden Operatoren sind für Datensatzwerte definiert:
| Operator | Ergebnis |
|---|---|
x = y |
Gleich |
x <> y |
Ungleich |
x & y |
Zusammenführen |
x ?? y |
Coalesce |
In den folgenden Beispielen werden die oben genannten Operatoren veranschaulicht. Beachten Sie, dass die Felder des rechten Operanden bei der Zusammenführung der Datensätze zum Überschreiben der Felder des linken Operanden verwendet werden, wenn eine Überlappung bei den Feldnamen vorliegt.
[ a = 1, b = 2 ] & [ c = 3 ] // [ a = 1, b = 2, c = 3 ]
[ a = 1, b = 2 ] & [ a = 3 ] // [ a = 3, b = 2 ]
[ a = 1, b = 2 ] = [ b = 2, a = 1 ] // true
[ a = 1, b = 2, c = 3 ] <> [ a = 1, b = 2 ] // true
Der native Typ von Datensatzwerten ist der intrinsische Typ record, der eine offene leere Liste von Feldern angibt.
Tabelle
Ein Tabellenwert ist eine geordnete Sequenz von Zeilen. Eine Zeile ist eine geordnete Sequenz von Spaltenwerten. Der Typ der Tabelle bestimmt die Länge aller Zeilen in der Tabelle, die Namen der Tabellenspalten, die Typen der Tabellenspalten und die Struktur der Tabellenschlüssel (sofern vorhanden).
Obwohl es keine Literalsyntax für Tabellenwerte gibt, stehen mehrere Standardbibliotheksfunktionen zur Verfügung, um sie zu erstellen. Tabellenwerte können mit der intrinsischen Funktion #table erzeugt werden.
Im folgenden Beispiel wird eine Tabelle aus einer Liste von Spaltennamen und einer Liste von Zeilen erstellt. Die resultierende Tabelle enthält zwei type any-Spalten und drei Zeilen.
#table({"x", "x^2"}, {{1,1}, {2,4}, {3,9}})
#table kann auch zum Angeben eines vollständigen Tabellentyps verwendet werden:
#table(
type table [Digit = number, Name = text],
{{1,"one"}, {2,"two"}, {3,"three"}}
)
Hier verfügt der neue Tabellenwert über einen Tabellentyp, der Spaltennamen und -typen angibt.
Die folgenden Operatoren sind für Tabellenwerte definiert:
| Operator | Ergebnis |
|---|---|
x = y |
Gleich |
x <> y |
Ungleich |
x & y |
Verkettung |
x ?? y |
Coalesce |
Bei der Tabellenverkettung werden ähnlich benannte Spalten ausgerichtet, und der Wert null wird in Spalten eingefügt, die nur in einer der Operandentabellen vorhanden sind. Im folgenden Beispiel wird die Tabellenverkettung veranschaulicht:
#table({"A","B"}, {{1,2}})
& #table({"B","C"}, {{3,4}})
| A | B | C |
|---|---|---|
1 |
2 |
null |
null |
3 |
4 |
Der native Typ von Tabellenwerten ist ein benutzerdefinierter Tabellentyp (der vom intrinsischen Typ table abgeleitet wird), der die Spaltennamen auflistet, für alle Spaltentypen „any“ (beliebig) festlegt und über keine Schlüssel verfügt. (Ausführliche Informationen über Tabellentypen finden Sie unter Tabellentypen.)
Funktion
Funktionswerte sind Werte, die einem einzelnen Wert mehrere Argumente zuordnen. Ausführliche Informationen über Funktionswerte finden Sie unter Funktionen.
Typ
Ein Typwert ist ein Wert, der andere Werte klassifiziert. Ausführliche Informationen über Typwerte finden Sie unter Typen.
Feedback
Bald verfügbar: Im Laufe des Jahres 2024 werden wir GitHub-Issues stufenweise als Feedbackmechanismus für Inhalte abbauen und durch ein neues Feedbacksystem ersetzen. Weitere Informationen finden Sie unter https://aka.ms/ContentUserFeedback.
Feedback senden und anzeigen für