Del via

Funktionsmåde for operator

  • Artikel

I dette afsnit defineres funktionsmåden for de forskellige M-operatorer.

Operatorrækkefølge

Når et udtryk indeholder flere operatorer, styrer operatorernes prioritet den rækkefølge, som de enkelte operatorer evalueres i. Udtrykket x + y * z evalueres f.eks. som x + (y * z) , fordi operatoren * har højere prioritet end den binære + operator. En operators forrang bestemmes af definitionen af dens tilknyttede grammatikproduktion. Et additivt-udtryk består f.eks. af en sekvens af multiplikative-udtryk adskilt af + operatorerne eller - , hvilket giver operatorerne + og - lavere prioritet end operatorerne * og / .

Produktionen af parenteser-udtryk kan bruges til at ændre standardrækkefølgen.

parentesiseret-udtryk:
       ( udtryk)

Eksempler:

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

I følgende tabel opsummeres M-operatorerne med en liste over operatorkategorierne i prioriteret rækkefølge fra højeste til laveste. Operatorer i samme kategori har samme prioritet.

Kategori Udtryk Beskrivelse
Primær Jeg
@ Jeg		 Id-udtryk
(x) Udtryk med parentes
x[i] Søg
x{y} Elementadgang
x(...) Funktionsaktivering
{x, y, ...} Initialisering af liste
[ i = x, ... ] Initialisering af post
... Ikke implementeret
Monadiske + x Identitet
- x Negation
not x Logisk negation
Metadata xmetay Tilknyt metadata
Multiplicative x * y Multiplikation
x / y Afdeling
Tilsætningsstof x + y Tilføjelse
x - y Subtraktion
Relationel x< y Mindre end
x > y Større end
x<= y Mindre end eller lig med
x >= y Større end eller lig med
Lighed x = y Lig med
x<> y Ikke lig med
Typeantagelse xasy Er kompatibel null-primitiv type eller fejl
Typeoverensstemmelse xisy Test, om kompatibel null-primitiv type
Logisk AND xandy Kortslutnings-konjunktion
Logisk OR xory Fjernelse af kortslutning
Coalesce x??y Null-samlingsoperator

Operatorer og metadata

Hver værdi har en tilknyttet postværdi, der kan indeholde yderligere oplysninger om værdien. Denne post kaldes metadataposten for en værdi. En metadatapost kan knyttes til enhver form for værdi, selv null. Resultatet af en sådan tilknytning er en ny værdi med de angivne metadata.

En metadatapost er blot en almindelig post og kan indeholde alle felter og værdier, som en almindelig post kan, og selv har en metadatapost. Tilknytning af en metadatapost med en værdi er "ikke-påtrængende". Den ændrer ikke værdiens funktionsmåde i evalueringer undtagen dem, der eksplicit undersøger metadataposter.

Hver værdi har en standardmetadatapost, selvom der ikke er angivet en. Standardmetadataposten er tom. I følgende eksempler vises adgang til metadataposten for en tekstværdi ved hjælp af standardbiblioteksfunktionen Value.Metadata :

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

Metadataposter bevares generelt ikke, når en værdi bruges sammen med en operator eller funktion, der opretter en ny værdi. Hvis to tekstværdier f.eks. sammenkædes ved hjælp af operatoren & , er metadataene for den resulterende tekstværdi den tomme post []. Følgende udtryk svarer til hinanden:

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

Standardbiblioteksfunktionerne Value.RemoveMetadata og Value.ReplaceMetadata kan bruges til at fjerne alle metadata fra en værdi og til at erstatte en værdis metadata (i stedet for at flette metadata til muligvis eksisterende metadata).

Den eneste operator, der returnerer resultater, der indeholder metadata, er metaoperatoren.

Strukturelt rekursive operatorer

Værdier kan være cykliske. Eksempler:

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

M håndterer cykliske værdier ved at holde oprettelsen af poster, lister og tabeller dovne. Et forsøg på at konstruere en cyklisk værdi, der ikke har fordel af afbrudte strukturerede værdier, giver en fejl:

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

Nogle operatorer i M er defineret af strukturel rekursion. Lighed mellem poster og lister defineres f.eks. af den sammenhængende lighed mellem de tilsvarende postfelter og elementlister.

For ikke-cykliske værdier giver anvendelse af strukturel rekursion en endelig udvidelse af værdien: Delte indlejrede værdier gennemgås gentagne gange, men rekursionsprocessen afsluttes altid.

En cyklisk værdi har en uendelig udvidelse , når der anvendes strukturel rekursion. M's semantik gør ingen særlige tilpasninger til sådanne uendelige udvidelser – et forsøg på at sammenligne cykliske værdier for lighed vil f.eks. typisk løbe tør for ressourcer og afslutte undtagelsesvist.

Markerings- og projektionsoperatorer

Markerings- og projektionsoperatorer gør det muligt at udtrække data fra liste- og postværdier.

Elementadgang

En værdi kan vælges fra en liste eller tabel baseret på dens nulbaserede placering på den pågældende liste eller tabel ved hjælp af et element-access-udtryk.

item-access-expression:
      elementvalg
      optional-item-selection
elementvalg:
      primary-expression{item-selector}
optional-item-selection:
      primary-expression{item-selector} ?
elementvælger:
      udtryk

Item-access-expression x{y} returnerer:

  • For en liste x og et tal yer elementet på listen x på positionen y. Det første element på en liste anses for at have et ordenstalsindeks på nul. Hvis den ønskede placering ikke findes på listen, udløses der en fejl.

  • For en tabel x og et tal yer rækken i tabellen x ved position y. Den første række i en tabel anses for at have et ordenstalsindeks på nul. Hvis den anmodede placering ikke findes i tabellen, udløses der en fejl.

  • For en tabel x og en post yer den række i tabellen x , der svarer til feltværdierne for posten y for felter med feltnavne, der svarer til tilsvarende tabelkolonnenavne. Hvis der ikke er nogen entydig matchende række i tabellen, udløses der en fejl.

Eksempler:

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

Item-access-expression understøtter også formularen x{y}?, som returnerer null , når positionen (eller match) y ikke findes på listen eller i tabellen x. Hvis der er flere forekomster for y, udløses der stadig en fejl.

Eksempler:

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

Elementadgang gennemtvinger ikke evalueringen af andre liste- eller tabelelementer end det, der opnås adgang til. Eksempler:

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

Følgende gælder, når elementadgangsoperatoren x{y} evalueres:

  • Fejl, der opstår under evalueringen af udtryk x eller y overføres.

  • Udtrykket x opretter en liste eller en tabelværdi.

  • Udtrykket y producerer en talværdi eller en postværdi, hvis x der oprettes en tabelværdi.

  • Hvis y producerer en talværdi, og værdien af y er negativ, udløses der en fejl med årsagskoden "Expression.Error" .

  • Hvis y opretter en talværdi, og værdien af y er større end eller lig med antallet af x, udløses der en fejl med årsagskoden "Expression.Error" , medmindre den valgfrie operatorformular x{y}? bruges, i hvilket tilfælde værdien null returneres.

  • Hvis x opretter en tabelværdi og y opretter en postværdi, og der ikke er nogen match for y i x, udløses der en fejl med årsagskoden "Expression.Error" , medmindre den valgfrie operatorformular x{y}? bruges, i hvilket tilfælde værdien null returneres.

  • Hvis x opretter en tabelværdi og y opretter en postværdi, og der er flere forekomster for y i x, udløses der en fejl med årsagskoden "Expression.Error" .

Ingen elementer på x anden måde end dem på placeringen y evalueres under processen med valg af element. (I forbindelse med streaminglister eller tabeller springes elementerne eller rækkerne før dem på positionen y over, hvilket kan medføre, at de evalueres, afhængigt af kilden til listen eller tabellen).

Feltadgang

Feltadgangsudtrykket bruges til at vælge en værdi fra en post eller til at projektere en post eller tabel til en med færre felter eller kolonner.

field-access-expression:
      feltmarkering
      implicit-target-field-selection
      Projektion
      implicit-target-projection
field-selection:
      primary-expression field-selector
field-selector:
      required-field-selector
      optional-field-selector
required-field-selector:
       [ field-name]
optional-field-selector:
       [ field-name] ?
field-name:
      generalized-identifier
      quoted-identifier
implicit-target-field-selection:
      feltvælger
Projektion:
      primary-expression required-projection
      primary-expression optional-projection
required-projection:
       [ required-selector-list]
valgfri projektion:
       [ required-selector-list] ?
required-selector-list:
      required-field-selector
      required-selector-list,required-field-selector
implicit-target-projection:
      required-projection
      valgfri projektion

Den nemmeste form for feltadgang er obligatorisk feltvalg. Den bruger operatoren x[y] til at søge efter et felt i en post efter feltnavn. Hvis feltet y ikke findes i x, udløses der en fejl. Formularen x[y]? bruges til at udføre valgfri feltvalg og returnerer null , hvis det ønskede felt ikke findes i posten.

Eksempler:

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

Kollektiv adgang til flere felter understøttes af operatorerne til påkrævet postprojektion og valgfri postprojektion. Operatoren x[[y1],[y2],...] projekterer posten til en ny post med færre felter (valgt af y1, y2, ...). Hvis der ikke findes et markeret felt, udløses der en fejl. Operatoren x[[y1],[y2],...]? projekterer posten til en ny post med de felter, der er valgt af y1, y2. ...Hvis et felt mangler, null bruges i stedet. Eksempler:

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

Formularerne [y] og [y]? understøttes som en oversigtsreference til identifikatoren _ (understregningstegn). Følgende to udtryk svarer til hinanden:

[A]                 
_[A]

I følgende eksempel illustreres den korte form for feltadgang:

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

Formularen [[y1],[y2],...] og [[y1],[y2],...]? understøttes også som en oversigt, og følgende to udtryk svarer også til hinanden:

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

Den korte form er især nyttig i kombination med each oversigt, en måde at introducere en funktion af en enkelt parameter med navnet _ (du kan finde flere oplysninger under Forenklede erklæringer). Tilsammen forenkler de to oversigter almindelige funktionsudtryk i højere rækkefølge:

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

Ovenstående udtryk svarer til følgende mere kryptiske udseende longhand:

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

Feltadgang gennemtvinger ikke evalueringen af andre felter end dem, der åbnes. Eksempler:

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

Følgende gælder, når en feltadgangsoperator x[y], x[y]?, x[[y]]eller x[[y]]? evalueres:

  • Fejl, der opstår under evalueringen af udtrykket x , overføres.

  • Fejl, der udløses ved evaluering af feltet y , er permanent knyttet til feltet yog overføres derefter. Enhver fremtidig adgang til feltet y udløser den samme fejl.

  • Udtrykket x opretter en post- eller tabelværdi, eller der udløses en fejl.

  • Hvis id'et y navngiver et felt, der ikke findes i x, udløses der en fejl med årsagskoden "Expression.Error" , medmindre den valgfrie operatorformular ...? bruges, i hvilket tilfælde værdien null returneres.

Ingen andre felter end x det, der er navngivet af y , evalueres under feltadgangsprocessen.

Metadataoperator

Metadataposten for en værdi ændres ved hjælp af metaoperatoren (x meta y).

metadata-udtryk:
      monadisk-udtryk
      monadisk-udtrykmetamonadisk-udtryk

I følgende eksempel konstrueres en tekstværdi med en metadatapost ved hjælp af operatoren meta og får derefter adgang til metadataposten for den resulterende værdi ved hjælp af Value.Metadata:

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

Følgende gælder ved anvendelse af metadatakombinationsoperatoren x meta y:

  • Fejl, der udløses ved evaluering af udtrykkene x eller y , overføres.

  • Udtrykket y skal være en post, eller der udløses en fejl med årsagskoden "Expression.Error" .

  • Den resulterende metadatapost er x's metadatapost flettet med y. (Se semantik for postfletning under Postfletning.)

  • Den resulterende værdi er værdien fra x udtrykket uden dens metadata, hvor den nyligt beregnede metadatapost er vedhæftet.

Standardbiblioteksfunktionerne Value.RemoveMetadata og Value.ReplaceMetadata kan bruges til at fjerne alle metadata fra en værdi og til at erstatte en værdis metadata (i stedet for at flette metadata til muligvis eksisterende metadata). Følgende udtryk svarer til hinanden:

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

Lighedsoperatorer

Lighedsoperatoren = bruges til at bestemme, om to værdier er ens. Ulighedsoperatoren <> bruges til at bestemme, om to værdier ikke er ens.

lighedsudtryk:
      relationsudtryk
      relationsudtryk=lighedsudtryk
      relationsudtryk<>lighedsudtryk

Eksempler:

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

Metadata er ikke en del af ligheds- eller ulighedssammenligningen. Eksempler:

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

Følgende gælder ved anvendelse af lighedsoperatorer x = y og x <> y:

  • Fejl, der udløses ved evaluering af udtrykkene x eller y , overføres.

  • Operatoren = har et resultat af true , hvis værdierne er lige, og false ellers.

  • Operatoren <> har et resultat af false , hvis værdierne er lige, og true ellers.

  • Metadataposter er ikke inkluderet i sammenligningen.

  • Hvis værdier, der produceres ved at evaluere udtrykkene x og y , ikke er den samme type værdi, er værdierne ikke ens.

  • Hvis de værdier, der oprettes ved at evaluere x udtrykket og y , er den samme type værdi, er der specifikke regler for, om de er ens, som defineret nedenfor.

  • Følgende er altid sandt:

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

Lighedsoperatorer er defineret for følgende typer:

  • Værdien null er kun lig med sig selv.
    null = null    // true 
    null = true    // false 
    null = false   // false
  • De logiske værdier true og false er kun lig med sig selv. Eksempler:
    true = true      // true 
    false = false    // true 
    true = false     // false 
    true = 1         // false

  • Tal sammenlignes med den angivne præcision:

    • Hvis et af tallene er #nan, er tallene ikke de samme.

    • Når ingen af tallene er #nan, sammenlignes tallene ved hjælp af en bitvis sammenligning af den numeriske værdi.

    • #nan er den eneste værdi, der ikke er lig med sig selv.

      Eksempler:

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

  • To varigheder er lige, hvis de repræsenterer det samme antal 100-nanosekunder-akser.

  • To gange er lige, hvis størrelsen af deres dele (time, minut, sekund) er lige.

  • To datoer er lige, hvis størrelsen af deres dele (år, måned, dag) er lige.

  • To datetimes er lige, hvis størrelsen af deres dele (år, måned, dag, time, minut, sekund) er lige.

  • To datetimezones er lige, hvis de tilsvarende UTC-datetimes er ens. Hvis du vil modtage den tilsvarende UTC-datetime, trækkes forskydningen af timer/minutter fra datetime-komponenten i datetimezone.

  • To tekstværdier er ens, hvis de har samme længde og lige tegn på tilsvarende positioner, når der bruges en sammenligning, hvor der skelnes mellem store og små bogstaver.

  • To listeværdier er ens, hvis alle følgende er sande:

    • Begge lister indeholder det samme antal elementer.

    • Værdierne for hvert positionsmæssigt tilsvarende element på listerne er ens. Det betyder, at ikke kun listerne skal indeholde lige elementer, men at elementerne skal være i samme rækkefølge.

      Eksempler:

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

  • To poster er ens, hvis alle følgende er sande:

    • Antallet af felter er det samme.

    • Hvert feltnavn på én post findes også i den anden post.

    • Værdien af hvert felt i én post er lig med feltet med samme navn i den anden post.

      Eksempler:

        [ 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

  • To tabeller er ens, hvis alle følgende er sande:

    • Antallet af kolonner er det samme.

    • Hvert kolonnenavn i én tabel findes også i den anden tabel.

    • Antallet af rækker er det samme.

    • Hver række har ens værdier i tilsvarende celler.

      Eksempler:

        #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

  • En funktionsværdi er lig med sig selv, men kan være lig med en anden funktionsværdi. Hvis to funktionsværdier anses for at være lige, fungerer de identisk, når de aktiveres.

    To givne funktionsværdier vil altid have den samme lighedsrelation.

  • En typeværdi er lig med sig selv, men kan være lig med en anden typeværdi. Hvis to typeværdier anses for at være lige, fungerer de identisk, når der forespørges om overensstemmelse.

    To angivne typeværdier vil altid have den samme lighedsrelation.

Relationsoperatorer

Operatorerne , , og < kaldes relationsoperatorer.><=>=

relationelt-udtryk:
      additivt-udtryk
      additive-expression<relational-expression
      additive-expression>relational-expression
      additive-expression<=relational-expression
      additive-expression>=relational-expression

Disse operatorer bruges til at bestemme den relative sorteringsrelation mellem to værdier, som vist i følgende tabel:

Handling Resultat
x < y true hvis x er mindre end y, false ellers
x > y true hvis x er større end y, false ellers
x <= y true hvis x er mindre end eller lig med y, false ellers
x >= y true hvis x er større end eller lig med y, false ellers

Eksempler:

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

Følgende gælder ved evaluering af et udtryk, der indeholder relationsoperatorer:

  • Fejl, der udløses ved evaluering af x operand-udtrykkene eller y , overføres.

  • De værdier, der oprettes ved at evaluere både udtrykkene x og y , skal være en binær værdi, en dato, datetime, datetimezone, varighed, logisk, tal, null, tekst eller klokkeslætsværdi. Ellers udløses der en fejl med årsagskoden "Expression.Error" .

  • Begge operander skal være den samme type værdi eller null. Ellers udløses der en fejl med årsagskoden "Expression.Error" .

  • Hvis en eller begge operander er null, er resultatet værdien null .

  • To binære filer sammenlignes byte byte.

  • To datoer sammenlignes ved at sammenligne deres årsdele og, hvis de er lige, deres månedsdele og, hvis de er lige, deres dagsdele.

  • To datetimes sammenlignes ved at sammenligne deres årsdele og, hvis de er lige, deres månedsdele og, hvis de er lige, deres dagsdele og, hvis de er lige, deres timedele og, hvis de er lige, deres minutdele og, hvis de er lige, deres anden dele.

  • To datetimezones sammenlignes ved at normalisere dem til UTC ved at fratrække deres time/minut-forskydning og derefter sammenligne deres datetime-komponenter.

  • To varigheder sammenlignes i henhold til det samlede antal 100-nanosecond-akser, de repræsenterer.

  • To logiske elementer sammenlignes, så de true anses for at være større end false.

  • To tal x og y sammenlignes i henhold til reglerne i IEEE 754-standarden:

    • Hvis en af operanderne er #nan, er false resultatet for alle relationsoperatorer.

    • Når ingen operand er #nan, sammenligner operatorerne værdierne for de to flydende punktoperander med hensyn til den rækkefølge -∞ < -max < ... < -min < -0.0 = +0.0 < +min < ... < +max < +∞ , hvor min. og maks. er de mindste og største positive endelige værdier, der kan repræsenteres. M-navnene for -∞ og +∞ er -#infinity og #infinity.

      Bemærkelsesværdige virkninger af denne rækkefølge er:

      • Negative og positive nuller anses for at være lige.

      • En -#infinity værdi anses for at være mindre end alle andre talværdier, men lig med en anden -#infinity.

      • En #infinity værdi anses for at være større end alle andre talværdier, men lig med en anden #infinity.

  • To tekster sammenlignes ved hjælp af en ordinal, hvor der skelnes mellem store og små bogstaver, kulturfølsom sammenligning.

  • To gange sammenlignes ved at sammenligne deres timedele og, hvis de er lige, deres minutdele og, hvis de er lige, deres anden dele.

Betingede logiske operatorer

Operatorerne and og or kaldes de betingede logiske operatorer.

logical-or-expression:
      logical-and-expression
logical-and-expressionorlogical-or-expression
logical-and-expression:
      is-expression
      is-expressionandlogical-and-expression

Operatoren or returnerer true , når mindst én af operanderne er true. Den højre operand evalueres kun, hvis og kun hvis den venstre operand ikke trueer .

Operatoren and returnerer false , når mindst én af operanderne er false. Den højre operand evalueres kun, hvis og kun hvis den venstre operand ikke falseer .

Sandhedstabeller for operatorerne or og and vises nedenfor med resultatet af evalueringen af det venstre operand-udtryk på den lodrette akse og resultatet af evalueringen af det højre operand-udtryk på den vandrette akse.

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

Følgende gælder ved evaluering af et udtryk, der indeholder betingede logiske operatorer:

  • Fejl, der udløses ved evaluering af udtrykkene x eller y , overføres.

  • De betingede logiske operatorer er defineret for typerne logical og null. Hvis operandværdierne ikke er af disse typer, udløses der en fejl med årsagskoden "Expression.Error" .

  • Resultatet er en logisk værdi.

  • I udtrykket x eller yevalueres udtrykket y kun, hvis og kun hvis x ikke evalueres til true.

  • I udtrykket x og yevalueres udtrykket y kun, hvis og kun hvis x ikke evalueres til false.

De to sidste egenskaber giver de betingede logiske operatorer deres "betingede" kvalifikation. egenskaber, der også kaldes "kortslutning". Disse egenskaber er nyttige til at skrive kompakte beskyttede prædikater. Følgende udtryk svarer f.eks. til hinanden:

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

Aritmetiske operatorer

Operatorerne +, -*og / er de aritmetiske operatorer.

additivt-udtryk:
      multiplikativt-udtryk
      additive-expression+multiplicative-expression
      additive-expression-multiplicative-expression
multiplikativt-udtryk:
      metadata- udtryk
      multiplicative-expression*metadata-expression
      multiplicative-expression/metadata-expression

Præcision

Tal i M gemmes ved hjælp af en række repræsentationer for at bevare så mange oplysninger som muligt om tal, der kommer fra en række forskellige kilder. Tal konverteres kun fra én repræsentation til en anden efter behov af operatorer, der er anvendt på dem. To præcisioner understøttes i M:

Præcision Semantik
Precision.Decimal 128-bit decimalrepræsentation med et interval på ±1,0 x 10-28 til ±7,9 x 1028 og 28-29 betydende cifre.
Precision.Double Videnskabelig repræsentation ved hjælp af mantissa og eksponent; overholder 64-bit binær dobbelt præcision IEEE 754 aritmetisk standard IEEE 754-2008.

Aritmetiske handlinger udføres ved at vælge en præcision, konvertere begge operander til denne præcision (hvis det er nødvendigt), derefter udføre den faktiske handling og til sidst returnere et tal i den valgte præcision.

De indbyggede aritmetiske operatorer (+, -, *) /bruger dobbelt præcision. Standardbiblioteksfunktioner (Value.Add, Value.Subtract, Value.Multiply, Value.Divide) kan bruges til at anmode om disse handlinger ved hjælp af en bestemt præcisionsmodel.

  • Numerisk overløb er ikke muligt: #infinity eller -#infinity repræsenterer værdier af størrelser, der er for store til at blive repræsenteret.

  • Numerisk underflow er ikke muligt: 0 og -0 repræsenterer værdier af størrelser, der er for små til at blive repræsenteret.

  • IEEE 754-specialværdien #nan (NaN – Ikke et tal) bruges til at dække aritmetisk ugyldige tilfælde, f.eks. en division på nul med nul.

  • Konvertering fra Decimal til Dobbelt præcision udføres ved at afrunde decimaltal til den nærmeste tilsvarende dobbeltværdi.

  • Konvertering fra dobbelt til decimalpræcision udføres ved at afrunde dobbelte tal til den nærmeste tilsvarende decimalværdi og om nødvendigt overløb til #infinity eller -#infinity værdier.

Additionsoperator

Fortolkningen af additionsoperatoren (x + y) afhænger af typen af værdi for de evaluerede udtryk x og y på følgende måde:

x y Resultat Fortolkning
type number type number type number Numerisk sum
type number null null
null type number null
type duration type duration type duration Numerisk sum af størrelser
type duration null null
null type duration null
type datetime type duration type datetime Datetime-forskydning efter varighed
type duration type datetime type datetime
type datetime null null
null type datetime null

I tabellen typestår datetime for en af , type datetype datetime, type datetimezoneeller type time. Når du tilføjer en varighed og en værdi af en type datetime, er den resulterende værdi af samme type.

For andre kombinationer af værdier end dem, der er angivet i tabellen, udløses der en fejl med årsagskoden "Expression.Error" . Hver kombination beskrives i følgende afsnit.

Fejl, der udløses ved evaluering af en operand, overføres.

Numerisk sum

Summen af to tal beregnes ved hjælp af additionsoperatoren, der producerer et tal.

Eksempler:

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

Additionsoperatoren + over tal bruger dobbelt præcision. Standardbiblioteksfunktionen Value.Add kan bruges til at angive decimalpræcision. Følgende gælder ved beregning af en sum af tal:

  • Summen i dobbelt præcision beregnes i henhold til reglerne for 64-bit binær dobbelt præcision IEEEE 754 aritmetisk IEEE 754-2008. I følgende tabel vises resultaterne af alle mulige kombinationer af ikke-nulgrænseværdier, nuller, uendeligheder og NaN'er. I tabellen x er og y ikke-nulgrænseværdier, og z er resultatet af x + y. Hvis x og y har samme størrelse, men modsatte tegn, z er positivt nul. Hvis x + y er for stor til at blive repræsenteret i destinationstypen, z er en uendelighed med det samme fortegn som 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

  • Summen i decimalpræcision beregnes uden at miste præcision. Skalaen af resultatet er den største af skalaerne for de to operander.

Sum af varigheder

Summen af to varigheder er den varighed, der repræsenterer summen af antallet af 100nanosecond-akser, der repræsenteres af varighederne. Eksempler:

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

Datetime-forskydning efter varighed

Der og en varighed x ved hjælp af y for at beregne en ny x + y, hvis afstand fra på en lineær tidslinje er nøjagtigt størrelsen på x. Her står datetime for et vilkårligt resultat af Datetypen , DateTime, DateTimeZoneeller , og Time et resultat, der ikke er null, vil være af samme type. Forskydningen af datetime efter varighed kan beregnes på følgende måde:

  • Hvis datetimes dage siden epokeværdien er angivet, skal du konstruere en ny datetime med følgende oplysningselementer:

    • Beregn nye dage siden epoken, hvilket svarer til at dividere størrelsen af y med antallet af 100-nanosekunder-akser i en 24-timers periode, afkorte decimaldelen af resultatet og føje denne værdi til x's dage siden epoken.

    • Beregn en ny akse siden midnat, hvilket svarer til at føje størrelsen af y til x's akser siden midnat, modulo antallet af 100-nanosekunder-akser i en 24-timers periode. Hvis x ikke angiver en værdi for akser siden midnat, antages værdien 0.

    • Kopiér x's værdi for minutter forskudt fra UTC uændret.

  • Hvis datetime-dagene siden epokeværdien ikke er angivet, skal du konstruere en ny datetime med følgende oplysningselementer angivet:

    • Beregn en ny akse siden midnat, hvilket svarer til at føje størrelsen af y til x's akser siden midnat, modulo antallet af 100-nanosekunder-akser i en 24-timers periode. Hvis x ikke angiver en værdi for akser siden midnat, antages værdien 0.

    • Kopiér x's værdier for dage siden epoke og minutter forskydning fra UTC uændret.

Følgende eksempler viser beregning af den absolutte tidsmæssige sum, når datetime angiver dagene siden epoken:

#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

I følgende eksempel kan du se beregning af datetime-forskydningen efter varighed for et givet klokkeslæt:

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

Subtraktionsoperator

Fortolkningen af subtraktionsoperatoren (x - y) afhænger af typen af værdien af de evaluerede udtryk x og ypå følgende måde:

x J Resultat Fortolkning
type number type number type number Numerisk forskel
type number null null
null type number null
type duration type duration type duration Numerisk forskel mellem størrelser
type duration null null
null type duration null
type datetime type datetime type duration Varighed mellem datetimes
type datetime type duration type datetime Datetime-forskydning efter negeret varighed
type datetime null null
null type datetime null

I tabellen typestår datetime for en af , type datetype datetime, type datetimezoneeller type time. Når du trækker en varighed fra en værdi af en type datetime, er den resulterende værdi af samme type.

For andre kombinationer af værdier end dem, der er angivet i tabellen, udløses der en fejl med årsagskoden "Expression.Error" . Hver kombination beskrives i følgende afsnit.

Fejl, der udløses ved evaluering af en operand, overføres.

Numerisk forskel

Forskellen mellem to tal beregnes ved hjælp af subtraktionsoperatoren, der producerer et tal. Eksempler:

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

Subtraktionsoperatoren - over tal bruger dobbelt præcision. Standardbiblioteksfunktionen Value.Subtract kan bruges til at angive decimalpræcision. Følgende gælder ved beregning af en forskel mellem tal:

  • Forskellen i dobbelt præcision beregnes i henhold til reglerne for 64-bit binær dobbelt præcision IEEE 754 aritmetisk IEEE 754-2008. I følgende tabel vises resultaterne af alle mulige kombinationer af ikke-nulgrænseværdier, nuller, uendeligheder og NaN'er. I tabellen x er og y ikke-nulgrænseværdier, og z er resultatet af x - y. Hvis x og y er lige, z er positivt nul. Hvis x - y er for stor til at blive repræsenteret i destinationstypen, z er en uendelighed med det samme fortegn som 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

  • Forskellen i decimalpræcision beregnes uden at miste præcision. Skalaen af resultatet er den største af skalaerne for de to operander.

Forskel på varigheder

Forskellen på to varigheder er den varighed, der repræsenterer forskellen mellem antallet af 100-nanosekunder-akser, der repræsenteres af hver varighed. Eksempler:

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

Datetime-forskydning efter negeret varighed

En datetimex og en varighed y kan fratrækkes ved hjælp af x - y for at beregne en ny datetime. Her står datetime for en af date, datetime, datetimezoneeller time. Den resulterende datetime Hvis du trækker positive varigheder fra, giver det resultater, der er bagud i tid i forhold til x, mens fratrækning af negative værdier giver resultater, der er fremadrettet i tiden.

#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

Varighed mellem to datetimes

To datetimest og u kan trækkes fra ved hjælp af t - u for at beregne varigheden mellem dem. Her står datetime for en af date, datetime, datetimezoneeller time. Den varighed, der fremkommer ved at u trække fra t , skal give sig ud, t når den føjes til 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

t - u Fratrækning af når u > t resulterer i en negativ varighed:

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

Følgende gælder ved fratrækning af to datetimes ved hjælp af t - u:

  • u + (t - u) = t

Multiplikationsoperator

Fortolkningen af multiplikationsoperatoren (x * y) afhænger af typen af værdi for de evaluerede udtryk x og y på følgende måde:

X J Resultat Fortolkning
type number type number type number Numerisk produkt
type number null null
null type number null
type duration type number type duration Multiplum af varighed
type number type duration type duration Multiplum af varighed
type duration null null
null type duration null

For andre kombinationer af værdier end dem, der er angivet i tabellen, udløses der en fejl med årsagskoden "Expression.Error" . Hver kombination beskrives i følgende afsnit.

Fejl, der udløses ved evaluering af en operand, overføres.

Numerisk produkt

Produktet af to tal beregnes ved hjælp af multiplikationsoperatoren, der producerer et tal. Eksempler:

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

Multiplikationsoperatoren * over tal bruger dobbelt præcision. Standardbiblioteksfunktionen Value.Multiply kan bruges til at angive decimalpræcision. Følgende gælder ved beregning af et produkt af tal:

  • Produktet i dobbelt præcision beregnes i henhold til reglerne i 64-bit binær dobbelt præcision IEEE 754 aritmetisk IEEE 754-2008. I følgende tabel vises resultaterne af alle mulige kombinationer af ikke-nulgrænseværdier, nuller, uendeligheder og NaN'er. I tabellen x er og y positive endelige værdier. z er resultatet af x * y. Hvis resultatet er for stort til destinationstypen, z er uendeligt. Hvis resultatet er for lille til destinationstypen, z er 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

  • Produktet i decimalpræcision beregnes uden at miste præcision. Skalaen af resultatet er den største af skalaerne for de to operander.

Flere varigheder

Produktet af en varighed og et tal er den varighed, der repræsenterer antallet af 100nanosecond-akser, der repræsenteres af operandens varighed gange tallets operand. Eksempler:

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

Divisionsoperator

Fortolkningen af divisionsoperatoren (x / y) afhænger af typen af værdi for de evaluerede udtryk x og ypå følgende måde:

X J Resultat Fortolkning
type number type number type number Numerisk kvotient
type number null null
null type number null
type duration type number type duration Brøkdel af varighed
type duration type duration type number Numerisk kvotient af varigheder
type duration null null
null type duration null

For andre kombinationer af værdier end dem, der er angivet i tabellen, udløses der en fejl med årsagskoden "Expression.Error" . Hver kombination beskrives i følgende afsnit.

Fejl, der udløses ved evaluering af en operand, overføres.

Numerisk kvotient

Kvotienten af to tal beregnes ved hjælp af divisionsoperatoren, der producerer et tal. Eksempler:

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

Divisionsoperatoren / over tal bruger dobbelt præcision. Standardbiblioteksfunktionen Value.Divide kan bruges til at angive decimalpræcision. Følgende gælder ved beregning af en kvotient af tal:

  • Kvotienten i dobbelt præcision beregnes i henhold til reglerne i 64-bit binær dobbelt præcision IEEE 754 aritmetisk IEEE 754-2008. I følgende tabel vises resultaterne af alle mulige kombinationer af ikke-nulgrænseværdier, nuller, uendeligheder og NaN'er. I tabellen x er og y positive endelige værdier. z er resultatet af x / y. Hvis resultatet er for stort til destinationstypen, z er uendeligt. Hvis resultatet er for lille til destinationstypen, z er 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

  • Summen i decimalpræcision beregnes uden at miste præcision. Skalaen af resultatet er den største af skalaerne for de to operander.

Kvotient af varigheder

Kvotienten af to varigheder er det tal, der repræsenterer kvotienten af antallet af 100nanosecond-akser, der repræsenteres af varighederne. Eksempler:

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

Skalerede varigheder

Kvotienten af en varighed x og et tal y er den varighed, der repræsenterer kvotienten af antallet af 100-nanosecond-akser repræsenteret af varigheden x og tallet y. Eksempler:

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

Strukturkombination

Kombinationsoperatoren (x & y) er defineret for følgende typer værdier:

X J Resultat Fortolkning
type text type text type text Sammenkædning
type text null null
null type text null
type date type time type datetime Fletning
type date null null
null type time null
type list type list type list Sammenkædning
type record type record type record Fletning
type table type table type table Sammenkædning

Sammenkædning

To tekst-, to liste- eller to tabelværdier kan sammenkædes ved hjælp af x & y.

I følgende eksempel illustreres sammenkædning af tekstværdier:

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

I følgende eksempel illustreres sammenkædning af lister:

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

Følgende gælder ved sammenkædning af to værdier ved hjælp af x & y:

  • Fejl, der udløses ved evaluering af udtrykkene x eller y , overføres.

  • Der overføres ingen fejl, hvis et element af enten x eller y indeholder en fejl.

  • Resultatet af sammenkædningen af to tekstværdier er en tekstværdi, der indeholder værdien af x umiddelbart efterfulgt af y. Hvis en af operanderne er null, og den anden er en tekstværdi, er resultatet null.

  • Resultatet af sammenkædningen af to lister er en liste, der indeholder alle elementerne i efterfulgt af x alle elementerne i y.

  • Resultatet af sammenkædningen af to tabeller er en tabel, der har foreningen af kolonnerne i den to operandtabel. Kolonnerækkefølgen bevares x efterfulgt af, at kolonnerne kun vises i y, og deres relative rækkefølge bevares. For kolonner, der kun vises i en af operanderne, null bruges til at udfylde celleværdier for den anden operand.

Fletning

Postfletning

To poster kan flettes ved hjælp af x & y, hvilket producerer en post, der indeholder felter fra både x og y.

I følgende eksempler illustreres fletning af poster:

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

Følgende gælder ved fletning af to poster ved hjælp af x + y:

  • Fejl, der udløses ved evaluering af udtrykkene x eller y , overføres.

  • Hvis et felt vises i både x og y, bruges værdien fra y .

  • Rækkefølgen af felterne i den resulterende post er , efterfulgt af xfelter i y , der ikke er en del af x, i den samme rækkefølge, som de vises i y.

  • Fletning af poster medfører ikke evaluering af værdierne.

  • Der udløses ingen fejl, fordi et felt indeholder en fejl.

  • Resultatet er en post.

Dato/klokkeslæt-fletning

En dato x kan flettes med et klokkeslæt y ved hjælp af x & y, hvilket producerer en datetime, der kombinerer delene fra både x og y.

I følgende eksempel illustreres fletning af en dato og et klokkeslæt:

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

Følgende gælder ved fletning af to poster ved hjælp af x + y:

  • Fejl, der udløses ved evaluering af udtrykkene x eller y , overføres.

  • Resultatet er en datetime.

Unære operatorer

Operatorerne +, -og not er monadiske operatorer.

monadisk-udtryk:
      type-expression
       + monadisk udtryk
       - monadisk udtryk
       not monadisk udtryk

Monadisk plusoperator

Den monadiske plusoperator (+x) er defineret for følgende typer værdier:

X Resultat Fortolkning
type number type number Monadisk plus
type duration type duration Monadisk plus
null 'null

For andre værdier udløses der en fejl med årsagskoden "Expression.Error" .

Den monadiske plusoperator gør det muligt at anvende et + fortegn på et tal, datetime eller en null-værdi. Resultatet er den samme værdi. Eksempler:

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

Følgende gælder ved evaluering af den monadiske plusoperator +x:

  • Fejl, der udløses ved evaluering, x overføres.

  • Hvis resultatet af evalueringen x ikke er en talværdi, udløses der en fejl med årsagskoden "Expression.Error" .

Monadisk minusoperator

Den monadiske minusoperator (-x) er defineret for følgende typer værdier:

X Resultat Fortolkning
type number type number Negation
type duration type duration Negation
null null

For andre værdier udløses der en fejl med årsagskoden "Expression.Error" .

Den monadiske minusoperator bruges til at ændre fortegnet for et tal eller en varighed. Eksempler:

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

Følgende gælder ved evaluering af den monadiske minusoperator -x:

  • Fejl, der udløses ved evaluering, x overføres.

  • Hvis udtrykket er et tal, er resultatet talværdien fra udtrykket x med dets fortegn ændret. Hvis værdien er NaN, er resultatet også NaN.

Logisk negationsoperator

Den logiske negationsoperator (not) er defineret for følgende typer værdier:

X Resultat Fortolkning
type logical type logical Negation
null null

Denne operator beregner den logiske not handling på en given logisk værdi. Eksempler:

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

Følgende gælder ved evaluering af den logiske negationsoperator not x:

  • Fejl, der udløses ved evaluering, x overføres.

  • Den værdi, der oprettes ud fra evalueringsudtrykket x, skal være en logisk værdi, eller der skal udløses en fejl med årsagskoden "Expression.Error" . Hvis værdien er true, er falseresultatet . Hvis operanden er false, er trueresultatet .

Resultatet er en logisk værdi.

Typeoperatorer

Operatorerne is og as kaldes typeoperatorer.

Typekompatibilitetsoperator

Typekompatibilitetsoperatoren x is y er defineret for følgende typer værdier:

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

Udtrykket x is y returnerer true , hvis den tilskrevne type er x kompatibel med y, og returnerer false , hvis den tilskrevne type ikke x er kompatibel med y. y skal være en null-primitiv type.

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

Typekompatibilitet, som understøttes af operatoren is , er et undersæt af generel typekompatibilitet og defineres ved hjælp af følgende regler:

  • Hvis x er null, er den kompatibel, hvis y er typen any, typen nulleller en type, der kan være null.

  • Hvis x er ikke-null, så hvis den er kompatibel, hvis den primitive type af x er den samme som y.

Følgende gælder ved evaluering af udtrykket x is y:

  • Der opstod en fejl under overførsel af evalueringsudtrykket x .

Typeantagelsesoperator

Typeantagelsesoperatoren x as y er defineret for følgende typer værdier:

X J Resultat
type any nullable-primitive-type type any

Udtrykket x as y hævder, at værdien x er kompatibel med y i henhold til operatoren is . Hvis den ikke er kompatibel, udløses der en fejl. y skal være en null-primitiv-type.

as-expression:
      lighedsudtryk
      as-expressionasnullable-primitive-type

Udtrykket x as y evalueres på følgende måde:

  • Der udføres en typekompatibilitetskontrol x is y , og antagelsen returnerer x uændret, hvis denne test lykkes.

  • Hvis kompatibilitetskontrollen mislykkes, udløses der en fejl med årsagskoden "Expression.Error" .

Eksempler:

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

Følgende gælder ved evaluering af udtrykket x as y:

  • Der opstod en fejl under overførsel af evalueringsudtrykket x .

Samleoperatør

Coalesce-operatoren ?? returnerer resultatet af sin venstre operand, hvis den ikke er null, ellers returnerer den resultatet af dens højre operand. Den højre operand evalueres kun, hvis og kun hvis den venstre operand er null.