Sdílet prostřednictvím

Chování operátoru

Tato část definuje chování různých operátorů jazyka M.

Priorita operátorů

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 xmetay 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 Nerovná se
Kontrolní výraz typu xasy Je kompatibilní primitivní nebo primitivní typ nebo chyba s možnou hodnotou null.
Shoda typu xisy Test, jestli je typ kompatibilní s primitivním typem nebo primitivním typem s možnou hodnotou null
Logický operátor AND xandy Zkratové spojení
Logický operátor OR xory Zkratová disjunkce
Coalesce x??y Operátor sjednocení s hodnotou Null

Operátory a metadata

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.

Rekurzivní operátory strukturálně

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

Operátory výběru a projekce umožňují extrahovat data ze seznamu a hodnot záznamů.

Přístup k položce

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 číslo ypoložka seznamu x na pozici y. 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 číslo y, řádek tabulky x na pozici y. 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áznam yje řádek tabulky x , který odpovídá hodnotám polí záznamu y 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 xneexistuje . 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 nebo y se šíří.

  • Výraz x vytvoří seznam nebo hodnotu tabulky.

  • Výraz y vytvoří číselnou hodnotu, nebo pokud x vytvoří hodnotu tabulky, hodnotu záznamu.

  • Pokud y vytvoří číselnou hodnotu a hodnota y je záporná, vyvolá se chyba s kódem "Expression.Error" důvodu.

  • Pokud y vytvoří číselnou hodnotu a hodnota y je větší nebo rovna počtu x, 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í hodnota null .

  • Pokud x vytvoří hodnotu tabulky a y vytvoří hodnotu záznamu a neobsahuje žádné shody, yxvyvolá 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 hodnota null vrátí.

  • Pokud x vytvoří hodnotu tabulky a y vytvoří hodnotu záznamu a existuje více shod pro y in x, 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.)

Přístup k poli

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 y1hodnotou , 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 poli ya následně se rozšíří. Jakýkoli budoucí přístup k poli y 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 neexistuje x, 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í hodnota null .

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.

Operátor metadat

Záznam metadat pro hodnotu se mění pomocí operátoru meta (x meta y).

výraz metadat:
      unary-expression
      unary-expressionmetaunary-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 ykombinování metadat platí následující:

  • Chyby vyvolané při vyhodnocování x výrazů nebo y 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 xzáznam metadat sloučený s y. (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átory rovnosti

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 = yx <> yrovnosti platí následující:

  • Chyby vyvolané při vyhodnocování x výrazů nebo y výrazů se šíří.

  • Operátor = má výsledek true , jestli jsou hodnoty stejné, a false jinak.

  • Operátor <> má výsledek false , jestli jsou hodnoty stejné, a true 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 a y 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 se false 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 #nanně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.

Relační operátory

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 xy se šíří.

  • Hodnoty vytvořené vyhodnocením xy 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 nulloperandy nebo oba operandy , je null 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 a y porovnávají se podle pravidel standardu IEEE 754:

    • Pokud je #nanněkterý z operandů , výsledek je false 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.

Podmíněné logické operátory

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-expressionorlogical-or-expression
logický výraz:
      is-expression
      is-expressionandlogical-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ů nebo y výrazů se šíří.

  • Podmíněné logické operátory jsou definovány nad typy logical a null. 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 nebo yse výraz y vyhodnotí, pokud a pouze v případě, že x se nevyhodnotí jako true.

  • Ve výrazu x a yvýraz y bude vyhodnocen, pokud a pouze v případě, že x se nevyhodnocuje na false.

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

Aritmetické operátory

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

Počet deset. míst

Čí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.

operátor sčítání

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 typepředstavuje datum a čas libovolnou z type datehodnot , type datetime, type datetimezonenebo 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šíří.

Číselný součet

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 a y jsou nenulové konečné hodnoty a z je výsledkem x + y. Pokud x a y mají stejnou velikost, ale opačné znaky, z je kladná nula. Pokud x + y je příliš velký, aby byl reprezentován v cílovém typu, z je nekonečno se stejným znaménkem jako x + 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 dob trvání

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)

Posun data a času podle doby trvání

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, DateTimeZonenebo 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

operátor odčítání

Interpretace operátoru odčítání (x - y) je závislá na druhu hodnoty vyhodnocených výrazů x a yná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 typepředstavuje datum a čas libovolnou z type datehodnot , type datetime, type datetimezonenebo 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šíří.

Číselný rozdíl

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 a y jsou nenulové konečné hodnoty a z je výsledkem x - y. Pokud x a y jsou rovny, z je kladná nula. Pokud x - y je příliš velký, aby byl reprezentován v cílovém typu, z je nekonečno se stejným znaménkem jako x - 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 doby trvání

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)

Posun data a času o negovanou dobu trvání

K x a dobu trvání.y Zde představuje datum a čas libovolnou z date, datetime, datetimezonenebo 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

Doba trvání mezi dvěma hodnotami datetime

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, datetimezonenebo 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

operátor násobení

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šíří.

Číselný produkt

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 jsou y kladné konečné hodnoty. zje 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ů.

Násobky doby trvání

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)

operátor dělení

Interpretace operátoru dělení (x / y) závisí na druhu hodnoty vyhodnocených výrazů x a yná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šíří.

Číselný podíl

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 jsou y kladné konečné hodnoty. zje 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 dob trvání

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

Škálované doby trvání

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)

Kombinace struktury

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í

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ů nebo y výrazů se šíří.

  • Pokud položka nebo xy 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žkami y.

  • 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 v y, 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.

Sloučení

Sloučení záznamů

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ů nebo y výrazů se šíří.

  • Pokud se pole zobrazí v obou x polích, ypoužije se hodnota z y .

  • Pořadí polí ve výsledném záznamu je v xpořadí , po kterém následují pole, která y nejsou součástí x, ve stejném pořadí, v yjaké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.

Sloučení s datem a časem

Datum x lze sloučit s časem y pomocí , x & yvytvoří 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ů nebo y výrazů se šíří.

  • Výsledkem je datum a čas.

Unární operátory

Operátory , +a - operátory notjsou unární operátory.

unární výraz:
      type-expression
       + unární výraz
       - unární výraz
       not unární výraz

Jednočlenný operátor plus

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 +xplus 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.

Unární operátor minus

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 -xuná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

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 xnegace 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 je truehodnota , výsledek je false. Pokud je falseoperand , výsledek je true.

Výsledkem je logická hodnota.

Operátory typů

Operátory is a as jsou známé jako operátory typu.

Operátor kompatibility typů

Operátor x is y kompatibility typů je definován pro následující typy hodnot:

X Y Výsledek
type any primitive-or-nullable-primitive-type type logical

Výraz x is y vrátí true , pokud je přiřazený x typ kompatibilní s ya vrátí false , pokud není kompatibilní. y musí být primitivní typ nebo primitivní typ s možnou hodnotou null.

is-expression:
      as-expression
      is-expressionisprimitive-or-nullable-primitive-type
primitive-or-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í, pokud y je typ any, typ nullnebo primitivní typ s možnou hodnotou null.

  • Pokud x není null, je kompatibilní, pokud primitivní typ x je stejný jako y.

Při vyhodnocování výrazu x is yplatí následující:

  • Při vyhodnocování výrazu x se rozšíří chyba.

Operátor kontrolního výrazu typu

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 primitive-or-nullable-primitive-type type any

x as y Výraz tvrdí, že hodnota x je kompatibilní s operátorem yis. Pokud není kompatibilní, vyvolá se chyba. y musí být primitivní typ nebo primitivní typ s možnou hodnotou null.

as-expression:
      výraz rovnosti
      jako výrazasprimitive-or-nullable-primitive-type
primitive-or-nullable-primitive-type:
       nullable opt 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 yplatí následující:

  • Při vyhodnocování výrazu x se rozšíří chyba.

Operátor Coalesce

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.

  • Last updated on