Share via

Gedrag van operatoren

  • Artikel

In deze sectie wordt het gedrag van de verschillende M-operators gedefinieerd.

Prioriteit van operator

Wanneer een expressie meerdere operators bevat, bepaalt de prioriteit van de operators de volgorde waarin de afzonderlijke operators worden geëvalueerd. De expressie x + y * z wordt bijvoorbeeld geëvalueerd omdat x + (y * z) de operator een hogere prioriteit heeft dan de * binaire + operator. De prioriteit van een operator wordt bepaald door de definitie van de bijbehorende grammaticaproductie. Een additieve expressie bestaat bijvoorbeeld uit een reeks vermenigvuldigingsexpressies, gescheiden door + of - operatoren, waardoor de operatoren - een + lagere prioriteit krijgen dan de * operatoren en / de operatoren.

De productie van haakjes kan worden gebruikt om de standaardvolgorde van prioriteit te wijzigen.

haakjes-expressie:
      (Expressie)

Bijvoorbeeld:

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

De volgende tabel bevat een overzicht van de M-operators, waarbij de operatorcategorieën in volgorde van prioriteit van hoog naar laag worden weergegeven. Operators in dezelfde categorie hebben gelijke prioriteit.

Categorie Expression Omschrijving
Primair I
@I		 Id-expressie
(x) Expressie tussen haakjes
x[i] Zoekopdracht
x{y} Toegang tot items
x(...) Functie aanroepen
{x, y, ...} Initialisatie van lijsten
[ i = x, ... ] Initialisatie van records
... Niet geïmplementeerd
Unaire +X Identiteit
-X Ontkenning
notX Logische negatie
Metagegevens xmetay Metagegevens koppelen
Multiplicatieve x * y Vermenigvuldiging
x / y Divisie
Toevoegingsmiddel x + y Aanvullend
x - y Aftrekken
Relationeel x< y Kleiner dan
x > y Groter dan
x<= y Kleiner dan of gelijk aan
x >= y Groter dan of gelijk aan
Equality x = y Is gelijk aan
x<> y Not equal
Type assertie xasy Is compatibel nullable-primitieve type of fout
Typeconformance xisy Testen of compatibel nullable-primitief type is
Logische EN xandy Samensluiting
Logische OR xory Kortsluiting disjunction
Coalesce x??y Null-samensnookoperator

Operators en metagegevens

Elke waarde heeft een gekoppelde recordwaarde die aanvullende informatie over de waarde kan bevatten. Deze record wordt de metagegevensrecord voor een waarde genoemd. Een metagegevensrecord kan worden gekoppeld aan elk soort waarde, zelfs null. Het resultaat van een dergelijke koppeling is een nieuwe waarde met de opgegeven metagegevens.

Een metagegevensrecord is slechts een gewone record en kan velden en waarden bevatten die een gewone record kan en zelf een metagegevensrecord heeft. Het koppelen van een metagegevensrecord aan een waarde is 'niet-intrusief'. Het gedrag van de waarde in evaluaties wordt niet gewijzigd, met uitzondering van de waarden die expliciet metagegevensrecords inspecteren.

Elke waarde heeft een standaardmetagegevensrecord, zelfs als deze niet is opgegeven. De standaardrecord voor metagegevens is leeg. In de volgende voorbeelden ziet u toegang tot de metagegevensrecord van een tekstwaarde met behulp van de Value.Metadata standaardbibliotheekfunctie:

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

Metagegevensrecords blijven over het algemeen niet behouden wanneer een waarde wordt gebruikt met een operator of functie waarmee een nieuwe waarde wordt samengesteld. Als bijvoorbeeld twee tekstwaarden worden samengevoegd met behulp van de & operator, zijn de metagegevens van de resulterende tekstwaarde de lege record []. De volgende expressies zijn equivalent:

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

De standaardbibliotheekfuncties Value.RemoveMetadata en Value.ReplaceMetadata kunnen worden gebruikt om alle metagegevens uit een waarde te verwijderen en de metagegevens van een waarde te vervangen (in plaats van metagegevens samen te voegen in mogelijk bestaande metagegevens).

De enige operator die resultaten retourneert die metagegevens bevatten, is de meta-operator.

Structureel recursieve operators

Waarden kunnen cyclisch zijn. Bijvoorbeeld:

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

M verwerkt cyclische waarden door de constructie van records, lijsten en tabellen lui te houden. Een poging om een cyclische waarde te maken die niet baat heeft bij gekruiste luie gestructureerde waarden, resulteert in een fout:

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

Sommige operators in M worden gedefinieerd door structurele recursie. Zo wordt gelijkheid van records en lijsten gedefinieerd door respectievelijk de gekoppelde gelijkheid van overeenkomende recordvelden en itemlijsten.

Voor niet-cyclische waarden resulteert het toepassen van structurele recursie in een eindige uitbreiding van de waarde: gedeelde geneste waarden worden herhaaldelijk doorkruist, maar het proces van recursie wordt altijd beëindigd.

Een cyclische waarde heeft een oneindige uitbreiding bij het toepassen van structurele recursie. De semantiek van M maakt geen speciale accommodaties voor dergelijke oneindige uitbreidingen, een poging om cyclische waarden voor gelijkheid te vergelijken, bijvoorbeeld, zal meestal geen resources meer hebben en uitzonderlijk worden beëindigd.

Selectie- en projectieoperators

Met de selectie- en projectieoperators kunnen gegevens worden geëxtraheerd uit lijst- en recordwaarden.

Itemtoegang

Een waarde kan worden geselecteerd uit een lijst of tabel op basis van de positie op nul in die lijst of tabel met behulp van een item-access-expression.

item-access-expression:
      itemselectie
      optioneel-itemselectie
itemselectie:
      primary-expression{item-selector}
optioneel-itemselectie:
      primary-expression{item-selector} ?
itemselector:
      Expressie

De item-access-expressionx{y} retourneert:

  • Voor een lijst x en een getal y, het item van de lijst x op positie y. Het eerste item van een lijst wordt beschouwd als een rangtelindex van nul. Als de aangevraagde positie niet in de lijst bestaat, treedt er een fout op.

  • Voor een tabel x en een getal y, de rij van de tabel x op positie y. De eerste rij van een tabel wordt beschouwd als een rangtelindex van nul. Als de aangevraagde positie niet in de tabel bestaat, treedt er een fout op.

  • Voor een tabel x en een record ykomt de rij van de tabel x die overeenkomt met de veldwaarden van de record y voor velden met veldnamen die overeenkomen met overeenkomende tabelkolomnamen. Als er geen unieke overeenkomende rij in de tabel staat, wordt er een fout gegenereerd.

Bijvoorbeeld:

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

De item-access-expression ondersteunt ook het formulier x{y}?, dat retourneert null wanneer de positie (of overeenkomst) y niet bestaat in de lijst of tabel x. Als er meerdere overeenkomsten zijn, ywordt er nog steeds een fout gegenereerd.

Bijvoorbeeld:

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

Itemtoegang dwingt de evaluatie van andere lijst- of tabelitems dan de items die worden geopend niet af. Bijvoorbeeld:

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

Het volgende geldt wanneer de operator x{y} voor itemtoegang wordt geëvalueerd:

  • Fouten die zijn opgetreden tijdens de evaluatie van expressies x of y worden doorgegeven.

  • De expressie x produceert een lijst of tabelwaarde.

  • De expressie y produceert een getalwaarde of, als x deze een tabelwaarde produceert, een recordwaarde.

  • Als y er een getalwaarde wordt gegenereerd en de waarde y negatief is, wordt er een fout met redencode "Expression.Error" gegenereerd.

  • Als y een getalwaarde wordt gegenereerd en de waarde y groter is dan of gelijk is aan het aantal x, wordt een fout met redencode "Expression.Error" gegenereerd, tenzij het optionele operatorformulier x{y}? wordt gebruikt, in welk geval de waarde null wordt geretourneerd.

  • Als x een tabelwaarde wordt geproduceerd en y een recordwaarde wordt geproduceerd en er geen overeenkomsten y zijn, xwordt er een fout met redencode "Expression.Error" gegenereerd, tenzij het optionele operatorformulier x{y}? wordt gebruikt, in welk geval de waarde null wordt geretourneerd.

  • Als x een tabelwaarde wordt geproduceerd en y een recordwaarde wordt geproduceerd en er meerdere overeenkomsten yxzijn, wordt er een fout met redencode "Expression.Error" gegenereerd.

Er worden geen items in x andere items dan die op positie y geëvalueerd tijdens het selectieproces van het item. (Voor streaminglijsten of tabellen worden de items of rijen die voorafgaan aan die op positie y overgeslagen, wat kan leiden tot de evaluatie, afhankelijk van de bron van de lijst of tabel.)

Veldtoegang

De veldtoegangsexpressie wordt gebruikt om een waarde te selecteren uit een record of om een record of tabel te projecteren op een record of tabel met respectievelijk minder velden of kolommen.

field-access-expression:
      veldselectie
      impliciete selectie van doelvelden
      Projectie
      impliciete doelprojectie
veldselectie:
      primary-expression field-selector
veldkiezer:
      required-field-selector
      optioneel-veldselector
required-field-selector:
      [veldnaam]
optioneel-veldselector:
      [veldnaam] ?
veldnaam:
      gegeneraliseerde id
      id tussen aan/ uit
impliciete doelveldselectie:
      veldkiezer
Projectie:
      primary-expression required-projection
      primaire-expressie optioneel-projectie
vereiste projectie:
      [required-selector-list]
optioneel-projectie:
      [required-selector-list] ?
required-selector-list:
      required-field-selector
      required-selector-list,required-field-selector
impliciete doelprojectie:
      vereiste projectie
      optioneel-projectie

De eenvoudigste vorm van veldtoegang is vereiste veldselectie. De operator gebruikt de operator x[y] om een veld in een record op te zoeken op veldnaam. Als het veld y niet bestaat, xwordt er een fout gegenereerd. Het formulier x[y]? wordt gebruikt om optionele veldselectie uit te voeren en retourneert null als het aangevraagde veld niet in de record bestaat.

Bijvoorbeeld:

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

Collectieve toegang van meerdere velden wordt ondersteund door de operators voor de vereiste recordprojectie en optionele recordprojectie. De operator x[[y1],[y2],...] projecteert de record naar een nieuwe record met minder velden (geselecteerd door y1, y2, ...). Als er geen geselecteerd veld bestaat, wordt er een fout gegenereerd. De operator x[[y1],[y2],...] projecteert de record naar een nieuwe record met de velden die zijn geselecteerd door y1, y2; ...als er een veld ontbreekt, null wordt in plaats daarvan gebruikt. Bijvoorbeeld:

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

De formulieren [y] en [y]? worden ondersteund als een verkorte verwijzing naar de id _ (onderstrepingsteken). De volgende twee expressies zijn equivalent:

[A]                 
_[A]

In het volgende voorbeeld ziet u de verkorte vorm van veldtoegang:

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

Het formulier [[y1],[y2],...] en [[y1],[y2],...]? worden ook ondersteund als een afkorting en de volgende twee expressies zijn eveneens gelijkwaardig:

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

De verkorte vorm is met name handig in combinatie met de each afkorting, een manier om een functie van één parameter met de naam _ te introduceren (zie Vereenvoudigde declaraties voor meer informatie. Samen vereenvoudigen de twee afkortingen algemene functionele expressies met een hogere volgorde:

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

De bovenstaande expressie is gelijk aan de volgende meer cryptische ogende longhand:

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

Veldtoegang dwingt de evaluatie van andere velden dan de velden die worden geopend niet af. Bijvoorbeeld:

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

Het volgende geldt wanneer een operator x[y]voor veldtoegang, x[y]?of x[[y]]x[[y]]? wordt geëvalueerd:

  • Fouten die tijdens de evaluatie van de expressie x worden gegenereerd, worden doorgegeven.

  • Fouten die optreden bij het evalueren van het veld y , worden permanent gekoppeld aan het veld yen vervolgens doorgegeven. Bij toekomstige toegang tot het veld y wordt de identieke fout gegenereerd.

  • De expressie x produceert een record- of tabelwaarde, of er wordt een fout gegenereerd.

  • Als de id y een veld noemt waarin geen veld bestaat x, wordt er een fout met redencode "Expression.Error" gegenereerd, tenzij het optionele operatorformulier ...? wordt gebruikt, in welk geval de waarde null wordt geretourneerd.

Er worden geen velden van x andere dan de benoemde y velden geëvalueerd tijdens het proces van veldtoegang.

Operator voor metagegevens

De metagegevensrecord voor een waarde wordt gewijzigd met behulp van de metaoperator (x meta y).

metadata-expression:
      unary-expression
      unary-expressionmetaunary-expression

In het volgende voorbeeld wordt een tekstwaarde gemaakt met een metagegevensrecord met behulp van de meta operator en wordt vervolgens de metagegevensrecord van de resulterende waarde geopend met behulp van Value.Metadata:

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

Het volgende geldt voor het toepassen van de operator x meta yvoor het combineren van metagegevens:

  • Fouten die optreden bij het evalueren van de x of y expressies worden doorgegeven.

  • De y expressie moet een record zijn of er wordt een fout met redencode "Expression.Error" gegenereerd.

  • De resulterende metagegevensrecord is xde metagegevensrecord samengevoegd met y. (Zie voor de semantiek van recordsamenvoeging Record samenvoegen.)

  • De resulterende waarde is de waarde van de x expressie, zonder de metagegevens, waarbij de zojuist berekende metagegevensrecord is gekoppeld.

De standaardbibliotheekfuncties Value.RemoveMetadata en Value.ReplaceMetadata kunnen worden gebruikt om alle metagegevens uit een waarde te verwijderen en de metagegevens van een waarde te vervangen (in plaats van metagegevens samen te voegen in mogelijk bestaande metagegevens). De volgende expressies zijn equivalent:

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

Gelijkheidsoperators

De gelijkheidsoperator= wordt gebruikt om te bepalen of twee waarden gelijk zijn. De ongelijkheidsoperator<> wordt gebruikt om te bepalen of twee waarden niet gelijk zijn.

gelijkheidsexpressie:
      relationele expressie
      relationele-expressie=gelijkheidsexpressie
      relationele-expressie<>gelijkheidsexpressie

Bijvoorbeeld:

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

Metagegevens maken geen deel uit van gelijkheid of ongelijkheidsvergelijking. Bijvoorbeeld:

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

Het volgende geldt voor het toepassen van de gelijkheidsoperatoren x = y en x <> y:

  • Fouten die optreden bij het evalueren van de x of y expressies worden doorgegeven.

  • De = operator heeft het resultaat als true de waarden gelijk zijn en false anders.

  • De <> operator heeft het resultaat als false de waarden gelijk zijn en true anders.

  • Metagegevensrecords worden niet opgenomen in de vergelijking.

  • Als waarden die worden geproduceerd door het evalueren van de x en y expressies niet hetzelfde soort waarde zijn, zijn de waarden niet gelijk.

  • Als de waarden die worden geproduceerd door het evalueren van de x en y expressie hetzelfde soort waarde zijn, zijn er specifieke regels om te bepalen of ze gelijk zijn, zoals hieronder is gedefinieerd.

  • Het volgende is altijd waar:

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

De gelijkheidsoperators worden gedefinieerd voor de volgende typen:

  • De null waarde is alleen gelijk aan zichzelf.
    null = null    // true 
    null = true    // false 
    null = false   // false
  • De logische waarden true en false zijn alleen gelijk aan zichzelf. Bijvoorbeeld:
    true = true      // true 
    false = false    // true 
    true = false     // false 
    true = 1         // false

  • Getallen worden vergeleken met behulp van de opgegeven precisie:

    • Als een van beide getallen is #nan, zijn de getallen niet hetzelfde.

    • Als geen van beide getallen is #nan, worden de getallen vergeleken met behulp van een bitgewijze vergelijking van de numerieke waarde.

    • #nan is de enige waarde die niet gelijk is aan zichzelf.

      Bijvoorbeeld:

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

  • Twee duurs zijn gelijk als ze hetzelfde aantal tikken van 100 nanoseconden vertegenwoordigen.

  • Twee keer zijn gelijk als de grootten van hun delen (uur, minuut, seconde) gelijk zijn.

  • Twee datums zijn gelijk als de grootten van hun onderdelen (jaar, maand, dag) gelijk zijn.

  • Twee datum/tijd zijn gelijk als de grootten van hun onderdelen (jaar, maand, dag, uur, minuut, seconde) gelijk zijn.

  • Twee datum/tijdzones zijn gelijk als de bijbehorende UTC-datum/tijd gelijk is. Om de bijbehorende UTC-datum/tijd te bereiken, wordt de offset uren/minuten afgetrokken van het datum/tijd-onderdeel van de datum/tijdzone.

  • Twee tekstwaarden zijn gelijk als ze een ordinale, hoofdlettergevoelige, cultuurgevoelige vergelijking gebruiken met dezelfde lengte en gelijke tekens op overeenkomende posities.

  • Twee lijstwaarden zijn gelijk als alle volgende waar zijn:

    • Beide lijsten bevatten hetzelfde aantal items.

    • De waarden van elk positioneel overeenkomend item in de lijsten zijn gelijk. Dit betekent dat niet alleen de lijsten gelijke items moeten bevatten, dat de items in dezelfde volgorde moeten staan.

      Bijvoorbeeld:

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

  • Twee records zijn gelijk als alle volgende waar zijn:

    • Het aantal velden is hetzelfde.

    • Elke veldnaam van een record is ook aanwezig in de andere record.

    • De waarde van elk veld van één record is gelijk aan het achtige veld in de andere record.

      Bijvoorbeeld:

        [ 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

  • Twee tabellen zijn gelijk als alle volgende waar zijn:

    • Het aantal kolommen is hetzelfde.

    • Elke kolomnaam in de ene tabel is ook aanwezig in de andere tabel.

    • Het aantal rijen is hetzelfde.

    • Elke rij heeft gelijke waarden in overeenkomende cellen.

      Bijvoorbeeld:

        #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

  • Een functiewaarde is gelijk aan zichzelf, maar kan wel of niet gelijk zijn aan een andere functiewaarde. Als twee functiewaarden als gelijk worden beschouwd, gedragen ze zich identiek wanneer ze worden aangeroepen.

    Twee opgegeven functiewaarden hebben altijd dezelfde gelijkheidsrelatie.

  • Een typewaarde is gelijk aan zichzelf, maar kan wel of niet gelijk zijn aan een andere typewaarde. Als twee typewaarden als gelijk worden beschouwd, gedragen ze zich identiek wanneer een query wordt uitgevoerd op overeenstemming.

    Twee opgegeven typewaarden hebben altijd dezelfde gelijkheidsrelatie.

Relationele operators

De <operators , >en <=>= operators worden de relationele operatoren genoemd.

relationele expressie:
      additieve expressie
      relationele expressie voor additieve expressie<
      relationele expressie voor additieve expressie>
      additieve expressie<= _relational-expressie
      relationele expressie voor additieve expressie >=

Deze operators worden gebruikt om de relatieve volgorderelatie tussen twee waarden te bepalen, zoals wordt weergegeven in de volgende tabel:

Bewerking Resultaat
x < y true indien x kleiner dan y, false anders
x > y true als x groter is dan y, false anders
x <= y true indien x kleiner dan of gelijk aan y, false anders
x >= y true indien x groter dan of gelijk aan y, false anders

Bijvoorbeeld:

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

Het volgende geldt voor het evalueren van een expressie die de relationele operators bevat:

  • Fouten die optreden bij het evalueren van de x of y operand-expressies, worden doorgegeven.

  • De waarden die worden geproduceerd door zowel de xy als expressies te evalueren, moeten een binaire waarde, datum/tijd, datum/tijdzone, duur, logisch, getal, null, tekst of tijd zijn. Anders wordt er een fout met redencode "Expression.Error" gegenereerd.

  • Beide operanden moeten hetzelfde soort waarde of null. Anders wordt er een fout met redencode "Expression.Error" gegenereerd.

  • Als beide operanden of beide operanden zijn null, is het resultaat de null waarde.

  • Twee binaire bestanden worden byte byte vergeleken.

  • Twee datums worden vergeleken door hun jaaronderdelen en, indien gelijk, hun maanddelen en, indien gelijk, hun dagdelen te vergelijken.

  • Twee datum/tijd worden vergeleken door hun jaaronderdelen en, indien gelijk, hun maanddelen en, indien gelijk, hun dagdelen en, indien gelijk, hun uurdelen en, indien gelijk, hun minuutdelen en, indien gelijk, hun tweede delen te vergelijken.

  • Twee datum/tijdzones worden vergeleken door ze te normaliseren naar UTC door hun verschuiving per uur/minuut af te trekken en vervolgens hun datum/tijd-onderdelen te vergelijken.

  • Twee duurs worden vergeleken op basis van het totale aantal tikken van 100 nanoseconden die ze vertegenwoordigen.

  • Twee logische waarden worden zodanig vergeleken dat true wordt beschouwd als groter dan false.

  • Twee getallen x en y worden vergeleken volgens de regels van de IEEE 754-standaard:

    • Als een van beide operanden is #nan, is false het resultaat voor alle relationele operatoren.

    • Wanneer geen van beide operanden is #nan, vergelijken de operators de waarden van de twee drijvendekommage operanden met betrekking tot de volgorde -∞ < -max < ... < -min < -0.0 = +0.0 < +min < ... < +max < +∞ waarin min en max de kleinste en grootste positieve eindige waarden zijn die kunnen worden weergegeven. De M-namen voor -∞ en +∞ zijn -#infinity en #infinity.

      Belangrijke effecten van deze volgorde zijn:

      • Negatieve en positieve nullen worden als gelijk beschouwd.

      • Een -#infinity waarde wordt beschouwd als kleiner dan alle andere getalwaarden, maar gelijk aan een andere -#infinity.

      • Een #infinity waarde wordt beschouwd als groter dan alle andere getalwaarden, maar gelijk aan een andere #infinity.

  • Twee teksten worden vergeleken met behulp van een ordinale, hoofdlettergevoelige, cultuurgevoelige vergelijking.

  • Twee keer worden vergeleken door hun uurdelen te vergelijken en, indien gelijk, hun minuutdelen en, indien gelijk, hun tweede delen.

Voorwaardelijke logische operators

De and en or operators worden de voorwaardelijke logische operators genoemd.

logische of expressie:
      logical-and-expression logical-and-expression
or logical-or-expression
logische en expressie:
      is-expression
      is-expressionandlogical-and-expression

De or operator retourneert true wanneer ten minste één van de operanden is true. De rechteroperand wordt geëvalueerd als en alleen als de linkeroperand niet trueis.

De and operator retourneert false wanneer ten minste één van de operanden is false. De rechteroperand wordt geëvalueerd als en alleen als de linkeroperand niet falseis.

De waarheidstabellen voor de or en and operators worden hieronder weergegeven, met het resultaat van het evalueren van de linkeroperandexpressie op de verticale as en het resultaat van het evalueren van de rechteroperandexpressie op de horizontale as.

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

Het volgende geldt voor het evalueren van een expressie met voorwaardelijke logische operators:

  • Fouten die optreden bij het evalueren van de x of y expressies worden doorgegeven.

  • De voorwaardelijke logische operators worden gedefinieerd voor de typen logical en null. Als de operandwaarden niet van deze typen zijn, wordt er een fout met redencode "Expression.Error" gegenereerd.

  • Het resultaat is een logische waarde.

  • In de expressie x of ywordt de expressie y geëvalueerd als en alleen als x dat niet het geval trueis.

  • In de expressie x en ywordt de expressie y geëvalueerd als en alleen als x dat niet het geval falseis.

De laatste twee eigenschappen geven de voorwaardelijke logische operators de kwalificatie 'voorwaardelijk'; eigenschappen ook wel 'kortsluiting' genoemd. Deze eigenschappen zijn handig voor het schrijven van compacte beveiligde predicaten. De volgende expressies zijn bijvoorbeeld gelijkwaardig:

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

Rekenkundige operatoren

De +operatoren , *-en / operators zijn de rekenkundige operatoren.

additieve expressie:
      vermenigvuldigingsexpressie
      additieve expressie+multiplicative-expression
      additieve expressie-multiplicative-expression
vermenigvuldigingsexpressie:
      metagegevens- expressie
      multiplicative-expression*metadata-expression
      multiplicative-expression/metadata-expression

Precisie

Getallen in M worden opgeslagen met behulp van verschillende representaties om zoveel mogelijk informatie te bewaren over getallen die afkomstig zijn van verschillende bronnen. Getallen worden alleen naar behoefte geconverteerd van de ene weergave naar de andere door operators die erop zijn toegepast. Er worden twee precisies ondersteund in M:

Precisie Semantiek
Precision.Decimal 128-bits decimale weergave met een bereik van ±1,0 x 10-28 tot ±7,9 x 1028 en 28-29 significante cijfers.
Precision.Double Wetenschappelijke representatie met behulp van mantissa en exponent; voldoet aan de 64-bits binaire IEEE 754-rekenkundige standaard IEEE 754-2008.

Rekenkundige bewerkingen worden uitgevoerd door een precisie te kiezen, beide operanden naar die precisie te converteren (indien nodig), de werkelijke bewerking uit te voeren en ten slotte een getal in de gekozen precisie te retourneren.

De ingebouwde rekenkundige operatoren (+, -, *, ) /gebruiken dubbele precisie. Standaardbibliotheekfuncties (Value.Add, Value.Subtract, Value.Multiply, ) Value.Dividekunnen worden gebruikt om deze bewerkingen aan te vragen met behulp van een specifiek precisiemodel.

  • Er is geen numerieke overloop mogelijk: #infinity of -#infinity vertegenwoordigen waarden van grootten die te groot zijn om te worden weergegeven.

  • Er is geen numerieke onderstroom mogelijk: 0 en -0 vertegenwoordigen waarden van grootten die te klein zijn om weer te geven.

  • De speciale waarde #nan van IEEE 754 (NaN— Not a Number) wordt gebruikt om rekenkundige ongeldige gevallen te behandelen, zoals een deling van nul door nul.

  • Conversie van decimale naar dubbele precisie wordt uitgevoerd door decimale getallen af te ronden op de dichtstbijzijnde equivalente dubbele waarde.

  • Conversie van dubbele naar decimale precisie wordt uitgevoerd door dubbele getallen af te ronden op de dichtstbijzijnde decimale waarde en, indien nodig, overloop naar #infinity of -#infinity waarden.

Operator voor optellen

De interpretatie van de optellingsoperator (x + y) is als volgt afhankelijk van het soort waarde van de geëvalueerde expressies x en y:

x y Result Interpretatie
type number type number type number Numerieke som
type number null null
null type number null
type duration type duration type duration Numerieke som van grootten
type duration null null
null type duration null
typeDatetime type duration typeDatetime Datum/tijd-verschuiving op duur
type duration typeDatetime typeDatetime
typeDatetime null null
null typeDatetime null

In de tabel typestaat datum/tijd voor een vantype date, type datetimeof type datetimezonetype time. Wanneer u een duur en een waarde van een bepaald type datum/tijd toevoegt, is de resulterende waarde van hetzelfde type.

Voor andere combinaties van waarden dan in de tabel wordt een fout met redencode "Expression.Error" gegenereerd. Elke combinatie wordt behandeld in de volgende secties.

Fouten die optreden bij het evalueren van een van beide operanden, worden doorgegeven.

Numerieke som

De som van twee getallen wordt berekend met behulp van de opteloperator, waardoor een getal wordt geproduceerd.

Bijvoorbeeld:

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

De operator voor optellen + van getallen maakt gebruik van dubbele precisie. De standaardbibliotheekfunctie Value.Add kan worden gebruikt om decimale precisie op te geven. Het volgende geldt voor het berekenen van een som van getallen:

  • De som in dubbele precisie wordt berekend volgens de regels van 64-bits binaire dubbelprecisie IEEE 754-rekenkundige IEEE 754-2008. De volgende tabel bevat de resultaten van alle mogelijke combinaties van niet-nulwaarden, nullen, infiniteiten en NaN's. In de tabel x en y niet-nul eindige waarden zijn en z het resultaat is van x + y. Als x en y dezelfde grootte maar tegengestelde tekenen hebben, z is positief nul. Als x + y te groot is om te worden weergegeven in het doeltype, z is een oneindigheid met hetzelfde teken als 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

  • De som in decimale precisie wordt berekend zonder precisie te verliezen. De schaal van het resultaat is de grotere schaal van de twee operanden.

Som van duur

De som van twee duur is de duur die de som aangeeft van het aantal tikken van 100nanoseconden die worden vertegenwoordigd door de duur. Bijvoorbeeld:

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

Datum/tijd-verschuiving op duur

Een datum/tijdx en een duur y kunnen worden toegevoegd om x + y een nieuwe datum/tijd te berekenen waarvan de afstand op x een lineaire tijdlijn precies de grootte is van y. Hier staat datum/tijd voor een vanDate,DateTime, DateTimeZoneof Time en een niet-null-resultaat van hetzelfde type. De datum/tijd-verschuiving op duur kan als volgt worden berekend:

  • Als de datum/tijd-dagen sinds de tijdwaarde is opgegeven, maakt u een nieuwe datum/tijd met de volgende informatie-elementen:

    • Bereken een nieuwe dagen sinds epoch gelijk aan het delen van de grootte van y door het aantal tikken van 100 nanoseconden in een periode van 24 uur, het decimale gedeelte van het resultaat afkappen en deze waarde toe te voegen aan de x-dagen sinds epoch.

    • Bereken een nieuwe maatstreepjes sinds middernacht gelijk aan het toevoegen van de grootte van y aan de tikken van de x sinds middernacht, modulo het aantal tikken van 100 nanoseconden in een periode van 24 uur. Als x geen waarde opgeeft voor tikken sinds middernacht, wordt uitgegaan van een waarde van 0.

    • Kopieer de waarde van x voor minuten offset van UTC ongewijzigd.

  • Als de datum/tijd-dagen sinds de epoch-waarde niet is opgegeven, maakt u een nieuwe datum/tijd met de volgende informatie-elementen die zijn opgegeven:

    • Bereken een nieuwe maatstreepjes sinds middernacht gelijk aan het toevoegen van de grootte van y aan de tikken van de x sinds middernacht, modulo het aantal tikken van 100 nanoseconden in een periode van 24 uur. Als x geen waarde opgeeft voor tikken sinds middernacht, wordt uitgegaan van een waarde van 0.

    • Kopieer x's waarden voor dagen sinds tijdsduur en minuten offset van UTC ongewijzigd.

In de volgende voorbeelden ziet u hoe de absolute tijdelijke som wordt berekend wanneer de datum/tijd de dagen sinds de periode aangeeft:

#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

In het volgende voorbeeld ziet u hoe u de datum/tijd-offset berekent op duur voor een bepaalde tijd:

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

Operator voor aftrekken

De interpretatie van de aftrekkingsoperator (x - y) is afhankelijk van het type waarde van de geëvalueerde expressies x en y, als volgt:

x J Result Interpretatie
type number type number type number Numeriek verschil
type number null null
null type number null
type duration type duration type duration Numeriek verschil van grootten
type duration null null
null type duration null
typeDatetime typeDatetime type duration Duur tussen datum/tijd
typeDatetime type duration typeDatetime Datum/tijd-verschuiving op negatieve duur
typeDatetime null null
null typeDatetime null

In de tabel typestaat datum/tijd voor een vantype date, type datetimeof type datetimezonetype time. Wanneer u een duur aftrekken van een waarde van een bepaald type datum/tijd, is de resulterende waarde van hetzelfde type.

Voor andere combinaties van waarden dan in de tabel wordt een fout met redencode "Expression.Error" gegenereerd. Elke combinatie wordt behandeld in de volgende secties.

Fouten die optreden bij het evalueren van een van beide operanden, worden doorgegeven.

Numeriek verschil

Het verschil tussen twee getallen wordt berekend met behulp van de aftrekkingsoperator, waardoor een getal wordt geproduceerd. Bijvoorbeeld:

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

De aftrekkingsoperator - voor getallen maakt gebruik van dubbele precisie. De standaardbibliotheekfunctie Value.Subtract kan worden gebruikt om decimale precisie op te geven. Het volgende geldt voor het berekenen van een verschil in getallen:

  • Het verschil in dubbele precisie wordt berekend volgens de regels van 64-bits binaire dubbele precisie IEEE 754-rekenkundige IEEE 754-2008. De volgende tabel bevat de resultaten van alle mogelijke combinaties van niet-nulwaarden, nullen, infiniteiten en NaN's. In de tabel x en y niet-nul eindige waarden zijn en z het resultaat is van x - y. Als x en y gelijk zijn, z is positief nul. Als x - y te groot is om te worden weergegeven in het doeltype, z is een oneindigheid met hetzelfde teken als 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

  • Het verschil in decimale precisie wordt berekend zonder precisie te verliezen. De schaal van het resultaat is de grotere schaal van de twee operanden.

Verschil in duur

Het verschil van twee duur is de duur die het verschil aangeeft tussen het aantal tikken van 100 nanoseconden dat wordt vertegenwoordigd door elke duur. Bijvoorbeeld:

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

Datum/tijd-verschuiving op negatieve duur

Een datum/tijdx en een duur y kunnen worden afgetrokken met behulp van het berekenen van x - y een nieuwe datum/tijd. Hier staat datum/tijd voor een vandate, datetime, datetimezoneof time. De resulterende datum/tijd heeft een afstand van x een lineaire tijdlijn die precies de grootte is van y, in de richting tegenover het teken van y. Het aftrekken van positieve duur resulteert in resultaten die achteruitgaan in de tijd ten opzichte xvan , terwijl het aftrekken van negatieve waarden resultaten oplevert die vooruitlopen in de tijd.

#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

Duur tussen twee datum/tijd

Twee datum/tijd en ut kunnen worden afgetrokken met behulp van t - u het berekenen van de duur ertussen. Hier staat datum/tijd voor een vandate, datetime, datetimezoneof time. De duur die wordt geproduceerd door af te u trekken, t moet opleveren t wanneer deze wordt toegevoegd aan 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

Aftrekken t - u wanneer u > t het resultaat een negatieve duur oplevert:

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

Het volgende geldt voor het aftrekken van twee datum/ tijd met behulp van t - u:

  • u + (t - u) = t

Vermenigvuldigingsoperator

De interpretatie van de vermenigvuldigingsoperator (x * y) is als volgt afhankelijk van het soort waarde van de geëvalueerde expressies x en y:

X J Result Interpretatie
type number type number type number Numeriek product
type number null null
null type number null
type duration type number type duration Meerdere duur
type number type duration type duration Meerdere duur
type duration null null
null type duration null

Voor andere combinaties van waarden dan in de tabel wordt een fout met redencode "Expression.Error" gegenereerd. Elke combinatie wordt behandeld in de volgende secties.

Fouten die optreden bij het evalueren van een van beide operanden, worden doorgegeven.

Numeriek product

Het product van twee getallen wordt berekend met behulp van de vermenigvuldigingsoperator, waardoor een getal wordt geproduceerd. Bijvoorbeeld:

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

De vermenigvuldigingsoperator * voor getallen maakt gebruik van dubbele precisie. De standaardbibliotheekfunctie Value.Multiply kan worden gebruikt om decimale precisie op te geven. Het volgende geldt voor het berekenen van een product van getallen:

  • Het product in Dubbele precisie wordt berekend volgens de regels van 64-bits binaire dubbele precisie IEEE 754-rekenkundige IEEE 754-2008. De volgende tabel bevat de resultaten van alle mogelijke combinaties van niet-nulwaarden, nullen, infiniteiten en NaN's. In de tabel x staan y positieve eindige waarden. z is het resultaat van x * y. Als het resultaat te groot is voor het doeltype, z is oneindig. Als het resultaat te klein is voor het doeltype, z is dit nul.

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

  • Het product in Decimal Precision wordt berekend zonder precisie te verliezen. De schaal van het resultaat is de grotere schaal van de twee operanden.

Veelvouden van duur

Het product van een duur en een getal is de duur die het aantal tikken van 100nanoseconden vertegenwoordigt die worden vertegenwoordigd door de duuroperand maal de getaloperand. Bijvoorbeeld:

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

Operator voor delen

De interpretatie van de delingsoperator (x / y) is afhankelijk van het soort waarde van de geëvalueerde expressies x en yals volgt:

X J Result Interpretatie
type number type number type number Numeriek quotiënt
type number null null
null type number null
type duration type number type duration Fractie van duur
type duration type duration type duration Numeriek quotiënt van duur
type duration null null
null type duration null

Voor andere combinaties van waarden dan in de tabel wordt een fout met redencode "Expression.Error" gegenereerd. Elke combinatie wordt behandeld in de volgende secties.

Fouten die optreden bij het evalueren van een van beide operanden, worden doorgegeven.

Numeriek quotiënt

Het quotiënt van twee getallen wordt berekend met behulp van de delingsoperator, waardoor een getal wordt geproduceerd. Bijvoorbeeld:

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

De operator voor delen / van getallen maakt gebruik van dubbele precisie. De standaardbibliotheekfunctie Value.Divide kan worden gebruikt om decimale precisie op te geven. Het volgende geldt voor het berekenen van een quotiënt van getallen:

  • Het quotiënt in dubbele precisie wordt berekend volgens de regels van 64-bits binaire IEEE 754-rekenkundige IEEE 754-2008. De volgende tabel bevat de resultaten van alle mogelijke combinaties van niet-nulwaarden, nullen, infiniteiten en NaN's. In de tabel x staan y positieve eindige waarden. z is het resultaat van x / y. Als het resultaat te groot is voor het doeltype, z is oneindig. Als het resultaat te klein is voor het doeltype, z is dit nul.

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

  • De som in decimale precisie wordt berekend zonder precisie te verliezen. De schaal van het resultaat is de grotere schaal van de twee operanden.

Quotiënt van duur

Het quotiënt van twee duur is het getal dat het quotiënt aangeeft van het aantal tikken van 100nanoseconden dat wordt vertegenwoordigd door de duur. Bijvoorbeeld:

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

Geschaalde duur

Het quotiënt van een duur x en een getal y is de duur die het quotiënt aangeeft van het aantal tikken van 100 nanoseconden die worden vertegenwoordigd door de duur x en het getal y. Bijvoorbeeld:

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

Structuurcombinatie

De combinatieoperator (x & y) wordt gedefinieerd voor de volgende soorten waarden:

X J Result Interpretatie
type text type text type text Samenvoegen
type text null null
null type text null
type date type time type datetime Samenvoeging
type date null null
null type time null
type list type list type list Samenvoegen
type record type record type record Samenvoeging
type table type table type table Samenvoegen

Samenvoegen

Twee tekst- of twee lijstwaarden of twee tabelwaarden kunnen worden samengevoegd met behulp van x & y.

In het volgende voorbeeld ziet u het samenvoegen van tekstwaarden:

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

Het volgende voorbeeld illustreert het samenvoegen van lijsten:

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

Het volgende geldt voor het samenvoegen van twee waarden met behulp van x & y:

  • Fouten die optreden bij het evalueren van de x of y expressies worden doorgegeven.

  • Er wordt geen fout doorgegeven als een item van of xy een fout bevat.

  • Het resultaat van het samenvoegen van twee tekstwaarden is een tekstwaarde die de waarde van x direct gevolgd door y bevat. Als een van de operanden null is en de andere een tekstwaarde is, is het resultaat null.

  • Het resultaat van het samenvoegen van twee lijsten is een lijst die alle items bevat van x gevolgd door alle items van y.

  • Het resultaat van het samenvoegen van twee tabellen is een tabel met de samenvoeging van de kolommen van de twee operandtabellen. De volgorde van x de kolommen blijft behouden, gevolgd door de kolommen die alleen worden weergegeven, ywaarbij de relatieve volgorde behouden blijft. Voor kolommen die slechts in een van de operanden worden weergegeven, null wordt gebruikt om celwaarden voor de andere operand in te vullen.

Samenvoeging

Record samenvoegen

Twee records kunnen worden samengevoegd met behulp van x & yeen record die velden van beide x en y.

De volgende voorbeelden illustreren het samenvoegen van records:

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

Het volgende geldt voor het samenvoegen van twee records met behulp van x + y:

  • Fouten die optreden bij het evalueren van de x of y expressies worden doorgegeven.

  • Als een veld wordt weergegeven in beide x en y, wordt de waarde uit y gebruikt.

  • De volgorde van de velden in de resulterende record is die van x, gevolgd door velden y die geen deel uitmaken van x, in dezelfde volgorde waarin ze worden weergegeven y.

  • Het samenvoegen van records veroorzaakt geen evaluatie van de waarden.

  • Er wordt geen fout gegenereerd omdat een veld een fout bevat.

  • Het resultaat is een record.

Datum/tijd samenvoegen

Een datum x kan worden samengevoegd met een tijd y met behulp van x & yeen datum/tijd die de delen van beide x en y.

In het volgende voorbeeld ziet u hoe u een datum en tijd samenvoegt:

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

Het volgende geldt voor het samenvoegen van twee records met behulp van x + y:

  • Fouten die optreden bij het evalueren van de x of y expressies worden doorgegeven.

  • Het resultaat is een datum/tijd.

Unaire operators

De +operatoren , -en not operators zijn unaire operatoren.

unary-expression:
      type-expressie
      +unaire expressie
      -unaire expressie
      notunaire expressie

Unary plus operator

De unaire plus-operator (+x) wordt gedefinieerd voor de volgende soorten waarden:

X Result Interpretatie
type number type number Unary plus
type duration type duration Unary plus
null 'null

Voor andere waarden wordt een fout met redencode "Expression.Error" gegenereerd.

Met de unaire plus-operator kan een + teken worden toegepast op een getal, datum/tijd of null-waarde. Het resultaat is dezelfde waarde. Bijvoorbeeld:

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

Het volgende geldt voor het evalueren van de unaire plus-operator +x:

  • Fouten die optreden bij het evalueren x , worden doorgegeven.

  • Als het resultaat van de evaluatie x geen numerieke waarde is, wordt er een fout met redencode "Expression.Error" gegenereerd.

Unary min-operator

De unaire min-operator (-x) wordt gedefinieerd voor de volgende soorten waarden:

X Result Interpretatie
type number type number Ontkenning
type duration type duration Ontkenning
null null

Voor andere waarden wordt een fout met redencode "Expression.Error" gegenereerd.

De unaire min-operator wordt gebruikt om het teken van een getal of duur te wijzigen. Bijvoorbeeld:

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

Het volgende geldt voor het evalueren van de unaire min-operator -x:

  • Fouten die optreden bij het evalueren x , worden doorgegeven.

  • Als de expressie een getal is, is het resultaat de getalwaarde van de expressie x met het bijbehorende teken gewijzigd. Als de waarde NaN is, is het resultaat ook NaN.

Logische negatieoperator

De logische negatieoperator (not) is gedefinieerd voor de volgende soorten waarden:

X Result Interpretatie
type logical type logical Ontkenning
null null

Deze operator berekent de logische not bewerking op een bepaalde logische waarde. Bijvoorbeeld:

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

Het volgende geldt voor het evalueren van de logische negatieoperator not x:

  • Fouten die optreden bij het evalueren x , worden doorgegeven.

  • De waarde die wordt geproduceerd door het evalueren van expressie x moet een logische waarde zijn of een fout met redencode "Expression.Error" moet worden gegenereerd. Als de waarde is true, is falsehet resultaat . Als de operand is false, is truehet resultaat .

Het resultaat is een logische waarde.

Typeoperators

De operators en as worden de typeoperators is genoemd.

Typecompatibiliteitsoperator

De operator voor typecompatibiliteit x is y wordt gedefinieerd voor de volgende typen waarden:

X J Result
type any nullable-primitive-type type logical

De expressie x is y retourneert als het getscribeerde type x compatibel is met y, en retourneert truefalse als het getscribeerde type x niet compatibel is met y. y moet een nullable-primitivetype zijn.

is-expression:
      as-expression
      is-expressionisnullable-primitive-type
nullable-primitive-type:
      nullableopt primitive-type

Typecompatibiliteit, zoals ondersteund door de is operator, is een subset van algemene typecompatibiliteit en wordt gedefinieerd met behulp van de volgende regels:

  • Als x null is, is het compatibel als y het type any, het type nullof een null-type is.

  • Als x het niet null is, dan als het een compatibel is als het primitieve type x hetzelfde is als y.

Het volgende geldt voor het evalueren van de expressie x is y:

  • Er is een fout opgetreden bij het evalueren van de expressie x .

Operator voor assertie typen

De operator x as y type assertion wordt gedefinieerd voor de volgende typen waarden:

X J Result
type any nullable-primitive-type type any

De expressie x as y geeft aan dat de waarde x compatibel is met y de is operator. Als deze niet compatibel is, wordt er een fout gegenereerd. y moet een nullable-primitive-type zijn.

as-expression:
      gelijkheidsexpressie
      as-expressionasnullable-primitive-type

De expressie x as y wordt als volgt geëvalueerd:

  • Er wordt een typecompatibiliteitscontrole x is y uitgevoerd en de assertie retourneert x ongewijzigd als deze test slaagt.

  • Als de compatibiliteitscontrole mislukt, wordt er een fout met redencode "Expression.Error" gegenereerd.

Voorbeelden:

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

Het volgende geldt voor het evalueren van de expressie x as y:

  • Er is een fout opgetreden bij het evalueren van de expressie x .

Samenvoegingsoperator

De samenvoegoperator ?? retourneert het resultaat van de linkeroperand als deze niet null is, anders wordt het resultaat van de rechteroperand geretourneerd. De rechteroperand wordt geëvalueerd als en alleen als de linkeroperand null is.