Operatörsbeteende
Det här avsnittet definierar beteendet för de olika M-operatorerna.
När ett uttryck innehåller flera operatorer styr operatorernas prioritet i vilken ordning de enskilda operatorerna utvärderas. Uttrycket x + y * z
utvärderas till exempel som x + (y * z)
eftersom operatorn *
har högre prioritet än den binära +
operatorn. Prioriteten för en operator fastställs genom definitionen av dess associerade grammatikproduktion. Till exempel består ett additivt uttryck av en sekvens av multiplicativa uttryck avgränsade med +
eller -
operatorer, vilket ger +
operatorerna och -
lägre prioritet än operatorerna *
och /
.
Parentes-uttrycksproduktionen kan användas för att ändra standardprioretsordningen.
parentes-expression:
(
uttryck)
Till exempel:
1 + 2 * 3 // 7
(1 + 2) * 3 // 9
I följande tabell sammanfattas M-operatorerna och operatorkategorierna visas i prioritetsordning från högsta till lägsta. Operatorer i samma kategori har samma prioritet.
Kategori | Uttryck | beskrivning |
---|---|---|
Primär |
jag @ jag |
Identifieraruttryck |
(x) | Parenteserat uttryck | |
x[i] | Sökning | |
x{y} | Objektåtkomst | |
x(...) | Funktionsanrop | |
{x, y, ...} | Listinitiering | |
[ i = x, ... ] | Postinitiering | |
... | Inte implementerad | |
Unär | + x | Identitet |
- x | Negation | |
not
x |
Logisk negation | |
Metadata |
xmeta y |
Associera metadata |
Multiplicative | x * y | Multiplikation |
x / y | Division | |
Tillsats | x + y | Tillägg |
x - y | Subtraktion | |
Relation | x< y | Mindre än |
x > y | Större än | |
x<= y | Mindre än eller lika med | |
x >= y | Större än eller lika med | |
Tillämplig | x = y | Lika med |
x<> y | Not equal | |
Typkontroll |
xas y |
Är kompatibel null-primitiv typ eller fel |
Typefterlevnad |
xis y |
Testa om kompatibel null-primitiv typ |
Logiskt OCH |
xand y |
Kortslutningskonjunktion |
Logiskt ELLER |
xor y |
Kortslutningsdisjunction |
Coalesce |
x?? y |
Null-sammankopplingsoperator |
Varje värde har ett associerat postvärde som kan innehålla ytterligare information om värdet. Den här posten kallas metadataposten för ett värde. En metadatapost kan associeras med alla typer av värden, till och med null
. Resultatet av en sådan association är ett nytt värde med angivna metadata.
En metadatapost är bara en vanlig post och kan innehålla alla fält och värden som en vanlig post kan, och i sig har en metadatapost. Att associera en metadatapost med ett värde är "icke-påträngande". Det ändrar inte värdets beteende i utvärderingar förutom de som uttryckligen inspekterar metadataposter.
Varje värde har en standardmetadatapost, även om en inte har angetts. Standardmetadataposten är tom. I följande exempel visas åtkomst till metadataposten för ett textvärde med hjälp av standardbiblioteksfunktionen Value.Metadata
:
Value.Metadata( "Mozart" ) // []
Metadataposter bevaras vanligtvis inte när ett värde används med en operator eller funktion som konstruerar ett nytt värde. Om till exempel två textvärden sammanfogas med operatorn &
är metadata för det resulterande textvärdet den tomma posten []
. Följande uttryck är likvärdiga:
"Amadeus " & ("Mozart" meta [ Rating = 5 ])
"Amadeus " & "Mozart"
Standardbiblioteksfunktionerna Value.RemoveMetadata
och Value.ReplaceMetadata
kan användas för att ta bort alla metadata från ett värde och för att ersätta ett värdes metadata (i stället för att sammanfoga metadata till befintliga metadata).
Den enda operator som returnerar resultat som bär metadata är metaoperatorn.
Värden kan vara cykliska. Till exempel:
let l = {0, @l} in l
// {0, {0, {0, ... }}}
[A={B}, B={A}]
// [A = {{ ... }}, B = {{ ... }}]
M hanterar cykliska värden genom att hålla konstruktionen av poster, listor och tabeller lat. Ett försök att konstruera ett cykliskt värde som inte drar nytta av interjected lazy structured values ger ett fel:
[A=B, B=A]
// [A = Error.Record("Expression.Error",
// "A cyclic reference was encountered during evaluation"),
// B = Error.Record("Expression.Error",
// "A cyclic reference was encountered during evaluation"),
// ]
Vissa operatorer i M definieras av strukturell rekursion. Till exempel definieras likhet mellan poster och listor av den sammanlänkade likheten mellan motsvarande postfält respektive objektlistor.
För icke-cykliska värden ger tillämpning av strukturell rekursion en begränsad utökning av värdet: delade kapslade värden kommer att korsas upprepade gånger, men rekursionsprocessen avslutas alltid.
Ett cykliskt värde har en oändlig expansion vid tillämpning av strukturell rekursion. Semantiken i M gör inga särskilda boenden för sådana oändliga expansioner – ett försök att jämföra cykliska värden för likhet, till exempel, kommer vanligtvis att få slut på resurser och avslutas exceptionellt.
Markerings- och projektionsoperatorerna tillåter att data extraheras från list- och postvärden.
Ett värde kan väljas från en lista eller tabell baserat på dess nollbaserade position i listan eller tabellen med hjälp av ett objektåtkomstuttryck.
item-access-expression:
objektval
optional-item-selection
objektval:
primary-expression{
item-selector}
optional-item-selection:
primary-expression{
item-selector} ?
item-selector:
uttryck
Item-access-expression x{y}
returnerar:
För en lista
x
och ett taly
, objektet i listanx
på positiony
. Det första objektet i en lista anses ha ett ordningstalsindex på noll. Om den begärda positionen inte finns i listan utlöses ett fel.För en tabell
x
och ett taly
, raden i tabellenx
på positiony
. Den första raden i en tabell anses ha ett ordningstalsindex på noll. Om den begärda positionen inte finns i tabellen utlöses ett fel.För en tabell
x
och en posty
matchar den tabellradx
som matchar fältvärdena för posty
för fält med fältnamn som matchar motsvarande tabellkolumnnamn. Om det inte finns någon unik matchande rad i tabellen utlöses ett fel.
Till exempel:
{"a","b","c"}{0} // "a"
{1, [A=2], 3}{1} // [A=2]
{true, false}{2} // error
#table({"A","B"},{{0,1},{2,1}}){0} // [A=0,B=1]
#table({"A","B"},{{0,1},{2,1}}){[A=2]} // [A=2,B=1]
#table({"A","B"},{{0,1},{2,1}}){[B=3]} // error
#table({"A","B"},{{0,1},{2,1}}){[B=1]} // error
Item-access-expression stöder också formuläret , som returnerar x{y}?
när position (eller matchning) null
inte finns i listan eller tabellen y
.x
Om det finns flera matchningar för y
genereras fortfarande ett fel.
Till exempel:
{"a","b","c"}{0}? // "a"
{1, [A=2], 3}{1}? // [A=2]
{true, false}{2}? // null
#table({"A","B"},{{0,1},{2,1}}){0}? // [A=0,B=1]
#table({"A","B"},{{0,1},{2,1}}){[A=2]}? // [A=2,B=1]
#table({"A","B"},{{0,1},{2,1}}){[B=3]}? // null
#table({"A","B"},{{0,1},{2,1}}){[B=1]}? // error
Objektåtkomst tvingar inte utvärdering av andra list- eller tabellobjekt än den som används. Till exempel:
{ error "a", 1, error "c"}{1} // 1
{ error "a", error "b"}{1} // error "b"
Följande gäller när objektets åtkomstoperator x{y}
utvärderas:
Fel som uppstår under utvärderingen av uttryck
x
ellery
sprids.Uttrycket
x
skapar en lista eller ett tabellvärde.Uttrycket
y
genererar ett talvärde eller, omx
det genererar ett tabellvärde, ett postvärde.Om
y
genererar ett talvärde och värdet föry
är negativt genereras ett fel med orsakskoden"Expression.Error"
.Om
y
genererar ett talvärde och värdety
för är större än eller lika med antaletx
utlöses ett fel med orsakskoden"Expression.Error"
om inte det valfria operatorformuläretx{y}?
används, i vilket fall värdetnull
returneras.Om
x
skapar ett tabellvärde ochy
genererar ett postvärde och det inte finns några matchningar föry
ix
genereras ett fel med orsakskoden"Expression.Error"
om inte det valfria operatorformuläretx{y}?
används, i vilket fall värdetnull
returneras.Om
x
skapar ett tabellvärde ochy
genererar ett postvärde och det finns flera matchningar föry
ix
genereras ett fel med orsakskoden"Expression.Error"
.
Inga andra objekt x
i än den positionen y
utvärderas under processen för objektval. (För direktuppspelningslistor eller tabeller hoppas objekten eller raderna före position y
över, vilket kan orsaka deras utvärdering, beroende på källan till listan eller tabellen.)
Field-access-expression används för att välja ett värde från en post eller för att projicera en post eller tabell till ett med färre fält eller kolumner.
field-access-expression:
fältval
implicit-target-field-selection
projektion
implicit målprojektion
fältval:
fältväljare för primärt uttryck
field-selector:
required-field-selector
optional-field-selector
required-field-selector:
[
fältnamn]
optional-field-selector:
[
fältnamn] ?
field-name:
generalized-identifier
quoted-identifier
implicit-target-field-selection:
fältväljare
projektion:
primary-expression required-projection
primary-expression optional-projection
obligatorisk projektion:
[
required-selector-list]
optional-projection:
[
required-selector-list] ?
required-selector-list:
required-field-selector
required-selector-list,
required-field-selector
implicit målprojektion:
obligatorisk projektion
optional-projection
Den enklaste formen av fältåtkomst är obligatorisk fältval. Den använder operatorn x[y]
för att leta upp ett fält i en post efter fältnamn. Om fältet y
inte finns i x
genereras ett fel. Formuläret x[y]?
används för att utföra val av valfritt fält och returnerar null
om det begärda fältet inte finns i posten.
Till exempel:
[A=1,B=2][B] // 2
[A=1,B=2][C] // error
[A=1,B=2][C]? // null
Kollektiv åtkomst för flera fält stöds av operatorerna för nödvändig postprojektion och valfri postprojektion. Operatorn x[[y1],[y2],...]
projicerar posten till en ny post med färre fält (valda av y1
, y2
, ...
). Om ett markerat fält inte finns utlöses ett fel. Operatorn x[[y1],[y2],...]?
projicerar posten till en ny post med fälten valda av y1
, y2
, ...
, , om ett fält saknas, null
används i stället.
Till exempel:
[A=1,B=2][[B]] // [B=2]
[A=1,B=2][[C]] // error
[A=1,B=2][[B],[C]]? // [B=2,C=null]
Formulären [y]
och [y]?
stöds som en kortfattad referens till identifieraren _
(understreck). Följande två uttryck är likvärdiga:
[A]
_[A]
I följande exempel visas den korta formen av fältåtkomst:
let _ = [A=1,B=2] in [A] //1
Formuläret [[y1],[y2],...]
och [[y1],[y2],...]?
stöds också som en förkortning och följande två uttryck är på samma sätt likvärdiga:
[[A],[B]]
_[[A],[B]]
Det kortfattade formuläret är särskilt användbart i kombination med förkortningen each
, ett sätt att introducera en funktion av en enskild parameter med namnet _
(mer information finns i Förenklade deklarationer). Tillsammans förenklar de två förkortningarna vanliga funktionella uttryck i högre ordning:
List.Select( {[a=1, b=1], [a=2, b=4]}, each [a] = [b])
// {[a=1, b=1]}
Ovanstående uttryck motsvarar följande mer kryptiska långhandsuttryck:
List.Select( {[a=1, b=1], [a=2, b=4]}, (_) => _[a] = _[b])
// {[a=1, b=1]}
Fältåtkomst tvingar inte utvärdering av andra fält än de som används. Till exempel:
[A=error "a", B=1, C=error "c"][B] // 1
[A=error "a", B=error "b"][B] // error "b"
Följande gäller när en fältåtkomstoperator x[y]
, x[y]?
, x[[y]]
eller x[[y]]?
utvärderas:
Fel som uppstår under utvärderingen av uttrycket
x
sprids.Fel som uppstår vid utvärdering av fält
y
associeras permanent med fältety
och sprids sedan. All framtida åtkomst till fältety
genererar det identiska felet.Uttrycket
x
genererar ett post- eller tabellvärde, eller så utlöses ett fel.Om identifieraren namnger
y
ett fält som inte finns ix
genereras ett fel med orsakskoden"Expression.Error"
om inte det valfria operatorformuläret...?
används, i vilket fall värdetnull
returneras.
Inga andra fält x
än de som namnges av y
utvärderas under fältåtkomstprocessen.
Metadataposten för ett värde ändras med metaoperatorn (x meta y
).
metadata-expression:
unary-expression
unary-expressionmeta
unary-expression
I följande exempel skapas ett textvärde med en metadatapost med operatorn meta
och åtkomst till metadataposten för det resulterande värdet med hjälp av Value.Metadata
:
Value.Metadata( "Mozart" meta [ Rating = 5 ] )
// [Rating = 5 ]
Value.Metadata( "Mozart" meta [ Rating = 5 ] )[Rating]
// 5
Följande gäller vid användning av metadata som kombinerar operatorn x meta y
:
Fel som uppstår när du utvärderar
x
ellery
uttryck sprids.Uttrycket
y
måste vara en post, eller så utlöses ett fel med orsakskoden"Expression.Error"
.Den resulterande metadataposten är
x
metadataposten som sammanfogats medy
. (För semantiken för sammanslagning av poster, se Koppla poster.)Det resulterande värdet är värdet från
x
uttrycket, utan dess metadata, med den nyligen beräknade metadataposten kopplad.
Standardbiblioteksfunktionerna Value.RemoveMetadata
och Value.ReplaceMetadata
kan användas för att ta bort alla metadata från ett värde och för att ersätta ett värdes metadata (i stället för att sammanfoga metadata till befintliga metadata). Följande uttryck är likvärdiga:
x meta y
Value.ReplaceMetadata(x, Value.Metadata(x) & y)
Value.RemoveMetadata(x) meta (Value.Metadata(x) & y)
Likhetsoperatorn =
används för att avgöra om två värden är lika. Ojämlikhetsoperatorn <>
används för att avgöra om två värden inte är lika med.
likhetsuttryck:
relationsuttryck
relational-expression=
equality-expression
relational-expression<>
equality-expression
Till exempel:
1 = 1 // true
1 = 2 // false
1 <> 1 // false
1 <> 2 // true
null = true // false
null = null // true
Metadata är inte en del av likhets- eller ojämlikhetsjämförelse. Till exempel:
(1 meta [ a = 1 ]) = (1 meta [ a = 2 ]) // true
(1 meta [ a = 1 ]) = 1 // true
Följande gäller när likhetsoperatorerna x = y
tillämpas och x <> y
:
Fel som uppstår när du utvärderar
x
ellery
uttryck sprids.Operatorn
=
har ett resultat avtrue
om värdena är lika ochfalse
i annat fall.Operatorn
<>
har ett resultat avfalse
om värdena är lika ochtrue
i annat fall.Metadataposter ingår inte i jämförelsen.
Om värden som skapas genom utvärdering av uttrycken
x
ochy
inte är samma typ av värde är värdena inte lika.Om värdena som skapas genom utvärdering
x
av uttrycket ochy
är samma typ av värde finns det specifika regler för att avgöra om de är lika, enligt definitionen nedan.Följande är alltid sant:
(x = y) = not (x <> y)
Likhetsoperatorerna definieras för följande typer:
- Värdet
null
är bara lika med sig självt.
null = null // true
null = true // false
null = false // false
- De logiska värdena
true
ochfalse
är bara lika med sig själva. Till exempel:
true = true // true
false = false // true
true = false // false
true = 1 // false
Tal jämförs med den angivna precisionen:
Om något av talen är
#nan
är talen inte samma.När inget av talen är
#nan
jämförs talen med hjälp av en bitvis jämförelse av det numeriska värdet.#nan
är det enda värde som inte är lika med sig självt.Till exempel:
1 = 1, // true
1.0 = 1 // true
2 = 1 // false
#nan = #nan // false
#nan <> #nan // true
Två varaktigheter är lika med om de representerar samma antal tick på 100 nanosekunder.
Två gånger är lika med om storleken på deras delar (timme, minut, sekund) är lika.
Två datum är lika med om storleken på deras delar (år, månad, dag) är lika med.
Två datetimes är lika med om storleken på deras delar (år, månad, dag, timme, minut och sekund) är lika.
Två datetimezones är lika med om motsvarande UTC-datetimes är lika. För att komma fram till motsvarande UTC-datetime subtraheras förskjutningen timmar/minuter från datetime-komponenten i datetimezone.
Två textvärden är lika med om de använder en ordningstalskänslig, skiftlägeskänslig, kulturokänslig jämförelse med samma längd och lika med tecken på motsvarande positioner.
Två listvärden är lika med om alla följande är sanna:
Båda listorna innehåller samma antal objekt.
Värdena för varje positionsmässigt motsvarande objekt i listorna är lika med. Det innebär att listorna inte bara behöver innehålla samma objekt, utan att objekten måste vara i samma ordning.
Till exempel:
{1, 2} = {1, 2} // true {2, 1} = {1, 2} // false {1, 2, 3} = {1, 2} // false
Två poster är lika med om alla följande är sanna:
Antalet fält är detsamma.
Varje fältnamn för en post finns också i den andra posten.
Värdet för varje fält i en post är lika med fältet med samma namn i den andra posten.
Till exempel:
[ A = 1, B = 2 ] = [ A = 1, B = 2 ] // true [ B = 2, A = 1 ] = [ A = 1, B = 2 ] // true [ A = 1, B = 2, C = 3 ] = [ A = 1, B = 2 ] // false [ A = 1 ] = [ A = 1, B = 2 ] // false
Två tabeller är lika om alla följande är sanna:
Antalet kolumner är detsamma.
Varje kolumnnamn i en tabell finns också i den andra tabellen.
Antalet rader är detsamma.
Varje rad har samma värden i motsvarande celler.
Till exempel:
#table({"A","B"},{{1,2}}) = #table({"A","B"},{{1,2}}) // true #table({"A","B"},{{1,2}}) = #table({"X","Y"},{{1,2}}) // false #table({"A","B"},{{1,2}}) = #table({"B","A"},{{2,1}}) // true
Ett funktionsvärde är lika med sig självt, men kan vara lika med ett annat funktionsvärde. Om två funktionsvärden anses vara lika beter de sig identiskt när de anropas.
Två angivna funktionsvärden har alltid samma likhetsrelation.
Ett typvärde är lika med sig självt, men kan vara lika med ett annat typvärde. Om två typvärden anses vara lika beter de sig identiskt när de efterfrågas för överensstämmelse.
Två angivna typvärden har alltid samma likhetsrelation.
Operatorerna <
, >
, <=
och >=
kallas för relationsoperatorer.
relational-expression:
additivt uttryck
relationellt uttryck för additivt uttryck<
relationellt uttryck för additivt uttryck>
relationellt uttryck för additivt uttryck<=
relationellt uttryck för additivt uttryck>=
Dessa operatorer används för att fastställa den relativa ordningsrelationen mellan två värden, enligt följande tabell:
Åtgärd | Result |
---|---|
x < y |
true om x är mindre än y , false annars |
x > y |
true om x är större än y , false annars |
x <= y |
true om x är mindre än eller lika med y , false annars |
x >= y |
true om x är större än eller lika med y , false annars |
Till exempel:
0 <= 1 // true
null < 1 // null
null <= null // null
"ab" < "abc" // true
#nan >= #nan // false
#nan <= #nan // false
Följande gäller vid utvärdering av ett uttryck som innehåller relationsoperatorerna:
Fel som uppstår vid utvärdering av operanduttrycken
x
spridsy
.Värdena som skapas genom utvärdering av både uttrycken
x
ochy
måste vara ett binärt värde, datum, datetime, datetimezone, varaktighet, logiskt värde, tal, null, text eller tid. Annars utlöses ett fel med orsakskoden"Expression.Error"
.Båda operanderna måste ha samma typ av värde eller
null
. Annars utlöses ett fel med orsakskoden"Expression.Error"
.Om antingen eller båda operanderna är
null
ärnull
resultatet värdet.Två binärfiler jämförs byte per byte.
Två datum jämförs genom att jämföra deras årsdelar och, om de är lika, deras månadsdelar och, om de är lika, deras dagdelar.
Två datetimes jämförs genom att jämföra deras årsdelar och, om de är lika, deras månadsdelar och, om de är lika, deras dagdelar och, om de är lika, deras timdelar och, om de är lika, deras minutdelar och, om de är lika, deras andra delar.
Två datetimezones jämförs genom att normalisera dem till UTC genom att subtrahera deras tim-/minutförskjutning och sedan jämföra deras datetime-komponenter.
Två varaktigheter jämförs enligt det totala antalet tick på 100 nanosekunder som de representerar.
Två logiska värden jämförs så att de
true
anses vara större änfalse
.Två tal
x
ochy
jämförs enligt reglerna i IEEE 754-standarden:Om någon av operanderna är
#nan
ärfalse
resultatet för alla relationsoperatorer.När ingen av operanderna är
#nan
jämför operatorerna värdena för de två flyttalsopernderna med avseende på ordningen-∞ < -max < ... < -min < -0.0 = +0.0 < +min < ... < +max < +∞
där min och max är de minsta och största positiva finita värdena som kan representeras. M-namnen för -∞ och +∞ är-#infinity
och#infinity
.Viktiga effekter av den här ordningen är:
Negativa och positiva nollor anses vara lika.
Ett
-#infinity
värde anses vara mindre än alla andra talvärden, men lika med ett annat-#infinity
.Ett
#infinity
värde anses vara större än alla andra talvärden, men lika med ett annat#infinity
.
Två texter jämförs med hjälp av en ordningstalstal, skiftlägeskänslig, kulturokänslig jämförelse.
Två gånger jämförs genom att jämföra deras timdelar och, om de är lika, deras minutdelar och, om de är lika, deras andra delar.
Operatorerna and
och or
kallas för villkorsstyrda logiska operatorer.
logical-or-expression:
logical-and-expression
logical-and-expressionor
logical-or-expression
logical-and-expression:
is-expression
is-expressionand
logical-and-expression
Operatorn or
returnerar true
när minst en av dess operander är true
. Den högra operanden utvärderas om och endast om den vänstra operanden inte true
är .
Operatorn and
returnerar false
när minst en av dess operander är false
. Den högra operanden utvärderas om och endast om den vänstra operanden inte false
är .
Sanningstabeller för operatorerna or
och and
visas nedan, med resultatet av utvärderingen av det vänstra operanduttrycket på den lodräta axeln och resultatet av utvärderingen av det högra operanduttrycket på den vågräta axeln.
and |
true |
false |
null |
error |
---|---|---|---|---|
true |
true |
false |
null |
error |
false |
false |
false |
false |
false |
null |
null |
false |
null |
error |
error |
error |
error |
error |
error |
or |
true |
false |
null |
error |
---|---|---|---|---|
or |
true |
false |
null |
error |
true |
true |
true |
true |
true |
false |
true |
false |
null |
error |
null |
true |
null |
null |
error |
error |
error |
error |
error |
error |
Följande gäller när du utvärderar ett uttryck som innehåller villkorsstyrda logiska operatorer:
Fel som uppstår när du utvärderar
x
ellery
uttryck sprids.De villkorsstyrda logiska operatorerna definieras över typerna
logical
ochnull
. Om operandvärdena inte är av dessa typer utlöses ett fel med orsakskoden"Expression.Error"
.Resultatet är ett logiskt värde.
I uttrycket
x
ellery
utvärderas uttryckety
om och endast omx
inte utvärderas tilltrue
.I uttrycket
x
ochy
utvärderas uttryckety
om och endast omx
inte utvärderas tillfalse
.
De två sista egenskaperna ger de villkorsstyrda logiska operatorerna sin "villkorsstyrda" kvalificering. egenskaper som även kallas "kortslutning". De här egenskaperna är användbara för att skriva kompakta skyddade predikat. Följande uttryck är till exempel likvärdiga:
d <> 0 and n/d > 1 if d <> 0 then n/d > 1 else false
Operatorerna +
, -
och *
/
är de aritmetiska operatorerna.
additivt uttryck:
multiplicativt uttryck
additivt uttryck+
multiplicativt uttryck
additivt uttryck-
multiplicativt uttryck
multiplicative-expression:
metadata- uttryck
metadatauttryck för multiplicative-expression*
metadatauttryck för multiplicative-expression/
Tal i M lagras med hjälp av en mängd olika representationer för att behålla så mycket information som möjligt om tal som kommer från en mängd olika källor. Tal konverteras endast från en representation till en annan efter behov av operatorer som tillämpas på dem. Två precisioner stöds i M:
Precision | Semantik |
---|---|
Precision.Decimal |
128-bitars decimalrepresentation med ett intervall på ±1,0 x 10–28 till ±7,9 x 1028 och 28–29 signifikanta siffror. |
Precision.Double |
Vetenskaplig representation med mantissa och exponent; överensstämmer med den 64-bitars binära dubbelprecisionen IEEE 754 aritmetiska standard-IEEE 754-2008. |
Aritmetiska åtgärder utförs genom att välja en precision, konvertera båda operanderna till den precisionen (om det behövs), sedan utföra den faktiska åtgärden och slutligen returnera ett tal i den valda precisionen.
De inbyggda aritmetiska operatorerna (+
, -
, *
, /
) använder dubbel precision. Standardbiblioteksfunktioner (Value.Add
, Value.Subtract
, Value.Multiply
, Value.Divide
) kan användas för att begära dessa åtgärder med hjälp av en specifik precisionsmodell.
Inget numeriskt spill är möjligt:
#infinity
eller-#infinity
representera värden med för stora magnituder för att representeras.Inget numeriskt underflöde är möjligt:
0
och-0
representerar värden med magnituder som är för små för att representeras.Specialvärdet
#nan
IEEE 754 (NaN – Inte ett tal) används för att täcka aritmetiskt ogiltiga fall, till exempel en division med noll med noll.Konvertering från decimal till dubbel precision utförs genom avrundning av decimaltal till närmaste motsvarande dubbla värde.
Konvertering från Dubbel till Decimal precision utförs genom avrundning av dubbla tal till närmaste ekvivalent decimalvärde och vid behov spills över till
#infinity
eller-#infinity
värden.
Tolkningen av additionsoperatorn (x + y
) är beroende av typen av värde för de utvärderade uttrycken x och y enligt följande:
x | y | Result | Tolkning |
---|---|---|---|
type number |
type number |
type number |
Numerisk summa |
type number |
null |
null |
|
null |
type number |
null |
|
type duration |
type duration |
type duration |
Numerisk summa av magnituder |
type duration |
null |
null |
|
null |
type duration |
null |
|
type
datetime |
type duration |
type
datetime |
Datetime-förskjutning efter varaktighet |
type duration |
type
datetime |
type
datetime |
|
type
datetime |
null |
null |
|
null |
type
datetime |
null |
I tabellen type
står datetime för någon av type date
, type datetime
, type datetimezone
eller type time
. När du lägger till en varaktighet och ett värde av någon typ datetime är det resulterande värdet av samma typ.
För andra kombinationer av värden än de som anges i tabellen genereras ett fel med orsakskoden "Expression.Error"
. Varje kombination beskrivs i följande avsnitt.
Fel som uppstår vid utvärdering av någon av operanderna sprids.
Summan av två tal beräknas med hjälp av additionsoperatorn, vilket ger ett tal.
Till exempel:
1 + 1 // 2
#nan + #infinity // #nan
Additionsoperatorn +
över tal använder dubbel precision. Standardbiblioteksfunktionen Value.Add
kan användas för att ange decimalprecision. Följande gäller vid beräkning av en summa tal:
Summan i Dubbel precision beräknas enligt reglerna för 64-bitars binär dubbelprecision IEEE 754 aritmetik IEEE 754-2008. I följande tabell visas resultatet av alla möjliga kombinationer av icke-ändliga värden, nollor, infiniteter och NaN:er. I tabellen
x
, ochy
är ickezero ändliga värden, ochz
är resultatet avx + y
. Omx
ochy
har samma storlek men motsatta tecken,z
är positiv noll. Omx + y
är för stort för att representeras i måltypen ärz
en oändlighet med samma tecken somx + y
.+ y +0 0– +∞ -∞ NaN x z x x +∞ -∞ NaN +0 y +0 +0 +∞ -∞ NaN -0 y +0 0– +∞ -∞ NaN +∞ +∞ +∞ +∞ +∞ NaN NaN -∞ -∞ -∞ -∞ NaN -∞ NaN Nan NaN NaN NaN NaN NaN NaN Summan i decimalprecision beräknas utan att precisionen går förlorad. Resultatets skala är den större av de två operandernas skalor.
Summan av två varaktigheter är varaktigheten som representerar summan av antalet tick på 100nanosecond som representeras av varaktigheterna. Till exempel:
#duration(2,1,0,15.1) + #duration(0,1,30,45.3)
// #duration(2, 2, 31, 0.4)
En datetimex
och en varaktighet y
kan läggas till med hjälp av x + y
för att beräkna en ny datetime vars avstånd från x
på en linjär tidslinje är exakt storleken på y
.
Här står datetime för något av Date
, DateTime
, DateTimeZone
eller Time
och ett resultat som inte är null kommer att vara av samma typ. Datetime-förskjutningen efter varaktighet kan beräknas på följande sätt:
Om datetimes dagar sedan epokvärdet har angetts skapar du en ny datetime med följande informationselement:
Beräkna en ny dag sedan epok som motsvarar att dividera storleken på y med antalet tick på 100 nanosekunder under en 24-timmarsperiod, trunkera decimaldelen av resultatet och lägga till det här värdet till x-dagarna sedan epoken.
Beräkna nya fästingar sedan midnatt, vilket motsvarar att lägga till storleken y till x:ets fästingar sedan midnatt, och ange antalet tick på 100 nanosekunder under en 24-timmarsperiod. Om x inte anger något värde för fästingar sedan midnatt antas värdet 0.
Kopiera x-värdet för minuter förskjutning från UTC oförändrat.
Om datetimes dagar sedan epokvärdet är ospecificerat skapar du en ny datetime med följande informationselement angivna:
Beräkna nya fästingar sedan midnatt, vilket motsvarar att lägga till storleken y till x:ets fästingar sedan midnatt, och ange antalet tick på 100 nanosekunder under en 24-timmarsperiod. Om x inte anger något värde för fästingar sedan midnatt antas värdet 0.
Kopiera x-värden för dagar sedan epok och minuter förskjutning från UTC oförändrat.
I följande exempel visas beräkning av den absoluta temporala summan när datetime anger dagarna sedan epoken:
#date(2010,05,20) + #duration(0,8,0,0)
//#datetime( 2010, 5, 20, 8, 0, 0 )
//2010-05-20T08:00:00
#date(2010,01,31) + #duration(30,08,0,0)
//#datetime(2010, 3, 2, 8, 0, 0)
//2010-03-02T08:00:00
#datetime(2010,05,20,12,00,00,-08) + #duration(0,04,30,00)
//#datetime(2010, 5, 20, 16, 30, 0, -8, 0)
//2010-05-20T16:30:00-08:00
#datetime(2010,10,10,0,0,0,0) + #duration(1,0,0,0)
//#datetime(2010, 10, 11, 0, 0, 0, 0, 0)
//2010-10-11T00:00:00+00:00
I följande exempel visas beräkning av datetime-förskjutningen efter varaktighet för en viss tid:
#time(8,0,0) + #duration(30,5,0,0)
//#time(13, 0, 0)
//13:00:00
Tolkningen av subtraktionsoperatorn (x - y
) är beroende av typen av värdet för de utvärderade uttrycken x
och y
, enligt följande:
x | Y | Result | Tolkning |
---|---|---|---|
type number |
type number |
type number |
Numerisk skillnad |
type number |
null |
null |
|
null |
type number |
null |
|
type duration |
type duration |
type duration |
Numerisk skillnad mellan magnituder |
type duration |
null |
null |
|
null |
type duration |
null |
|
type
datetime |
type
datetime |
type duration |
Varaktighet mellan datetimes |
type
datetime |
type duration |
type
datetime |
Datetime-förskjutning efter negerad varaktighet |
type
datetime |
null |
null |
|
null |
type
datetime |
null |
I tabellen type
står datetime för någon av type date
, type datetime
, type datetimezone
eller type time
. När du subtraherar en varaktighet från ett värde av någon typ datetime, är det resulterande värdet av samma typ.
För andra kombinationer av värden än de som anges i tabellen genereras ett fel med orsakskoden "Expression.Error"
. Varje kombination beskrivs i följande avsnitt.
Fel som uppstår vid utvärdering av någon av operanderna sprids.
Skillnaden mellan två tal beräknas med hjälp av subtraktionsoperatorn, vilket ger ett tal. Till exempel:
1 - 1 // 0
#nan - #infinity // #nan
Subtraktionsoperatorn -
över tal använder dubbel precision. Standardbiblioteksfunktionen Value.Subtract
kan användas för att ange decimalprecision. Följande gäller vid beräkning av en skillnad mellan tal:
Skillnaden i dubbel precision beräknas enligt reglerna för 64-bitars binär dubbelprecision IEEE 754 aritmetik IEEE 754-2008. I följande tabell visas resultatet av alla möjliga kombinationer av icke-ändliga värden, nollor, infiniteter och NaN:er. I tabellen
x
, ochy
är ickezero ändliga värden, ochz
är resultatet avx - y
. Omx
ochy
är lika med,z
är positiv noll. Omx - y
är för stort för att representeras i måltypen ärz
en oändlighet med samma tecken somx - y
.- y +0 0– +∞ -∞ NaN x z x x -∞ +∞ NaN +0 -y +0 +0 -∞ +∞ NaN -0 -y 0– +0 -∞ +∞ NaN +∞ +∞ +∞ +∞ NaN +∞ NaN -∞ -∞ -∞ -∞ -∞ NaN NaN Nan NaN NaN NaN NaN NaN NaN Skillnaden i decimalprecision beräknas utan att precisionen går förlorad. Resultatets skala är den större av de två operandernas skalor.
Skillnaden mellan två varaktigheter är varaktigheten som representerar skillnaden mellan antalet tick på 100 nanosekunder som representeras av varje varaktighet. Till exempel:
#duration(1,2,30,0) - #duration(0,0,0,30.45)
// #duration(1, 2, 29, 29.55)
En datetimex
och en varaktighet y
kan subtraheras med hjälp av x - y
för att beräkna en ny datetime.
Här står datetime för någon av date
, datetime
, datetimezone
eller time
. Den resulterande datetime har ett avstånd från x
på en linjär tidslinje som är exakt storleken y
på , i riktning mot tecknet för y
. Om du subtraherar positiva varaktigheter returneras resultat som är bakåt i tiden i förhållande till x
, medan subtrahering av negativa värden ger resultat som är framåt i tiden.
#date(2010,05,20) - #duration(00,08,00,00)
//#datetime(2010, 5, 19, 16, 0, 0)
//2010-05-19T16:00:00
#date(2010,01,31) - #duration( 30,08,00,00)
//#datetime(2009, 12, 31, 16, 0, 0)
//2009-12-31T16:00:00
Två datetimest
och u
kan subtraheras med hjälp av t - u
för att beräkna varaktigheten mellan dem.
Här står datetime för någon av date
, datetime
, datetimezone
eller time
. Varaktigheten som genereras genom att subtrahera u
från t
måste ge när t
den läggs till u
i .
#date(2010,01,31) - #date(2010,01,15)
// #duration(16,00,00,00)
// 16.00:00:00
#date(2010,01,15)- #date(2010,01,31)
// #duration(-16,00,00,00)
// -16.00:00:00
#datetime(2010,05,20,16,06,00,-08,00) -
#datetime(2008,12,15,04,19,19,03,00)
// #duration(521,22,46,41)
// 521.22:46:41
Subtrahera t - u
när u > t
resulterar i en negativ varaktighet:
#time(01,30,00) - #time(08,00,00)
// #duration(0, -6, -30, 0)
Följande gäller när du subtraherar två datetimes med hjälp av t - u
:
- u + (t - u) = t
Tolkningen av multiplikationsoperatorn (x * y
) är beroende av typen av värde för de utvärderade uttrycken x och y, enligt följande:
X | Y | Result | Tolkning |
---|---|---|---|
type number |
type number |
type number |
Numerisk produkt |
type number |
null |
null |
|
null |
type number |
null |
|
type duration |
type number |
type duration |
Flera varaktigheter |
type number |
type duration |
type duration |
Flera varaktigheter |
type duration |
null |
null |
|
null |
type duration |
null |
För andra kombinationer av värden än de som anges i tabellen genereras ett fel med orsakskoden "Expression.Error"
. Varje kombination beskrivs i följande avsnitt.
Fel som uppstår vid utvärdering av någon av operanderna sprids.
Produkten av två tal beräknas med hjälp av multiplikationsoperatorn och producerar ett tal. Till exempel:
2 * 4 // 8
6 * null // null
#nan * #infinity // #nan
Multiplikationsoperatorn *
över tal använder dubbel precision. Standardbiblioteksfunktionen Value.Multiply
kan användas för att ange decimalprecision. Följande gäller vid beräkning av en produkt med siffror:
Produkten i Dubbel precision beräknas enligt reglerna för 64-bitars binär dubbelprecision IEEE 754 aritmetik IEEE 754-2008. I följande tabell visas resultatet av alla möjliga kombinationer av icke-ändliga värden, nollor, infiniteter och NaN:er. I tabellen
x
ochy
är positiva ändliga värden.z
är resultatet avx * y
. Om resultatet är för stort för måltypenz
är oändligheten. Om resultatet är för litet för måltypenz
är det noll.* +y -y +0 0– +∞ -∞ NaN +x +z -z +0 0– +∞ -∞ NaN -x -z +z 0– +0 -∞ +∞ NaN +0 +0 0– +0 0– NaN NaN NaN -0 0– +0 0– +0 NaN NaN NaN +∞ +∞ -∞ NaN NaN +∞ -∞ NaN -∞ -∞ +∞ NaN NaN -∞ +∞ NaN Nan NaN NaN NaN NaN NaN NaN NaN Produkten i Decimalprecision beräknas utan att förlora precision. Resultatets skala är den större av de två operandernas skalor.
Produkten av en varaktighet och ett tal är varaktigheten som representerar antalet 100nanosecond-tick som representeras av varaktigheten operand gånger talet operand. Till exempel:
#duration(2,1,0,15.1) * 2
// #duration(4, 2, 0, 30.2)
Tolkningen av divisionsoperatorn (x / y
) är beroende av typen av värde för de utvärderade uttrycken x
och y
, enligt följande:
X | Y | Result | Tolkning |
---|---|---|---|
type number |
type number |
type number |
Numerisk kvot |
type number |
null |
null |
|
null |
type number |
null |
|
type duration |
type number |
type duration |
Del av varaktigheten |
type duration |
type duration |
type number |
Numerisk kvot för varaktigheter |
type duration |
null |
null |
|
null |
type duration |
null |
För andra kombinationer av värden än de som anges i tabellen genereras ett fel med orsakskoden "Expression.Error"
. Varje kombination beskrivs i följande avsnitt.
Fel som uppstår vid utvärdering av någon av operanderna sprids.
Kvoten för två tal beräknas med hjälp av divisionsoperatorn och genererar ett tal. Till exempel:
8 / 2 // 4
8 / 0 // #infinity
0 / 0 // #nan
0 / null // null
#nan / #infinity // #nan
Divisionsoperatorn /
över tal använder dubbel precision. Standardbiblioteksfunktionen Value.Divide
kan användas för att ange decimalprecision. Följande gäller vid beräkning av en kvot med tal:
Kvoten i Dubbel precision beräknas enligt reglerna för 64-bitars binär dubbelprecision IEEE 754 aritmetik IEEE 754-2008. I följande tabell visas resultatet av alla möjliga kombinationer av icke-ändliga värden, nollor, infiniteter och NaN:er. I tabellen
x
ochy
är positiva ändliga värden.z
är resultatet avx / y
. Om resultatet är för stort för måltypenz
är oändligheten. Om resultatet är för litet för måltypenz
är det noll./ +y -y +0 0– +∞ -∞ NaN +x +z -z +∞ -∞ +0 0– NaN -x -z +z -∞ +∞ 0– +0 NaN +0 +0 0– NaN NaN +0 0– NaN -0 0– +0 NaN NaN 0– +0 NaN +∞ +∞ -∞ +∞ -∞ NaN NaN NaN -∞ -∞ +∞ -∞ +∞ NaN NaN NaN Nan NaN NaN NaN NaN NaN NaN NaN Summan i decimalprecision beräknas utan att precisionen går förlorad. Resultatets skala är den större av de två operandernas skalor.
Kvoten för två varaktigheter är det tal som representerar kvoten för antalet tick på 100stinglar som representeras av varaktigheterna. Till exempel:
#duration(2,0,0,0) / #duration(0,1,30,0)
// 32
Kvoten för en varaktighet x
och ett tal y
är varaktigheten som representerar kvoten för antalet tick på 100 nanosekunder som representeras av varaktigheten x
och talet y
. Till exempel:
#duration(2,0,0,0) / 32
// #duration(0,1,30,0)
Kombinationsoperatorn (x & y
) definieras över följande typer av värden:
X | Y | Result | Tolkning |
---|---|---|---|
type text |
type text |
type text |
Sammanfogning |
type text |
null |
null |
|
null |
type text |
null |
|
type date |
type time |
type datetime |
Slå ihop |
type date |
null |
null |
|
null |
type time |
null |
|
type list |
type list |
type list |
Sammanfogning |
type record |
type record |
type record |
Slå ihop |
type table |
type table |
type table |
Sammanfogning |
Två text-, två- eller två tabellvärden kan sammanfogas med hjälp av x & y
.
I följande exempel visas sammanlänkning av textvärden:
"AB" & "CDE" // "ABCDE"
I följande exempel visas sammanlänkningslistor:
{1, 2} & {3} // {1, 2, 3}
Följande gäller vid sammanfogning av två värden med hjälp av x & y
:
Fel som uppstår när du utvärderar
x
ellery
uttryck sprids.Inget fel sprids om ett objekt i något
x
av ellery
innehåller ett fel.Resultatet av att sammanfoga två textvärden är ett textvärde som innehåller värdet x omedelbart följt av y. Om någon av operanderna är null och den andra är ett textvärde är resultatet null.
Resultatet av att sammanfoga två listor är en lista som innehåller alla objekt
x
i följt av alla objekty
i .Resultatet av att sammanfoga två tabeller är en tabell som har en union av de två operandtabellens kolumner. Kolumnordningen
x
för bevaras, följt av kolumnerna som endast visas iy
, vilket bevarar deras relativa ordning. För kolumner som endast visas i en av operandernanull
används för att fylla i cellvärden för den andra operanden.
Två poster kan sammanfogas med hjälp av x & y
, vilket skapar en post som innehåller fält från både x
och y
.
Följande exempel illustrerar sammanslagning av poster:
[ x = 1 ] & [ y = 2 ] // [ x = 1, y = 2 ]
[ x = 1, y = 2 ] & [ x = 3, z = 4 ] // [ x = 3, y = 2, z = 4 ]
Följande gäller vid sammanslagning av två poster med hjälp av x + y
:
Fel som uppstår när du utvärderar
x
ellery
uttryck sprids.Om ett fält visas i både
x
ochy
används värdet fråny
.Ordningen på fälten i den resulterande posten är , följt av
x
fält iy
som inte är en del avx
, i samma ordning som de visas iy
.Sammanslagning av poster orsakar inte utvärdering av värdena.
Inget fel utlöses eftersom ett fält innehåller ett fel.
Resultatet är en post.
Ett datum x
kan sammanfogas med en tid y
med hjälp av x & y
, vilket skapar en datetime som kombinerar delarna från både x
och y
.
I följande exempel visas sammanslagning av ett datum och en tid:
#date(2013,02,26) & #time(09,17,00)
// #datetime(2013,02,26,09,17,00)
Följande gäller vid sammanslagning av två poster med hjälp av x + y
:
Fel som uppstår när du utvärderar
x
ellery
uttryck sprids.Resultatet är en datetime.
Operatorerna +
, -
och not
är unary-operatorer.
unary-expression:
type-expression
+
unary-uttryck
-
unary-uttryck
not
unary-uttryck
Den unary plus-operatorn (+x
) definieras för följande typer av värden:
X | Result | Tolkning |
---|---|---|
type number |
type number |
Unary plus |
type duration |
type duration |
Unary plus |
null |
'null |
För andra värden utlöses ett fel med orsakskoden "Expression.Error"
.
Med operatorn unary plus kan ett +
tecken tillämpas på ett tal, en datetime eller ett null-värde. Resultatet är samma värde. Till exempel:
+ - 1 // -1
+ + 1 // 1
+ #nan // #nan
+ #duration(0,1,30,0) // #duration(0,1,30,0)
Följande gäller vid utvärdering av unary plus-operatorn +x
:
Fel som uppstår vid utvärdering
x
sprids.Om resultatet av utvärderingen
x
inte är ett talvärde genereras ett fel med orsakskoden"Expression.Error"
.
Unary minus-operatorn (-x
) definieras för följande typer av värden:
X | Result | Tolkning |
---|---|---|
type number |
type number |
Negation |
type duration |
type duration |
Negation |
null |
null |
För andra värden utlöses ett fel med orsakskoden "Expression.Error"
.
Operatorn unary minus används för att ändra tecknet för ett tal eller en varaktighet. Till exempel:
- (1 + 1) // -2
- - 1 // 1
- - - 1 // -1
- #nan // #nan
- #infinity // -#infinity
- #duration(1,0,0,0) // #duration(-1,0,0,0)
- #duration(0,1,30,0) // #duration(0,-1,-30,0)
Följande gäller vid utvärdering av unary minus-operatorn -x
:
Fel som uppstår vid utvärdering
x
sprids.Om uttrycket är ett tal blir resultatet talvärdet från uttrycket
x
med dess tecken ändrat. Om värdet är NaN blir resultatet även NaN.
Operatorn för logisk negation (not
) definieras för följande typer av värden:
X | Result | Tolkning |
---|---|---|
type logical |
type logical |
Negation |
null |
null |
Den här operatorn beräknar den logiska not
åtgärden för ett visst logiskt värde. Till exempel:
not true // false
not false // true
not (true and true) // false
Följande gäller när du utvärderar operatorn not x
för logisk negation :
Fel som uppstår vid utvärdering
x
sprids.Värdet som genereras från utvärderingen av uttrycket x måste vara ett logiskt värde, eller så måste ett fel med orsakskoden
"Expression.Error"
genereras. Om värdet ärtrue
ärfalse
resultatet . Om operand ärfalse
ärtrue
resultatet .
Resultatet är ett logiskt värde.
Operatorerna is
och as
kallas typoperatorer.
Typkompatibilitetsoperatorn x is y
definieras för följande typer av värden:
X | Y | Result |
---|---|---|
type any |
nullable-primitive-type | type logical |
Uttrycket x is y
returnerar true
om den tillskrivna typen av x
är kompatibel med y
och returnerar false
om den tillskrivna typen av x
är inkompatibel med y
.
y
måste vara en nullable-primitivetype.
is-expression:
as-expression
is-expressionis
nullable-primitive-type
nullable-primitive-type:
nullable
opt primitive-type
Typkompatibilitet, som stöds av operatornis
, är en delmängd av allmän typkompatibilitet och definieras med hjälp av följande regler:
Om
x
är null är det kompatibelt omy
är typenany
, typennull
eller en nullbar typ.Om
x
är icke-null så om det är en kompatibel om den primitiva typen avx
är samma somy
.
Följande gäller vid utvärdering av uttrycket x is y
:
- Ett fel som uppstår vid utvärdering av uttryck
x
sprids.
Typkontrolloperatorn x as y
definieras för följande typer av värden:
X | Y | Result |
---|---|---|
type any |
nullable-primitive-type | type any |
Uttrycket x as y
hävdar att värdet x
är kompatibelt med y
enligt operatorn is
. Om det inte är kompatibelt utlöses ett fel.
y
måste vara en nullable-primitive-type.
as-expression:
likhetsuttryck
as-expressionas
nullable-primitive-type
Uttrycket x as y
utvärderas på följande sätt:
En typkompatibilitetskontroll
x is y
utförs och försäkran returnerarx
oförändrad om testet lyckas.Om kompatibilitetskontrollen misslyckas utlöses ett fel med orsakskoden
"Expression.Error"
.
Exempel:
1 as number // 1
"A" as number // error
null as nullable number // null
Följande gäller vid utvärdering av uttrycket x as y
:
- Ett fel som uppstår vid utvärdering av uttryck
x
sprids.
Kolesceoperatorn ??
returnerar resultatet av sin vänstra operand om den inte är null, annars returneras resultatet av dess högra operande. Den högra operanden utvärderas om och endast om den vänstra operanden är null.