Správanie operátorov
Táto časť definuje správanie rôznych operátorov jazyka M.
Keď výraz obsahuje viacero operátorov, poradie operátorov podľa priority určuje poradie, v ktorom sa jednotlivé operátory hodnotia. Napríklad výraz x + y * z
sa vyhodnotí ako x + (y * z)
, pretože *
operátor má vyššiu prioritu ako binárny +
operátor. Priorita operátora je stanovená definíciou jeho gramatiky vytvárania. Napríklad výraz additive-expression
Vytváranie výrazu parenthesized-expression možno použiť na zmenu predvoleného poradia podľa priority.
parenthesized-expression:
(
výraz)
Napríklad:
1 + 2 * 3 // 7
(1 + 2) * 3 // 9
Nasledujúca tabuľka obsahuje súhrn operátorov jazyka M vrátane uvedenia kategórií operátorov v poradí podľa priority od najvyššej po najnižšiu. Operátory v rovnakej kategórii majú rovnaké poradie podľa priority.
Kategória | Expression | Description |
---|---|---|
Primárne |
ja @ ja |
Výraz identifikátora |
(x) | Výraz v zátvorkách | |
x[i] | Vyhľadávanie | |
x{y} | Prístup k položke | |
x(...) | Vyvolanie funkcie | |
{x, y, ...} | Inicializácia zoznamu | |
[ i = x, ... ] | Inicializácia záznamu | |
... | Neimplementované | |
Unárne | + x | Identita |
- x | Negácia | |
not
x |
Logická negácia | |
Metaúdaje |
xmeta y |
Metaúdaje priradenia |
Násobné | x * y | Násobenie |
x / y | Divízia | |
Prísada | x + y | Sčítanie |
x - y | Odčítanie | |
Relačnej | x< y | Menšie než |
x > y | Väčšie než | |
x<= y | Menšie ako alebo rovná sa | |
x >= y | Väčšie alebo rovné | |
Rovnosť | x = y | Equal |
x<> y | Nerovná sa | |
Kontrolný výraz typu |
xas y |
Je kompatibilným typom alebo chybou nullable-primitive |
Zhoda typu |
xis y |
Otestovať, či je kompatibilným typom nullable-primitive |
Logický operátor AND |
xand y |
Skratová konjunkcia |
Logický operátor OR |
xor y |
Skratová disjunkcia |
Coalesce |
x?? y |
Operátor coalescing null |
Každá hodnota má priradenú hodnotu záznamu, ktorá môže obsahovať ďalšie informácie o hodnote. Tento záznam sa označuje ako záznam metaúdajov pre hodnotu. Záznam metaúdajov môže byť priradený k ľubovoľnému druhu hodnoty, a to aj null
. Výsledkom takéhoto priradenia je nová hodnota s danými metaúdajmi.
Záznam metaúdajov je len bežný záznam a môže obsahovať všetky polia a hodnoty bežného záznamu, a sám obsahuje záznam metaúdajov. Priradenie záznamu metaúdajov k hodnote je neintruzívne. Nezmení sa tým správanie hodnoty v hodnoteniach. Výnimkou sú tie, ktoré explicitne kontrolujú záznamy metaúdajov.
Každá hodnota má predvolený záznam metaúdajov, dokonca aj vtedy, ak nebol zadaný. Predvolený záznam metaúdajov je prázdny. Nasledujúce príklady zobrazujú prístup k záznamu metaúdajov textovej hodnoty pomocou štandardnej Value.Metadata
funkcie knižnice:
Value.Metadata( "Mozart" ) // []
Záznamy metaúdajov sa vo všeobecnosti nezachovajú , keď sa použije hodnota s operátorom alebo funkciou, ktorá vytvára novú hodnotu. Ak sú napríklad dve textové hodnoty zreťazené pomocou &
operátora , metaúdaje výslednej textovej hodnoty sú prázdnym záznamom []
. Nasledujúce výrazy sú rovnocenné:
"Amadeus " & ("Mozart" meta [ Rating = 5 ])
"Amadeus " & "Mozart"
Štandardné funkcie Value.RemoveMetadata
knižnice a Value.ReplaceMetadata
možno použiť na odstránenie všetkých metaúdajov z hodnoty a na nahradenie metaúdajov hodnoty (namiesto zlučovania metaúdajov do metaúdajov s možnou existujúcou).
Jediným operátorom, ktorý vracia výsledky obsahujúce metaúdaje, je meta operátor.
Hodnoty môžu byť cyklické. Napríklad:
let l = {0, @l} in l
// {0, {0, {0, ... }}}
[A={B}, B={A}]
// [A = {{ ... }}, B = {{ ... }}]
Jazyk M spracováva cyklické hodnoty tak, že zachováva pomalú tvorbu záznamov, zoznamov a tabuliek. Pri pokuse o vytvorenie cyklickej hodnoty, ktorá nevyužíva vložené pomalé štruktúrované hodnoty, sa vyskytne chyba:
[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"),
// ]
Niekoľko operátorov v jazyku M je definovaných štrukturálnou rekurziou. Napríklad rovnosť záznamov a zoznamov je definovaná príslušnou rovnosťou zodpovedajúcich polí záznamov a zoznamov položiek.
V prípade necyklických hodnôt pri použití štrukturálnej rekurzie nastane konečná expanzia hodnoty: zdieľané vnorené hodnoty sa budú prechádzať opakovane, ale proces rekurzie sa vždy ukončí.
Cyklická hodnota má pri použití štrukturálnej rekurzie nekonečnú expanziu . Sémantika jazyka M neposkytuje žiadne špeciálne ubytovanie pre takéto nekonečné rozšírenia – napríklad pokus o porovnanie cyklických hodnôt z hľadiska rovnosti sa zvyčajne vypustí zo zdrojov a výnimočne sa ukončí.
Operátory výberu a projekcie umožňujú extrahovanie údajov z hodnôt zoznamu a záznamov.
Hodnota sa môže vybrať zo zoznamu alebo tabuľky na základe nulovej pozície v tomto zozname alebo tabuľke pomocou výrazu item-access-expression.
item-access-expression:
item-selection (výber položky)
optional-item-selection
item-selection:
primary-expression{
item-selector}
optional-item-selection:
primary-expression{
item-selector} ?
item-selector:
výraz
Výraz item-access-expressionx{y}
vráti toto:
V prípade zoznamu
x
a číslay
je to položka zoznamux
na pozíciiy
. Prvá položka zoznamu sa považuje za položku s poradovým indexom nula. Ak požadovaná pozícia v zozname neexistuje, vyskytne sa chyba.V prípade tabuľky
x
a číslay
je to riadok tabuľkyx
na pozíciiy
. Prvý riadok tabuľky sa považuje za riadok s poradovým indexom nula. Ak požadovaná pozícia v tabuľke neexistuje, vyskytne sa chyba.V prípade tabuľky
x
a záznamuy
je to riadok tabuľkyx
, ktorý zodpovedá hodnotám polí záznamuy
pre polia s názvami polí, ktoré zodpovedajú príslušným názvom stĺpcov tabuľky. Ak sa v tabuľke nenachádza žiadny jedinečný zodpovedajúci riadok, vyskytne sa chyba.
Napríklad:
{"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
Výraz item-access-expression tiež podporuje formát x{y}?
, ktorý vráti null
hodnotu , ak pozícia (alebo zhoda) y
neexistuje v zozname alebo tabuľke x
. Ak pre existujú viaceré zhody y
, aj vtedy sa vyskytne chyba.
Napríklad:
{"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
Prístup k položke nevynúti vyhodnotenie ďalších položiek zoznamu alebo tabuľky, ale iba tejto jednej. Napríklad:
{ error "a", 1, error "c"}{1} // 1
{ error "a", error "b"}{1} // error "b"
Pri vyhodnocovaní operátora x{y}
prístupu k položke bude platiť toto:
Chyby vzniknuté počas vyhodnocovania výrazov
x
aleboy
sa rozšíria.Výraz
x
vyprodukuje zoznam alebo hodnotu tabuľky.Výraz
y
vyprodukuje číselnú hodnotu alebo, akx
vyprodukuje hodnotu tabuľky, hodnotu záznamu.Ak
y
vyprodukuje číselnú hodnotu a hodnota je zápornáy
, vyskytne sa chyba s kódom"Expression.Error"
príčiny .Ak
y
vyprodukuje číselnú hodnotu a hodnotay
je väčšia alebo rovná počtux
, vyskytne sa chyba s kódom"Expression.Error"
príčiny , pokiaľ sa nepoužije voliteľný formátx{y}?
operátora , pričom v takom prípade sa vráti hodnotanull
.Ak
x
vyprodukuje hodnotu tabuľky ay
vyprodukuje hodnotu záznamu a neobsahuje žiadne zhody prey
x
, vyskytne sa chyba s kódom"Expression.Error"
príčiny , pokiaľ sa nepoužije voliteľný formátx{y}?
operátora , pričom v takom prípade sa vráti hodnotanull
.Ak
x
vyprodukuje hodnotu tabuľky ay
vyprodukuje hodnotu záznamu, pričom obsahujey
viaceré zhody prex
, vyskytne sa chyba s kódom"Expression.Error"
príčiny .
Počas procesu výberu položky sa nevyhodnotia žiadne ďalšie položky x
, ktoré obsahuje, ale len táto na pozícii y
. (V prípade streamovacích zoznamov alebo tabuliek sa vynechajú položky alebo riadky, ktoré predchádzajú pozícii y
, čo môže spôsobiť ich vyhodnocovanie v závislosti od zdroja zoznamu alebo tabuľky.)
Výraz field-access-expression sa používa na výber hodnoty zo záznamu alebo na projekt záznamu alebo tabuľky s menším počtom polí alebo stĺpcov.
field-access-expression:
výber poľa
implicit-target-field-selection
výčnelok
implicit-target-projection
field-selection:
primary-expression field-selector
field-selector:
required-field-selector
optional-field-selector
required-field-selector:
[
field-name]
optional-field-selector:
[
field-name] ?
field-name:
generalized-identifier
quoted-identifier
implicit-target-field-selection:
field-selector (selektor polí)
výčnelok:
primary-expression required-projection
primary-expression optional-projection
required-projection:
[
required-selector-list]
optional-projection:
[
required-selector-list] ?
required-selector-list:
required-field-selector
required-selector-list,
required-field-selector
implicit-target-projection:
required-projection
optional-projection (voliteľná projekcia)
Najjednoduchšou formou prístupu k poľu je výber povinných polí. Pomocou operátora x[y]
sa podľa názvu poľa vyhľadá pole v zázname. Ak pole y
neexistuje v x
, vyskytne sa chyba. Formulár x[y]?
sa používa na vykonanie výberu voliteľných polí a vráti null
, ak požadované pole v zázname neexistuje.
Napríklad:
[A=1,B=2][B] // 2
[A=1,B=2][C] // error
[A=1,B=2][C]? // null
Kolektívny prístup k viacerým poliam podporujú operátory pre projekciu povinného záznamu a projekciu povinného záznamu. Operátor x[[y1],[y2],...]
projektuje záznam do nového záznamu s menším počtom polí (vybratých podľa , y1
y2
, ...
). Ak vybraté pole neexistuje, vyskytne sa chyba. Operátor x[[y1],[y2],...]?
projektuje záznam do nového záznamu s poľami vybratými podľa identifikátorov y1
, , y2
...
. Ak pole chýba, null
namiesto toho sa použije .
Napríklad:
[A=1,B=2][[B]] // [B=2]
[A=1,B=2][[C]] // error
[A=1,B=2][[B],[C]]? // [B=2,C=null]
Formáty [y]
a [y]?
sú podporované ako skrátený odkaz na identifikátor _
(znak podčiarknutia). Nasledujúce dva výrazy sú rovnocenné:
[A]
_[A]
Nasledujúci príklad ilustruje skrátený formát prístupu k poľu:
let _ = [A=1,B=2] in [A] //1
Formáty [[y1],[y2],...]
a [[y1],[y2],...]?
sú tiež podporované ako skrátené a nasledujúce dva výrazy sú rovnako rovnocenné:
[[A],[B]]
_[[A],[B]]
Skrátený formát je užitočný najmä v kombinácii so skratkou , čím sa dá uviesť funkcia jedného parametra s each
názvom _
(podrobnosti nájdete v téme Zjednodušené deklarácie). Obe skratky spoločne zjednodušujú bežné funkčné výrazy s vyšším poradím:
List.Select( {[a=1, b=1], [a=2, b=4]}, each [a] = [b])
// {[a=1, b=1]}
Vyššie uvedený výraz je rovnocenný s nasledujúcou dlhou rukou s kryptickým vzhľadom:
List.Select( {[a=1, b=1], [a=2, b=4]}, (_) => _[a] = _[b])
// {[a=1, b=1]}
Prístup k poľu nevynúti vyhodnotenie iných než sprístupnených polí. Napríklad:
[A=error "a", B=1, C=error "c"][B] // 1
[A=error "a", B=error "b"][B] // error "b"
Pri vyhodnocovaní operátora x[y]
prístupu k poľu , x[y]?
, x[[y]]
alebo x[[y]]?
bude platiť toto:
Chyby vzniknuté počas vyhodnocovania výrazu
x
sa rozšíria.Chyby vzniknuté pri vyhodnocovaní poľa
y
sa permanentne pridajú k poľuy
a potom sa rozšíria. Pri každom budúcom prístupe k poľuy
sa vyskytne rovnaká chyba.Výraz
x
vyprodukuje hodnotu záznamu alebo tabuľky, alebo sa vyskytne chyba.Ak identifikátor
y
pomenuje pole, ktoré neexistujex
, vyskytne sa chyba s kódom"Expression.Error"
príčiny , pokiaľ sa nepoužije voliteľný formát...?
operátora , pričom v takom prípade sa vráti hodnotanull
.
Počas procesu prístupu k poľu x
sa nevyhodnotia žiadne iné polia okrem polí pomenovaných podľa y
hodnoty .
Záznam metaúdajov hodnoty sa mení pomocou meta operátora (x meta y
).
metadata-expression:
unary-expression
unary-expressionmeta
unary-expression
V nasledujúcom príklade sa vytvorí textová hodnota so záznamom metaúdajov pomocou meta
operátora a potom sa získa prístup k záznamu metaúdajov výslednej hodnoty pomocou Value.Metadata
:
Value.Metadata( "Mozart" meta [ Rating = 5 ] )
// [Rating = 5 ]
Value.Metadata( "Mozart" meta [ Rating = 5 ] )[Rating]
// 5
Pri použití operátora x meta y
kombinujúce metaúdaje platí toto:
Chyby vzniknuté pri vyhodnocovaní
x
výrazov aleboy
sa rozšíria.Výraz
y
musí byť záznam, v opačnom prípade sa vyskytne chyba s kódom"Expression.Error"
príčiny .Výsledný záznam metaúdajov je
x
záznam metaúdajov výrazu zlúčený s výrazomy
. (Informácie o sémantike zlučovania záznamov nájdete v téme Zlúčenie záznamov.)Výsledná hodnota je hodnota z výrazu
x
, bez jeho metaúdajov, s priloženým záznamom nových vypočítaných metaúdajov.
Štandardné funkcie Value.RemoveMetadata
knižnice a Value.ReplaceMetadata
možno použiť na odstránenie všetkých metaúdajov z hodnoty a na nahradenie metaúdajov hodnoty (namiesto zlučovania metaúdajov do metaúdajov s možnou existujúcou). Nasledujúce výrazy sú rovnocenné:
x meta y
Value.ReplaceMetadata(x, Value.Metadata(x) & y)
Value.RemoveMetadata(x) meta (Value.Metadata(x) & y)
Operátor =
rovnosti sa používa na určenie toho, či sa dve hodnoty rovnajú. Operátorpoužíva na určenie toho, či dve hodnoty nie sú rovné.
equality-expression:
relational-expression
relational-expression=
equality-expression
relational-expression<>
equality-expression
Napríklad:
1 = 1 // true
1 = 2 // false
1 <> 1 // false
1 <> 2 // true
null = true // false
null = null // true
Metaúdaje nie sú súčasťou porovnania rovnosti alebo nerovnosti. Napríklad:
(1 meta [ a = 1 ]) = (1 meta [ a = 2 ]) // true
(1 meta [ a = 1 ]) = 1 // true
Pri použití operátorov x = y
rovnosti a x <> y
platí toto:
Chyby vzniknuté pri vyhodnocovaní
x
výrazov aleboy
sa rozšíria.Ak
=
sa hodnoty rovnajú, operátor má výsledoktrue
, vfalse
opačnom prípade to bude .Ak
<>
sa hodnoty rovnajú, operátor má výsledokfalse
, vtrue
opačnom prípade to bude .Záznamy metaúdajov nie sú zahrnuté v porovnaní.
Ak hodnoty vygenerované vyhodnotením
x
výrazov ay
nie sú rovnakým druhom hodnoty, hodnoty sa nerovná.Ak hodnoty vygenerované vyhodnotením výrazov
x
andy
sú rovnakým druhom hodnoty, potom existujú konkrétne pravidlá na určenie toho, či sa rovnajú, ako je definované nižšie.Toto platí vždy:
(x = y) = not (x <> y)
Operátory rovnosti sú definované pre nasledujúce typy:
- Hodnota
null
je rovná len sama sebe.
null = null // true
null = true // false
null = false // false
- Logické hodnoty
true
afalse
sú rovné len samé sebe. Napríklad:
true = true // true
false = false // true
true = false // false
true = 1 // false
Čísla sa porovnávajú pomocou zadanej presnosti:
Ak niektoré číslo je
#nan
, potom čísla nie sú rovnaké.Ak žiadne číslo nie je
#nan
, potom sa čísla porovnajú pomocou bitového porovnania číselnej hodnoty.#nan
Hodnota je jedinou hodnotou, ktorá sa nerovná sebe samej.Napríklad:
1 = 1, // true
1.0 = 1 // true
2 = 1 // false
#nan = #nan // false
#nan <> #nan // true
Dve trvania sú rovnaké, ak predstavujú rovnaký počet 100-nanosekundových intervalov.
Dva časy sú rovnaké, ak sa rovnajú rozsahy ich častí (hodina, minúta, sekunda).
Dva dátumy sú rovnaké, ak sa rovnajú rozsahy ich častí (rok, mesiac, deň).
Dve hodnoty datetime sú rovnaké, ak sa rovnajú rozsahy ich častí (rok, mesiac, deň, hodina, minúta, sekunda).
Dve hodnoty datetimezone sú rovnaké, ak sa rovnajú zodpovedajúce hodnoty datetime UTC. Na načítanie zodpovedajúcej hodnoty datetime UTC sa posun hodín/minút odpočíta od komponentu datetime hodnoty datetimezone.
Dve textové hodnoty sú rovnaké, ak v porovnaní z hľadiska ordinality, malých a veľkých písmen a bez rozlišovania majú rovnakú dĺžku a rovnaké znaky na zodpovedajúcich pozíciách.
Dve hodnoty zoznamu sú rovnaké, ak sú splnené všetky nasledujúce podmienky:
Oba zoznamy obsahujú rovnaký počet položiek.
Hodnoty jednotlivých pozične zodpovedajúcich položiek v zoznamoch sú rovnaké. To znamená, že zoznamy musia nielen obsahovať rovnaké položky, ale tieto položky musia byť v rovnakom poradí.
Napríklad:
{1, 2} = {1, 2} // true {2, 1} = {1, 2} // false {1, 2, 3} = {1, 2} // false
Dva záznamy sú rovnaké, ak sú splnené všetky tieto podmienky:
Počet polí je rovnaký.
Každý názov poľa jedného záznamu sa nachádza aj v druhom zázname.
Hodnota každého poľa jedného záznamu sa rovná poľu s rovnakým názvom v druhom zázname.
Napríklad:
[ 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
Dve tabuľky sú rovnaké, ak sú splnené všetky tieto podmienky:
Počet stĺpcov je rovnaký.
Každý názov stĺpca v jednej tabuľke sa nachádza aj v druhej tabuľke.
Počet riadkov je rovnaký.
Každý riadok má rovnaké hodnoty v zodpovedajúcich bunkách.
Napríklad:
#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
Hodnota funkcie sa rovná samej sebe, ale môže alebo nemusí sa rovnať hodnote inej funkcie. Ak sa dve hodnoty funkcie považujú za rovnaké, potom sa po vyvolaní budú správať rovnako.
Dve dané hodnoty funkcie budú mať vždy rovnaký vzťah rovnosti.
Hodnota typu sa rovná samej sebe, ale môže alebo nemusí sa rovnať hodnote iného typu. Ak sa dve hodnoty typu považujú za rovnaké, potom sa pri dotazovaní na zhodu budú správať rovnako.
Dve dané hodnoty typu budú mať vždy rovnaký vzťah rovnosti.
Operátory , <
, >
a <=
sa >=
nazývajú relačné operátory.
relational-expression:
additive-expression
additive-expression<
relational-expression
additive-expression>
relational-expression
additive-expression<=
relational-expression
additive-expression>=
relational-expression
Tieto operátory sa používajú na určenie relatívneho vzťahu poradia medzi dvomi hodnotami, ako je to znázornené v nasledujúcej tabuľke:
Operácia | Result |
---|---|
x < y |
true Hodnota , ak x je menšie ako y , false v opačnom prípade hodnota |
x > y |
true Hodnota , ak x je väčšie ako y , false v opačnom prípade hodnota |
x <= y |
true Hodnota , ak x je menšie ako alebo sa rovná , y v opačnom prípade hodnota false |
x >= y |
true Hodnota , ak x je väčšie ako alebo sa rovná , y v opačnom prípade hodnota false |
Napríklad:
0 <= 1 // true
null < 1 // null
null <= null // null
"ab" < "abc" // true
#nan >= #nan // false
#nan <= #nan // false
Pri vyhodnocovaní výrazu obsahujúceho relačné operátory platí toto:
Chyby vzniknuté pri vyhodnocovaní operandu
x
aleboy
sa rozšíria.Hodnoty vygenerované vyhodnotením oboch
x
výrazov ay
musia byť binárnymi výrazmi, dátumom, datetime, datetimezone, trvaním, logickou, číslom, hodnotou null, textom alebo hodnotou času. V opačnom prípade sa vyskytne chyba s kódom"Expression.Error"
príčiny .Obidva operandy musia byť rovnakého druhu hodnoty alebo
null
. V opačnom prípade sa vyskytne chyba s kódom"Expression.Error"
príčiny .Ak jeden alebo obidva operandy sú
null
, výsledkom jenull
hodnota .Dve binárne údaje sa porovnávajú bajt po bajte.
Pri porovnávaní dvoch dátumov sa porovnajú ich časti s rokom, a ak sú rovnaké, potom časti s mesiacmi, a ak sú rovnaké, potom časti s dňami.
Pri porovnávaní dvoch častí datetime sa porovnajú ich časti s rokom, a ak sú rovnaké, potom časti s mesiacmi, a ak sú rovnaké, potom časti s dňami, a ak sú rovnaké, potom časti s hodinami, a ak sú rovnaké, potom časti s minútami, a ak sú rovnaké, potom časti so sekundami.
Dve hodnoty datetimezone sa porovnávajú tak, že sa normalizujú na UTC odčítaním posunu hodín/minút a potom sa porovnajú ich komponenty datetime.
Dve trvania sa porovnávajú podľa celkového počtu 100-nanosekundových intervalov, ktoré predstavujú.
Porovnávajú sa dve logické parametre, ktoré
true
sa považujú za väčšie akofalse
.Dve čísla
x
ay
sa porovnávajú podľa pravidiel štandardu IEEE 754:Ak niektorý operand je
#nan
, výsledok jefalse
pre všetky relačné operátory.Ak ani jeden operand nie je
#nan
, operátory porovnajú hodnoty dvoch operandov s pohyblivou desatinnou čiarkou s ohľadom na poradie-∞ < -max < ... < -min < -0.0 = +0.0 < +min < ... < +max < +∞
, kde minimum a maximum sú najmenšie a najväčšie kladné konečné hodnoty, ktoré môžu byť vyjadrené. Názvy v jazyku M pre -∞ a +∞ sú-#infinity
a#infinity
.Pri tomto zoradení sú viditeľné tieto účinky:
Záporné a kladné nuly sa považujú za rovné.
Hodnota
-#infinity
sa považuje za menšiu ako všetky ostatné číselné hodnoty, ale rovná sa ďalšej-#infinity
hodnote .Hodnota
#infinity
sa považuje za väčšiu ako všetky ostatné číselné hodnoty, ale rovná sa ďalšej#infinity
hodnote .
Dva texty sa porovnávajú pomocou radového porovnania od znakov po znaku, rozlišovania veľkých a malých písmen a bez rozlišovania v jazykovej verzii.
Pri porovnávaní dvoch časov sa porovnajú ich časti s hodinami, a ak sú rovnaké, potom časti s minútami, a ak sú rovnaké, potom časti so sekundami.
Operátory a and
sa or
nazývajú podmienkové logické operátory.
logical-or-expression:
logical-and-expression
logical-and-expressionor
logical-or-expression
logical-and-expression:
is-expression
is-expressionand
logical-and-expression
Operátor or
vráti true
, ak aspoň jeden z jeho operandov je true
. Pravý operand sa vyhodnotí vtedy a len vtedy, ak ľavý operand nie true
je .
Operátor and
vráti false
, ak aspoň jeden z jeho operandov je false
. Pravý operand sa vyhodnotí vtedy a len vtedy, ak ľavý operand nie false
je .
Tabuľky pravdivosti pre or
operátory a and
sú zobrazené nižšie, pričom výsledok hodnotenia výrazu ľavého operandu je na zvislej osi a výsledok hodnotenia výrazu pravého operandu je na vodorovnej osi.
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 |
Pri vyhodnocovaní výrazu obsahujúceho podmienkové logické operátory platí toto:
Chyby vzniknuté pri vyhodnocovaní
x
výrazov aleboy
sa rozšíria.Podmienkové logické operátory sú definované v typoch
logical
anull
. Ak hodnoty operandov nie sú týchto typov, vyskytne sa chyba s kódom"Expression.Error"
príčiny .Výsledkom je logická hodnota.
Vo výraze
x
aleboy
sa výrazy
vyhodnotí vtedy a len vtedy, akx
sa nevyhodnotí akotrue
.Vo výraze
x
ay
sa výrazy
vyhodnotí vtedy a len vtedy, akx
sa nevyhodnotí akofalse
.
Posledné dve vlastnosti poskytujú podmienkám logické operátory ich "podmienenú" kvalifikáciu; vlastnosti sa označujú aj ako "skratujúce". Tieto vlastnosti sú užitočné na zapisovaie kompaktných chránených predikátov. Napríklad nasledujúce výrazy sú rovnocenné:
d <> 0 and n/d > 1 if d <> 0 then n/d > 1 else false
Operátory +
, -
*
a /
sú aritmetické operátory.
additive-expression:
multiplicative-expression
additive-expression+
multiplicative-expression
additive-expression-
multiplicative-expression
multiplicative-expression:
metadata- expression
multiplicative-expression*
metadata-expression
multiplicative-expression/
metadata-expression
Čísla v jazyku M sa ukladajú pomocou rôznych vyjadrení, aby sa zachovalo čo najviac informácií o číslach z rôznych zdrojov. Čísla sa podľa potreby konvertujú iba z jedného vyjadrenia na druhé pomocou operátorov, ktoré sa na ne použili. V jazyku M sú podporované dve presnosti:
Presnosť | Sémantika |
---|---|
Precision.Decimal |
128-bitové desatinné vyjadrenie s rozsahom ± 1,0 x 10 – 28 po ±7,9 x 1028 a 28 – 29 významných číslic. |
Precision.Double |
Vedecké vyjadrenie pomocou mantissa a exponentu; Zodpovedá aritmetickému štandardu IEEE 754 binárnej dvojitej presnosti IEEE 754. |
Aritmetické operácie sa vykonávajú výberom presnosti a konverziou oboch operandov na túto presnosť (ak je to potrebné), potom sa vykoná skutočná operácia a nakoniec sa vráti číslo vo vybratej presnosti.
Vstavané aritmetické operátory (+
, , -
*
, /
) používajú dvojitú presnosť. Štandardné funkcie knižnice (Value.Add
, Value.Subtract
, Value.Multiply
, Value.Divide
) možno použiť na vyžiadanie týchto operácií pomocou konkrétneho modelu presnosti.
Nie je možné žiadne číselné pretečenie:
#infinity
alebo-#infinity
predstavujú hodnoty rozsahov, ktoré sú príliš veľké na vyjadrenie.Nie je možné žiadne číselné podtečenie:
0
a-0
predstavujú hodnoty rozsahov, ktoré sú príliš malé na vyjadrenie.Špeciálna hodnota
#nan
IEEE 754 (NaN – nie číslo) sa používa na pokrytie aritmeticky neplatných prípadov, ako je napríklad delenie nuly nulou.Konverzia z presnosti na desatinné miesta na dvojitú presnosť sa vykoná zaokrúhlením desatinných čísel na najbližšiu ekvivalentnú hodnotu s dvojitou presnosťou.
Konverzia z presnosti double na desatinné číslo sa vykoná zaokrúhlením dvojitých čísel na najbližšiu ekvivalentnú desatinnú hodnotu a v prípade potreby pretečením na
#infinity
hodnoty alebo-#infinity
.
Interpretácia operátora sčítania (x + y
) závisí od druhu hodnoty vyhodnotených výrazov x a y nasledovne:
x | y | Result | Interpretácia |
---|---|---|---|
type number |
type number |
type number |
Číselný súčet |
type number |
null |
null |
|
null |
type number |
null |
|
type duration |
type duration |
type duration |
Číselný súčet rozsahov |
type duration |
null |
null |
|
null |
type duration |
null |
|
type
datetime (dátumu a času) |
type duration |
type
datetime (dátumu a času) |
Posun hodnoty datetime podľa trvania |
type duration |
type
datetime (dátumu a času) |
type
datetime (dátumu a času) |
|
type
datetime (dátumu a času) |
null |
null |
|
null |
type
datetime (dátumu a času) |
null |
Hodnota datetime v tabuľke type
Pri sčítaní trvania a hodnoty určitého typu datetime je výsledná hodnota toho istého typu.
V prípade kombinácií hodnôt iných ako uvedených v tabuľke sa vyskytne chyba s kódom "Expression.Error"
príčiny . Každá kombinácia je popísaná v nasledujúcich sekciách.
Chyby vzniknuté pri vyhodnocovaní niektorého operandu sa rozšíria.
Súčet dvoch čísel sa vypočíta pomocou operátora sčítania, ktorý vygeneruje číslo.
Napríklad:
1 + 1 // 2
#nan + #infinity // #nan
Operátor +
sčítania čísel používa dvojitú presnosť. Funkcia Value.Add
štandardnej knižnice sa dá použiť na zadanie presnosti na desatinné miesta. Pri výpočte súčtu čísel platí toto:
Súčet použitím dvojitej presnosti sa vypočíta podľa pravidiel aritmetického základu IEEE 754 týkajúceho sa 64-bitovej binárnej dvojitej presnosti IEEE 754-2008. Nasledujúca tabuľka obsahuje zoznam výsledkov všetkých možných kombinácií nenulových konečných hodnôt, núl, nekonečností a hodnôt NaN. V tabuľke
x
sú hodnoty ay
nenulové konečné hodnoty az
je výsledkomx + y
. Akx
ay
majú rovnaký rozsah, ale opačné znamienka,z
je kladná nula. Akx + y
je príliš veľké na znázornenie v cieľovom type,z
je nekonečná hodnota s rovnakým znamienkom akox + 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 Súčet v presnosti na desatinné čísla sa vypočíta bez straty presnosti. Mierka výsledku je väčšia z mierok dvoch operandov.
Súčet dvoch trvaní je trvanie predstavujúce súčet počtu 100-nanosekundových intervalov vyjadrených trvaniami. Napríklad:
#duration(2,1,0,15.1) + #duration(0,1,30,45.3)
// #duration(2, 2, 31, 0.4)
Hodnotu datetimex
a trvanie y
je možné pridať pomocou x + y
a vypočítať tak novú hodnotu datetime , ktorej vzdialenosť od x
na lineárnej časovej osi je presne rozsah y
. Hodnota datetimektorý nemá hodnotu null, bude rovnakého typu. Posun hodnoty datetime podľa trvania sa môže vypočítať takto:
Ak je zadaná hodnota dní pre datetime od hodnoty Epoch zadaná, vytvorte novú hodnotu datetime s nasledujúcimi prvkami informácií:
Vypočítajte počet nových dní od obdobia Epoch rovnocenný delenie rozsahu y počtom 100-nanosekundových intervalov v rámci 24-hodinového obdobia, pričom desatinná časť výsledku sa skráti a táto hodnota sa pripočíta k počtu dní x od obdobia Epoch.
Vypočítajte počet nových intervalov od polnoci rovnocenný pripočítania rozsahu y k intervalom x od polnoci, čím sa inštruuje počet 100-nanosekundových intervalov v rámci 24-hodinového obdobia. Ak x nešpecifikuje hodnotu pre intervaly od polnoci, predpokladá sa hodnota 0.
Skopíruje hodnotu x pre posun minút od UTC bez zmeny.
Ak nie je zadaná hodnota dní pre datetime od obdobia Epoch, vytvorte novú hodnotu datetime so zadanými nasledujúcimi prvkami informácií:
Vypočítajte počet nových intervalov od polnoci rovnocenný pripočítania rozsahu y k intervalom x od polnoci, čím sa inštruuje počet 100-nanosekundových intervalov v rámci 24-hodinového obdobia. Ak x nešpecifikuje hodnotu pre intervaly od polnoci, predpokladá sa hodnota 0.
Skopírujú sa hodnoty x pre počet dní od obdobia Epoch a posun minút od UTC bez zmeny.
V nasledujúcich príkladoch je znázornený výpočet absolútneho časového súčtu, keď hodnota datetime určuje počet dní od obdobia Epoch:
#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
V nasledujúcom príklade je znázornený výpočet posunu hodnoty datetime podľa trvania daného času:
#time(8,0,0) + #duration(30,5,0,0)
//#time(13, 0, 0)
//13:00:00
Interpretácia operátora odčítania (x - y
) závisí od druhu hodnoty vyhodnotených výrazov x
a y
nasledovne:
x | Y | Result | Interpretácia |
---|---|---|---|
type number |
type number |
type number |
Číselný rozdiel |
type number |
null |
null |
|
null |
type number |
null |
|
type duration |
type duration |
type duration |
Číselný rozdiel rozsahov |
type duration |
null |
null |
|
null |
type duration |
null |
|
type
datetime (dátumu a času) |
type
datetime (dátumu a času) |
type duration |
Trvanie medzi hodnotami datetime |
type
datetime (dátumu a času) |
type duration |
type
datetime (dátumu a času) |
Posun hodnoty datetime podľa negovaného trvania |
type
datetime (dátumu a času) |
null |
null |
|
null |
type
datetime (dátumu a času) |
null |
Hodnota datetime v tabuľke type
Pri odčítaní trvania od hodnoty určitého typu datetime je výsledná hodnota toho istého typu.
V prípade kombinácií hodnôt iných ako uvedených v tabuľke sa vyskytne chyba s kódom "Expression.Error"
príčiny . Každá kombinácia je popísaná v nasledujúcich sekciách.
Chyby vzniknuté pri vyhodnocovaní niektorého operandu sa rozšíria.
Rozdiel medzi dvomi číslami sa vypočíta pomocou operátora odčítania, ktorý vygeneruje číslo. Napríklad:
1 - 1 // 0
#nan - #infinity // #nan
Operátor -
odčítania čísel používa dvojitú presnosť. Funkcia Value.Subtract
štandardnej knižnice sa dá použiť na zadanie presnosti na desatinné miesta. Pri výpočte rozdielu čísel platí toto:
Rozdiel v dvojitej presnosti sa vypočíta podľa pravidiel aritmetického systému IEEE 754 týkajúceho sa 64-bitovej binárnej dvojitej presnosti IEEE 754-2008. Nasledujúca tabuľka obsahuje zoznam výsledkov všetkých možných kombinácií nenulových konečných hodnôt, núl, nekonečností a hodnôt NaN. V tabuľke
x
sú hodnoty ay
nenulové konečné hodnoty az
je výsledkomx - y
. Akx
ay
sú rovné,z
je kladná nula. Akx - y
je príliš veľké na znázornenie v cieľovom type,z
je nekonečná hodnota s rovnakým znamienkom akox - 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 Rozdiel v presnosti na desatinné čísla sa vypočíta bez straty presnosti. Mierka výsledku je väčšia z mierok dvoch operandov.
Rozdiel dvoch trvaní je trvanie predstavujúce rozdiel medzi počtom 100-nanosekundových intervalov vyjadrených jednotlivými trvaniami. Napríklad:
#duration(1,2,30,0) - #duration(0,0,0,30.45)
// #duration(1, 2, 29, 29.55)
Hodnotu datetimex
a trvanie y
je možné odčítať pomocou a x - y
vypočítať tak novú hodnotu datetime.
Hodnota datetime tu predstavuje , date
, datetime
datetimezone
alebo time
. Výsledná hodnota datetime má vzdialenosť od x
na lineárnej časovej osi, ktorá je presne rozsahom y
, a to v smere opačnom od znamienka y
. Odčítaním kladných hodnôt trvaní sa vrátia výsledky, ktoré sú v čase späť vo vzťahu k x
, pričom odčítaním záporných hodnôt sa vrátia výsledky, ktoré sú v čase dopredu.
#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
Dve hodnoty datetimet
a u
možno odčítať pomocou t - u
a vypočítať tak trvanie medzi nimi.
Hodnota datetime tu predstavuje , date
, datetime
datetimezone
alebo time
. Trvanie vygenerované odčítaním od u
musí mať výsledok t
pri sčítaní t
hodnoty u
.
#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
Odčítanie t - u
, keď u > t
má za následok záporné trvanie:
#time(01,30,00) - #time(08,00,00)
// #duration(0, -6, -30, 0)
Pri odčítaní dvoch hodnôt datetime pomocou t - u
platí toto:
- u + (t - u) = t
Interpretácia operátora násobenia (x * y
) závisí od druhu hodnoty vyhodnotených výrazov x a y nasledovne:
X | Y | Result | Interpretácia |
---|---|---|---|
type number |
type number |
type number |
Číselný súčin |
type number |
null |
null |
|
null |
type number |
null |
|
type duration |
type number |
type duration |
Násobok trvania |
type number |
type duration |
type duration |
Násobok trvania |
type duration |
null |
null |
|
null |
type duration |
null |
V prípade kombinácií hodnôt iných ako uvedených v tabuľke sa vyskytne chyba s kódom "Expression.Error"
príčiny . Každá kombinácia je popísaná v nasledujúcich sekciách.
Chyby vzniknuté pri vyhodnocovaní niektorého operandu sa rozšíria.
Súčin dvoch čísel sa vypočíta pomocou operátora násobenia, ktorý vygeneruje číslo. Napríklad:
2 * 4 // 8
6 * null // null
#nan * #infinity // #nan
Operátor *
násobenia čísel používa dvojitú presnosť. Funkcia Value.Multiply
štandardnej knižnice sa dá použiť na zadanie presnosti na desatinné miesta. Pri výpočte súčinu čísel platí toto:
Súčin v dvojitej presnosti sa vypočíta podľa pravidiel aritmetického systému IEEE 754 týkajúceho sa 64-bitovej binárnej dvojitej presnosti IEEE 754-2008. Nasledujúca tabuľka obsahuje zoznam výsledkov všetkých možných kombinácií nenulových konečných hodnôt, núl, nekonečností a hodnôt NaN. V tabuľke
x
sú hodnoty ay
kladné konečné hodnoty.z
hodnota je výsledkom .x * y
Ak je výsledok príliš veľký pre cieľový typ,z
je nekonečná hodnota. Ak je výsledok príliš malý pre cieľový typ,z
je nula.* +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 Súčin v presnosti na desatinné čísla sa vypočíta bez straty presnosti. Mierka výsledku je väčšia z mierok dvoch operandov.
Súčin trvania a počtu je trvanie predstavujúce počet 100-nanosekundových intervalov vyjadrených časovým operandom trvania vynásobeným operandom počtu. Napríklad:
#duration(2,1,0,15.1) * 2
// #duration(4, 2, 0, 30.2)
Interpretácia operátora delenia (x / y
) závisí od druhu hodnoty vyhodnotených výrazov x
a y
nasledovne:
X | Y | Result | Interpretácia |
---|---|---|---|
type number |
type number |
type number |
Číselný podiel |
type number |
null |
null |
|
null |
type number |
null |
|
type duration |
type number |
type duration |
Zlomok trvania |
type duration |
type duration |
type number |
Číselný podiel trvaní |
type duration |
null |
null |
|
null |
type duration |
null |
V prípade kombinácií hodnôt iných ako uvedených v tabuľke sa vyskytne chyba s kódom "Expression.Error"
príčiny . Každá kombinácia je popísaná v nasledujúcich sekciách.
Chyby vzniknuté pri vyhodnocovaní niektorého operandu sa rozšíria.
Podiel dvoch čísel sa vypočíta pomocou operátora delenia, ktorý vygeneruje číslo. Napríklad:
8 / 2 // 4
8 / 0 // #infinity
0 / 0 // #nan
0 / null // null
#nan / #infinity // #nan
Operátor /
delenia čísel používa dvojitú presnosť. Funkcia Value.Divide
štandardnej knižnice sa dá použiť na zadanie presnosti na desatinné miesta. Pri výpočte podielu čísel platí toto:
Podiel v dvojitej presnosti sa vypočíta podľa pravidiel aritmetického systému IEEE 754 týkajúceho sa 64-bitovej binárnej dvojitej presnosti IEEE 754-2008. Nasledujúca tabuľka obsahuje zoznam výsledkov všetkých možných kombinácií nenulových konečných hodnôt, núl, nekonečností a hodnôt NaN. V tabuľke
x
sú hodnoty ay
kladné konečné hodnoty.z
hodnota je výsledkom .x / y
Ak je výsledok príliš veľký pre cieľový typ,z
je nekonečná hodnota. Ak je výsledok príliš malý pre cieľový typ,z
je nula./ +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 Súčet v presnosti na desatinné čísla sa vypočíta bez straty presnosti. Mierka výsledku je väčšia z mierok dvoch operandov.
Podiel dvoch trvaní je počet predstavujúci podiel počtu 100-nanosekundových intervalov vyjadrených trvaniami. Napríklad:
#duration(2,0,0,0) / #duration(0,1,30,0)
// 32
Podiel trvania x
a čísla y
je trvanie predstavujúce počet 100-nanosekundových intervalov vyjadrených trvaním x
a počtom y
. Napríklad:
#duration(2,0,0,0) / 32
// #duration(0,1,30,0)
Operátor kombinácie (x & y
) je definovaný pre nasledujúce druhy hodnôt:
X | Y | Result | Interpretácia |
---|---|---|---|
type text |
type text |
type text |
Zreťazenie |
type text |
null |
null |
|
null |
type text |
null |
|
type date |
type time |
type datetime |
Zlúčenie |
type date |
null |
null |
|
null |
type time |
null |
|
type list |
type list |
type list |
Zreťazenie |
type record |
type record |
type record |
Zlúčenie |
type table |
type table |
type table |
Zreťazenie |
Dve textové, dve zoznamové alebo dve tabuľkové hodnoty sa môžu zreťaziť pomocou .x & y
Nasledujúci príklad ilustruje zreťazenie textovej hodnoty:
"AB" & "CDE" // "ABCDE"
Nasledujúci príklad ilustruje zreťazenie zoznamov:
{1, 2} & {3} // {1, 2, 3}
Pri zreťazení dvoch hodnôt pomocou x & y
platí toto:
Chyby vzniknuté pri vyhodnocovaní
x
výrazov aleboy
sa rozšíria.Ak položka
x
aleboy
obsahuje chybu, chyba sa rozšíri.Výsledkom zreťazenia dvoch textových hodnôt je textová hodnota obsahujúca hodnotu x, za ktorou bezprostredne nasleduje y. Ak má jeden z operandov hodnotu null a druhý je textová hodnota, výsledkom je hodnota null.
Výsledkom zreťazenia dvoch zoznamov je zoznam obsahujúci všetky položky
x
, za ktorými nasledujú všetky položky .y
Výsledkom zreťazenia dvoch tabuliek je tabuľka, ktorá obsahuje zjednotenie dvoch stĺpcov tabuľky operandov. Poradie stĺpcov
x
sa zachová a nasledujú stĺpce, potom nasledujúy
stĺpce, ktoré zobrazuje iba , pričom sa zachová ich relatívne poradie. V prípade stĺpcov, ktoré zobrazujú iba jeden z operandov,null
sa používa na vyplnenie hodnôt buniek druhého operandu.
Dva záznamy je možné zlúčiť pomocou x & y
, pričom sa vygeneruje záznam obsahujúci polia, ktoré obsahuje aj x
y
.
Nasledujúce príklady ilustrujú zlučovanie záznamov:
[ x = 1 ] & [ y = 2 ] // [ x = 1, y = 2 ]
[ x = 1, y = 2 ] & [ x = 3, z = 4 ] // [ x = 3, y = 2, z = 4 ]
Pri zlučovaní dvoch záznamov pomocou x + y
platí toto:
Chyby vzniknuté pri vyhodnocovaní
x
výrazov aleboy
sa rozšíria.Ak sa pole zobrazí v rámci aj
x
y
, použije sa hodnota vy
.Poradie polí vo výslednom zázname je určené
x
podľa , potom nasledujú polia,y
ktoré obsahuje a neobsahujex
, v rovnakom poradí, v akom ich zobrazujey
.Zlúčením záznamov sa nespôsobí vyhodnocovanie hodnôt.
Nevytýli sa žiadne chyby, pretože pole obsahuje chybu.
Výsledkom je záznam.
Dátum x
je možné zlúčiť s časom y
pomocou x & y
, pričom sa vygeneruje hodnota datetime, ktorá kombinuje časti aj x
y
.
Nasledujúci príklad ilustruje zlúčenie dátumu a času:
#date(2013,02,26) & #time(09,17,00)
// #datetime(2013,02,26,09,17,00)
Pri zlučovaní dvoch záznamov pomocou x + y
platí toto:
Chyby vzniknuté pri vyhodnocovaní
x
výrazov aleboy
sa rozšíria.Výsledkom je hodnota datetime.
Operátory +
, -
a not
sú unárne operátory.
unary-expression:
type-expression
+
unary expression
-
unary expression
not
unary expression
Unárny operátor plus (+x
) je definovaný pre nasledujúce druhy hodnôt:
X | Result | Interpretácia |
---|---|---|
type number |
type number |
Unárne plus |
type duration |
type duration |
Unárne plus |
null |
hodnota null |
V prípade iných hodnôt sa vyskytne chyba s kódom "Expression.Error"
príčiny .
Unárny operátor plus umožňuje +
použiť znamienko na číslo, hodnotu datetime alebo hodnotu null. Výsledkom je tá istá hodnota. Napríklad:
+ - 1 // -1
+ + 1 // 1
+ #nan // #nan
+ #duration(0,1,30,0) // #duration(0,1,30,0)
Pri vyhodnocovaní unárneho operátora +x
plus platí toto:
Chyby vzniknuté pri vyhodnocovaní
x
sa rozšíria.Ak výsledok vyhodnocovania
x
nie je číselnou hodnotou, vyskytne sa chyba s kódom"Expression.Error"
príčiny .
Unárny operátor mínus (-x
) je definovaný pre nasledujúce druhy hodnôt:
X | Result | Interpretácia |
---|---|---|
type number |
type number |
Negácia |
type duration |
type duration |
Negácia |
null |
null |
V prípade iných hodnôt sa vyskytne chyba s kódom "Expression.Error"
príčiny .
Unárny operátor mínus sa používa na zmenu znamienka čísla alebo trvania. Napríklad:
- (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)
Pri vyhodnocovaní unárneho operátora -x
mínus platí toto:
Chyby vzniknuté pri vyhodnocovaní
x
sa rozšíria.Ak výraz je číslo, výsledkom je číselná hodnota z výrazu
x
so zmeneným znamienkom. Ak je hodnota NaN, výsledok je tiež Hodnota NaN.
Operátor logickej negácie (not
) je definovaný pre nasledujúce druhy hodnôt:
X | Result | Interpretácia |
---|---|---|
type logical |
type logical |
Negácia |
null |
null |
Tento operátor vypočíta logickú not
operáciu s danou logickou hodnotou. Napríklad:
not true // false
not false // true
not (true and true) // false
Pri vyhodnocovaní operátora not x
logickej negácie platí toto:
Chyby vzniknuté pri vyhodnocovaní
x
sa rozšíria.Hodnota vygenerovaná z vyhodnotenia výrazu x musí byť logickou hodnotou, v opačnom sa vyskytne chyba s kódom
"Expression.Error"
príčiny . Ak hodnota jetrue
, výsledok jefalse
. Ak operand jefalse
, výsledok jetrue
.
Výsledkom je logická hodnota.
Operátory is
a as
sa označujú ako operátory typu.
Operátor x is y
kompatibility typov je definovaný pre nasledujúce typy hodnôt:
X | Y | Result |
---|---|---|
type any |
nullable-primitive-type | type logical |
Výraz x is y
vráti true
, ak pripísaný typ x
je kompatibilný s y
, a vráti false
, ak pripísaný typ x
je nekompatibilný s y
.
y
Hodnota musí byť nullable-primitive-type.
is-expression:
as-expression
is-expressionis
nullable-primitive-type
nullable-primitive-type:
nullable
opt primitive-type
Kompatibilita typov, ktorú is
podporuje operátor, je podmnožinou všeobecnej kompatibility typov a definuje sa podľa nasledujúcich pravidiel:
Ak
x
hodnota je hodnotou null, potom je kompatibilná, aky
ide o typany
, typnull
alebo typ s povolenou hodnotou null.Ak
x
hodnota nie je null, potom je kompatibilná, ak primitívny typx
je rovnaký akoy
.
Pri vyhodnocovaní výrazu x is y
platí toto:
- Chyba, ktorá sa vyskytne pri vyhodnocovaní výrazu
x
, sa rozšíri.
Operátor x as y
kontrolného výrazu typu je definovaný pre nasledujúce typy hodnôt:
X | Y | Result |
---|---|---|
type any |
nullable-primitive-type | type any |
Výraz x as y
tvrdí, že hodnota je kompatibilná s hodnotou x
v súlade s y
operátorom is
. Ak nie je kompatibilná, vyvolá sa chyba.
y
Hodnota musí byť nullable-primitive-type.
as-expression:
equality-expression
as-expressionas
nullable-primitive-type
Výraz x as y
sa vyhodnotí takto:
Vykoná sa kontrola
x is y
kompatibility typov a kontrolný výraz vrátix
bez zmeny, ak je tento test úspešný.Ak je kontrola kompatibility neúspešná, vyskytne sa chyba s kódom
"Expression.Error"
príčiny .
Príklady:
1 as number // 1
"A" as number // error
null as nullable number // null
Pri vyhodnocovaní výrazu x as y
platí toto:
- Chyba, ktorá sa vyskytne pri vyhodnocovaní výrazu
x
, sa rozšíri.
Operátor coalesce ??
vráti výsledok svojho ľavého operandu, ak nemá hodnotu null, v opačnom prípade vráti výsledok pravého operandu. Pravý operand sa vyhodnotí vtedy a len vtedy, ak má ľavý operand hodnotu null.