Värden
Ett värde är data som skapas genom att utvärdera ett uttryck. I det här avsnittet beskrivs de olika typerna av värden på M-språket. Varje typ av värde associeras med en literalsyntax, en uppsättning värden som är av den typen, en uppsättning operatorer som definierats över den uppsättningen värden och en inbyggd typ som är tillskriven nyligen konstruerade värden.
Variant | Literal |
---|---|
Null | null |
Logisk | true false |
Antal | 0 1 -1 1.5 2.3e-5 |
Tid | #time(09,15,00) |
Datum | #date(2013,02,26) |
DateTime | #datetime(2013,02,26, 09,15,00) |
DateTimeZone | #datetimezone(2013,02,26, 09,15,00, 09,00) |
Varaktighet | #duration(0,1,30,0) |
Text | "hello" |
Binär | #binary("AQID") |
Lista | {1, 2, 3} |
Post | [ A = 1, B = 2 ] |
Tabell | #table({"X","Y"},{{0,1},{1,0}}) |
Funktion | (x) => x + 1 |
Typ | type { number } type table [ A = any, B = text ] |
Följande avsnitt beskriver varje värdetyp i detalj. Typer och typaskription definieras formellt i Typer. Funktionsvärden definieras i Functions. I följande avsnitt visas de operatorer som definierats för varje värdetyp och ger exempel. Den fullständiga definitionen av operatorsemantik följer i Operatorer.
Ett null-värde används för att representera frånvaron av ett värde, eller ett värde med obestämd eller okänt tillstånd. Ett null-värde skrivs med hjälp av literalen null
. Följande operatorer definieras för null-värden:
Operator | Result |
---|---|
x > y |
Större än |
x >= y |
Större än eller lika med |
x < y |
Mindre än |
x <= y |
Mindre än eller lika med |
x = y |
Equal |
x <> y |
Not equal |
x ?? y |
Coalesce |
Den interna typen av null
värdet är den inbyggda typen null
.
Ett logiskt värde används för booleska åtgärder som har värdet true eller false. Ett logiskt värde skrivs med hjälp av literalerna true
och false
. Följande operatorer definieras för logiska värden:
Operator | Result |
---|---|
x > y |
Större än |
x >= y |
Större än eller lika med |
x < y |
Mindre än |
x <= y |
Mindre än eller lika med |
x = y |
Equal |
x <> y |
Not equal |
x or y |
Villkorsstyrd logisk OR |
x ?? y |
Coalesce |
x and y |
Villkorsstyrd logisk AND |
not x |
Logiskt INTE |
Den interna typen av både logiska värden (true
och false
) är den inbyggda typen logical
.
Ett talvärde används för numeriska och aritmetiska åtgärder. Följande är exempel på tallitraler:
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)
Ett tal representeras med minst precisionen för en Double (men kan behålla mer precision). Dubbelrepresentationen är kongruent med IEEE 64-bitars dubbelprecisionsstandard för binär flyttalsaritmetik definierad i [IEEE 754-2008]. (Den Dubbel representation har ett ungefärligt dynamiskt intervall från 5,0 x 10324 till 1,7 x 10308 med en precision på 15–16 siffror.)
Följande specialvärden anses också vara talvärden :
Positiv noll och negativ nolla. I de flesta situationer fungerar positiv noll och negativ noll identiskt som det enkla värdet noll, men vissa åtgärder skiljer mellan de två.
Positiv oändlighet (
#infinity
) och negativ oändlighet (-#infinity
). Infinities produceras av sådana åtgärder som att dividera ett tal som inte är noll med noll. Till exempel1.0 / 0.0
ger positiv oändlighet och-1.0 / 0.0
ger negativ oändlighet.Värdet Not-a-Number (
#nan
), ofta förkortat NaN. NaN skapas av ogiltiga flyttalsåtgärder, till exempel att dividera noll med noll.
Binära matematiska åtgärder utförs med hjälp av en precision. Precisionen avgör den domän som operanderna avrundas till och domänen där åtgärden utförs. I avsaknad av en uttryckligen angiven precision utförs sådana åtgärder med dubbel precision.
Om resultatet av en matematisk åtgärd är för litet för målformatet blir resultatet av åtgärden positiv noll eller negativ nolla.
Om resultatet av en matematisk åtgärd är för stort för målformatet blir resultatet av åtgärden positiv oändlighet eller negativ oändlighet.
Om en matematisk åtgärd är ogiltig blir resultatet av åtgärden NaN.
Om en eller båda operanderna i en flyttalsåtgärd är NaN blir resultatet av åtgärden NaN.
Följande operatorer definieras för talvärden:
Operator | Result |
---|---|
x > y |
Större än |
x >= y |
Större än eller lika med |
x < y |
Mindre än |
x <= y |
Mindre än eller lika med |
x = y |
Equal |
x <> y |
Not equal |
x + y |
Sum |
x - y |
Differens |
x * y |
Produkt |
x / y |
Kvot |
x ?? y |
Coalesce |
+x |
Unary plus |
-x |
Negation |
Den interna typen av talvärden är den inbyggda typen number
.
Ett tidsvärde lagrar en ogenomskinlig representation av tid på dagen. En tid kodas som antalet fästingar sedan midnatt, vilket räknar antalet tick på 100 nanosekunder som har förflutit på en 24-timmarsklocka. Det maximala antalet tick sedan midnatt motsvarar 23:59:59,99999999 timmar.
Även om det inte finns någon literalsyntax för tider tillhandahålls flera standardbiblioteksfunktioner för att konstruera dem. Tider kan också konstrueras med hjälp av den inbyggda funktionen #time
:
#time(hour, minute, second)
Följande måste innehålla eller ett fel med orsakskoden Expression.Error
genereras:
0 ≤ timme ≤ 24
0 ≤ minut ≤ 59
0 ≤ andra ≤ 59
Dessutom måste minut och sekund vara noll om timme = 24.
Följande operatorer definieras för tidsvärden:
Operator | Result |
---|---|
x = y |
Equal |
x <> y |
Not equal |
x >= y |
Större än eller lika med |
x > y |
Större än |
x < y |
Mindre än |
x <= y |
Mindre än eller lika med |
x ?? y |
Coalesce |
Följande operatorer tillåter att en eller båda av deras operander är ett datum:
Operator | Vänster operand | Höger operand | Innebörd |
---|---|---|---|
x + y |
time |
duration |
Datumförskjutning efter varaktighet |
x + y |
duration |
time |
Datumförskjutning efter varaktighet |
x - y |
time |
duration |
Datumförskjutning efter negerad varaktighet |
x - y |
time |
time |
Varaktighet mellan datum |
x & y |
date |
time |
Sammanfogad datetime |
Den interna typen av tidsvärden är den inbyggda typen time
.
Ett datumvärde lagrar en ogenomskinlig representation av en viss dag. Ett datum kodas som ett antal dagar sedan epoken, från och med den 1 januari 0001 common era i den gregorianska kalendern. Det maximala antalet dagar sedan epoken är 3652058, motsvarande 31 december 9999.
Även om det inte finns någon literal syntax för datum tillhandahålls flera standardbiblioteksfunktioner för att konstruera dem. Datum kan också konstrueras med hjälp av den inbyggda funktionen #date
:
#date(year, month, day)
Följande måste innehålla eller ett fel med orsakskoden Expression.Error
genereras:
1 ≤ år ≤ 9999
1 ≤ månad ≤ 12
1 ≤ dag ≤ 31
Dessutom måste dagen vara giltig för den valda månaden och året.
Följande operatorer definieras för datumvärden:
Operator | Result |
---|---|
x = y |
Equal |
x <> y |
Not equal |
x >= y |
Större än eller lika med |
x > y |
Större än |
x < y |
Mindre än |
x <= y |
Mindre än eller lika med |
x ?? y |
Coalesce |
Följande operatorer tillåter att en eller båda av deras operander är ett datum:
Operator | Vänster operand | Höger operand | Innebörd |
---|---|---|---|
x + y |
date |
duration |
Datumförskjutning efter varaktighet |
x + y |
duration |
date |
Datumförskjutning efter varaktighet |
x - y |
date |
duration |
Datumförskjutning efter negerad varaktighet |
x - y |
date |
date |
Varaktighet mellan datum |
x & y |
date |
time |
Sammanfogad datetime |
Den interna typen av datumvärden är den inbyggda typen date
.
Ett datetime-värde innehåller både ett datum och en tid.
Även om det inte finns någon literalsyntax för datetimes tillhandahålls flera standardbiblioteksfunktioner för att konstruera dem. Datetimes kan också konstrueras med hjälp av den inbyggda funktionen #datetime
:
#datetime(year, month, day, hour, minute, second)
Följande måste innehålla eller ett fel med orsakskoden Expression.Error is raised: 1 ≤ year ≤ 9999
1 ≤ månad ≤ 12
1 ≤ dag ≤ 31
0 ≤ timme ≤ 23
0 ≤ minut ≤ 59
0 ≤ andra ≤ 59
Dessutom måste dagen vara giltig för den valda månaden och året.
Följande operatorer definieras för datetime-värden:
Operator | Result |
---|---|
x = y |
Equal |
x <> y |
Not equal |
x >= y |
Större än eller lika med |
x > y |
Större än |
x < y |
Mindre än |
x <= y |
Mindre än eller lika med |
x ?? y |
Coalesce |
Följande operatorer tillåter att en eller båda av deras operander är en datetime:
Operator | Vänster operand | Höger operand | Innebörd |
---|---|---|---|
x + y |
datetime |
duration |
Datetime-förskjutning efter varaktighet |
x + y |
duration |
datetime |
Datetime-förskjutning efter varaktighet |
x - y |
datetime |
duration |
Datetime-förskjutning efter negerad varaktighet |
x - y |
datetime |
datetime |
Varaktighet mellan datetimes |
Den interna typen av datetime-värden är den inbyggda typen datetime
.
Ett datetimezone-värde innehåller en datetime och en tidszon. En tidszon kodas som ett antal minuters förskjutning från UTC, vilket räknar antalet minuter som tidsdelen av datetime ska förskjutas från UNIVERSAL Coordinated Time (UTC). Det minsta antalet minuter som förskjuts från UTC är -840, vilket representerar en UTC-förskjutning på -14:00 eller fjorton timmar tidigare än UTC. Det maximala antalet minuter förskjutning från UTC är 840, vilket motsvarar en UTC-förskjutning på 14:00.
Även om det inte finns någon literal syntax för datetimezones tillhandahålls flera standardbiblioteksfunktioner för att konstruera dem. Datetimezones kan också konstrueras med hjälp av den inbyggda funktionen #datetimezone
:
#datetimezone(
year, month, day,
hour, minute, second,
offset-hours, offset-minutes)
Följande måste innehålla eller ett fel med orsakskoden Expression.Error
genereras:
1 ≤ år ≤ 9999
1 ≤ månad ≤ 12
1 ≤ dag ≤ 31
0 ≤ timme ≤ 23
0 ≤ minut ≤ 59
0 ≤ andra ≤ 59
-14 ≤ förskjutningstimmar ≤ 14
-59 ≤ förskjutningsminuter ≤ 59
Dessutom måste dagen vara giltig för den valda månaden och året, och om offset-hours = 14, sedan offset-minutes <= 0 och, om offset-hours = -14, sedan offset-minutes >= 0.
Följande operatorer definieras för datetimezone-värden:
Operator | Result |
---|---|
x = y |
Equal |
x <> y |
Not equal |
x >= y |
Större än eller lika med |
x > y |
Större än |
x < y |
Mindre än |
x <= y |
Mindre än eller lika med |
x ?? y |
Coalesce |
Följande operatorer tillåter att en eller båda av deras operander är en datetimezone:
Operator | Vänster operand | Höger operand | Innebörd |
---|---|---|---|
x + y |
datetimezone |
duration |
Datetimezone-förskjutning efter varaktighet |
x + y |
duration |
datetimezone |
Datetimezone-förskjutning efter varaktighet |
x - y |
datetimezone |
duration |
Datetimezone-förskjutning efter negerad varaktighet |
x - y |
datetimezone |
datetimezone |
Varaktighet mellan datetimezones |
Den interna typen av datetimezone-värden är den inbyggda typen datetimezone
.
Ett varaktighetsvärde lagrar en ogenomskinlig representation av avståndet mellan två punkter på en tidslinje som mäts med tick på 100 nanosekunder. Varaktighetens omfattning kan vara antingen positiv eller negativ, med positiva värden som anger förlopp framåt i tiden och negativa värden som anger förloppet bakåt i tiden. Det minsta värde som kan lagras under en varaktighet är -9 223 372 036 854 775 808 tick eller 10 675 199 dagar 2 timmar 48 minuter 05,4775808 sekunder bakåt i tiden. Det maximala värdet som kan lagras under en varaktighet är 9 223 372 036 854 775 807 tick, eller 10 675 199 dagar 2 timmar 48 minuter 05,4775807 sekunder framåt i tiden.
Även om det inte finns någon literalsyntax för varaktigheter tillhandahålls flera standardbiblioteksfunktioner för att konstruera dem. Varaktigheter kan också konstrueras med hjälp av den inbyggda funktionen #duration
:
#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
Följande operatorer definieras för varaktighetsvärden:
Operator | Result |
---|---|
x = y |
Equal |
x <> y |
Not equal |
x >= y |
Större än eller lika med |
x > y |
Större än |
x < y |
Mindre än |
x <= y |
Mindre än eller lika med |
x ?? y |
Coalesce |
Dessutom tillåter följande operatorer att en eller båda av deras operander är ett varaktighetsvärde:
Operator | Vänster operand | Höger operand | Innebörd |
---|---|---|---|
x + y |
datetime |
duration |
Datetime-förskjutning efter varaktighet |
x + y |
duration |
datetime |
Datetime-förskjutning efter varaktighet |
x + y |
duration |
duration |
Summa av varaktigheter |
x - y |
datetime |
duration |
Datetime-förskjutning efter negerad varaktighet |
x - y |
datetime |
datetime |
Varaktighet mellan datetimes |
x - y |
duration |
duration |
Skillnad mellan varaktigheter |
x * y |
duration |
number |
N gånger en varaktighet |
x * y |
number |
duration |
N gånger en varaktighet |
x / y |
duration |
number |
Del av en varaktighet |
Den interna typen av varaktighetsvärden är den inbyggda typen duration
.
Ett textvärde representerar en sekvens med Unicode-tecken. Textvärden har en literal form som överensstämmer med följande 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:
Alla tecken utom "
(U+0022
) eller #
(U+0023
) följt av (
(U+0028
)
double-quote-escape-sequence:
""
(U+0022
, U+0022
)
Följande är ett exempel på ett textvärde :
"ABC" // the text value ABC
Följande operatorer definieras för textvärden :
Operator | Result |
---|---|
x = y |
Equal |
x <> y |
Not equal |
x >= y |
Större än eller lika med |
x > y |
Större än |
x < y |
Mindre än |
x <= y |
Mindre än eller lika med |
x & y |
Sammanfogning |
x ?? y |
Coalesce |
Den interna typen av textvärden är den inbyggda typen text
.
Ett binärt värde representerar en sekvens med byte.
Även om det inte finns någon literal syntax för binära värden tillhandahålls flera standardbiblioteksfunktioner för att konstruera dem. Binära värden kan också konstrueras med hjälp av den inbyggda funktionen #binary
.
I följande exempel skapas ett binärt värde från en lista med byte:
#binary( {0x00, 0x01, 0x02, 0x03} )
Följande operatorer definieras för binära värden:
Operator | Result |
---|---|
x = y |
Equal |
x <> y |
Not equal |
x >= y |
Större än eller lika med |
x > y |
Större än |
x < y |
Mindre än |
x <= y |
Mindre än eller lika med |
x ?? y |
Coalesce |
Den interna typen av binära värden är den inbyggda typen binär.
Ett listvärde är ett värde som skapar en sekvens med värden när de räknas upp. Ett värde som skapas av en lista kan innehålla alla typer av värden, inklusive en lista. Listor kan skapas med hjälp av initieringssyntaxen enligt följande:
listuttryck:
{ alternativ för objektlista}
item-list:
sak
objektobjektlista ,
sak:
uttryck
uttrycksuttryck..
Följande är ett exempel på ett listuttryck som definierar en lista med tre textvärden: "A"
, "B"
och "C"
.
{"A", "B", "C"}
Värdet "A"
är det första objektet i listan och värdet "C"
är det sista objektet i listan.
- Objekten i en lista utvärderas inte förrän de har använts.
- Även om listvärden som skapas med hjälp av listsyntaxen skapar objekt i den ordning de visas i objektlistan, kan listor som returneras från biblioteksfunktioner i allmänhet generera en annan uppsättning eller ett annat antal värden varje gång de räknas upp.
Om du vill inkludera en sekvens med heltal i en lista kan formuläret a..b
användas:
{ 1, 5..9, 11 } // { 1, 5, 6, 7, 8, 9, 11 }
Antalet objekt i en lista, som kallas listantal, kan fastställas med hjälp av List.Count
funktionen .
List.Count({true, false}) // 2
List.Count({}) // 0
En lista kan i praktiken ha ett oändligt antal objekt. List.Count
för sådana listor är odefinierat och kan antingen orsaka ett fel eller inte avslutas.
Om en lista inte innehåller några objekt kallas den för en tom lista. En tom lista skrivs som:
{} // empty list
Följande operatorer definieras för listor:
Operator | Result |
---|---|
x = y |
Equal |
x <> y |
Not equal |
x & y |
Concatenate |
x ?? y |
Coalesce |
Till exempel:
{1, 2} & {3, 4, 5} // {1, 2, 3, 4, 5}
{1, 2} = {1, 2} // true
{2, 1} <> {1, 2} // true
Den interna typen av listvärden är den inbyggda typen list
, som anger en objekttyp av any
.
Ett postvärde är en ordnad sekvens med fält. Ett fält består av ett fältnamn, vilket är ett textvärde som unikt identifierar fältet i posten och ett fältvärde. Fältvärdet kan vara vilken typ av värde som helst, inklusive post. Poster kan konstrueras med hjälp av initieringssyntaxen enligt följande:
record-expression:
[
val av fältlista ]
fältlista:
fält
fältfältlista,
fält:
fältnamnsuttryck=
field-name:
generalized-identifier
quoted-identifier
I följande exempel skapas en post med ett fält med namnet x
med värdet 1
, och ett fält med namnet y
med värdet 2
.
[ x = 1, y = 2 ]
I följande exempel skapas en post med a
fältet med namnet a med ett kapslat postvärde. Den kapslade posten har ett fält med namnet b
med värdet 2
.
[ a = [ b = 2 ] ]
Följande gäller vid utvärdering av ett postuttryck:
Uttrycket som tilldelas varje fältnamn används för att fastställa värdet för det associerade fältet.
Om uttrycket som tilldelas ett fältnamn genererar ett värde när det utvärderas blir det värdet för fältet för den resulterande posten.
Om uttrycket som tilldelats ett fältnamn genererar ett fel när det utvärderas registreras det faktum att ett fel uppstod med fältet tillsammans med det felvärde som uppstod. Efterföljande åtkomst till fältet gör att ett fel genereras på nytt med det registrerade felvärdet.
Uttrycket utvärderas i en miljö som den överordnade miljön endast med variabler sammanfogade i som motsvarar värdet för varje fält i posten, förutom den som initieras.
Ett värde i en post utvärderas inte förrän motsvarande fält har använts.
Ett värde i en post utvärderas högst en gång.
Resultatet av uttrycket är ett postvärde med en tom metadatapost.
Ordningen på fälten i posten definieras av den ordning som de visas i postinitieringsuttrycket.
Varje fältnamn som anges måste vara unikt i posten, eller så är det ett fel. Namn jämförs med hjälp av en ordningstalsjämförelse.
[ x = 1, x = 2 ] // error: field names must be unique
[ X = 1, x = 2 ] // OK
En post utan fält kallas för en tom post och skrivs på följande sätt:
[] // empty record
Även om ordningen på fälten i en post inte är betydande vid åtkomst till ett fält eller jämförelse av två poster, är det viktigt i andra sammanhang, till exempel när fälten i en post räknas upp.
Samma två poster ger olika resultat när fälten hämtas:
Record.FieldNames([ x = 1, y = 2 ]) // [ "x", "y" ]
Record.FieldNames([ y = 1, x = 2 ]) // [ "y", "x" ]
Antalet fält i en post kan fastställas med hjälp av Record.FieldCount
funktionen . Till exempel:
Record.FieldCount([ x = 1, y = 2 }) // 2
Record.FieldCount([]) // 0
Förutom att använda syntaxen [ ]
för postinitiering kan poster konstrueras från en lista med värden och en lista med fältnamn eller en posttyp. Till exempel:
Record.FromList({1, 2}, {"a", "b"})
Ovanstående motsvarar:
[ a = 1, b = 2 ]
Följande operatorer definieras för postvärden:
Operator | Result |
---|---|
x = y |
Equal |
x <> y |
Not equal |
x & y |
Slå ihop |
x ?? y |
Coalesce |
Följande exempel illustrerar operatorerna ovan. Observera att sammanslagning av poster använder fälten från den högra operanden för att åsidosätta fält från den vänstra operanden, om det skulle finnas en överlappning i fältnamnen.
[ 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
Den interna typen av postvärden är den inbyggda typen record
, som anger en öppen tom lista med fält.
Ett tabellvärde är en ordnad sekvens med rader. En rad är en ordnad sekvens med kolumnvärden. Tabellens typ avgör längden på alla rader i tabellen, namnen på tabellens kolumner, typerna av tabellens kolumner och strukturen för tabellens nycklar (om någon).
Även om det inte finns någon literalsyntax för tabeller tillhandahålls flera standardbiblioteksfunktioner för att konstruera dem. Tabeller kan också konstrueras med hjälp av den inbyggda funktionen #table
.
I följande exempel skapas en tabell från en lista med kolumnnamn och en lista med rader. Den resulterande tabellen innehåller två kolumner med type any
och tre rader.
#table({"x", "x^2"}, {{1,1}, {2,4}, {3,9}})
#table
kan också användas för att ange en fullständig tabelltyp:
#table(
type table [Digit = number, Name = text],
{{1,"one"}, {2,"two"}, {3,"three"}}
)
Här har det nya tabellvärdet en tabelltyp som anger kolumnnamn och kolumntyper.
Följande operatorer definieras för tabellvärden:
Operator | Result |
---|---|
x = y |
Equal |
x <> y |
Not equal |
x & y |
Sammanfogning |
x ?? y |
Coalesce |
Tabellsammanfogning justerar kolumner med samma namn och fyller i null
för kolumner som endast visas i en av operandtabellerna. I följande exempel visas tabellsammanfogning:
#table({"A","B"}, {{1,2}})
& #table({"B","C"}, {{3,4}})
A | B | C |
---|---|---|
1 |
2 |
null |
null |
3 |
4 |
Den interna typen av tabellvärden är en anpassad tabelltyp (härledd från den inbyggda typen table
) som visar kolumnnamnen, anger att alla kolumntyper ska vara valfria och inte har några nycklar. (Gå till Tabelltyper för information om tabelltyper.)
Ett funktionsvärde är ett värde som mappar en uppsättning argument till ett enda värde. Information om funktionsvärden beskrivs i Functions.
Ett typvärde är ett värde som klassificerar andra värden. Information om typvärden beskrivs i Typer.