Del via

Operatorvirkemåte

  • Artikkel

Denne delen definerer virkemåten til de ulike M-operatorene.

Operatorprioriteten

Når et uttrykk inneholder flere operatorer, styrer operatorenes prioritet rekkefølgen de individuelle operatorene evalueres i. Uttrykket x + y * z evalueres for eksempel som x + (y * z) fordi operatoren * har høyere prioritet enn binæroperatoren + . Prioriteten til en operator er etablert av definisjonen av den tilknyttede grammatikkproduksjonen. Et additivuttrykk består for eksempel av en sekvens av multiplikative uttrykk atskilt med + eller operatorer, noe - som gir operatorene + og operatorene - lavere prioritet enn operatorene * og / operatorene.

Produksjonen av parentesert uttrykk kan brukes til å endre standard prioritetsrekkefølge.

parentes-uttrykk:
       ( uttrykk)

Eksempel:

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

Tabellen nedenfor oppsummerer M-operatorene, og viser operatorkategoriene etter prioritet fra høyeste til laveste. Operatorer i samme kategori har lik prioritet.

Kategori Uttrykk Bekrivelse
Primært jeg
@ jeg		 Identifikatoruttrykk
(x) Parentesert uttrykk
x[i] Lookup
x{y} Elementtilgang
x(...) Funksjonsinvokasjon
{x, y, ...} Liste initialisering
[ i = x, ... ] Post initialisering
... Ikke implementert
Unær + x Identitet
- x Negasjonen
not x Logisk nektelse
Metadata xmetay Knytt metadata
Multiplikativ x * y Multiplikasjon
x / y Avdeling
Tilsetningsstoff x + y Addisjon
x - y Subtraksjon
Relasjonelt x< y Mindre enn
x > y Større enn
x<= y Mindre enn eller lik
x >= y Større enn eller lik
Likhet x = y Lik
x<> y Not equal
Typedeklarasjon xasy Er kompatibel nullbar-primitiv type eller feil
Typekonformitet xisy Test om kompatibel, nullbar-primitiv type
Logisk OG xandy Konjunksjon for kortslutning
Logisk ELLER xory Kortslutningsdejunksjon
Coalesce x??y Null-koaguleringsoperator

Operatorer og metadata

Hver verdi har en tilknyttet postverdi som kan inneholde tilleggsinformasjon om verdien. Denne posten kalles metadataposten for en verdi. En metadatapost kan knyttes til alle typer verdier, selv null. Resultatet av en slik tilknytning er en ny verdi med de angitte metadataene.

En metadatapost er bare en vanlig post og kan inneholde alle felt og verdier som en vanlig post kan, og selv har en metadatapost. Å knytte en metadatapost til en verdi er «ikke-påtrengende». Den endrer ikke verdiens virkemåte i evalueringer, bortsett fra de som eksplisitt inspiserer metadataposter.

Hver verdi har en standard metadatapost, selv om en ikke er angitt. Standard metadatapost er tom. Eksemplene nedenfor viser tilgang til metadataposten for en tekstverdi ved hjelp Value.Metadata av standard bibliotekfunksjon:

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

Metadataposter bevares vanligvis ikke når en verdi brukes med en operator eller funksjon som konstruerer en ny verdi. Hvis for eksempel to tekstverdier kjedes sammen ved hjelp & av operatoren, er metadataene for den resulterende tekstverdien den tomme posten []. Følgende uttrykk tilsvarer:

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

Standard bibliotekfunksjoner Value.RemoveMetadata og Value.ReplaceMetadata kan brukes til å fjerne alle metadata fra en verdi og erstatte metadataene til en verdi (i stedet for å slå sammen metadata til muligens eksisterende metadata).

Den eneste operatoren som returnerer resultater som inneholder metadata, er metaoperatoren.

Strukturelt rekursive operatorer

Verdier kan være sykliske. Eksempel:

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

M håndterer sykliske verdier ved å holde konstruksjonen av poster, lister og tabeller late. Et forsøk på å konstruere en syklisk verdi som ikke drar nytte av sammenflettede late strukturerte verdier, gir en feil:

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

Noen operatorer i M er definert av strukturell rekursjon. Likhet mellom poster og lister defineres for eksempel av den sammenkoblede likheten mellom tilsvarende postfelt og elementlister.

For ikke-sykliske verdier gir bruk av strukturell rekursjon en begrenset utvidelse av verdien: delte nestede verdier vil bli krysset gjentatte ganger, men prosessen med rekursjon avsluttes alltid.

En syklisk verdi har en uendelig utvidelse når du bruker strukturell rekursjon. Semantikken til M gjør ingen spesielle overnattingssteder for slike uendelige utvidelser – et forsøk på å sammenligne sykliske verdier for likestilling, for eksempel, vil vanligvis gå tom for ressurser og avsluttes eksepsjonelt.

Valg- og projeksjonsoperatorer

Operatorene for valg og projeksjon tillater at data trekkes ut fra liste- og postverdier.

Elementtilgang

En verdi kan velges fra en liste eller tabell basert på den nullbaserte posisjonen i listen eller tabellen ved hjelp av et elementtilgangsuttrykk.

element-tilgang-uttrykk:
      elementvalg
      valgfritt elementvalg
elementvalg:
      elementvelger for primært uttrykk{}
valgfritt elementvalg:
      elementvelger for primært uttrykk{} ?
elementvelger:
      uttrykk

Elementtilgangsuttrykket x{y} returnerer:

  • For en liste x og et tall yer listeelementet x i posisjon y. Det første elementet i en liste anses å ha en ordenstallindeks på null. Hvis den forespurte posisjonen ikke finnes i listen, utløses en feil.

  • For en tabell x og et tall y, raden i tabellen x i posisjon y. Den første raden i en tabell anses å ha en ordenstallindeks på null. Hvis den forespurte posisjonen ikke finnes i tabellen, utløses en feil.

  • For en tabell x og en post y, raden i tabellen x som samsvarer med feltverdiene i posten y for felt med feltnavn som samsvarer med tilsvarende tabellkolonnenavn. Hvis det ikke er noen unik samsvarende rad i tabellen, utløses en feil.

Eksempel:

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

Elementtilgangsuttrykket støtter også skjemaet x{y}?, som returneres null når posisjon (eller samsvar) y ikke finnes i listen eller tabellenx. Hvis det finnes flere treff for y, utløses det fortsatt en feil.

Eksempel:

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

Elementtilgang tvinger ikke evalueringen av andre liste- eller tabellelementer enn det som åpnes. Eksempel:

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

Følgende gjelder når operatoren for elementtilgang x{y} evalueres:

  • Feil som oppstår under evalueringen av uttrykk eller x overføresy.

  • Uttrykket x produserer en liste eller en tabellverdi.

  • Uttrykket y produserer en tallverdi eller, hvis x det produserer en tabellverdi, en postverdi.

  • Hvis y produserer en tallverdi og verdien av y er negativ, utløses en feil med årsakskode "Expression.Error" .

  • Hvis y produserer en tallverdi og verdien av y er større enn eller lik antallet x, utløses en feil med årsakskode "Expression.Error" med mindre det valgfrie operatorskjemaet x{y}? brukes, i så fall returneres verdien null .

  • Hvis x produserer en tabellverdi og y produserer en postverdi og det ikke finnes noen treff for y i x, utløses en feil med årsakskode "Expression.Error" med mindre det valgfrie operatorskjemaet x{y}? brukes, i så fall returneres verdien null .

  • Hvis x produserer en tabellverdi og y produserer en postverdi og det finnes flere treff for y i x, utløses en feil med årsakskode "Expression.Error" .

Ingen elementer i x annet enn plasseringen y evalueres under prosessen med elementvalg. (For strømming av lister eller tabeller hoppes elementene eller radene foran plasseringen y over, noe som kan føre til evaluering, avhengig av kilden til listen eller tabellen.)

Felttilgang

Felttilgangsuttrykket brukes til å velge en verdi fra en post, eller til å projisere en post eller tabell til en med henholdsvis færre felt eller kolonner.

felttilgangsuttrykk:
      feltvalg
      implisitt målfeltvalg
      projeksjon
      implisitt målprojeksjon
feltvalg:
      feltvelger for primæruttrykk
feltvelger:
      obligatorisk feltvelger
      valgfritt feltvelger
obligatorisk feltvelger:
       [ feltnavn]
valgfritt feltvelger:
       [ feltnavn] ?
feltnavn:
      generalisert identifikator
      quoted-identifier
implisitt målfeltvalg:
      feltvelger
projeksjon:
      obligatorisk projeksjon av primæruttrykk
      valgfri projeksjon av primæruttrykk
obligatorisk projeksjon:
       [ obligatorisk velgerliste]
valgfri projeksjon:
       [ obligatorisk velgerliste] ?
obligatorisk velgerliste:
      obligatorisk feltvelger
      obligatorisk velgerliste,obligatorisk feltvelger
implisitt målprojeksjon:
      obligatorisk projeksjon
      valgfri projeksjon

Den enkleste formen for felttilgang er obligatorisk feltvalg. Den bruker operatoren x[y] til å slå opp et felt i en post etter feltnavn. Hvis feltet y ikke finnes i x, utløses en feil. Skjemaet x[y]? brukes til å utføre valgfritt feltvalg, og returnerer null hvis det forespurte feltet ikke finnes i posten.

Eksempel:

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

Kollektiv tilgang til flere felt støttes av operatorene for nødvendig postprojeksjon og valgfri postprojeksjon. Operatoren x[[y1],[y2],...] projiserer posten til en ny post med færre felt (valgt av y1, y2, ...). Hvis et valgt felt ikke finnes, utløses en feil. Operatoren x[[y1],[y2],...]? projiserer posten til en ny post med feltene valgt av y1, , y2; ...hvis et felt mangler, null brukes i stedet. Eksempel:

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

Skjemaene [y] og [y]? støttes som en korthåndsreferanse til identifikatoren _ (understrekingstegn). Følgende to uttrykk tilsvarer:

[A]                 
_[A]

Følgende eksempel illustrerer kortfattet form for felttilgang:

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

Skjemaet [[y1],[y2],...] og [[y1],[y2],...]? støttes også som en shorthand, og følgende to uttrykk tilsvarer også:

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

Shorthand-skjemaet er spesielt nyttig i kombinasjon med each shorthand, en måte å introdusere en funksjon av en enkelt parameter kalt _ (for detaljer, se forenklede deklarasjoner). Sammen forenkler de to shorthands vanlige funksjonsuttrykk med høyere rekkefølge:

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

Uttrykket ovenfor tilsvarer følgende mer kryptiske utseende på langhånd:

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

Felttilgang tvinger ikke evalueringen av andre felt enn de(e) som åpnes. Eksempel:

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

Følgende gjelder når en felttilgangsoperator x[y], x[y]?, x[[y]]eller x[[y]]? evalueres:

  • Feil som oppstår under evalueringen av uttrykket x , overføres.

  • Feil som oppstår når du evaluerer feltet y , er permanent knyttet til feltet y, og overføres deretter. Eventuell fremtidig tilgang til feltet y vil øke den identiske feilen.

  • Uttrykket x produserer en post- eller tabellverdi, eller det oppstår en feil.

  • Hvis identifikatoren y gir navn til et felt som ikke finnes i x, utløses en feil med årsakskode "Expression.Error" med mindre det valgfrie operatorskjemaet ...? brukes, i så fall returneres verdien null .

Ingen andre felt x enn det som er navngitt av y , evalueres under prosessen med felttilgang.

Metadataoperator

Metadataposten for en verdi endres ved hjelp av metaoperatoren (x meta y).

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

Følgende eksempel konstruerer en tekstverdi med en metadatapost ved hjelp av operatoren meta , og får deretter tilgang til metadataposten for resultatverdien ved hjelp av Value.Metadata:

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

Følgende gjelder når du bruker operatoren for metadata som kombinerer x meta y:

  • Feil som oppstår når du evaluerer x eller y uttrykkene overføres.

  • Uttrykket y må være en post, eller det oppstår en feil med årsakskoden "Expression.Error" .

  • Den resulterende metadataposten er xmetadataposten som er slått sammen med y. (Hvis du vil semantikk for postfletting, kan du se Postfletting.)

  • Resultatverdien er verdien fra x uttrykket, uten metadata, med den nylig beregnede metadataposten vedlagt.

Standard bibliotekfunksjoner Value.RemoveMetadata og Value.ReplaceMetadata kan brukes til å fjerne alle metadata fra en verdi og erstatte metadataene til en verdi (i stedet for å slå sammen metadata til muligens eksisterende metadata). Følgende uttrykk tilsvarer:

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

Likhetsoperatorer

Likhetsoperatoren = brukes til å avgjøre om to verdier er like. Ulikhetsoperatoren <> brukes til å avgjøre om to verdier ikke er like.

likhetsuttrykk:
      relasjonsuttrykk
      likhetsuttrykk for relasjonsuttrykk=
      likhetsuttrykk for relasjonsuttrykk<>

Eksempel:

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

Metadata er ikke en del av sammenligning av likhet eller ulikhet. Eksempel:

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

Følgende gjelder når du bruker likhetsoperatorene x = y og x <> y:

  • Feil som oppstår når du evaluerer x eller y uttrykkene overføres.

  • Operatoren = har et resultat av true om verdiene er like, og false ellers.

  • Operatoren <> har et resultat av false om verdiene er like, og true ellers.

  • Metadataposter er ikke inkludert i sammenligningen.

  • Hvis verdier som produseres ved å x evaluere og y uttrykkene ikke er den samme typen verdi, er ikke verdiene like.

  • Hvis verdiene som produseres ved å x evaluere og y uttrykket er den samme typen verdi, finnes det spesifikke regler for å avgjøre om de er like, som definert nedenfor.

  • Følgende gjelder alltid:

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

Likhetsoperatorene er definert for følgende typer:

  • Verdien null er bare lik seg selv.
    null = null    // true 
    null = true    // false 
    null = false   // false
  • De logiske verdiene true og false er bare lik seg selv. Eksempel:
    true = true      // true 
    false = false    // true 
    true = false     // false 
    true = 1         // false

  • Tall sammenlignes med den angitte presisjonen:

    • Hvis et av tallene er #nandet, er ikke tallene like.

    • Når ingen av tallene er #nandet, sammenlignes tallene med en bitvis sammenligning av den numeriske verdien.

    • #nan er den eneste verdien som ikke er lik seg selv.

      Eksempel:

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

  • To varigheter er like hvis de representerer samme antall 100 nanosekunder.

  • To ganger er lik hvis størrelsen på delene (time, minutt, sekund) er like.

  • To datoer er like hvis størrelsen på delene (år, måned, dag) er like.

  • To datetimes er like hvis størrelsen på delene (år, måned, dag, time, minutt, sekund) er like.

  • To datetimezones er like hvis tilsvarende UTC datetimes er like. Hvis du vil komme frem til tilsvarende UTC-datetime, trekkes forskyvningen av timer/minutter fra datetime-komponenten i datetimezone.

  • To tekstverdier er like hvis de bruker en ordinal, skiller mellom store og små bokstaver, og de har samme lengde og like tegn i tilsvarende posisjoner.

  • To listeverdier er like hvis alle følgende er sanne:

    • Begge listene inneholder samme antall elementer.

    • Verdiene for hvert posisjonsmessig tilsvarende element i listene er like. Dette betyr at listene ikke bare må inneholde like elementer, elementene må være i samme rekkefølge.

      Eksempel:

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

  • To poster er like hvis alle følgende er sanne:

    • Antall felt er det samme.

    • Hvert feltnavn for én post finnes også i den andre posten.

    • Verdien for hvert felt i én post er lik feltet med samme navn i den andre posten.

      Eksempel:

        [ 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 like hvis alle følgende er sanne:

    • Antall kolonner er det samme.

    • Hvert kolonnenavn i én tabell finnes også i den andre tabellen.

    • Antall rader er det samme.

    • Hver rad har like verdier i tilsvarende celler.

      Eksempel:

        #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 funksjonsverdi er lik seg selv, men kan være lik en annen funksjonsverdi. Hvis to funksjonsverdier anses som like, vil de fungere identisk når de aktiveres.

    To gitte funksjonsverdier vil alltid ha samme likhetsrelasjon.

  • En typeverdi er lik seg selv, men kan være lik en annen typeverdi. Hvis to typeverdier anses som like, vil de fungere identiske når de blir spurt om samsvar.

    To angitte typeverdier vil alltid ha samme likhetsrelasjon.

Relasjonsoperatorer

Operatorene <, >, <=og kalles >=relasjonsoperatorene.

relasjonsuttrykk:
      additive-uttrykk
      additive-uttrykk<relasjonsuttrykk
      additive-uttrykk>relasjonsuttrykk
      additive-uttrykk<=relasjonsuttrykk
      additive-uttrykk>=relasjonsuttrykk

Disse operatorene brukes til å bestemme den relative bestillingsrelasjonen mellom to verdier, som vist i tabellen nedenfor:

Operasjon Resultat
x < y true hvis x er mindre enn y, false ellers
x > y true hvis x er større enn y, false ellers
x <= y true hvis x er mindre enn eller lik y, false ellers
x >= y true hvis x er større enn eller lik y, false ellers

Eksempel:

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

Følgende gjelder når du evaluerer et uttrykk som inneholder relasjonsoperatorene:

  • Feil som oppstår når du evaluerer x eller y operanduttrykkene overføres.

  • Verdiene som produseres ved å evaluere både x og y uttrykkene, må være binære, dato, datetime, datetimezone, varighet, logisk, tall, null, tekst eller tidsverdi. Ellers utløses en feil med årsakskode "Expression.Error" .

  • Begge operandene må være av samme type verdi eller null. Ellers utløses en feil med årsakskode "Expression.Error" .

  • Hvis enten eller begge operandene er null, er null resultatet verdien.

  • To binærfiler sammenlignes byte byte.

  • To datoer sammenlignes ved å sammenligne årsdelene og, hvis de er like, månedsdelene og, hvis de er like, deres dagdeler.

  • To datetimes sammenlignes ved å sammenligne sine årdeler og, hvis de er like, deres månedsdeler og, hvis de er like, deres dagdeler og, hvis de er like, deres timedeler og, hvis de er like, deres minuttdeler og, hvis de er like, deres andre deler.

  • To datetimezones sammenlignes ved å normalisere dem til UTC ved å trekke fra time-/minuttforskyvningen og deretter sammenligne datetime-komponentene.

  • To varigheter sammenlignes i henhold til det totale antallet 100 nanosekunder de representerer.

  • To logiske verdier sammenlignes slik at det true anses å være større enn false.

  • To tall x og y sammenlignes i henhold til reglene i IEEE 754-standarden:

    • Hvis en av operandene er #nan, er false resultatet for alle relasjonsoperatorer.

    • Når ingen av operandene er #nan, sammenligner operatorene verdiene for de to flytende punktoperandene med hensyn til rekkefølgen -∞ < -max < ... < -min < -0.0 = +0.0 < +min < ... < +max < +∞ der min og maks er de minste og største positive begrensede verdiene som kan representeres. M-navnene for -∞ og +∞ er -#infinity og #infinity.

      Viktige effekter av denne bestillingen er:

      • Negative og positive nuller anses som like.

      • En -#infinity verdi regnes som mindre enn alle andre tallverdier, men lik en annen -#infinity.

      • En #infinity verdi regnes som større enn alle andre tallverdier, men lik en annen #infinity.

  • To tekster sammenlignes ved hjelp av en tegn-for-tegn-ordenal, skiller mellom store og små bokstaver, kultur-ufølsom sammenligning.

  • To ganger sammenlignes ved å sammenligne timedelene og, hvis de er like, deres minuttdeler og, hvis de er like, deres andre deler.

Betingede logiske operatorer

Operatorene and og or kalles de betingede logiske operatorene.

logisk-eller-uttrykk:
      logisk-og-uttrykk
logisk-og-uttrykkorlogisk-eller-uttrykk
logisk og uttrykk:
      er-uttrykk
      er-uttrykkandlogisk-og-uttrykk

Operatoren or returnerer true når minst én av operandene er true. Den høyre operanden evalueres hvis og bare hvis den venstre operanden ikke trueer .

Operatoren and returnerer false når minst én av operandene er false. Den høyre operanden evalueres hvis og bare hvis den venstre operanden ikke falseer .

Sannhetstabeller for operatorene or og and vises nedenfor, med resultatet av evalueringen av venstre operanduttrykk på den loddrette aksen og resultatet av evalueringen av høyre operanduttrykk på den vannrette aksen.

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 gjelder når du evaluerer et uttrykk som inneholder betingede logiske operatorer:

  • Feil som oppstår når du evaluerer x eller y uttrykkene overføres.

  • De betingede logiske operatorene er definert over typene logical og null. Hvis operandverdiene ikke er av disse typene, utløses en feil med årsakskode "Expression.Error" .

  • Resultatet er en logisk verdi.

  • I uttrykket x eller yevalueres uttrykket y hvis og bare hvis x det ikke evalueres til true.

  • I uttrykket x og yevalueres uttrykket y hvis og bare hvis x det ikke evalueres til false.

De to siste egenskapene gir de betingede logiske operatorene sin "betingede" kvalifikasjon; egenskaper også kalt «kortslutning». Disse egenskapene er nyttige for å skrive kompaktbevoktede predikater. Følgende uttrykk tilsvarer for eksempel:

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

Aritmetiske operatorer

Operatorene +, -*og / er aritmetiske operatorer.

additive-uttrykk:
      multiplikativt uttrykk
      additive-uttrykk+multiplikativt uttrykk
      additive-uttrykk-multiplikativt uttrykk
multiplikativt uttrykk:
      metadata- uttrykk
      metadata-uttrykk for multiplikativt uttrykk*
      metadata-uttrykk for multiplikativt uttrykk/

Presisjon

Tall i M lagres ved hjelp av en rekke representasjoner for å beholde så mye informasjon som mulig om tall som kommer fra en rekke kilder. Tall konverteres bare fra én representasjon til en annen etter behov av operatorer som brukes på dem. To presisjoner støttes i M:

Presisjon Semantikk
Precision.Decimal 128-biters desimalrepresentasjon med et område på ±1,0 x 10-28 til ±7,9 x 1028 og 28-29 signifikante sifre.
Precision.Double Vitenskapelig representasjon ved hjelp av mantissa og eksponent; samsvarer med 64-biters binær dobbel presisjon IEEE 754 aritmetisk standard IEEE 754-2008.

Aritmetiske operasjoner utføres ved å velge en presisjon, konvertere begge operandene til den presisjonen (om nødvendig), deretter utføre den faktiske operasjonen og til slutt returnere et tall i valgt presisjon.

De innebygde aritmetiske operatorene (+, -, , *, /) bruker Dobbel presisjon. Standard bibliotekfunksjoner (Value.Add, , Value.Subtract, Value.MultiplyValue.Divide) kan brukes til å be om disse operasjonene ved hjelp av en bestemt presisjonsmodell.

  • Ingen numerisk overflyt er mulig, #infinity eller -#infinity representerer verdier av størrelser som er for store til å representeres.

  • Ingen numerisk underflyt er mulig, 0 og -0 representerer verdier av størrelser som er for små til å representeres.

  • IEEE 754-spesialverdien #nan (NaN – ikke et tall) brukes til å dekke aritmetisk ugyldige tilfeller, for eksempel en deling på null med null.

  • Konvertering fra desimal til dobbel presisjon utføres ved å avrunde desimaltall til nærmeste tilsvarende doble verdi.

  • Konvertering fra dobbel til desimalpresisjon utføres ved å avrunde doble tall til nærmeste tilsvarende desimalverdi og eventuelt overflyt til #infinity eller -#infinity verdier.

Tilleggsoperator

Tolkningen av addisjonsoperatoren (x + y) er avhengig av typen verdi for de evaluerte uttrykkene x og y, som følger:

x y Resultat Tolkning
type number type number type number Numerisk sum
type number null null
null type number null
type duration type duration type duration Numerisk størrelsessum
type duration null null
null type duration null
type datetime type duration type datetime Datetime forskjøvet etter varighet
type duration type datetime type datetime
type datetime null null
null type datetime null

I tabellen typestår datetime for hvilken som helst av type date, type datetime, type datetimezoneeller type time. Når du legger til en varighet og en verdi av en type datetime, er den resulterende verdien av samme type.

For andre kombinasjoner av verdier enn de som er oppført i tabellen, utløses en feil med årsakskode "Expression.Error" . Hver kombinasjon dekkes i avsnittene nedenfor.

Feil som oppstår når du evaluerer en operande, overføres.

Numerisk sum

Summen av to tall beregnes ved hjelp av tilleggsoperatoren, og produserer et tall.

Eksempel:

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

Tilleggsoperatoren + over tall bruker Dobbel presisjon. Standard bibliotekfunksjonen Value.Add kan brukes til å angi desimalpresisjon. Følgende gjelder når du beregner en sum tall:

  • Summen i Dobbel presisjon beregnes i henhold til reglene for 64-biters binær doubleprecision IEEE 754 aritmetisk IEEE 754-2008. Tabellen nedenfor viser resultatene av alle mulige kombinasjoner av ikke-null-begrensede verdier, nuller, infiniteter og NaN-er. I tabellen, x og y er ikke-null begrensede verdier, og z er resultatet av x + y. Hvis x og y har samme størrelse, men motsatte tegn, z er positiv null. Hvis x + y det er for stort til å representeres i måltypen, z er det uendelig med 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 desimalpresisjon beregnes uten å miste presisjon. Omfanget av resultatet er den største av skalaene til de to operandene.

Summen av varigheter

Summen av to varigheter er varigheten som representerer summen av antallet 100nanosekunder som representeres av varighetene. Eksempel:

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

Datetime forskjøvet etter varighet

En datetimex og en varighet y kan legges til ved hjelp av x + y for å beregne en ny x hvis avstand fra y på en lineær tidslinje er nøyaktig størrelsen på . Her vil datetime står for hvilken som helst av Date, DateTime, DateTimeZoneeller Time og et resultat som ikke er null, være av samme type. Datetime-forskyvningen etter varighet kan beregnes på følgende måte:

  • Hvis datetime-dagene siden epokeverdien er angitt, kan du konstruere en ny datetime med følgende informasjonselementer:

    • Beregn en ny dag siden epoke tilsvarer å dele størrelsen på y med antall 100-nanosekund flått i en 24-timers periode, avkorte desimaldelen av resultatet, og legge denne verdien til x dager siden epoke.

    • Beregn nye flått siden midnatt tilsvarer å legge størrelsen på y til x-flått siden midnatt, modulere antall 100-nanosekund flått i en 24-timers periode. Hvis x ikke angir en verdi for flått siden midnatt, brukes verdien 0.

    • Kopier x-verdien for minutter forskjøvet fra UTC uendret.

  • Hvis datetime-dagene siden epokeverdien er uspesifisert, kan du konstruere en ny datetime med følgende informasjonselementer angitt:

    • Beregn nye flått siden midnatt tilsvarer å legge størrelsen på y til x-flått siden midnatt, modulere antall 100-nanosekund flått i en 24-timers periode. Hvis x ikke angir en verdi for flått siden midnatt, brukes verdien 0.

    • Kopier x-verdier for dager siden epoke og minutter forskyvning fra UTC uendret.

Eksemplene nedenfor viser beregning av den absolutte tidsmessige summen når datetime angir 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

Følgende eksempel viser beregning av datetime-forskyvningen etter varighet for et gitt tidspunkt:

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

Subtraksjonsoperator

Tolkningen av subtraksjonsoperatoren (x - y) er avhengig av verdien for de evaluerte uttrykkene x og y, som følger:

x Y Resultat Tolkning
type number type number type number Numerisk forskjell
type number null null
null type number null
type duration type duration type duration Numerisk størrelsesforskjell
type duration null null
null type duration null
type datetime type datetime type duration Varighet mellom datetimes
type datetime type duration type datetime Datetime motvirket av negeret varighet
type datetime null null
null type datetime null

I tabellen typestår datetime for hvilken som helst av type date, type datetime, type datetimezoneeller type time. Når du trekker fra en varighet fra en verdi av en type datetime, er den resulterende verdien av samme type.

For andre kombinasjoner av verdier enn de som er oppført i tabellen, utløses en feil med årsakskode "Expression.Error" . Hver kombinasjon dekkes i avsnittene nedenfor.

Feil som oppstår når du evaluerer en operande, overføres.

Numerisk forskjell

Forskjellen mellom to tall beregnes ved hjelp av subtraksjonsoperatoren, og produserer et tall. Eksempel:

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

Subtraksjonsoperatoren - over tall bruker Dobbel presisjon. Standard bibliotekfunksjonen Value.Subtract kan brukes til å angi desimalpresisjon. Følgende gjelder når du beregner en forskjell på tall:

  • Forskjellen i dobbel presisjon beregnes i henhold til reglene for 64-biters binær dobbelpresisjon IEEE 754 aritmetisk IEEE 754-2008. Tabellen nedenfor viser resultatene av alle mulige kombinasjoner av ikke-null-begrensede verdier, nuller, infiniteter og NaN-er. I tabellen, x og y er ikke-null begrensede verdier, og z er resultatet av x - y. Hvis x og y er lik, z er positiv null. Hvis x - y det er for stort til å representeres i måltypen, z er det uendelig med 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

  • Forskjellen i desimalpresisjon beregnes uten å miste presisjon. Omfanget av resultatet er den største av skalaene til de to operandene.

Differanse for varigheter

Forskjellen mellom to varigheter er varigheten som representerer forskjellen mellom antall 100 nanosekunder som representeres av hver varighet. Eksempel:

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

Datetime motvirket av negeret varighet

En datetimex og en varighet y kan trekkes fra ved hjelp av x - y for å beregne en ny datetime. Her står datetime for noen av date, datetime, datetimezoneeller time. Den resulterende datetime Å trekke fra positive varigheter gir resultater som er bakover i tid i forhold til x, mens fratredelse av negative verdier gir resultater som er fremover i tid.

#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

Varighet mellom to datetimes

To t fra ved hjelp av u for å beregne varigheten mellom dem. Her står datetime for noen av date, datetime, datetimezoneeller time. Varigheten som produseres ved å u trekke fra t , må gis t når den legges 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

Trekke fra når t - u resulterer u > t i en negativ varighet:

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

Følgende gjelder når du trekker fra to datetimes ved hjelp av t - u:

  • u + (t - u) = t

Multiplikasjonsoperator

Tolkningen av multiplikasjonsoperatoren (x * y) er avhengig av typen verdi for de evaluerte uttrykkene x og y, som følger:

X Y Resultat Tolkning
type number type number type number Numerisk produkt
type number null null
null type number null
type duration type number type duration Multiplum av varighet
type number type duration type duration Multiplum av varighet
type duration null null
null type duration null

For andre kombinasjoner av verdier enn de som er oppført i tabellen, utløses en feil med årsakskode "Expression.Error" . Hver kombinasjon dekkes i avsnittene nedenfor.

Feil som oppstår når du evaluerer en operande, overføres.

Numerisk produkt

Produktet av to tall beregnes ved hjelp av multiplikasjonsoperatoren, og produserer et tall. Eksempel:

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

Multiplikasjonsoperatoren * over tall bruker Dobbel presisjon. Standard bibliotekfunksjonen Value.Multiply kan brukes til å angi desimalpresisjon. Følgende gjelder når du beregner et produkt av tall:

  • Produktet i Dobbel presisjon beregnes i henhold til reglene for 64-biters binær dobbelpresisjon IEEE 754 aritmetisk IEEE 754-2008. Tabellen nedenfor viser resultatene av alle mulige kombinasjoner av ikke-null-begrensede verdier, nuller, infiniteter og NaN-er. I tabellen, x og y er positive begrensede verdier. z er resultatet av x * y. Hvis resultatet er for stort for måltypen, z er uendelig. Hvis resultatet er for lite for måltypen, z er null.

    * +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 desimalpresisjon beregnes uten å miste presisjon. Omfanget av resultatet er den største av skalaene til de to operandene.

Multiplum av varigheter

Produktet av en varighet og et tall er varigheten som representerer antallet 100nanosekunder som representeres av varighetsoperanden ganger tallet operand. Eksempel:

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

Divisjonsoperator

Tolkningen av divisjonsoperatoren (x / y) er avhengig av typen verdi for de evaluerte uttrykkene x , og ysom følger:

X Y Resultat Tolkning
type number type number type number Numerisk kvotient
type number null null
null type number null
type duration type number type duration Brøk av varighet
type duration type duration type number Numerisk kvotient av varigheter
type duration null null
null type duration null

For andre kombinasjoner av verdier enn de som er oppført i tabellen, utløses en feil med årsakskode "Expression.Error" . Hver kombinasjon dekkes i avsnittene nedenfor.

Feil som oppstår når du evaluerer en operande, overføres.

Numerisk kvotient

Kvotienten av to tall beregnes ved hjelp av divisjonsoperatoren, og produserer et tall. Eksempel:

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

Divisjonsoperatoren / over tall bruker Dobbel presisjon. Standard bibliotekfunksjonen Value.Divide kan brukes til å angi desimalpresisjon. Følgende gjelder når du beregner en kvotient av tall:

  • Kvotienten i Dobbel presisjon beregnes i henhold til reglene for 64-biters binær dobbelpresisjon IEEE 754 aritmetisk IEEE 754-2008. Tabellen nedenfor viser resultatene av alle mulige kombinasjoner av ikke-null-begrensede verdier, nuller, infiniteter og NaN-er. I tabellen, x og y er positive begrensede verdier. z er resultatet av x / y. Hvis resultatet er for stort for måltypen, z er uendelig. Hvis resultatet er for lite for måltypen, z er null.

    / +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 desimalpresisjon beregnes uten å miste presisjon. Omfanget av resultatet er den største av skalaene til de to operandene.

Kvotient av varigheter

Kvotienten av to varigheter er tallet som representerer kvotienten til antallet 100nanosekunder som representeres av varighetene. Eksempel:

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

Skalerte varigheter

Kvotienten for en varighet x og et tall y er varigheten som representerer kvotienten for antall 100 nanosekunder som representeres av varigheten x og tallet y. Eksempel:

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

Strukturkombinasjon

Kombinasjonsoperatoren (x & y) er definert over følgende typer verdier:

X Y Resultat Tolkning
type text type text type text Sammenkobling
type text null null
null type text null
type date type time type datetime Flett
type date null null
null type time null
type list type list type list Sammenkobling
type record type record type record Flett
type table type table type table Sammenkobling

Sammenkobling

To tekst-, to- eller to tabellverdier kan kjedes sammen ved hjelp av x & y.

Følgende eksempel illustrerer sammenkobling av tekstverdier:

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

Følgende eksempel illustrerer sammenkobling av lister:

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

Følgende gjelder når du setter sammen to verdier ved hjelp av x & y:

  • Feil som oppstår når du evaluerer x eller y uttrykkene overføres.

  • Ingen feil overføres hvis et element av et eller flere av x dem y inneholder en feil.

  • Resultatet av å sette sammen to tekstverdier er en tekstverdi som inneholder verdien x umiddelbart etterfulgt av y. Hvis en av operandene er null og den andre er en tekstverdi, er resultatet null.

  • Resultatet av å kjede sammen to lister er en liste som inneholder alle elementene etterfulgt av x alle elementene yi .

  • Resultatet av å sette sammen to tabeller er en tabell som har unionen av kolonnene i de to operandtabellene. Kolonnerekkefølgen x for bevares, etterfulgt av kolonnene som bare vises i y, og beholder den relative rekkefølgen. For kolonner som bare vises i én av operandene, null brukes til å fylle ut celleverdier for den andre operanden.

Flett

Postfletting

To poster kan slås sammen ved hjelp av x & y, som produserer en post som inneholder felt fra både x og y.

Følgende eksempler illustrerer fletting av 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 gjelder når du slår sammen to poster ved hjelp av x + y:

  • Feil som oppstår når du evaluerer x eller y uttrykkene overføres.

  • Hvis et felt vises i begge x og y, brukes verdien fra y .

  • Rekkefølgen på feltene i resultatposten er xden av , etterfulgt av felt i y som ikke er en del av x, i samme rekkefølge som de vises i y.

  • Sammenslåing av poster forårsaker ikke evaluering av verdiene.

  • Det oppstår ingen feil fordi et felt inneholder en feil.

  • Resultatet er en post.

Dato/klokkeslett-fletting

En dato x kan slås sammen med et klokkeslett y ved hjelp av x & y, som produserer en datetime som kombinerer delene fra både x og y.

Følgende eksempel illustrerer fletting av en dato og et klokkeslett:

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

Følgende gjelder når du slår sammen to poster ved hjelp av x + y:

  • Feil som oppstår når du evaluerer x eller y uttrykkene overføres.

  • Resultatet er en datetime.

Monooperatorer

Operatorene +, -og not er ikke-sekundære operatorer.

uær-uttrykk:
      type-uttrykk
       + uært uttrykk
       - uært uttrykk
       not uært uttrykk

Unary plus operator

Den uary plus operator (+x) er definert for følgende typer verdier:

X Resultat Tolkning
type number type number Unary plus
type duration type duration Unary plus
null Null

For andre verdier utløses en feil med årsakskode "Expression.Error" .

Den ikke-adskilte plussoperatoren tillater at et + tegn brukes på en tall-, datetime- eller nullverdi. Resultatet er den samme verdien. Eksempel:

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

Følgende gjelder når du evaluerer den ikke-sekundære plussoperatoren +x:

  • Feil som oppstår når du evaluerer x , overføres.

  • Hvis resultatet av evalueringen x ikke er en tallverdi, utløses en feil med årsakskode "Expression.Error" .

Unary minus operator

Den unary minus operator (-x) er definert for følgende typer verdier:

X Resultat Tolkning
type number type number Negasjonen
type duration type duration Negasjonen
null null

For andre verdier utløses en feil med årsakskode "Expression.Error" .

Den ikke-sekundære minusoperatoren brukes til å endre fortegnet for et tall eller en varighet. Eksempel:

- (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 gjelder når du evaluerer den ikke-sekundære minusoperatoren -x:

  • Feil som oppstår når du evaluerer x , overføres.

  • Hvis uttrykket er et tall, er resultatet tallverdien fra uttrykket x med tegnet endret. Hvis verdien er NaN, er resultatet også NaN.

Logisk negasjonsoperator

Den logiske negasjonsoperatoren (not) er definert for følgende verdityper:

X Resultat Tolkning
type logical type logical Negasjonen
null null

Denne operatoren beregner den logiske not operasjonen på en gitt logisk verdi. Eksempel:

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

Følgende gjelder når du evaluerer den logiske negasjonsoperatoren not x:

  • Feil som oppstår når du evaluerer x , overføres.

  • Verdien som produseres fra evaluering av uttrykk x, må være en logisk verdi, eller en feil med årsakskode "Expression.Error" må heves. Hvis verdien er true, er falseresultatet . Hvis operanden er false, er trueresultatet .

Resultatet er en logisk verdi.

Typeoperatorer

Operatorene is og as kalles typeoperatorer.

Typekompatibilitetsoperator

Typekompatibilitetsoperatoren x is y er definert for følgende verdityper:

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

Uttrykket x is y returnerer true hvis den tilskrevne typen x er kompatibel med y, og returnerer false hvis den tilskrevne typen x er inkompatibel med y. y må være en primitiv type som kan nullstilles.

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

Typekompatibilitet, som støttes av operatorenis, er et delsett av generell typekompatibilitet og defineres ved hjelp av følgende regler:

  • Hvis x den er null, er den kompatibel hvis y den er typen any, typen nulleller en nullverditype.

  • Hvis x den ikke er null, hvis den er kompatibel hvis den primitive typen x er den samme som y.

Følgende gjelder når du evaluerer uttrykket x is y:

  • Det oppstod en feil under evaluering av uttrykk x .

Typedeklarasjonsoperator

Typedeklarasjonsoperatoren x as y er definert for følgende verdityper:

X Y Resultat
type any nullable-primitive-type type any

Uttrykket x as y hevder at verdien x er kompatibel med y i henhold til operatoren is . Hvis den ikke er kompatibel, utløses en feil. y må være en primitiv type som kan nullstilles.

as-expression:
      likhetsuttrykk
      as-expressionasnullable-primitive-type

Uttrykket x as y evalueres på følgende måte:

  • En typekompatibilitetskontroll x is y utføres, og deklarasjonen returnerer x uendret hvis denne testen lykkes.

  • Hvis kompatibilitetskontrollen mislykkes, utløses en feil med årsakskode "Expression.Error" .

Eksempler:

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

Følgende gjelder når du evaluerer uttrykket x as y:

  • Det oppstod en feil under evaluering av uttrykk x .

Coalesce operatør

Coalesce-operatøren ?? returnerer resultatet av sin venstre operand hvis den ikke er null, ellers vil den returnere resultatet av sin høyre operand. Den høyre operanden evalueres hvis og bare hvis den venstre operanden er null.