Chování operátoru
Tato část definuje chování různých operátorů jazyka M.
Pokud výraz obsahuje více operátorů, priorita operátorů řídí pořadí, ve kterém jsou jednotlivé operátory vyhodnoceny. Výraz se například vyhodnotí jako x + y * z
proto, x + (y * z)
že *
operátor má vyšší prioritu než binární +
operátor. Priorita operátoru je stanovena definicí přidružené gramatické produkce. Výraz sčítání se například skládá z posloupnosti násobení výrazu odděleného operátory +
nebo -
operátory, takže operátory a +
operátory mají -
nižší prioritu *
než operátory a /
operátory.
K změně výchozího pořadí priority lze použít závorky a produkci výrazů .
parenthesized-expression:
(
výraz)
Příklad:
1 + 2 * 3 // 7
(1 + 2) * 3 // 9
Následující tabulka shrnuje operátory M a uvádí kategorie operátorů v pořadí podle priority od nejvyššího po nejnižší. Operátory ve stejné kategorii mají stejnou prioritu.
Kategorie | Expression | Popis |
---|---|---|
Primární |
já @ já |
Výraz identifikátoru |
(x) | Výraz závorek | |
x[i] | Vyhledání | |
x{y} | Přístup k položce | |
x(...) | Vyvolání funkce | |
{x, y, ...} | Inicializace seznamu | |
[ i = x, ... ] | Inicializace záznamu | |
... | Není implementováno | |
Unární | + x | Identita |
- x | Negace | |
not
x |
Logický operátor negace | |
Metadata |
xmeta y |
Přidružení metadat |
Multiplikativní | x * y | Násobení |
x / y | Oddělení | |
Aditivní | x + y | Součet |
x - y | Odčítání | |
Relační | x< y | Je menší než |
x > y | Je větší než | |
x<= y | Menší než nebo rovno | |
x >= y | Větší než nebo rovno | |
Rovnost | x = y | Je rovno |
x<> y | Not equal | |
Kontrolní výraz typu |
xas y |
Je kompatibilní primitivní typ nebo chyba s možnou hodnotou null. |
Shoda typu |
xis y |
Test, jestli kompatibilní primitivní typ s možnou hodnotou null |
Logický operátor AND |
xand y |
Zkratové spojení |
Logický operátor OR |
xor y |
Zkratová disjunkce |
Coalesce |
x?? y |
Operátor sjednocení s hodnotou Null |
Každá hodnota má přidruženou hodnotu záznamu, která může obsahovat další informace o hodnotě. Tento záznam se označuje jako záznam metadat pro hodnotu. Záznam metadat lze přidružit k jakémukoli druhu hodnoty, a to i null
. Výsledkem takového přidružení je nová hodnota s danými metadaty.
Záznam metadat je jenom běžný záznam a může obsahovat všechna pole a hodnoty, které může běžný záznam obsahovat a sám má záznam metadat. Přidružení záznamu metadat k hodnotě je "nerušivé". Nezmění chování hodnoty při vyhodnocování s výjimkou těch, které explicitně kontrolují záznamy metadat.
Každá hodnota má výchozí záznam metadat, i když nebyla zadána. Výchozí záznam metadat je prázdný. Následující příklady ukazují přístup k záznamu metadat textové hodnoty pomocí Value.Metadata
standardní funkce knihovny:
Value.Metadata( "Mozart" ) // []
Záznamy metadat se obvykle nezachovají , pokud se hodnota používá s operátorem nebo funkcí, která vytváří novou hodnotu. Pokud jsou například pomocí operátoru &
zřetězeny dvě textové hodnoty, metadata výsledné textové hodnoty je prázdný záznam []
. Následující výrazy jsou ekvivalentní:
"Amadeus " & ("Mozart" meta [ Rating = 5 ])
"Amadeus " & "Mozart"
Standardní funkce Value.RemoveMetadata
knihovny a Value.ReplaceMetadata
lze je použít k odebrání všech metadat z hodnoty a k nahrazení metadat hodnoty (místo sloučení metadat do pravděpodobně existujících metadat).
Jediným operátorem, který vrací výsledky, které přenášejí metadata, je meta operátor.
Hodnoty mohou být cyklické. Příklad:
let l = {0, @l} in l
// {0, {0, {0, ... }}}
[A={B}, B={A}]
// [A = {{ ... }}, B = {{ ... }}]
Jazyk M zpracovává cyklické hodnoty tím, že udržuje řadu záznamů, seznamů a tabulek opožděně. Pokus o vytvoření cyklické hodnoty, která nemá prospěch z vložených opožděných strukturovaných hodnot, přináší chybu:
[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"),
// ]
Některé operátory v jazyce M jsou definovány strukturální rekurzí. Rovnost záznamů a seznamů je například definována konjovovanou rovností odpovídajících polí záznamů a seznamů položek.
U necyklických hodnot při použití strukturální rekurze dojde k konečnému rozšíření hodnoty: sdílené vnořené hodnoty se budou opakovaně procházet, ale proces rekurze se vždy ukončí.
Cyklická hodnota má nekonečné rozšíření při použití strukturální rekurze. Sémantika jazyka M neposkytuje žádná zvláštní ubytování pro takové nekonečné rozšíření – pokus o porovnání cyklických hodnot pro rovnost, například, bude obvykle nedostatek prostředků a ukončí výjimečně.
Operátory výběru a projekce umožňují extrahovat data ze seznamu a hodnot záznamů.
Hodnotu lze vybrat ze seznamu nebo tabulky na základě nulové pozice v daném seznamu nebo tabulce pomocí výrazu item-access-expression.
item-access-expression:
item-selection
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átí:
Pro seznam
x
a čísloy
položka seznamux
na poziciy
. První položka seznamu se považuje za pořadový index nuly. Pokud požadovaná pozice v seznamu neexistuje, vyvolá se chyba.Pro tabulku
x
a čísloy
, řádek tabulkyx
na poziciy
. První řádek tabulky se považuje za pořadový index nuly. Pokud požadovaná pozice v tabulce neexistuje, vyvolá se chyba.Pro tabulku
x
a záznamy
je řádek tabulkyx
, který odpovídá hodnotám polí záznamuy
pro pole s názvy polí, které odpovídají odpovídajícím názvům sloupců tabulky. Pokud v tabulce není žádný jedinečný odpovídající řádek, vyvolá se chyba.
Pří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-také podporuje formulář x{y}?
, který vrátí null
, když pozice (nebo shoda) y
v seznamu nebo tabulce x
neexistuje . Pokud existuje více shod pro y
, je stále vyvolána chyba.
Pří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
Přístup k položce nevynucuje vyhodnocení položek seznamu nebo tabulek, které jsou jiné než položky, ke které se přistupuje. Příklad:
{ error "a", 1, error "c"}{1} // 1
{ error "a", error "b"}{1} // error "b"
Při vyhodnocování operátoru x{y}
přístupu k položce platí následující:
Chyby vyvolané při vyhodnocování výrazů
x
neboy
se šíří.Výraz
x
vytvoří seznam nebo hodnotu tabulky.Výraz
y
vytvoří číselnou hodnotu, nebo pokudx
vytvoří hodnotu tabulky, hodnotu záznamu.Pokud
y
vytvoří číselnou hodnotu a hodnotay
je záporná, vyvolá se chyba s kódem"Expression.Error"
důvodu.Pokud
y
vytvoří číselnou hodnotu a hodnotay
je větší nebo rovna počtux
, je vyvolána chyba s kódem"Expression.Error"
důvodu, pokud se nepoužije volitelný formulářx{y}?
operátoru, v takovém případě se vrátí hodnotanull
.Pokud
x
vytvoří hodnotu tabulky ay
vytvoří hodnotu záznamu a neobsahuje žádné shody,y
x
vyvolá se chyba s kódem"Expression.Error"
důvodu, pokud se nepoužije volitelný formulářx{y}?
operátoru, v takovém případě se hodnotanull
vrátí.Pokud
x
vytvoří hodnotu tabulky ay
vytvoří hodnotu záznamu a existuje více shod proy
inx
, vyvolá se chyba s kódem"Expression.Error"
důvodu.
Během procesu výběru položky se nevyhodnocují žádné položky, které jsou na x
pozici y
. (U streamovaných seznamů nebo tabulek se položky nebo řádky předcházející dané pozici y
přeskočí, což může způsobit jejich vyhodnocení v závislosti na zdroji seznamu nebo tabulky.)
Výraz field-access-expression slouží k výběru hodnoty ze záznamu nebo k promítnutí záznamu nebo tabulky do jednoho s menším počtem polí nebo sloupců.
field-access-expression:
výběr polí
implicitní výběr cílového pole
projekce
implicitní cílová projekce
výběr pole:
primary-expression field-selector
selektor polí:
required-field-selector
optional-field-selector
required-field-selector:
[
název pole]
optional-field-selector:
[
název pole] ?
název pole:
generalizovaný identifikátor
quoted-identifier
implicit-target-field-selection:
selektor polí
projekce:
primární výraz required-projection
primary-expression optional-projection
požadované projekce:
[
required-selector-list]
volitelná projekce:
[
required-selector-list] ?
required-selector-list:
required-field-selector
required-selector-list,
required-field-selector
implicitní cílová projekce:
požadované projekce
volitelná projekce
Nejjednodušší forma přístupu k poli je povinná pro výběr polí. Pomocí operátoru x[y]
vyhledá pole v záznamu podle názvu pole. Pokud pole y
neexistuje x
, vyvolá se chyba. Formulář x[y]?
slouží k provedení volitelného výběru pole a vrátí null
, pokud požadované pole v záznamu neexistuje.
Příklad:
[A=1,B=2][B] // 2
[A=1,B=2][C] // error
[A=1,B=2][C]? // null
Operátory pro požadovanou projekci záznamu a volitelnou projekci záznamů podporují kolektivní přístup k více polím. Operátor x[[y1],[y2],...]
prodá záznam do nového záznamu s menším počtem polí (vybraných pomocí y1
, y2
...
). Pokud vybrané pole neexistuje, vyvolá se chyba. Operátor x[[y1],[y2],...]?
prodá záznam do nového záznamu s poli vybranými y1
hodnotou , y2
...
; pokud pole chybí, null
použije se místo toho.
Příklad:
[A=1,B=2][[B]] // [B=2]
[A=1,B=2][[C]] // error
[A=1,B=2][[B],[C]]? // [B=2,C=null]
Formuláře [y]
a [y]?
jsou podporovány jako zkrácený odkaz na identifikátor _
(podtržítko). Následující dva výrazy jsou ekvivalentní:
[A]
_[A]
Následující příklad znázorňuje zkrácenou formu přístupu k poli:
let _ = [A=1,B=2] in [A] //1
[[y1],[y2],...]
Formulář a [[y1],[y2],...]?
jsou také podporovány jako zkratka a následující dva výrazy jsou podobně ekvivalentní:
[[A],[B]]
_[[A],[B]]
Zkrácený tvar je zvlášť užitečný v kombinaci s each
zkratkou, způsob, jak zavést funkci jednoho parametru s názvem _
(podrobnosti viz zjednodušené deklarace). Obě zkratky společně zjednodušují běžné funkční výrazy vyššího řádu:
List.Select( {[a=1, b=1], [a=2, b=4]}, each [a] = [b])
// {[a=1, b=1]}
Výše uvedený výraz je ekvivalentní následujícímu šifrnějšímu dlouhému výrazu:
List.Select( {[a=1, b=1], [a=2, b=4]}, (_) => _[a] = _[b])
// {[a=1, b=1]}
Přístup k poli nevynucuje vyhodnocení jiných polí, než ke které se přistupuje. Příklad:
[A=error "a", B=1, C=error "c"][B] // 1
[A=error "a", B=error "b"][B] // error "b"
Při vyhodnocování operátoru x[y]
přístupu k poli , x[y]?
, x[[y]]
, nebo x[[y]]?
je vyhodnocen následující:
Chyby vyvolané při vyhodnocování výrazu
x
se šíří.Chyby vyvolané při vyhodnocování pole
y
jsou trvale přidruženy k poliy
a následně se rozšíří. Jakýkoli budoucí přístup k poliy
vyvolá stejnou chybu.Výraz
x
vytvoří záznam nebo hodnotu tabulky nebo dojde k chybě.Pokud identifikátor
y
pojmenuje pole, ve kterém neexistujex
, je vyvolána chyba s kódem"Expression.Error"
důvodu, pokud není použit volitelný formulář...?
operátoru, v takovém případě se vrátí hodnotanull
.
Během procesu přístupu k polím se nevyhodnocují žádná pole x
s jiným názvem, než y
podle kterého se jmenuje.
Záznam metadat pro hodnotu se mění pomocí operátoru meta (x meta y
).
výraz metadat:
unary-expression
unary-expressionmeta
unary-expression
Následující příklad vytvoří textovou hodnotu se záznamem metadat pomocí meta
operátoru a pak přistupuje k záznamu metadat výsledné hodnoty pomocí Value.Metadata
:
Value.Metadata( "Mozart" meta [ Rating = 5 ] )
// [Rating = 5 ]
Value.Metadata( "Mozart" meta [ Rating = 5 ] )[Rating]
// 5
Při použití operátoru x meta y
kombinování metadat platí následující:
Chyby vyvolané při vyhodnocování
x
výrazů neboy
výrazů se šíří.Výraz
y
musí být záznam nebo je vyvolána chyba s kódem"Expression.Error"
důvodu.Výsledný záznam metadat je
x
záznam metadat sloučený sy
. (Sémantika sloučení záznamů najdete v tématu Sloučení záznamů.)Výsledná hodnota je hodnota z výrazu
x
bez jeho metadat s připojeným nově vypočítaným záznamem metadat.
Standardní funkce Value.RemoveMetadata
knihovny a Value.ReplaceMetadata
lze je použít k odebrání všech metadat z hodnoty a k nahrazení metadat hodnoty (místo sloučení metadat do pravděpodobně existujících metadat). Následující výrazy jsou ekvivalentní:
x meta y
Value.ReplaceMetadata(x, Value.Metadata(x) & y)
Value.RemoveMetadata(x) meta (Value.Metadata(x) & y)
Operátor =
rovnosti slouží k určení, zda jsou dvě hodnoty stejné. Operátor <>
nerovnosti se používá k určení, jestli se dvě hodnoty nerovnají.
výraz rovnosti:
relační výraz
relational-expression=
equality-expression
relational-expression<>
equality-expression
Příklad:
1 = 1 // true
1 = 2 // false
1 <> 1 // false
1 <> 2 // true
null = true // false
null = null // true
Metadata nejsou součástí porovnání rovnosti nebo nerovnosti. Příklad:
(1 meta [ a = 1 ]) = (1 meta [ a = 2 ]) // true
(1 meta [ a = 1 ]) = 1 // true
Při použití operátorů x = y
x <> y
rovnosti platí následující:
Chyby vyvolané při vyhodnocování
x
výrazů neboy
výrazů se šíří.Operátor
=
má výsledektrue
, jestli jsou hodnoty stejné, afalse
jinak.Operátor
<>
má výsledekfalse
, jestli jsou hodnoty stejné, atrue
jinak.Záznamy metadat nejsou zahrnuty do porovnání.
Pokud hodnoty vytvořené vyhodnocením
x
výrazůy
nejsou stejného typu hodnoty, hodnoty se nerovnají.Pokud hodnoty vytvořené vyhodnocením
x
ay
výrazem jsou stejného typu hodnoty, existují specifická pravidla pro určení, jestli jsou stejné, jak je definováno níže.Toto je vždy pravdivé:
(x = y) = not (x <> y)
Operátory rovnosti jsou definovány pro následující typy:
- Hodnota
null
se rovná pouze sobě.
null = null // true
null = true // false
null = false // false
- Logické hodnoty
true
sefalse
rovnají pouze sobě. Příklad:
true = true // true
false = false // true
true = false // false
true = 1 // false
Čísla se porovnávají pomocí zadané přesnosti:
Pokud je
#nan
některé z těchto čísel , nebudou čísla stejná.Pokud žádné číslo není
#nan
, pak se čísla porovnávají pomocí bitového porovnání číselné hodnoty.#nan
je jediná hodnota, která se nerovná sama sobě.Příklad:
1 = 1, // true
1.0 = 1 // true
2 = 1 // false
#nan = #nan // false
#nan <> #nan // true
Dvě doby trvání jsou stejné, pokud představují stejný počet 100 nanosekundových tisekund.
Pokud se velikost jejich částí (hodina, minuta, sekunda) rovná dvěma časy.
Pokud jsou velikost jejich částí (rok, měsíc, den) stejná, jsou dvě kalendářní data rovna.
Dvě hodnoty datetime jsou stejné, pokud se velikost jejich částí (rok, měsíc, den, hodina, minuta, sekunda) rovná.
Pokud jsou odpovídající data a časy UTC stejné, jsou dvě zóny datetime rovny. Aby bylo dosaženo odpovídajícího data a času UTC, od komponenty datetimezone se odečte posun hodin a minut.
Dvě textové hodnoty jsou stejné, pokud používáte řadové porovnání nerozlišující velká a malá písmena a nerozlišují jazykovou verzi, mají stejnou délku a stejné znaky na odpovídajících pozicích.
Pokud jsou splněny všechny následující hodnoty, jsou dvě hodnoty seznamu stejné:
Oba seznamy obsahují stejný počet položek.
Hodnoty každé poziční položky v seznamech jsou stejné. To znamená, že seznamy musí obsahovat nejen stejné položky, ale i položky musí být ve stejném pořadí.
Příklad:
{1, 2} = {1, 2} // true {2, 1} = {1, 2} // false {1, 2, 3} = {1, 2} // false
Pokud jsou splněny všechny následující záznamy, jsou dva záznamy stejné:
Počet polí je stejný.
Každý název pole jednoho záznamu se nachází také v druhém záznamu.
Hodnota každého pole jednoho záznamu se rovná podobnému poli v druhém záznamu.
Pří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
Pokud jsou splněny všechny následující podmínky, jsou dvě tabulky stejné:
Počet sloupců je stejný.
Každý název sloupce v jedné tabulce se nachází také v druhé tabulce.
Počet řádků je stejný.
Každý řádek má stejné hodnoty v odpovídajících buňkách.
Pří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 funkce se rovná sobě, ale může nebo nemusí být rovna jiné hodnotě funkce. Pokud jsou dvě hodnoty funkce považovány za stejné, budou se při vyvolání chovat stejně.
Dvě dané hodnoty funkce budou mít vždy stejný vztah rovnosti.
Hodnota typu se rovná sobě, ale může nebo nemusí být rovna jiné hodnotě typu. Pokud jsou dvě hodnoty typu považovány za stejné, budou se při dotazování na shodu chovat stejně.
Dvě zadané hodnoty typu budou mít vždy stejný vztah rovnosti.
Operátory <
, >
, <=
a >=
jsou volána relační operátory.
relační výraz:
additive-expression
additive-expression<
relational-expression
additive-expression>
relational-expression
additive-expression<=
relational-expression
additive-expression>=
relational-expression
Tyto operátory slouží k určení relativní relace řazení mezi dvěma hodnotami, jak je znázorněno v následující tabulce:
Operace | Výsledek |
---|---|
x < y |
true pokud x je menší než y , false jinak |
x > y |
true pokud x je větší než y , false jinak |
x <= y |
true je-li x menší nebo rovna y , false jinak |
x >= y |
true je-li x větší nebo rovna y , false jinak |
Příklad:
0 <= 1 // true
null < 1 // null
null <= null // null
"ab" < "abc" // true
#nan >= #nan // false
#nan <= #nan // false
Při vyhodnocování výrazu obsahujícího relační operátory platí následující:
Chyby vyvolané při vyhodnocování výrazů operandu
x
y
se šíří.Hodnoty vytvořené vyhodnocením
x
y
výrazů musí být binární, datum, datum, datetime, datetimezone, doba trvání, logická hodnota, číslo, null, text nebo časová hodnota. V opačném případě se vyvolá chyba s kódem"Expression.Error"
důvodu.Oba operandy musí být stejného typu hodnoty nebo
null
. V opačném případě se vyvolá chyba s kódem"Expression.Error"
důvodu.Pokud jsou
null
operandy nebo oba operandy , jenull
výsledkem hodnota.Dva binární soubory se porovnávají bajty bajtů.
Dvě kalendářní data jsou porovnána porovnáním jejich částí roku, a pokud jsou stejné, jejich měsíční části a pokud jsou stejné, jejich denní části.
Dvě data a časy se porovnávají porovnáním jejich částí roku, a pokud jsou stejné, jejich části měsíce a, jsou-li stejné, jejich denní části a, pokud jsou stejné, jejich hodinové části a, pokud jsou stejné, jejich minutové části a, pokud jsou stejné, jejich druhé části.
Dvě datatimezone se porovnávají tak, že je normalizujete do UTC odečtením posunu za hodinu/minutu a následným porovnáním jejich součástí data a času.
Dvě doby trvání se porovnávají podle celkového počtu 100 nanosekundových ticků, které představují.
Dvě logické funkce se porovnávají tak, aby
true
byly považovány za větší nežfalse
.Dvě čísla
x
ay
porovnávají se podle pravidel standardu IEEE 754:Pokud je
#nan
některý z operandů , výsledek jefalse
pro všechny relační operátory.Pokud žádný operand není
#nan
, operátory porovnávají hodnoty dvou operandů s plovoucí desetinnou čárkou s ohledem na pořadí,-∞ < -max < ... < -min < -0.0 = +0.0 < +min < ... < +max < +∞
kde min a max jsou nejmenší a největší kladné konečné hodnoty, které lze reprezentovat. Názvy M pro -∞ a +∞ jsou-#infinity
a#infinity
.Mezi efekty tohoto řazení patří:
Záporné a kladné nuly jsou považovány za stejné.
Hodnota
-#infinity
je považována za menší než všechny ostatní číselné hodnoty, ale rovna jiné-#infinity
.Hodnota
#infinity
je považována za větší než všechny ostatní číselné hodnoty, ale rovna jiné#infinity
.
Dva texty se porovnávají pomocí řadových znaků, rozlišujících velká a malá písmena a nerozlišují se jazykové verze.
Dvakrát se porovnávají jejich hodinové části a pokud jsou stejné, jejich minutové části a pokud jsou stejné, jejich druhé části.
Operátory and
a or
operátory se nazývají podmíněné logické operátory.
logický nebo výraz:
logical-and-expression
logical-and-expressionor
logical-or-expression
logický výraz:
is-expression
is-expressionand
logical-and-expression
Operátor or
se vrátí true
, pokud je alespoň jeden z jeho operandů true
. Pravý operand je vyhodnocen, pokud a pouze pokud levý operand není true
.
Operátor and
se vrátí false
, pokud je alespoň jeden z jeho operandů false
. Pravý operand je vyhodnocen, pokud a pouze pokud levý operand není false
.
Tabulky pravdy pro operátory or
a and
operátory jsou uvedeny níže, s výsledkem vyhodnocení levého výrazu operandu na svislé ose a výsledek vyhodnocení správného výrazu operandu na vodorovné ose.
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 |
Při vyhodnocování výrazu obsahujícího podmíněné logické operátory platí následující:
Chyby vyvolané při vyhodnocování
x
výrazů neboy
výrazů se šíří.Podmíněné logické operátory jsou definovány nad typy
logical
anull
. Pokud hodnoty operandu nejsou z těchto typů, vyvolá se chyba s kódem"Expression.Error"
důvodu.Výsledkem je logická hodnota.
Ve výrazu
x
neboy
se výrazy
vyhodnotí, pokud a pouze v případě, žex
se nevyhodnotí jakotrue
.Ve výrazu
x
ay
výrazy
bude vyhodnocen, pokud a pouze v případě, žex
se nevyhodnocuje nafalse
.
Poslední dvě vlastnosti poskytují podmíněným logickým operátorům jejich "podmíněnou" kvalifikaci; vlastnosti se také označují jako "zkratové obvody". Tyto vlastnosti jsou užitečné při psaní kompaktních strážených predikátů. Například následující výrazy jsou ekvivalentní:
d <> 0 and n/d > 1 if d <> 0 then n/d > 1 else false
Operátory +
, -
*
a /
jsou aritmetické operátory.
additive-expression:
multiplikativní výraz
additive-expression+
multiplicative-expression
additive-expression-
multiplicative-expression
multiplikativní výraz:
metadata – výraz
multiplicative-expression*
metadata-expression
multiplicative-expression/
metadata-expression
Čísla v jazyce M se ukládají pomocí různých reprezentací, aby se zachovalo co nejvíce informací o číslech pocházejících z různých zdrojů. Čísla jsou převedena pouze z jedné reprezentace na jinou podle potřeby operátory použitými na ně. V jazyce M jsou podporovány dvě přesnosti:
Počet deset. míst | Sémantika |
---|---|
Precision.Decimal |
128bitové desetinné číslo s rozsahem ±1,0 x 10–28 až ±7,9 x 1028 a 28–29 významných číslic. |
Precision.Double |
Vědecké vyjádření pomocí mantisy a exponentu; odpovídá 64bitové binární dvojité přesnosti IEEE 754 aritmetické normě IEEE 754-2008. |
Aritmetické operace se provádějí výběrem přesnosti, převodem obou operandů na danou přesnost (v případě potřeby), provedením skutečné operace a nakonec vrácením čísla ve zvolené přesnosti.
Předdefinované aritmetické operátory (+
, -
, *
, /
) používají dvojitou přesnost. Standardní funkce knihovny (Value.Add
, Value.Subtract
, Value.Multiply
, Value.Divide
) lze použít k vyžádání těchto operací pomocí konkrétního modelu přesnosti.
Není možný žádný číselný přetečení:
#infinity
nebo-#infinity
představují hodnoty moc velké, aby bylo možné reprezentovat.Není možný žádný číselný podtečení:
0
a-0
představují hodnoty moc malých, aby bylo možné reprezentovat.Speciální hodnota
#nan
IEEE 754 (NaN – Not a Number) se používá k pokrytí aritmeticky neplatných případů, například dělení nuly nulou.Převod z desetinné na dvojitou přesnost se provádí zaokrouhlením desetinných čísel na nejbližší ekvivalentní dvojitou hodnotu.
Převod z dvojité na desetinnou přesnost se provádí zaokrouhlením dvojitých čísel na nejbližší ekvivalentní desetinnou hodnotu a v případě potřeby přetečením na
#infinity
nebo-#infinity
hodnoty.
Interpretace operátoru sčítání (x + y
) závisí na druhu hodnoty vyhodnocených výrazů x a y následujícím způsobem:
linka | y | Výsledek | Interpretace |
---|---|---|---|
type number |
type number |
type number |
Číselný součet |
type number |
null |
null |
|
null |
type number |
null |
|
type duration |
type duration |
type duration |
Číselný součet velikostí |
type duration |
null |
null |
|
null |
type duration |
null |
|
type
datetime |
type duration |
type
datetime |
Posun data a času podle doby trvání |
type duration |
type
datetime |
type
datetime |
|
type
datetime |
null |
null |
|
null |
type
datetime |
null |
V tabulce type
představuje datum a čas libovolnou z type date
hodnot , type datetime
, type datetimezone
nebo type time
. Při přidávání doby trvání a hodnoty určitého typu datetime je výsledná hodnota stejného typu.
U jiných kombinací hodnot, než jsou hodnoty uvedené v tabulce, je vyvolána chyba s kódem "Expression.Error"
důvodu. Každá kombinace je popsána v následujících částech.
Chyby vyvolané při vyhodnocování jednoho operandu se rozšíří.
Součet dvou čísel se vypočítá pomocí operátoru sčítání a vytvoří číslo.
Příklad:
1 + 1 // 2
#nan + #infinity // #nan
Operátor +
sčítání nad čísly používá dvojitou přesnost. Funkci standardní knihovny Value.Add
lze použít k určení desetinné přesnosti. Při výpočtu součtu čísel platí následující:
Součet dvojité přesnosti se vypočítá podle pravidel 64bitové binární dvojitéprecize IEEE 754 aritmetické IEEE 754-2008. Následující tabulka uvádí výsledky všech možných kombinací nenulových konečných hodnot, nul, infinit a naN. V tabulce
x
ay
jsou nenulové konečné hodnoty az
je výsledkemx + y
. Pokudx
ay
mají stejnou velikost, ale opačné znaky,z
je kladná nula. Pokudx + y
je příliš velký, aby byl reprezentován v cílovém typu,z
je nekonečno se stejným znaménkem jakox + y
.+ y +0 0 až +∞ -∞ Není číslo x z linka linka +∞ -∞ Není číslo +0 y +0 +0 +∞ -∞ Není číslo -0 y +0 0 až +∞ -∞ Není číslo +∞ +∞ +∞ +∞ +∞ Není číslo Není číslo -∞ -∞ -∞ -∞ Není číslo -∞ Není číslo Nan Není číslo Není číslo Není číslo Není číslo Není číslo Není číslo Součet v desetinné přesnosti se vypočítá bez ztráty přesnosti. Měřítko výsledku je větší z měřítka dvou operandů.
Součet dvou dob trvání je doba trvání představující součet počtu 100nanosekundů, které představují doby trvání. Příklad:
#duration(2,1,0,15.1) + #duration(0,1,30,45.3)
// #duration(2, 2, 31, 0.4)
Datum doba trvání x
lze přidat pomocí y
výpočtu nového x + y
, jehož vzdálenost od lineární časové osy je přesně velikost x
. V tomto případě je datetime zkratka pro libovolný z Date
, DateTime
, DateTimeZone
nebo Time
a nenulový výsledek bude stejného typu. Posun data a času podle doby trvání se dá vypočítat takto:
Pokud jsou zadány dny datetime od hodnoty epochy, vytvořte nový datetime s následujícími informačními prvky:
Vypočítejte nové dny od epochy odpovídající rozdělení velikosti y počtem 100 nanosekundových klíštěte v období 24 hodin, zkrátí se desetinná část výsledku a přičte tuto hodnotu ke dnům x od epochy.
Vypočítejte nová klíště od půlnoci, která odpovídá přidání velikosti y k od půlnoci x, modulo počet 100 nanosekundových ticků v 24hodinovém období. Pokud x nezadá hodnotu pro ticks od půlnoci, předpokládá se hodnota 0.
Zkopírujte hodnotu x pro minuty posunu od UTC beze změny.
Pokud není zadána hodnota datetime od hodnoty epochy, vytvořte nový datetime se zadanými následujícími informačními prvky:
Vypočítejte nová klíště od půlnoci, která odpovídá přidání velikosti y k od půlnoci x, modulo počet 100 nanosekundových ticků v 24hodinovém období. Pokud x nezadá hodnotu pro ticks od půlnoci, předpokládá se hodnota 0.
Zkopírujte hodnoty x pro dny od epochy a minut posunu od času UTC beze změny.
Následující příklady ukazují výpočet absolutního dočasného součtu, když datetime určuje dny od epochy:
#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
Následující příklad ukazuje výpočet posunu data a času podle doby trvání pro daný čas:
#time(8,0,0) + #duration(30,5,0,0)
//#time(13, 0, 0)
//13:00:00
Interpretace operátoru odčítání (x - y
) je závislá na druhu hodnoty vyhodnocených výrazů x
a y
následujícím způsobem:
linka | Y | Výsledek | Interpretace |
---|---|---|---|
type number |
type number |
type number |
Číselný rozdíl |
type number |
null |
null |
|
null |
type number |
null |
|
type duration |
type duration |
type duration |
Číselný rozdíl velikostí |
type duration |
null |
null |
|
null |
type duration |
null |
|
type
datetime |
type
datetime |
type duration |
Doba trvání mezi datetimes |
type
datetime |
type duration |
type
datetime |
Posun data a času o negovanou dobu trvání |
type
datetime |
null |
null |
|
null |
type
datetime |
null |
V tabulce type
představuje datum a čas libovolnou z type date
hodnot , type datetime
, type datetimezone
nebo type time
. Při odečtení doby trvání od hodnoty určitého typu datetime je výsledná hodnota stejného typu.
U jiných kombinací hodnot, než jsou hodnoty uvedené v tabulce, je vyvolána chyba s kódem "Expression.Error"
důvodu. Každá kombinace je popsána v následujících částech.
Chyby vyvolané při vyhodnocování jednoho operandu se rozšíří.
Rozdíl mezi dvěma čísly se vypočítá pomocí operátoru odčítání a vytvoří číslo. Příklad:
1 - 1 // 0
#nan - #infinity // #nan
Operátor -
odčítání nad čísly používá dvojitou přesnost. Funkci standardní knihovny Value.Subtract
lze použít k určení desetinné přesnosti. Při výpočtu rozdílu čísel platí následující:
Rozdíl v dvojité přesnosti se vypočítá podle pravidel 64bitové binární dvojité přesnosti IEEE 754 aritmetické IEEE 754-2008. Následující tabulka uvádí výsledky všech možných kombinací nenulových konečných hodnot, nul, infinit a naN. V tabulce
x
ay
jsou nenulové konečné hodnoty az
je výsledkemx - y
. Pokudx
ay
jsou rovny,z
je kladná nula. Pokudx - y
je příliš velký, aby byl reprezentován v cílovém typu,z
je nekonečno se stejným znaménkem jakox - y
.- y +0 0 až +∞ -∞ Není číslo x z linka linka -∞ +∞ Není číslo +0 -y +0 +0 -∞ +∞ Není číslo -0 -y 0 až +0 -∞ +∞ Není číslo +∞ +∞ +∞ +∞ Není číslo +∞ Není číslo -∞ -∞ -∞ -∞ -∞ Není číslo Není číslo Nan Není číslo Není číslo Není číslo Není číslo Není číslo Není číslo Rozdíl v desítkové přesnosti se vypočítá bez ztráty přesnosti. Měřítko výsledku je větší z měřítka dvou operandů.
Rozdíl dvou dob trvání představuje rozdíl mezi počtem 100 nanosekundových ticků reprezentovaných každou dobou trvání. Příklad:
#duration(1,2,30,0) - #duration(0,0,0,30.45)
// #duration(1, 2, 29, 29.55)
K x
a dobu trvání.y
Zde představuje datum a čas libovolnou z date
, datetime
, datetimezone
nebo time
. Výsledný datetime má vzdálenost od x
lineární časové osy, která je přesně velikost y
, ve směru proti znaménku y
. Odečtení kladných dob trvání vrátí výsledky, které jsou zpětně relativní vzhledem k x
, zatímco odečtení záporných hodnot vrátí výsledky, které jsou v čase dopředu.
#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
Dva data a časyt
a u
je možné je odečíst pomocí k t - u
výpočtu doby trvání mezi nimi.
Zde představuje datum a čas libovolnou z date
, datetime
, datetimezone
nebo time
. Doba trvání získaná odečtením u
od t
musí být přičtována t
k 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
Odečtení t - u
, když u > t
výsledkem je záporná doba trvání:
#time(01,30,00) - #time(08,00,00)
// #duration(0, -6, -30, 0)
Při odečítání dvou hodnot datetime pomocí t - u
:
- u + (t - u) = t
Interpretace operátoru násobení (x * y
) závisí na druhu hodnoty vyhodnocených výrazů x a y následujícím způsobem:
X | Y | Výsledek | Interpretace |
---|---|---|---|
type number |
type number |
type number |
Číselný produkt |
type number |
null |
null |
|
null |
type number |
null |
|
type duration |
type number |
type duration |
Násobek doby trvání |
type number |
type duration |
type duration |
Násobek doby trvání |
type duration |
null |
null |
|
null |
type duration |
null |
U jiných kombinací hodnot, než jsou hodnoty uvedené v tabulce, je vyvolána chyba s kódem "Expression.Error"
důvodu. Každá kombinace je popsána v následujících částech.
Chyby vyvolané při vyhodnocování jednoho operandu se rozšíří.
Součin dvou čísel se vypočítá pomocí operátoru násobení a vytvoří číslo. Příklad:
2 * 4 // 8
6 * null // null
#nan * #infinity // #nan
Operátor *
násobení čísel používá dvojitou přesnost. Standardní funkce Value.Multiply
knihovny lze použít k určení desetinné přesnosti. Při výpočtu součinu čísel platí následující:
Produkt s dvojitou přesností se vypočítá podle pravidel 64bitové binární dvojité přesnosti IEEE 754 aritmetické IEEE 754-2008. Následující tabulka uvádí výsledky všech možných kombinací nenulových konečných hodnot, nul, infinit a naN. V tabulce
x
jsouy
kladné konečné hodnoty.z
je výsledkem .x * y
Pokud je výsledek pro cílový typ příliš velký,z
je nekonečno. Pokud je výsledek pro cílový typ příliš malý,z
je nula.* +y -y +0 0 až +∞ -∞ Není číslo +x +z -z +0 0 až +∞ -∞ Není číslo -x -z +z 0 až +0 -∞ +∞ Není číslo +0 +0 0 až +0 0 až Není číslo Není číslo Není číslo -0 0 až +0 0 až +0 Není číslo Není číslo Není číslo +∞ +∞ -∞ Není číslo Není číslo +∞ -∞ Není číslo -∞ -∞ +∞ Není číslo Není číslo -∞ +∞ Není číslo Nan Není číslo Není číslo Není číslo Není číslo Není číslo Není číslo Není číslo Součin v desetinné přesnosti se vypočítá bez ztráty přesnosti. Měřítko výsledku je větší z měřítka dvou operandů.
Součin doby trvání a číslo je doba trvání představující počet 100nanosekondů, které představují operand doby trvání krát číselný operand. Příklad:
#duration(2,1,0,15.1) * 2
// #duration(4, 2, 0, 30.2)
Interpretace operátoru dělení (x / y
) závisí na druhu hodnoty vyhodnocených výrazů x
a y
následujícím způsobem:
X | Y | Výsledek | Interpretace |
---|---|---|---|
type number |
type number |
type number |
Číselný podíl |
type number |
null |
null |
|
null |
type number |
null |
|
type duration |
type number |
type duration |
Zlomek doby trvání |
type duration |
type duration |
type number |
Číselný podíl dob trvání |
type duration |
null |
null |
|
null |
type duration |
null |
U jiných kombinací hodnot, než jsou hodnoty uvedené v tabulce, je vyvolána chyba s kódem "Expression.Error"
důvodu. Každá kombinace je popsána v následujících částech.
Chyby vyvolané při vyhodnocování jednoho operandu se rozšíří.
Podíl dvou čísel se vypočítá pomocí operátoru dělení a vytvoří číslo. Příklad:
8 / 2 // 4
8 / 0 // #infinity
0 / 0 // #nan
0 / null // null
#nan / #infinity // #nan
Operátor /
dělení nad čísly používá dvojitou přesnost. Standardní funkce Value.Divide
knihovny lze použít k určení desetinné přesnosti. Při výpočtu podílu čísel platí následující:
Podíl v dvojité přesnosti se vypočítá podle pravidel 64bitové binární dvojité přesnosti IEEE 754 aritmetické IEEE 754-2008. Následující tabulka uvádí výsledky všech možných kombinací nenulových konečných hodnot, nul, infinit a naN. V tabulce
x
jsouy
kladné konečné hodnoty.z
je výsledkem .x / y
Pokud je výsledek pro cílový typ příliš velký,z
je nekonečno. Pokud je výsledek pro cílový typ příliš malý,z
je nula./ +y -y +0 0 až +∞ -∞ Není číslo +x +z -z +∞ -∞ +0 0 až Není číslo -x -z +z -∞ +∞ 0 až +0 Není číslo +0 +0 0 až Není číslo Není číslo +0 0 až Není číslo -0 0 až +0 Není číslo Není číslo 0 až +0 Není číslo +∞ +∞ -∞ +∞ -∞ Není číslo Není číslo Není číslo -∞ -∞ +∞ -∞ +∞ Není číslo Není číslo Není číslo Nan Není číslo Není číslo Není číslo Není číslo Není číslo Není číslo Není číslo Součet v desetinné přesnosti se vypočítá bez ztráty přesnosti. Měřítko výsledku je větší z měřítka dvou operandů.
Podíl dvou dob trvání je číslo představující podíl počtu 100nanosekondů představovaných dobami trvání. Příklad:
#duration(2,0,0,0) / #duration(0,1,30,0)
// 32
Podíl doby trvání x
a čísla y
je doba trvání představující podíl počtu 100 nanosekundových ticků reprezentovaných dobou trvání x
a číslem y
. Příklad:
#duration(2,0,0,0) / 32
// #duration(0,1,30,0)
Operátor kombinace (x & y
) je definován v následujících typech hodnot:
X | Y | Výsledek | Interpretace |
---|---|---|---|
type text |
type text |
type text |
Zřetězení |
type text |
null |
null |
|
null |
type text |
null |
|
type date |
type time |
type datetime |
Sloučení |
type date |
null |
null |
|
null |
type time |
null |
|
type list |
type list |
type list |
Zřetězení |
type record |
type record |
type record |
Sloučení |
type table |
type table |
type table |
Zřetězení |
Dva texty, dva seznamy nebo dvě hodnoty tabulky mohou být zřetězeny pomocí x & y
.
Následující příklad znázorňuje zřetězení textových hodnot:
"AB" & "CDE" // "ABCDE"
Následující příklad znázorňuje zřetězení seznamů:
{1, 2} & {3} // {1, 2, 3}
Při zřetězení dvou hodnot pomocí x & y
:
Chyby vyvolané při vyhodnocování
x
výrazů neboy
výrazů se šíří.Pokud položka nebo
x
y
obsahuje chybu, není šířena žádná chyba.Výsledkem zřetězení dvou textových hodnot je textová hodnota, která obsahuje hodnotu x, za kterou bezprostředně následuje y. Pokud je některý z operandů null a druhý je textová hodnota, výsledek je null.
Výsledkem zřetězení dvou seznamů je seznam, který obsahuje všechny položky
x
následované všemi položkamiy
.Výsledkem zřetězení dvou tabulek je tabulka, která má sjednocení sloupců obou operandů. Pořadí sloupců
x
je zachováno, následované sloupci, které se zobrazují pouze vy
, zachovávají jejich relativní pořadí. Pro sloupce, které se zobrazují pouze v jednom z operandů,null
slouží k vyplnění hodnot buněk druhého operandu.
Dva záznamy lze sloučit pomocí x & y
, vytvořit záznam, který obsahuje pole z obou x
a y
.
Sloučení záznamů znázorňuje následující příklady:
[ x = 1 ] & [ y = 2 ] // [ x = 1, y = 2 ]
[ x = 1, y = 2 ] & [ x = 3, z = 4 ] // [ x = 3, y = 2, z = 4 ]
Při slučování dvou záznamů pomocí x + y
:
Chyby vyvolané při vyhodnocování
x
výrazů neboy
výrazů se šíří.Pokud se pole zobrazí v obou
x
polích,y
použije se hodnota zy
.Pořadí polí ve výsledném záznamu je v
x
pořadí , po kterém následují pole, kteráy
nejsou součástíx
, ve stejném pořadí, vy
jakém se zobrazují .Sloučení záznamů nezpůsobí vyhodnocení hodnot.
Není vyvolána žádná chyba, protože pole obsahuje chybu.
Výsledkem je záznam.
Datum x
lze sloučit s časem y
pomocí , x & y
vytvoří datum a čas, který kombinuje části z obou x
a y
.
Následující příklad znázorňuje sloučení data a času:
#date(2013,02,26) & #time(09,17,00)
// #datetime(2013,02,26,09,17,00)
Při slučování dvou záznamů pomocí x + y
:
Chyby vyvolané při vyhodnocování
x
výrazů neboy
výrazů se šíří.Výsledkem je datum a čas.
Operátory , +
a -
operátory not
jsou unární operátory.
unární výraz:
type-expression
+
unární výraz
-
unární výraz
not
unární výraz
Unární operátor plus (+x
) je definován pro následující typy hodnot:
X | Výsledek | Interpretace |
---|---|---|
type number |
type number |
Unární plus |
type duration |
type duration |
Unární plus |
null |
Null |
U jiných hodnot je vyvolána chyba s kódem "Expression.Error"
důvodu.
Unární operátor plus umožňuje použít znaménko +
na číslo, datum a čas nebo hodnotu null. Výsledek je stejná hodnota. Příklad:
+ - 1 // -1
+ + 1 // 1
+ #nan // #nan
+ #duration(0,1,30,0) // #duration(0,1,30,0)
Při vyhodnocování unárního operátoru +x
plus platí následující:
Chyby vyvolané při vyhodnocování
x
se rozšíří.Pokud výsledek vyhodnocení
x
není číselná hodnota, vyvolá se chyba s kódem"Expression.Error"
důvodu.
Operátor unární minus (-x
) je definován pro následující typy hodnot:
X | Výsledek | Interpretace |
---|---|---|
type number |
type number |
Negace |
type duration |
type duration |
Negace |
null |
null |
U jiných hodnot je vyvolána chyba s kódem "Expression.Error"
důvodu.
Operátor unární minus slouží ke změně znaménka čísla nebo doby trvání. Pří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)
Při vyhodnocování operátoru -x
unární minus platí následující:
Chyby vyvolané při vyhodnocování
x
se rozšíří.Pokud je výraz číslo, výsledek je číselná hodnota z výrazu
x
se změněným symbolem. Pokud je hodnota NaN, výsledek je také NaN.
Logický operátor negace (not
) je definován pro následující typy hodnot:
X | Výsledek | Interpretace |
---|---|---|
type logical |
type logical |
Negace |
null |
null |
Tento operátor vypočítá logickou not
operaci s danou logickou hodnotou. Příklad:
not true // false
not false // true
not (true and true) // false
Při vyhodnocování logického operátoru not x
negace platí následující:
Chyby vyvolané při vyhodnocování
x
se rozšíří.Hodnota vytvořená z vyhodnocení výrazu x musí být logická hodnota nebo musí být vyvolána chyba s kódem
"Expression.Error"
důvodu. Pokud jetrue
hodnota , výsledek jefalse
. Pokud jefalse
operand , výsledek jetrue
.
Výsledkem je logická hodnota.
Operátory is
a as
jsou známé jako operátory typu.
Operátor x is y
kompatibility typů je definován pro následující typy hodnot:
X | Y | Výsledek |
---|---|---|
type any |
nullable-primitive-type | type logical |
Výraz x is y
vrátí true
, pokud přiřazený typ x
je kompatibilní s y
, a vrátí false
, pokud přiřazený typ x
není kompatibilní s y
.
y
musí být primitivní typ s možnou hodnotou null.
is-expression:
as-expression
is-expressionis
nullable-primitive-type
nullable-primitive-type:
nullable
opt primitive-type
Kompatibilita typů podporovaná operátorem is
je podmnožinou obecné kompatibility typů a je definována pomocí následujících pravidel:
Pokud
x
je hodnota null, je kompatibilní, pokudy
je typany
, typnull
nebo typ s možnou hodnotou null.Pokud
x
není null, pak pokud je kompatibilní, pokud primitivní typx
je stejný jakoy
.
Při vyhodnocování výrazu x is y
platí následující:
- Při vyhodnocování výrazu
x
se rozšíří chyba.
Operátor x as y
kontrolního výrazu typu je definován pro následující typy hodnot:
X | Y | Výsledek |
---|---|---|
type any |
nullable-primitive-type | type any |
x as y
Výraz tvrdí, že hodnota x
je kompatibilní s operátorem y
is
. Pokud není kompatibilní, vyvolá se chyba.
y
musí být typu nullable-primitive-type.
as-expression:
výraz rovnosti
as-expressionas
nullable-primitive-type
Výraz x as y
se vyhodnotí takto:
Provede se kontrola
x is y
kompatibility typů a kontrolní výraz vrátíx
beze změny, pokud je test úspěšný.Pokud kontrola kompatibility selže, vyvolá se chyba s kódem
"Expression.Error"
důvodu.
Příklady:
1 as number // 1
"A" as number // error
null as nullable number // null
Při vyhodnocování výrazu x as y
platí následující:
- Při vyhodnocování výrazu
x
se rozšíří chyba.
Operátor ??
coalesce vrátí výsledek levého operandu, pokud není null, jinak vrátí výsledek jeho pravého operandu. Pravý operand se vyhodnotí, pokud je levý operand null.