Megosztás a következőn keresztül:

Operátorok viselkedése

  • Cikk

Ez a szakasz a különböző M operátorok viselkedését határozza meg.

Operátorok műveleti sorrendje

Ha egy kifejezés több operátort tartalmaz, az operátorok elsőbbsége határozza meg az egyes operátorok kiértékelésének sorrendjét. A kifejezés x + y * z kiértékelése például azért történik x + (y * z) , mert az * operátor nagyobb elsőbbséget élvez a bináris + operátornál. Az operátorok elsőbbséget a hozzá tartozó nyelvtani termelés definíciója határozza meg. Az additív kifejezés például a szorzókifejezésekáll, így az és + az - operátorok alacsonyabb elsőbbséget élveznek, mint az és + az - operátorok.

A zárójeles kifejezés élesítése az alapértelmezett sorrend módosítására használható.

zárójeles kifejezés:
       ( kifejezés)

Példa:

1 + 2 * 3       // 7 
(1 + 2) * 3     // 9

Az alábbi táblázat összefoglalja az M operátorokat, és felsorolja az operátorkategóriákat a legmagasabbtól a legalacsonyabbig tartó sorrendben. Az ugyanabban a kategóriában lévő operátorok elsőbbséget élveznek.

Kategória Expression Leírás
Elsődleges én
@ én		 Azonosító kifejezés
(x) Zárójeles kifejezés
x[i] Keresés
x{y} Elemhozzáférés
x(...) Függvényhívás
{x, y, ...} Lista inicializálása
[ i = x, ... ] Rekord inicializálása
... Nincs implementálva
Unáris + x Identitás
- x Tagadás
not x Logikai tagadás
Metaadatok xmetay Metaadatok társítása
Többtényezős x * y Szorzás
x / y Részleg
Adalékanyag x + y Összeadás
x - y Kivonás
Relációs x< y Kisebb mint
x > y Nagyobb mint
x<= y Kisebb vagy egyenlő
x >= y Nagyobb vagy egyenlő
Egyenlőség x = y Equal
x<> y Nem egyenlő
Típusmegjelenés xasy Kompatibilis nullable-primitív típussal vagy hibával
Típuskonformitás xisy Tesztelje, hogy kompatibilis-e nullable-primitív típus
Logikai ÉS xandy Rövidzárolás kötőszavai
Logikai VAGY xory Rövidzárolásos letiltás
Coalesce x??y Null szenesítési operátor

Operátorok és metaadatok

Minden értékhez tartozik egy rekordérték, amely további információkat tartalmazhat az értékről. Ezt a rekordot egy érték metaadatrekordjának nevezzük. A metaadatrekordok bármilyen értékhez társíthatók, akár .null Az ilyen társítás eredménye egy új érték a megadott metaadatokkal.

A metaadat-rekord csak egy reguláris rekord, amely tartalmazhat minden olyan mezőt és értéket, amelyet egy normál rekord képes, és maga is rendelkezik metaadatrekorddal. A metaadatrekordok értékhez való társítása "nem tolakodó". Nem változtatja meg az érték viselkedését az értékelésekben, kivéve azokat, amelyek kifejezetten ellenőrzik a metaadat-rekordokat.

Minden értékhez tartozik egy alapértelmezett metaadatrekord, még akkor is, ha nincs megadva. Az alapértelmezett metaadatrekord üres. Az alábbi példák egy szöveges érték metaadatrekordjának elérését mutatják be a Value.Metadata szabványos kódtárfüggvény használatával:

Value.Metadata( "Mozart" )   // []

A metaadatrekordok általában nem maradnak meg , ha egy értéket egy új értéket építő operátorral vagy függvénnyel használnak. Ha például két szöveges érték összefűzve van az & operátorral, az eredményül kapott szöveges érték metaadatai az üres rekord []. A következő kifejezések egyenértékűek:

"Amadeus " & ("Mozart" meta [ Rating = 5 ])  
"Amadeus " & "Mozart"

A standard kódtárfüggvények Value.RemoveMetadataValue.ReplaceMetadata segítségével eltávolítható az összes metaadat egy értékből, és lecserélhető egy érték metaadataira (ahelyett, hogy a metaadatokat esetleg meglévő metaadatokká egyesítené).

Az egyetlen olyan operátor, amely metaadatokat tartalmazó eredményeket ad vissza, a meta operátor.

Szerkezetileg rekurzív operátorok

Az értékek lehetnek ciklikusak. Példa:

let l = {0, @l} in l
// {0, {0, {0, ... }}}
[A={B}, B={A}]
// [A = {{ ... }}, B = {{ ... }}]

Az M a rekordok, listák és táblázatok lazán tartásával kezeli a ciklikus értékeket. Egy olyan ciklikus érték létrehozására tett kísérlet, amely nem profitál az interjected lazy strukturált értékekből, hibát eredményez:

[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"), 
// ]

Az M egyes operátorai szerkezeti rekurzióval vannak definiálva. A rekordok és listák egyenlőségét például a megfelelő rekordmezők és elemlisták egybefüggő egyenlősége határozza meg.

Nem ciklikus értékek esetén a strukturális rekurzió alkalmazása az érték véges bővülését eredményezi: a megosztott beágyazott értékek többször is bejárhatók, de a rekurziós folyamat mindig leáll.

A ciklikus értékek a szerkezeti rekurzió alkalmazásakor végtelenül tágulnak . Az M szemantikája nem tesz különleges szállást az ilyen végtelen bővítésekhez – például az egyenlőség ciklikus értékeinek összehasonlítására tett kísérlet általában elfogy az erőforrásokból, és kivételesen leáll.

Kijelölési és vetítési operátorok

A kijelölési és vetítési operátorok lehetővé teszik az adatok kinyert listáját és rekordértékeit.

Elemhozzáférés

Egy érték kiválasztható egy listából vagy táblából az adott listában vagy táblában lévő nulla alapú pozíciója alapján egy elemhozzáférési kifejezés használatával.

item-access-expression:
      elem kijelölése
      optional-item-selection
elem kijelölése:
      primary-expression{item-selector}
optional-item-selection:
      primary-expression{item-selector} ?
elemválasztó:
      kifejezés

Az elem-access-kifejezésx{y} a következőt adja vissza:

  • Egy lista x és egy szám yesetében a lista x elemet a pozícióban y. A lista első eleme nulla sorszámúnak minősül. Ha a kért pozíció nem szerepel a listában, hibaüzenet jelenik meg.

  • Táblázat x és szám yesetén a táblázat x sora a pozícióban y. A táblázat első sora nulla sorszámúnak minősül. Ha a kért pozíció nem szerepel a táblában, a rendszer hibát jelez.

  • Tábla x és rekord yesetén a tábla azon sora x , amely megfelel a megfelelő táblaoszlopneveknek megfelelő mezőnevekkel rendelkező mezők rekordértékeinek y . Ha a táblában nincs egyedi egyező sor, a program hibát jelez.

Példa:

{"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

Az elemhozzáférési kifejezés az űrlapot x{y}?is támogatja, amely akkor adja vissza null , ha a pozíció (vagy egyezés) y nem létezik a listában vagy a táblázatban x. Ha több egyezés is van, ya rendszer továbbra is hibát jelez.

Példa:

{"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

Az elemhozzáférés nem kényszeríti az elérni kívánttól eltérő lista- vagy táblaelemek kiértékelését. Példa:

{ error "a", 1, error "c"}{1}  // 1 
{ error "a", error "b"}{1}     // error "b"

Az elemhozzáférés-operátor x{y} kiértékelésekor a következők maradnak:

  • A kifejezések x kiértékelése során felmerülő vagy y propagált hibák.

  • A kifejezés x létrehoz egy listát vagy egy táblaértéket.

  • A kifejezés y egy számértéket, vagy ha x táblaértéket állít elő, rekordértéket állít elő.

  • Ha y számértéket állít elő, és értéke y negatív, a hiba okkóddal "Expression.Error" jelenik meg.

  • Ha y számértéket állít elő, és az érték y nagyobb vagy egyenlő a számmal x, akkor az okkóddal "Expression.Error" kapcsolatos hiba keletkezik, kivéve, ha az opcionális operátor űrlapot x{y}? használja, amely esetben az érték null lesz visszaadva.

  • Ha x táblaértéket állít elő, és y rekordértéket állít elő, és nincs egyezésyx, az okkóddal "Expression.Error" kapcsolatos hiba keletkezik, kivéve, ha az opcionális operátori űrlapot x{y}? használja, ebben az esetben az érték null lesz visszaadva.

  • Ha x táblaértéket állít elő, és y rekordértéket állít elő, és több egyezés y is szerepel benne x, a hiba okkóddal "Expression.Error" jelenik meg.

Az elemkijelölési folyamat során a pozíciótól xy eltérő elemek nem lesznek kiértékelve. (Streamelési listák vagy táblázatok esetén a rendszer kihagyja a pozíció y előtt álló elemeket vagy sorokat, ami a lista vagy tábla forrásától függően a kiértékelést okozhatja.)

Mezőhozzáférés

A mezőhozzáférés kifejezéssel kiválaszthat egy értéket egy rekordból, vagy kivetíthet egy rekordot vagy táblát egy olyanra, amelynek kevesebb mezője vagy oszlopa van.

mező-access-kifejezés:
      mező kijelölése
      implicit-target-field-selection
      vetítés
      implicit-target-projection
mezőválasztás:
      primary-expression field-selector
mezőválasztó:
      required-field-selector
      optional-field-selector
required-field-selector:
       [ mezőnév]
optional-field-selector:
       [ mezőnév] ?
mezőnév:
      generalized-identifier
      idézett azonosító
implicit-target-field-selection:
      mezőválasztó
vetítés:
      primary-expression required-projection
      primary-expression optional-projection
required-projection:
       [ required-selector-list]
opcionális vetítés:
       [ required-selector-list] ?
required-selector-list:
      required-field-selector
      required-selector-list,required-field-selector
implicit-target-projection:
      required-projection
      opcionális-vetítés

A mezőhozzáférés legegyszerűbb formája a mezőválasztás. Az operátor x[y] használatával keres egy mezőt egy rekordban mezőnév alapján. Ha a mező y nem létezik, xhibaüzenet jelenik meg. Az űrlap x[y]? az opcionális mezőkijelölés végrehajtására szolgál, és visszaadjanull, ha a kért mező nem szerepel a rekordban.

Példa:

[A=1,B=2][B]       // 2 
[A=1,B=2][C]       // error 
[A=1,B=2][C]?      // null

Több mező együttes elérését az operátorok támogatják a szükséges rekordvetítéshez és az opcionális rekordvetítéshez. Az operátor x[[y1],[y2],...] a rekordot egy új rekordra projekteli kevesebb mezővel (kijelölvey1: , y2). ... Ha egy kijelölt mező nem létezik, hibaüzenet jelenik meg. Az operátor x[[y1],[y2],...]? egy új rekordba helyezi a rekordot, és a program a kijelölt mezőket y1y2...használja, ha hiányzik null egy mező. Példa:

[A=1,B=2][[B]]           // [B=2] 
[A=1,B=2][[C]]           // error 
[A=1,B=2][[B],[C]]?      // [B=2,C=null]

Az űrlapok [y][y]? az azonosítóra (aláhúzásjelre) való rövid hivatkozásként _ támogatottak. A következő két kifejezés egyenértékű:

[A]                 
_[A]

Az alábbi példa a mezőhozzáférés rövidített formáját szemlélteti:

let _ = [A=1,B=2] in [A] //1

Az űrlap [[y1],[y2],...] és [[y1],[y2],...]? a rövidítések is támogatottak, és a következő két kifejezés is egyenértékű:

[[A],[B]]                 
_[[A],[B]]

A rövidített űrlap különösen hasznos a each rövidítéssel kombinálva, amely egyetlen, elnevezett _ paraméter függvényének bevezetésére használható (részletekért lásd az egyszerűsített deklarációkat). A két rövidítés együttesen leegyszerűsíti a gyakori, magasabb rendű funkcionális kifejezéseket:

List.Select( {[a=1, b=1], [a=2, b=4]}, each [a] = [b]) 
// {[a=1, b=1]}

A fenti kifejezés a következő, rejtélyesebb kinézetű longhand kifejezésnek felel meg:

List.Select( {[a=1, b=1], [a=2, b=4]}, (_) => _[a] = _[b]) 
// {[a=1, b=1]}

A mezőhozzáférés nem kényszeríti a hozzáférés alatt álló mezőkön kívül más mezők kiértékelését. Példa:

[A=error "a", B=1, C=error "c"][B]  // 1 
[A=error "a", B=error "b"][B]       // error "b"

A mezőhozzáférés-operátorok x[y]kiértékelésekor x[y]?x[[y]]x[[y]]? a következők a következők:

  • A kifejezés x kiértékelése során felmerülő hibák propagálása megtörténik.

  • A mező kiértékelésekor felmerülő hibák véglegesen a mezőhöz yyvannak társítva, majd propagálódnak. A mezőhöz y való jövőbeli hozzáférés azonos hibát fog eredményezni.

  • A kifejezés x rekord- vagy táblaértéket hoz létre, vagy hiba merül fel.

  • Ha az azonosító y olyan mezőt nevez el, amely nem létezik x, a rendszer okkóddal "Expression.Error" ellátott hibát jelez, kivéve, ha az opcionális operátor űrlapot ...? használja, amely esetben az érték null lesz visszaadva.

A mezőhozzáférés x folyamata során a névvel y nem rendelkező mezők nem lesznek kiértékelve.

Metaadat-operátor

Egy érték metaadatrekordja a meta operátor (x meta y) használatával módosul.

metaadat-kifejezés:
      unary-expression
      unary-expressionmetaunary-expression

Az alábbi példa egy metaadatrekorddal rendelkező szöveges értéket hoz létre az meta operátor használatával, majd az eredményként kapott érték metaadatrekordját a következővel Value.Metadataéri el:

Value.Metadata( "Mozart" meta [ Rating = 5 ] ) 
// [Rating = 5 ]
Value.Metadata( "Mozart" meta [ Rating = 5 ] )[Rating] 
// 5

A metaadat-egyesítési operátor x meta yalkalmazásakor az alábbiak érvényesek:

  • A rendszer a kifejezések kiértékelésekor xy felmerülő hibákat propagálja.

  • A y kifejezésnek rekordnak vagy okkóddal "Expression.Error" kapcsolatos hibának kell lennie.

  • Az eredményül kapott metaadatrekord a metaadatrekorddal xegyesítve vany. (A rekordegyesítés szemantikáját lásd: Rekordegyesítés.)

  • Az eredményül kapott érték a x kifejezés metaadatai nélküli értéke, amelyhez csatolták az újonnan kiszámított metaadatrekordot.

A standard kódtárfüggvények Value.RemoveMetadataValue.ReplaceMetadata segítségével eltávolítható az összes metaadat egy értékből, és lecserélhető egy érték metaadataira (ahelyett, hogy a metaadatokat esetleg meglévő metaadatokká egyesítené). A következő kifejezések egyenértékűek:

x meta y  
Value.ReplaceMetadata(x, Value.Metadata(x) & y) 
Value.RemoveMetadata(x) meta (Value.Metadata(x) & y)

Egyenlőségi operátorok

Az egyenlőség operátorral= állapítható meg, hogy két érték egyenlő-e. Az egyenlőtlenség-operátor<> segítségével állapítható meg, hogy két érték nem egyenlő-e.

egyenlőségi kifejezés:
      relációs kifejezés
      relációs-kifejezés=egyenlőség-kifejezés
      relációs-kifejezés<>egyenlőség-kifejezés

Példa:

1 = 1            // true 
1 = 2            // false 
1 <> 1           // false 
1 <> 2           // true 
null = true      // false 
null = null      // true

A metaadatok nem részei az egyenlőség vagy az egyenlőtlenség összehasonlításának. Példa:

(1 meta [ a = 1 ]) = (1 meta [ a = 2 ]) // true 
(1 meta [ a = 1 ]) = 1                  // true

Az egyenlőségi operátorok x = yx <> yalkalmazásakor a következők érvényesek:

  • A rendszer a kifejezések kiértékelésekor xy felmerülő hibákat propagálja.

  • Az = operátor eredménye true , ha az értékek egyenlőek, és false egyébként.

  • Az <> operátor eredménye false , ha az értékek egyenlőek, és true egyébként.

  • A metaadat-rekordok nem szerepelnek az összehasonlításban.

  • Ha a kifejezés és x a y kifejezés kiértékelésével előállított értékek nem azonos típusúak, akkor az értékek nem egyenlők.

  • Ha a kifejezés és x a y kifejezés kiértékelésével előállított értékek azonos típusúak, akkor az alábbiakban meghatározottak szerint meghatározott szabályok vannak annak meghatározására, hogy egyenlőek-e.

  • A következő mindig igaz:

    (x = y) = not (x <> y)

Az egyenlőségi operátorok a következő típusokhoz vannak definiálva:

  • Az null érték csak önmagával egyenlő.
    null = null    // true 
    null = true    // false 
    null = false   // false
  • A logikai értékek true csak false önmagukkal egyenlők. Példa:
    true = true      // true 
    false = false    // true 
    true = false     // false 
    true = 1         // false

  • A számokat a megadott pontosság alapján hasonlítjuk össze:

    • Ha bármelyik szám, #nanakkor a számok nem azonosak.

    • Ha egyik szám sem, #nanakkor a számokat a számérték bitszintű összehasonlításával hasonlítjuk össze.

    • #nan az egyetlen érték, amely nem egyenlő önmagával.

      Példa:

        1 = 1,              // true 
        1.0 = 1             // true 
        2 = 1               // false 
        #nan = #nan         // false 
        #nan <> #nan        // true

  • Két időtartam egyenlő, ha azonos számú 100 nanoszekundumos kullancsot jelölnek.

  • A két idő egyenlő, ha a részük (óra, perc, másodperc) nagysága egyenlő.

  • Két dátum egyenlő, ha a részük nagysága (év, hónap, nap) egyenlő.

  • Két dátum/idő egyenlő, ha a részük nagysága (év, hónap, nap, óra, perc, másodperc) egyenlő.

  • Két dátum/időzón egyenlő, ha a megfelelő UTC dátum/idő egyenlő. A megfelelő UTC dátum/idő időpont eléréséhez az órák/percek eltolása kivonva lesz a datetimezone datetime összetevőjéből.

  • Két szöveges érték egyenlő, ha egy sorszámos, kis- és nagybetűket megkülönböztető, kulturális szempontból nem érzékeny összehasonlítást használ, és azonos hosszúságú és egyenlő karakterekkel rendelkezik a megfelelő pozíciókban.

  • Két listaérték egyenlő, ha az alábbiak mindegyike igaz:

    • Mindkét lista azonos számú elemet tartalmaz.

    • A listákban lévő minden pozícióban megfelelő elem értéke egyenlő. Ez azt jelenti, hogy a listáknak nem csak egyenlő elemeket kell tartalmazniuk, hanem ugyanabban a sorrendben kell lenniük.

      Példa:

        {1, 2} = {1, 2}     // true 
  {2, 1} = {1, 2}     // false 
  {1, 2, 3} = {1, 2}  // false

  • Két rekord egyenlő, ha az alábbiak mindegyike igaz:

    • A mezők száma megegyezik.

    • Az egyik rekord minden mezőneve megtalálható a másik rekordban is.

    • Az egyik rekord mezőinek értéke megegyezik a másik rekord hasonló nevű mezőjével.

      Példa:

        [ 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

  • Két tábla egyenlő, ha az alábbiak mindegyike igaz:

    • Az oszlopok száma megegyezik.

    • Az egyik tábla minden oszlopneve megtalálható a másik táblában is.

    • A sorok száma megegyezik.

    • Minden sor azonos értékekkel rendelkezik a megfelelő cellákban.

      Példa:

        #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

  • A függvény értéke önmagával egyenlő, de lehet, hogy nem egyenlő egy másik függvényértékel. Ha két függvényérték egyenlőnek minősül, akkor a meghíváskor azonos módon fognak viselkedni.

    Két megadott függvényértéknek mindig ugyanaz az egyenlőségi kapcsolata lesz.

  • A típusérték önmagával egyenlő, de lehet, hogy nem egyenlő egy másik típusértékel. Ha két típusértéket egyenlőnek tekintünk, akkor azonosan fognak viselkedni a megfelelőség lekérdezésekor.

    Két megadott típusérték mindig ugyanazzal az egyenlőségi kapcsolatsal fog rendelkezni.

Relációs operátorok

A <, >, <=és >= operátorokat relációs operátoroknak nevezzük.

relációs kifejezés:
      additív kifejezés
      additív kifejezés<relációs kifejezés
      additív kifejezés>relációs kifejezés
      additív kifejezés<=relációs kifejezés
      additív kifejezés>=relációs kifejezés

Ezek az operátorok határozzák meg a két érték közötti relatív rendezési kapcsolatot, ahogyan az az alábbi táblázatban látható:

Művelet Eredmény
x < y true ha x kisebb, mint y, false ellenkező esetben
x > y true ha x nagyobb, mint y, false ellenkező esetben
x <= y true ha x kisebb vagy egyenlő y, false ellenkező esetben
x >= y true ha x nagyobb vagy egyenlő y, false ellenkező esetben

Példa:

0 <= 1            // true 
null < 1          // null 
null <= null      // null 
"ab" < "abc"      // true 
#nan >= #nan      // false  
#nan <= #nan      // false

A relációs operátorokat tartalmazó kifejezés kiértékelésekor az alábbiak érvényesek:

  • A rendszer az operandus vagy x az y operandus kifejezések kiértékelésekor felmerülő hibákat propagálja.

  • A kifejezés és x a y kifejezés kiértékelésével előállított értékeknek binárisnak, dátumnak, dátumnak, dátum-időnek, datetimezone-nak, időtartamnak, logikai, számnak, nullnak, szövegnek vagy időértéknek kell lenniük. Ellenkező esetben az okkóddal "Expression.Error" kapcsolatos hiba jelenik meg.

  • Mindkét operandusnak azonos értéknek nullvagy . Ellenkező esetben az okkóddal "Expression.Error" kapcsolatos hiba jelenik meg.

  • Ha vagy mindkét operandus, nullaz eredmény az null érték.

  • Két bináris fájlt hasonlít össze bájt bájtonként.

  • Két dátumot hasonlítunk össze az évrészek és ha egyenlők, a hónaprészek és ha egyenlők, a naprészek összehasonlításával.

  • Két dátumidőt hasonlítunk össze az évrészek és ha egyenlők, a hónaprészek és ha egyenlők, a naprészek, és ha egyenlők, az órarészek, és ha egyenlők, a percrészek, és ha egyenlők, a második részek.

  • Két dátum/időzónát hasonlítunk össze úgy, hogy normalizáljuk őket UTC-hez az óra/perc eltolás kivonásával, majd a dátum/idő összetevők összehasonlításával.

  • Két időtartamot hasonlítunk össze az általuk képviselt 100 nanoszekundumos kullancsok teljes száma alapján.

  • Két logikai értéket hasonlítunk össze, amelyek true nagyobbnak tekinthetők, mint false.

  • Két szám x , amelyeket y az IEEE 754 szabvány szabályai szerint hasonlítunk össze:

    • Ha bármelyik operandus is, #nanaz eredmény az false összes relációs operátorra lesz.

    • Ha egyik operandus #nansem, az operátorok összehasonlítják a két lebegőpontos operandus értékeit a rendezés -∞ < -max < ... < -min < -0.0 = +0.0 < +min < ... < +max < +∞ szempontjából, ahol a min és a max a legkisebb és legnagyobb pozitív véges érték, amely megjeleníthető. A -∞ és a +∞ M neve és -#infinity#infinity.

      A rendezés jelentős hatásai a következők:

      • A negatív és a pozitív nullák egyenlőnek minősülnek.

      • Az -#infinity értékek kisebbnek tekinthetők, mint az összes többi számérték, de egyenlőek egy másik -#infinityértékekkel.

      • Egy #infinity érték nagyobbnak tekinthető, mint az összes többi számérték, de egyenlő egy másik #infinityértékkel.

  • Két szöveget hasonlítunk össze karakterenkénti, betűrendes, kis- és nagybetűket megkülönböztető, kulturális szempontból érzéketlen összehasonlítással.

  • Két alkalommal hasonlítjuk össze az óra részeit, és ha egyenlő, a percrészeket, és ha egyenlő, a második részeket.

Feltételes logikai operátorok

Az and és or az operátorokat feltételes logikai operátoroknak nevezzük.

logikai vagy kifejezés:
      logikai és kifejezési
logikai és kifejezésiorlogikai vagy kifejezési
logikai és kifejezési:
      is-expression
      is-expressionandlogikai és kifejezés

Az or operátor akkor ad true vissza, ha legalább az egyik operandusa .true A jobb operandus akkor és csak akkor lesz kiértékelve, ha a bal operandus nem true.

Az and operátor akkor ad false vissza, ha legalább az egyik operandusa .false A jobb operandus akkor és csak akkor lesz kiértékelve, ha a bal operandus nem false.

Az alábbiakban a orand bal operandus kifejezés kiértékelésének eredménye látható a függőleges tengelyen, valamint a jobb operandus kifejezés kiértékelésének eredménye a vízszintes tengelyen.

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

A feltételes logikai operátorokat tartalmazó kifejezés kiértékelésekor az alábbiak érvényesek:

  • A rendszer a kifejezések kiértékelésekor xy felmerülő hibákat propagálja.

  • A feltételes logikai operátorok a típusok logical és nulla . Ha az operandus értékei nem ilyen típusúak, hiba lép fel az okkóddal "Expression.Error" .

  • Az eredmény logikai érték.

  • A kifejezésben x vagy ya kifejezés y akkor és csak akkor lesz kiértékelve, ha x nem.true

  • A kifejezésben xyés a kifejezés y akkor lesz kiértékelve, ha és csak akkor, ha x nem.false

Az utolsó két tulajdonság megadja a feltételes logikai operátorok "feltételes" minősítését; tulajdonságokkal, más néven "rövidzárolással". Ezek a tulajdonságok hasznosak kompakt védett predikátumok írásához. A következő kifejezések például egyenértékűek:

d <> 0 and n/d > 1 if d <> 0 then n/d > 1 else false

Számtani operátorok

A +, -* és / az operátorok a számtani operátorok.

additív kifejezés:
      multiplicative-expression
      additív kifejezés+multiplicative-expression
      additív kifejezés-multiplicative-expression
multiplicative-expression:
      metaadat-kifejezés
      multiplicative-expression*metadata-expression
      multiplicative-expression/metadata-expression

Pontosság

Az M-ben lévő számok különböző ábrázolások használatával vannak tárolva, hogy a lehető legtöbb információt megőrizzék a különböző forrásokból érkező számokról. A számokat csak a hozzájuk alkalmazott operátorok alakítja át az egyik ábrázolásból a másikba. Az M két pontosságot támogat:

Pontosság Szemantika
Precision.Decimal 128 bites decimális ábrázolás ±1,0 x 10-28 és ±7,9 x 1028 és 28-29 jelentős számjegyek tartományával.
Precision.Double Tudományos reprezentáció mantissa és kitevő használatával; megfelel a 64 bites bináris dupla pontosságú IEEE 754 aritmetikai standard IEEE 754-2008 szabványnak.

Az aritmetikai műveleteket úgy hajtjuk végre, hogy kiválasztunk egy pontosságot, mindkét operandust erre a pontosságra konvertáljuk (ha szükséges), majd végrehajtjuk a tényleges műveletet, és végül visszaadunk egy számot a választott pontosságban.

A beépített számtani operátorok (+, -, , */) dupla pontosságot használnak. A standard kódtárfüggvények (Value.Add, Value.Subtract, Value.Multiply, Value.Divide) egy adott pontossági modell használatával kérhetők le ezek a műveletek.

  • Numerikus túlcsordulás nem lehetséges: #infinity vagy -#infinity túl nagy értékeket jelöl ahhoz, hogy ábrázolni lehessen.

  • Numerikus alulcsordulás nem lehetséges: 0 és -0 olyan értékeket jelöl, amelyek túl kicsik ahhoz, hogy ábrázolhatók legyenek.

  • Az IEEE 754 speciális értéke #nan (NaN– Nem szám) aritmetikusan érvénytelen esetekre vonatkozik, például nullával való osztásra.

  • A decimálisról dupla pontosságúra történő konvertáláshoz a tizedes törteket a legközelebbi egyenértékű dupla értékre kell kerekíteni.

  • A dupla és a decimális pontosság közötti átalakítás úgy történik, hogy dupla számokat kerekítenek a legközelebbi egyenértékű decimális értékre, és szükség esetén túlcsordulnak az értékekre vagy #infinity értékekre-#infinity.

Összeadás operátor

Az összeadási operátor (x + y) értelmezése az x és y kiértékelt kifejezések értékétől függ az alábbiak szerint:

x y Eredmény Értelmezés
type number type number type number Numerikus összeg
type number null null
null type number null
type duration type duration type duration Numerikus magnitúdóösszeg
type duration null null
null type duration null
type datetime type duration type datetime Dátum/idő eltolás időtartam szerint
type duration type datetime type datetime
type datetime null null
null type datetime null

A táblázatban typea datetime az egyik type date, type datetimevagy type datetimezonetype timea . Egy időtartam és egy bizonyos típusú dátum/idő típusú érték hozzáadásakor az eredmény ugyanazzal a típussal történik.

A táblázatban felsorolt értékeken kívül más értékkombinációk esetén okkóddal "Expression.Error" kapcsolatos hiba jelenik meg. Az egyes kombinációkat a következő szakaszok ismertetik.

Az operandusok kiértékelésekor felmerülő hibák propagálása megtörténik.

Numerikus összeg

A két szám összegét az összeadás operátorral számítjuk ki, amely egy számot hoz létre.

Példa:

1 + 1             // 2 
#nan + #infinity  // #nan

A számokhoz való hozzáadás operátora + dupla pontosságot használ; a standard kódtárfüggvény Value.Add a Decimális pontosság megadására használható. A számok összegének kiszámításakor az alábbiak érvényesek:

  • A dupla pontosságú összeg kiszámítása a 64 bites bináris duplapreciziós IEEE 754 aritmetikai IEEE 754-2008 szabályai szerint történik. Az alábbi táblázat a nem véges értékek, nullák, végtelenek és NaN-értékek összes lehetséges kombinációjának eredményeit sorolja fel. A táblában xy nem véges értékek, és z a x + y. x Ha y és ugyanolyan nagyságú, de ellentétes jelek, z pozitív nulla. Ha x + y túl nagy ahhoz, hogy a céltípusban szerepeljen, akkor a végtelen ugyanazzal a jellel van jelölve, z mint x + ya .

    + 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

  • A decimális pontosságú összeg kiszámítása a pontosság elvesztése nélkül történik. Az eredmény skálája a két operandus skálái közül a nagyobb.

Időtartamok összege

A két időtartam összege az időtartam, amely az időtartamok által képviselt 100nanosecond kullancsok számának összegét jelöli. Példa:

#duration(2,1,0,15.1) + #duration(0,1,30,45.3) 
// #duration(2, 2, 31, 0.4)

Dátum/idő eltolás időtartam szerint

Egy dátum ésx egy időtartam y hozzáadható x + y egy új dátum/idő kiszámításához, amelynek távolsága x lineáris idővonalon pontosan a nagyságrendje y. Itt a datetime a , Date, DateTimevagy DateTimeZone nem null értékek bármelyikét Timejelenti, és a nem null értékű eredmény azonos típusú lesz. A dátum/idő idő eltolása az időtartam alapján az alábbiak szerint számítható ki:

  • Ha meg van adva a dátum/idő időszak óta eltelt napok száma, hozzon létre egy új dátumidőt a következő információs elemekkel:

    • Számítsa ki az új napokat az epoch óta úgy, hogy 24 órás időszak alatt 100 nanoszekundumos kullancsok számával osztja el az y nagyságrendjét, csonkolja az eredmény decimális részét, és adja hozzá ezt az értéket az x korszak óta eltelt napjaihoz.

    • Éjfél óta számítsunk ki egy új kullancsot, amely azzal egyenértékű, hogy éjfél óta hozzáadjuk az y nagyságrendjét az x ketyegéséhez, modulo a 100 nanoszekundumos kullancsok száma egy 24 órás időszakban. Ha x éjfél óta nem ad meg értéket a kullancsokhoz, akkor a függvény 0 értéket feltételez.

    • Másolja az x értékét az UTC-ről való perceltoláshoz változatlanul.

  • Ha a dátum/idő idő értéke nem határozható meg, hozzon létre egy új dátumidőt a következő információs elemekkel:

    • Éjfél óta számítsunk ki egy új kullancsot, amely azzal egyenértékű, hogy éjfél óta hozzáadjuk az y nagyságrendjét az x ketyegéséhez, modulo a 100 nanoszekundumos kullancsok száma egy 24 órás időszakban. Ha x éjfél óta nem ad meg értéket a kullancsokhoz, akkor a függvény 0 értéket feltételez.

    • Másolja az x értékeit az időszámítás óta eltelt napokra és a percek eltolására az UTC-től változatlanul.

Az alábbi példák az abszolút időbeli összeg kiszámítását mutatják be, amikor a dátum/idő az időszak óta eltelt napokat adja meg:

#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

Az alábbi példa a dátum/idő eltolás időtartam szerinti kiszámítását mutatja be egy adott időpontra vonatkozóan:

#time(8,0,0) + #duration(30,5,0,0) 
   //#time(13, 0, 0) 
   //13:00:00

Kivonás operátor

A kivonási operátor (x - y) értelmezése a kiértékelt kifejezések x értékének típusától függ, és yaz alábbiak szerint:

x I Eredmény Értelmezés
type number type number type number Numerikus különbség
type number null null
null type number null
type duration type duration type duration Numerikus nagyságok különbsége
type duration null null
null type duration null
type datetime type datetime type duration Dátum/idő közötti időtartam
type datetime type duration type datetime Dátum/idő eltolás negatív időtartammal
type datetime null null
null type datetime null

A táblázatban typea datetime az egyik type date, type datetimevagy type datetimezonetype timea . Ha egy időtartamot kivon egy dátum/idő típusú értékből, az eredményül kapott érték azonos típusú.

A táblázatban felsorolt értékeken kívül más értékkombinációk esetén okkóddal "Expression.Error" kapcsolatos hiba jelenik meg. Az egyes kombinációkat a következő szakaszok ismertetik.

Az operandusok kiértékelésekor felmerülő hibák propagálása megtörténik.

Numerikus különbség

A két szám közötti különbséget a kivonási operátorral számítjuk ki, amely egy számot hoz létre. Példa:

1 - 1                // 0 
#nan - #infinity     // #nan

A számokat tartalmazó kivonási operátor - dupla pontosságot használ, a standard kódtárfüggvény Value.Subtract pedig a Decimális pontosság megadására használható. A számok különbségének kiszámításakor az alábbiak érvényesek:

  • A dupla pontosság különbségét a 64 bites bináris dupla pontosságú IEEE 754 aritmetikai IEEE 754-2008 szabályai szerint számítjuk ki. Az alábbi táblázat a nem véges értékek, nullák, végtelenek és NaN-értékek összes lehetséges kombinációjának eredményeit sorolja fel. A táblában xy nem véges értékek, és z a x - y. Ha x és y egyenlő, z pozitív nulla. Ha x - y túl nagy ahhoz, hogy a céltípusban szerepeljen, akkor a végtelen ugyanazzal a jellel van jelölve, z mint x - ya .

    - 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

  • A decimális pontosság különbségét a pontosság elvesztése nélkül számítjuk ki. Az eredmény skálája a két operandus skálái közül a nagyobb.

Időtartamok különbsége

A két időtartam különbsége az időtartam, amely az egyes időtartamok által képviselt 100 nanoszekundumos kullancsok száma közötti különbséget jelöli. Példa:

#duration(1,2,30,0) - #duration(0,0,0,30.45) 
// #duration(1, 2, 29, 29.55)

Dátum/idő eltolás negatív időtartammal

Egy dátum ésx egy időtartam y kivonható x - y egy új dátumidő kiszámításához. Itt a datetime az egyik date, datetimedatetimezonetimevagy a . Az eredményként kapott dátumidő távolsága x lineáris idővonalon van, amely pontosan a nagyságrendje y, a jelével yellentétes irányban. A pozitív időtartamok kivonása olyan eredményeket eredményez, amelyek az időhöz képest xvisszafelé haladnak, míg a negatív értékek kivonása időben előremutató eredményeket eredményez.

#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

Két dátum/idő közötti időtartam

Két dátum/idő,t és u kivonható t - u a közöttük lévő időtartam kiszámításához. Itt a datetime az egyik date, datetimedatetimezonetimevagy a . A kivonással ut előállított időtartamnak a hozzáadáskor hozamot kell eredményeznietu.

#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

Kivonás, t - u ha u > t negatív időtartamot eredményez:

#time(01,30,00) - #time(08,00,00) 
// #duration(0, -6, -30, 0)

Két dátum/időa következők a következők:

  • u + (t - u) = t

Szorzás operátor

A szorzási operátor (x * y) értelmezése az x és y kiértékelt kifejezések értékétől függ az alábbiak szerint:

X I Eredmény Értelmezés
type number type number type number Numerikus termék
type number null null
null type number null
type duration type number type duration Időtartam többszöröse
type number type duration type duration Időtartam többszöröse
type duration null null
null type duration null

A táblázatban felsorolt értékeken kívül más értékkombinációk esetén okkóddal "Expression.Error" kapcsolatos hiba jelenik meg. Az egyes kombinációkat a következő szakaszok ismertetik.

Az operandusok kiértékelésekor felmerülő hibák propagálása megtörténik.

Numerikus termék

A két szám szorzatát a szorzási operátorral számítjuk ki, amely egy számot hoz létre. Példa:

2 * 4                // 8 
6 * null             // null 
#nan * #infinity     // #nan

A számok szorzási operátora * dupla pontosságot használ; a standard kódtárfüggvény Value.Multiply a Decimális pontosság megadására használható. A számok szorzatának kiszámításakor az alábbiak érvényesek:

  • A dupla pontosságú termék kiszámítása a 64 bites bináris dupla pontosságú IEEE 754 aritmetikai IEEE 754-2008 szabályai szerint történik. Az alábbi táblázat a nem véges értékek, nullák, végtelenek és NaN-értékek összes lehetséges kombinációjának eredményeit sorolja fel. A táblában xy pozitív véges értékek. zeredménye.x * y Ha az eredmény túl nagy a céltípushoz, z akkor a végtelen. Ha az eredmény túl kicsi a céltípushoz, z akkor nulla.

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

  • A decimális pontosságú terméket a rendszer a pontosság elvesztése nélkül számítja ki. Az eredmény skálája a két operandus skálái közül a nagyobb.

Időtartamok többszörösei

Egy időtartam és egy szám szorzata az az időtartam, amely a 100nanosecond osztásszámot jelöli, amelyet az operandus operandusának operandusa jelöl. Példa:

#duration(2,1,0,15.1) * 2 
// #duration(4, 2, 0, 30.2)

Osztás operátor

Az osztási operátor (x / y) értelmezése a kiértékelt kifejezések x értékétől függ, és yaz alábbiak szerint:

X I Eredmény Értelmezés
type number type number type number Numerikus hányados
type number null null
null type number null
type duration type number type duration Időtartam töredéke
type duration type duration type number Időtartamok numerikus hányadosa
type duration null null
null type duration null

A táblázatban felsorolt értékeken kívül más értékkombinációk esetén okkóddal "Expression.Error" kapcsolatos hiba jelenik meg. Az egyes kombinációkat a következő szakaszok ismertetik.

Az operandusok kiértékelésekor felmerülő hibák propagálása megtörténik.

Numerikus hányados

Két szám hányadosát az osztás operátorral számítjuk ki, amely egy számot állít elő. Példa:

8 / 2               // 4 
8 / 0               // #infinity 
0 / 0               // #nan 
0 / null            // null 
#nan / #infinity    // #nan

A számok osztási operátora / dupla pontosságot használ, a standard kódtárfüggvény Value.Divide pedig a Decimális pontosság megadására használható. A számok hányadosának kiszámításakor az alábbiak érvényesek:

  • A dupla pontosságú hányados kiszámítása a 64 bites bináris dupla pontosságú IEEE 754 aritmetikai IEEE 754-2008 szabályai szerint történik. Az alábbi táblázat a nem véges értékek, nullák, végtelenek és NaN-értékek összes lehetséges kombinációjának eredményeit sorolja fel. A táblában xy pozitív véges értékek. zeredménye.x / y Ha az eredmény túl nagy a céltípushoz, z akkor a végtelen. Ha az eredmény túl kicsi a céltípushoz, z akkor nulla.

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

  • A decimális pontosságú összeg kiszámítása a pontosság elvesztése nélkül történik. Az eredmény skálája a két operandus skálái közül a nagyobb.

Időtartamok hányadosa

A két időtartam hányadosa az időtartamok által képviselt 100nanosecond kullancsok számának hányadosa. Példa:

#duration(2,0,0,0) / #duration(0,1,30,0) 
// 32

Skálázott időtartamok

Az időtartam x és a szám y hányadosa a 100 nanoszekundumos kullancsok számának hányadosa, amelyet az időtartam x és a szám yjelöl . Példa:

#duration(2,0,0,0) / 32 
// #duration(0,1,30,0)

Struktúra kombináció

A kombinációs operátor (x & y) a következő típusú értékek alapján van definiálva:

X I Eredmény Értelmezés
type text type text type text Összeláncolás
type text null null
null type text null
type date type time type datetime Összefűzés
type date null null
null type time null
type list type list type list Összeláncolás
type record type record type record Összefűzés
type table type table type table Összeláncolás

Összeláncolás

Két szöveg, két lista vagy két táblaérték összefűzhető a használatával x & y.

Az alábbi példa a szöveges értékek összefűzését szemlélteti:

"AB" & "CDE"     // "ABCDE"

Az alábbi példa a listák összefűzését szemlélteti:

{1, 2} & {3}     // {1, 2, 3}

Két érték x & yösszefűzésekor a következők a következők:

  • A rendszer a kifejezések kiértékelésekor xy felmerülő hibákat propagálja.

  • A rendszer nem propagálja a hibát, ha valamelyik elem vagy xy hibát tartalmaz.

  • Két szöveges érték összefűzésének eredménye egy olyan szöveges érték, amely az x értékét tartalmazza, amelyet azonnal az y követ. Ha az operandusok egyike null értékű, a másik pedig szöveges érték, akkor az eredmény null.

  • A két lista összefűzésének eredménye egy lista, amely tartalmazza a lista összes elemét x , majd a lista összes elemét y.

  • Két tábla összefűzésének eredménye egy olyan tábla, amely a két operandustábla oszlopainak egyesítésével rendelkezik. Az oszlopok sorrendje x megmarad, majd az oszlopok csak a relatív sorrendjük megőrzésével yjelennek meg. Ha az oszlopok csak az egyik operandusban jelennek meg, null a másik operandus cellaértékeinek kitöltésére szolgál.

Összefűzés

Rekordegyesítés

Két rekord egyesíthető egy olyan rekordtal x & y, amely mindkét x rekordból és ya mezőből is tartalmaz mezőket.

Az alábbi példák a rekordok egyesítését szemléltetik:

[ x = 1 ] & [ y = 2 ]                // [ x = 1, y = 2 ] 
[ x = 1, y = 2 ] & [ x = 3, z = 4 ]  // [ x = 3, y = 2, z = 4 ]

Két rekord x + yegyesítésekor a következők a következők:

  • A rendszer a kifejezések kiértékelésekor xy felmerülő hibákat propagálja.

  • Ha egy mező megjelenik mind a kettőben x , akkor ya rendszer a forrásértéket y használja.

  • Az eredményként kapott rekord xmezőinek sorrendje az , majd y a nem része xmezők sorrendje, ugyanabban a sorrendben y, amelyben megjelennek.

  • A rekordok egyesítése nem eredményezi az értékek kiértékelését.

  • Nem történik hiba, mert egy mező hibát tartalmaz.

  • Az eredmény egy rekord.

Dátum-idő egyesítés

A dátumok x egy idővel egyesíthetők egy idő y használatával x & y, amely egy olyan dátumidőt hoz létre, amely egyesíti x a két és ya .

Az alábbi példa egy dátum és egy időpont egyesítését szemlélteti:

#date(2013,02,26) & #time(09,17,00) 
// #datetime(2013,02,26,09,17,00)

Két rekord x + yegyesítésekor a következők a következők:

  • A rendszer a kifejezések kiértékelésekor xy felmerülő hibákat propagálja.

  • Az eredmény dátum/idő.

Unary operátorok

A +, -és not az operátorok nem szereplő operátorok.

unary-expression:
      type-expression
       + unary kifejezés
       - unary kifejezés
       not unary kifejezés

Unary plus operátor

A unary plus operátor (+x) a következő értékekhez van definiálva:

X Eredmény Értelmezés
type number type number Unary plus
type duration type duration Unary plus
null 'null

Más értékek esetén az okkóddal "Expression.Error" kapcsolatos hiba jelenik meg.

A unary plus operátor lehetővé teszi egy + jel számra, datetime-ra vagy null értékre való alkalmazását. Az eredmény ugyanaz az érték. Példa:

+ - 1                 // -1 
+ + 1                 // 1 
+ #nan                // #nan 
+ #duration(0,1,30,0) // #duration(0,1,30,0)

A unary plus operátor +xkiértékelésekor a következők a következők:

  • Az értékelés propagálása x során felmerülő hibák.

  • Ha az értékelés x eredménye nem számérték, akkor okkóddal "Expression.Error" rendelkező hiba jelenik meg.

Unary mínusz operátor

A unáris mínusz operátor (-x) a következő típusú értékekhez van definiálva:

X Eredmény Értelmezés
type number type number Tagadás
type duration type duration Tagadás
null null

Más értékek esetén az okkóddal "Expression.Error" kapcsolatos hiba jelenik meg.

A unary mínusz operátor egy szám vagy időtartam jelének módosítására szolgál. Példa:

- (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)

A unáris mínusz operátor -xkiértékelésekor a következők a következők:

  • Az értékelés propagálása x során felmerülő hibák.

  • Ha a kifejezés szám, akkor az eredmény a kifejezés x számértéke, amelynek jelét módosították. Ha az érték NaN, akkor az eredmény szintén NaN.

Logikai negation operátor

A logikai negation operátor (not) a következő értékekhez van definiálva:

X Eredmény Értelmezés
type logical type logical Tagadás
null null

Ez az operátor kiszámítja a logikai not műveletet egy adott logikai értéken. Példa:

not true             // false 
not false            // true 
not (true and true)  // false

A logikai negation operátor not xkiértékelésekor az alábbiak a következők:

  • Az értékelés propagálása x során felmerülő hibák.

  • Az x kifejezés kiértékelésével előállított értéknek logikai értéknek kell lennie, vagy okkóddal "Expression.Error" kapcsolatos hibát kell jeleznie. Ha az érték az true, akkor az eredmény .false Ha az operandus az false, akkor az eredmény .true

Az eredmény logikai érték.

Típus operátorok

Az operátorok is és as az úgynevezett típusoperátorok.

Típuskompatibilitási operátor

A típuskompatibilitási operátor x is y a következő értéktípusokhoz van definiálva:

X I Eredmény
type any nullable-primitive-type type logical

A kifejezés x is y akkor ad vissza true értéket, ha az írott típus x kompatibilis a következővel y, és visszaadja false , ha az írott típus x nem kompatibilis azokkal y. ynull értékű primitív típusnak kell lennie.

is-expression:
      kifejezésként
      is-expressionisnullable-primitive-type
nullable-primitive-type:
       nullable opt primitív típusú

A típuskompatibilitás az is operátor által támogatott általános típuskompatibilitási részhalmaz, amely a következő szabályokkal van definiálva:

  • Ha x null, akkor kompatibilis, ha y a típus any, a típus nullvagy a null értékű típus.

  • Ha x nem null, akkor kompatibilis, ha a primitív típus x ugyanaz, mint ya .

A kifejezés x is ykiértékelésekor az alábbiak érvényesek:

  • A kifejezés x kiértékelésekor felmerülő hiba propagálása.

Típusérvényesítési operátor

A típusérvényesítési operátor x as y a következő értéktípusokhoz van definiálva:

X I Eredmény
type any nullable-primitive-type type any

A kifejezés x as y azt állítja, hogy az érték x kompatibilis y az operátorral is . Ha nem kompatibilis, hibaüzenet jelenik meg. ynull értékű primitív típusúnak kell lennie.

kifejezésként:
      egyenlőségi kifejezés
      as-expressionasnullable-primitive-type

A kifejezés x as y kiértékelése a következőképpen történik:

  • A típuskompatibilitás ellenőrzése x is y történik, és az állítás x változatlan marad, ha a teszt sikeres.

  • Ha a kompatibilitás-ellenőrzés sikertelen, hiba lép fel az okkóddal "Expression.Error" .

Példák:

1 as number               // 1 
"A" as number             // error 
null as nullable number   // null

A kifejezés x as ykiértékelésekor az alábbiak érvényesek:

  • A kifejezés x kiértékelésekor felmerülő hiba propagálása.

Coalesce operátor

A coalesce operátor ?? a bal operandus eredményét adja vissza, ha nem null értékű, ellenkező esetben a jobb operandus eredményét adja vissza. A jobb operandus akkor és csak akkor lesz kiértékelve, ha a bal operandus null.