Čítať v angličtine

Zdieľať cez


Správanie operátorov

Táto časť definuje správanie rôznych operátorov jazyka M.

Poradie operátorov podľa priority

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 xmetay 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 xasy Je kompatibilným typom alebo chybou nullable-primitive
Zhoda typu xisy Otestovať, či je kompatibilným typom nullable-primitive
Logický operátor AND xandy Skratová konjunkcia
Logický operátor OR xory Skratová disjunkcia
Coalesce x??y Operátor coalescing null

Operátory a metaúdaje

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.

Štrukturálne rekurzívne operátory

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

Operátory výberu a projekcie umožňujú extrahovanie údajov z hodnôt zoznamu a záznamov.

Prístup k položke

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 čísla yje to položka zoznamu x na pozícii y. 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 čísla yje to riadok tabuľky x na pozícii y. 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áznamu yje to riadok tabuľky x , ktorý zodpovedá hodnotám polí záznamu y 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 alebo y sa rozšíria.

  • Výraz x vyprodukuje zoznam alebo hodnotu tabuľky.

  • Výraz y vyprodukuje číselnú hodnotu alebo, ak x 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 hodnota y je väčšia alebo rovná počtu x, vyskytne sa chyba s kódom "Expression.Error" príčiny , pokiaľ sa nepoužije voliteľný formát x{y}? operátora , pričom v takom prípade sa vráti hodnota null .

  • Ak x vyprodukuje hodnotu tabuľky a y vyprodukuje hodnotu záznamu a neobsahuje žiadne zhody pre yx, vyskytne sa chyba s kódom "Expression.Error" príčiny , pokiaľ sa nepoužije voliteľný formát x{y}? operátora , pričom v takom prípade sa vráti hodnota null .

  • Ak x vyprodukuje hodnotu tabuľky a y vyprodukuje hodnotu záznamu, pričom obsahuje yviaceré zhody pre x , 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.)

Prístup k poľu

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 , y1y2, ...). 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ľu ya potom sa rozšíria. Pri každom budúcom prístupe k poľu y 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é neexistuje x, 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 hodnota null .

Počas procesu prístupu k poľu x sa nevyhodnotia žiadne iné polia okrem polí pomenovaných podľa y hodnoty .

Operátor metaúdajov

Záznam metaúdajov hodnoty sa mení pomocou meta operátora (x meta y).

metadata-expression:
      unary-expression
      unary-expression
metaunary-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 ykombinujúce metaúdaje platí toto:

  • Chyby vzniknuté pri vyhodnocovaní x výrazov alebo y 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 xzáznam metaúdajov výrazu zlúčený s výrazom y. (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átory rovnosti

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 <> yplatí toto:

  • Chyby vzniknuté pri vyhodnocovaní x výrazov alebo y sa rozšíria.

  • Ak = sa hodnoty rovnajú, operátor má výsledok true , v false opačnom prípade to bude .

  • Ak <> sa hodnoty rovnajú, operátor má výsledok false , v true opačnom prípade to bude .

  • Záznamy metaúdajov nie sú zahrnuté v porovnaní.

  • Ak hodnoty vygenerované vyhodnotením x výrazov a y nie sú rovnakým druhom hodnoty, hodnoty sa nerovná.

  • Ak hodnoty vygenerované vyhodnotením výrazov x and y 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 a false 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.

Relačné operátory

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 trueHodnota , ak x je menšie ako alebo sa rovná , y v opačnom prípade hodnota false
x >= y trueHodnota , 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 alebo y sa rozšíria.

  • Hodnoty vygenerované vyhodnotením oboch x výrazov a y 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 je null 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 ako false.

  • Dve čísla x a y sa porovnávajú podľa pravidiel štandardu IEEE 754:

    • Ak niektorý operand je #nan, výsledok je false 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 -#infinityhodnote .

      • Hodnota #infinity sa považuje za väčšiu ako všetky ostatné číselné hodnoty, ale rovná sa ďalšej #infinityhodnote .

  • 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.

Podmienkové logické operátory

Operátory a and sa or nazývajú podmienkové logické operátory.

logical-or-expression:
      logical-and-expression
logical-and-expression
orlogical-or-expression
logical-and-expression:
      is-expression
      is-expression
andlogical-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 trueje .

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 falseje .

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 alebo y sa rozšíria.

  • Podmienkové logické operátory sú definované v typoch logical a null. 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 alebo ysa výraz y vyhodnotí vtedy a len vtedy, ak x sa nevyhodnotí ako true.

  • Vo výraze x a ysa výraz y vyhodnotí vtedy a len vtedy, ak x sa nevyhodnotí ako false.

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

Aritmetické operátory

Operátory +, -*a /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

Presnosť

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

Operátor sčítania

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.

Číselný súčet

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 a y nenulové konečné hodnoty a z je výsledkom x + y. Ak x a y majú rovnaký rozsah, ale opačné znamienka, z je kladná nula. Ak x + y je príliš veľké na znázornenie v cieľovom type, z je nekonečná hodnota s rovnakým znamienkom ako x + 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 trvaní

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)

Posun hodnoty datetime podľa trvania

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

Operátor odčítania

Interpretácia operátora odčítania (x - y) závisí od druhu hodnoty vyhodnotených výrazov x a ynasledovne:

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.

Číselný rozdiel

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 a y nenulové konečné hodnoty a z je výsledkom x - y. Ak x a y sú rovné, z je kladná nula. Ak x - y je príliš veľké na znázornenie v cieľovom type, z je nekonečná hodnota s rovnakým znamienkom ako x - 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 trvaní

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)

Posun hodnoty datetime podľa negovaného trvania

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

Trvanie medzi dvomi hodnotami datetime

Dve hodnoty datetimet a u možno odčítať pomocou t - u a vypočítať tak trvanie medzi nimi. Hodnota datetime tu predstavuje , date, datetimedatetimezonealebo 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 - uplatí toto:

  • u + (t - u) = t

Operátor násobenia

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.

Číselný súčin

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 a y kladné konečné hodnoty. zhodnota 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.

Násobky trvania

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)

Operátor delenia

Interpretácia operátora delenia (x / y) závisí od druhu hodnoty vyhodnotených výrazov x a ynasledovne:

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.

Číselný podiel

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 a y kladné konečné hodnoty. zhodnota 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 trvaní

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

Škálované trvania

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)

Kombinácia štruktúry

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

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 & yplatí toto:

  • Chyby vzniknuté pri vyhodnocovaní x výrazov alebo y sa rozšíria.

  • Ak položka x alebo y 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ú ystĺ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.

Zlúčenie

Zlúčenie záznamov

Dva záznamy je možné zlúčiť pomocou x & y, pričom sa vygeneruje záznam obsahujúci polia, ktoré obsahuje aj xy.

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 + yplatí toto:

  • Chyby vzniknuté pri vyhodnocovaní x výrazov alebo y sa rozšíria.

  • Ak sa pole zobrazí v rámci aj xy, použije sa hodnota v y .

  • Poradie polí vo výslednom zázname je určené xpodľa , potom nasledujú polia, y ktoré obsahuje a neobsahuje x, v rovnakom poradí, v akom ich zobrazuje y.

  • 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.

Zlúčenie dátumu a času

Dátum x je možné zlúčiť s časom y pomocou x & y, pričom sa vygeneruje hodnota datetime, ktorá kombinuje časti aj xy .

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 + yplatí toto:

  • Chyby vzniknuté pri vyhodnocovaní x výrazov alebo y sa rozšíria.

  • Výsledkom je hodnota datetime.

Unárne operátory

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

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

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 -xmí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

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 xlogickej 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 je true, výsledok je false. Ak operand je false, výsledok je true.

Výsledkom je logická hodnota.

Operátory typu

Operátory is a as sa označujú ako operátory typu.

Operátor kompatibility typov

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-expression
isnullable-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á, ak y ide o typ any, typ nullalebo typ s povolenou hodnotou null.

  • Ak x hodnota nie je null, potom je kompatibilná, ak primitívny typ x je rovnaký ako y.

Pri vyhodnocovaní výrazu x is yplatí toto:

  • Chyba, ktorá sa vyskytne pri vyhodnocovaní výrazu x , sa rozšíri.

Operátor kontrolného výrazu typu

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. yHodnota musí byť nullable-primitive-type.

as-expression:
      equality-expression
      as-expression
asnullable-primitive-type

Výraz x as y sa vyhodnotí takto:

  • Vykoná sa kontrola x is y kompatibility typov a kontrolný výraz vráti x 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 yplatí toto:

  • Chyba, ktorá sa vyskytne pri vyhodnocovaní výrazu x , sa rozšíri.

Operátor Coalesce

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.