Verdier
En verdi er data som produseres ved å evaluere et uttrykk. Denne delen beskriver verditypene på M-språket. Hver type verdi er knyttet til en litteral syntaks, et sett med verdier som er av denne typen, et sett med operatorer definert over det verdisettet, og en innebygd type som er tilskrevet nylig konstruerte verdier.
Type | Literal |
---|---|
Null | null |
Logisk | true false |
Antall | 0 1 -1 1.5 2.3e-5 |
Time | #time(09,15,00) |
Dato | #date(2013,02,26) |
Dato/klokkeslett | #datetime(2013,02,26, 09,15,00) |
DateTimeZone | #datetimezone(2013,02,26, 09,15,00, 09,00) |
Varighet | #duration(0,1,30,0) |
Tekst | "hello" |
Binær | #binary("AQID") |
Vis | {1, 2, 3} |
Oppføring | [ A = 1, B = 2 ] |
Tabell | #table({"X","Y"},{{0,1},{1,0}}) |
Funksjon | (x) => x + 1 |
Type | type { number } type table [ A = any, B = text ] |
Avsnittene nedenfor dekker hver verditype i detalj. Typer og typebeskrivelse defineres formelt i Typer. Funksjonsverdier er definert i Funksjoner. Avsnittene nedenfor viser operatorene som er definert for hver verditype, og gir eksempler. Den fullstendige definisjonen av operatorsemantikk følger i operatorer.
En nullverdi brukes til å representere fraværet av en verdi, eller en verdi med ubestemt eller ukjent tilstand. En nullverdi skrives ved hjelp av litteral null
. Følgende operatorer er definert for nullverdier:
Operator | Resultat |
---|---|
x > y |
Større enn |
x >= y |
Større enn eller lik |
x < y |
Mindre enn |
x <= y |
Mindre enn eller lik |
x = y |
Equal |
x <> y |
Not equal |
x ?? y |
Coalesce |
Den opprinnelige null
typen av verdien er den innebygde typen null
.
En logisk verdi brukes for boolske operasjoner, og verdien er sann eller usann. En logisk verdi skrives ved hjelp av litteraler true
og false
. Følgende operatorer er definert for logiske verdier:
Operator | Resultat |
---|---|
x > y |
Større enn |
x >= y |
Større enn eller lik |
x < y |
Mindre enn |
x <= y |
Mindre enn eller lik |
x = y |
Equal |
x <> y |
Not equal |
x or y |
Betinget logisk ELLER |
x ?? y |
Coalesce |
x and y |
Betinget logisk OG |
not x |
Logisk IKKE |
Den opprinnelige typen av både logiske verdier (true
og false
) er den innebygde typen logical
.
En tallverdi brukes for numeriske og aritmetiske operasjoner. Følgende er eksempler på talllitteraler:
3.14 // Fractional number
-1.5 // Fractional number
1.0e3 // Fractional number with exponent
123 // Whole number
1e3 // Whole number with exponent
0xff // Whole number in hex (255)
Et tall representeres med minst presisjonen til et langt flyttall (men kan beholde mer presisjon). Dobbel representasjon er kongruent med IEEE 64-biters dobbel presisjonsstandard for binært flytende punkt aritmetisk definert i [IEEE 754-2008]. (Dobbel representasjon har et omtrentlig dynamisk område fra 5,0 x 10324 til 1,7 x 10308 med en presisjon på 15-16 sifre.)
Følgende spesialverdier anses også å være tallverdier :
Positiv null og negativ null. I de fleste situasjoner fungerer positiv null og negativ null identisk som den enkle verdien null, men visse operasjoner skiller mellom de to.
Positiv uendelighet (
#infinity
) og negativ uendelighet (-#infinity
). Infiniteter produseres av slike operasjoner som å dele et tall som ikke er null, med null. Gir for eksempel1.0 / 0.0
positiv uendelighet, og-1.0 / 0.0
gir negativ uendelighet.Not-a-Number-verdien (
#nan
), ofte forkortet NaN. NaN-er produseres av ugyldige flyttallsoperasjoner, for eksempel å dele null med null.
Binære matematiske operasjoner utføres ved hjelp av en presisjon. Presisjonen bestemmer domenet som operandene avrundes til, og domenet der operasjonen utføres. I mangel av en eksplisitt angitt presisjon utføres slike operasjoner ved hjelp av dobbel presisjon.
Hvis resultatet av en matematisk operasjon er for liten for målformatet, blir resultatet av operasjonen positiv null eller negativ null.
Hvis resultatet av en matematisk operasjon er for stor for målformatet, blir resultatet av operasjonen positiv uendelighet eller negativ uendelighet.
Hvis en matematisk operasjon er ugyldig, blir resultatet av operasjonen NaN.
Hvis én eller begge operandene for en flyttallsoperasjon er NaN, blir resultatet av operasjonen NaN.
Følgende operatorer er definert for tallverdier:
Operator | Resultat |
---|---|
x > y |
Større enn |
x >= y |
Større enn eller lik |
x < y |
Mindre enn |
x <= y |
Mindre enn eller lik |
x = y |
Equal |
x <> y |
Not equal |
x + y |
Sum |
x - y |
Differanse |
x * y |
Produkt |
x / y |
Kvotient |
x ?? y |
Coalesce |
+x |
Unary plus |
-x |
Negasjonen |
Den opprinnelige typen tallverdier er den innebygde typen number
.
En tidsverdi lagrer en ugjennomsiktig representasjon av tid på dagen. En tid er kodet som antall flått siden midnatt, som teller antall 100-nanosekunder flått som har gått på en 24-timers klokke. Maksimalt antall flått siden midnatt tilsvarer 23:59:59.9999999 timer.
Selv om det ikke finnes noen litteral syntaks for tider, angis det flere standard bibliotekfunksjoner for å konstruere dem. Klokkeslett kan også konstrueres ved hjelp av den innebygde funksjonen #time
:
#time(hour, minute, second)
Følgende må inneholde eller en feil med årsakskode Expression.Error
er hevet:
0 ≤ time ≤ 24
0 ≤ minutt ≤ 59
0 ≤ andre ≤ 59
I tillegg, hvis time = 24, må minutt og sekund være null.
Følgende operatorer er definert for tidsverdier:
Operator | Resultat |
---|---|
x = y |
Equal |
x <> y |
Not equal |
x >= y |
Større enn eller lik |
x > y |
Større enn |
x < y |
Mindre enn |
x <= y |
Mindre enn eller lik |
x ?? y |
Coalesce |
Følgende operatorer tillater at én eller begge operandene er en dato:
Operator | Venstre operand | Høyre operand | Betydning |
---|---|---|---|
x + y |
time |
duration |
Dato forskjøvet etter varighet |
x + y |
duration |
time |
Dato forskjøvet etter varighet |
x - y |
time |
duration |
Dato forskjøvet etter negeret varighet |
x - y |
time |
time |
Varighet mellom datoer |
x & y |
date |
time |
Flettet datetime |
Den opprinnelige typen tidsverdier er den innebygde typen time
.
En datoverdi lagrer en ugjennomsiktig representasjon av en bestemt dag. En dato er kodet som et antall dager siden epoken, fra og med 1. januar 0001 Common Era på den gregorianske kalenderen. Maksimalt antall dager siden epoken er 3652058, tilsvarende 31. desember 9999.
Selv om det ikke finnes noen litteral syntaks for datoer, angis det flere standard bibliotekfunksjoner for å konstruere dem. Datoer kan også konstrueres ved hjelp av den innebygde funksjonen #date
:
#date(year, month, day)
Følgende må inneholde eller en feil med årsakskode Expression.Error
er hevet:
1 ≤ år ≤ 9999
1 ≤ måned ≤ 12
1 ≤ dag ≤ 31
I tillegg må dagen være gyldig for den valgte måneden og året.
Følgende operatorer er definert for datoverdier:
Operator | Resultat |
---|---|
x = y |
Equal |
x <> y |
Not equal |
x >= y |
Større enn eller lik |
x > y |
Større enn |
x < y |
Mindre enn |
x <= y |
Mindre enn eller lik |
x ?? y |
Coalesce |
Følgende operatorer tillater at én eller begge operandene er en dato:
Operator | Venstre operand | Høyre operand | Betydning |
---|---|---|---|
x + y |
date |
duration |
Dato forskjøvet etter varighet |
x + y |
duration |
date |
Dato forskjøvet etter varighet |
x - y |
date |
duration |
Dato forskjøvet etter negeret varighet |
x - y |
date |
date |
Varighet mellom datoer |
x & y |
date |
time |
Flettet datetime |
Den opprinnelige typen datoverdier er den innebygde typen date
.
En datetime-verdi inneholder både en dato og et klokkeslett.
Selv om det ikke finnes litteral syntaks for datetimes, angis det flere standard bibliotekfunksjoner for å konstruere dem. Datetimes kan også konstrueres ved hjelp av den innebygde funksjonen #datetime
:
#datetime(year, month, day, hour, minute, second)
Følgende må inneholde eller en feil med årsakskodeuttrykk.Feil utløses: 1 ≤ år ≤ 9999
1 ≤ måned ≤ 12
1 ≤ dag ≤ 31
0 ≤ time ≤ 23
0 ≤ minutt ≤ 59
0 ≤ andre ≤ 59
I tillegg må dagen være gyldig for den valgte måneden og året.
Følgende operatorer er definert for datetime-verdier:
Operator | Resultat |
---|---|
x = y |
Equal |
x <> y |
Not equal |
x >= y |
Større enn eller lik |
x > y |
Større enn |
x < y |
Mindre enn |
x <= y |
Mindre enn eller lik |
x ?? y |
Coalesce |
Følgende operatorer tillater at én eller begge operandene er en datetime:
Operator | Venstre operand | Høyre operand | Betydning |
---|---|---|---|
x + y |
datetime |
duration |
Datetime forskjøvet etter varighet |
x + y |
duration |
datetime |
Datetime forskjøvet etter varighet |
x - y |
datetime |
duration |
Datetime motvirket av negeret varighet |
x - y |
datetime |
datetime |
Varighet mellom datetimes |
Den opprinnelige typen datetime-verdier er den innebygde typen datetime
.
En datetimezone-verdi inneholder en datetime og en tidssone. En tidssone er kodet som et antall minutter forskyvning fra UTC, som teller antall minutter tidsdelen av datetime bør forskyves fra Universal Coordinated Time (UTC). Minimum antall minutter forskyvning fra UTC er -840, som representerer en UTC-forskyvning på -14:00 eller fjorten timer tidligere enn UTC. Maksimalt antall minutter forskyvning fra UTC er 840, tilsvarende en UTC-forskyvning på 14:00.
Selv om det ikke finnes noen litteral syntaks for datetimezones, gis det flere standard bibliotekfunksjoner for å konstruere dem. Datetimezones kan også konstrueres ved hjelp av den innebygde funksjonen #datetimezone
:
#datetimezone(
year, month, day,
hour, minute, second,
offset-hours, offset-minutes)
Følgende må inneholde eller en feil med årsakskode Expression.Error
er hevet:
1 ≤ år ≤ 9999
1 ≤ måned ≤ 12
1 ≤ dag ≤ 31
0 ≤ time ≤ 23
0 ≤ minutt ≤ 59
0 ≤ andre ≤ 59
-14 ≤ offset-timer ≤ 14
-59 ≤ forskyvningsminutter ≤ 59
I tillegg må dagen være gyldig for den valgte måneden og året, og hvis forskyvningstimer = 14, deretter forskyvningsminutter <= 0 og, hvis forskyvning-timer = -14, deretter offset-minutter >= 0.
Følgende operatorer er definert for datetimezone-verdier:
Operator | Resultat |
---|---|
x = y |
Equal |
x <> y |
Not equal |
x >= y |
Større enn eller lik |
x > y |
Større enn |
x < y |
Mindre enn |
x <= y |
Mindre enn eller lik |
x ?? y |
Coalesce |
Følgende operatorer tillater at én eller begge operandene er en datetimezone:
Operator | Venstre operand | Høyre operand | Betydning |
---|---|---|---|
x + y |
datetimezone |
duration |
Datetimezone forskjøvet etter varighet |
x + y |
duration |
datetimezone |
Datetimezone forskjøvet etter varighet |
x - y |
datetimezone |
duration |
Datetimezone motvirket av negeret varighet |
x - y |
datetimezone |
datetimezone |
Varighet mellom datetimezones |
Den opprinnelige typen datetimezone-verdier er den innebygde typen datetimezone
.
En varighetsverdi lagrer en ugjennomsiktig representasjon av avstanden mellom to punkter på en tidslinje målt 100-nanosekunder. Størrelsen på en varighet kan være enten positiv eller negativ, med positive verdier som angir fremdrift fremover i tid og negative verdier som angir fremdriften bakover i tid. Minimumsverdien som kan lagres i en varighet , er -9 223 372 036 854 775 808 flått eller 10 675 199 dager 2 timer og 48 minutter 05,4775808 sekunder bakover i tid. Maksimumsverdien som kan lagres i en varighet , er 9 223 372 036 854 775 807 flått eller 10 675 199 dager 2 timer og 48 minutter 05,4775807 sekunder fremover i tid.
Selv om det ikke finnes litteral syntaks for varigheter, angis det flere standard bibliotekfunksjoner for å konstruere dem. Varigheter kan også konstrueres ved hjelp av den innebygde funksjonen #duration
:
#duration(0, 0, 0, 5.5) // 5.5 seconds
#duration(0, 0, 0, -5.5) // -5.5 seconds
#duration(0, 0, 5, 30) // 5.5 minutes
#duration(0, 0, 5, -30) // 4.5 minutes
#duration(0, 24, 0, 0) // 1 day
#duration(1, 0, 0, 0) // 1 day
Følgende operatorer er definert for varighetsverdier:
Operator | Resultat |
---|---|
x = y |
Equal |
x <> y |
Not equal |
x >= y |
Større enn eller lik |
x > y |
Større enn |
x < y |
Mindre enn |
x <= y |
Mindre enn eller lik |
x ?? y |
Coalesce |
I tillegg tillater følgende operatorer at én eller begge operandene er en varighetsverdi:
Operator | Venstre operand | Høyre operand | Betydning |
---|---|---|---|
x + y |
datetime |
duration |
Datetime forskjøvet etter varighet |
x + y |
duration |
datetime |
Datetime forskjøvet etter varighet |
x + y |
duration |
duration |
Summen av varigheter |
x - y |
datetime |
duration |
Datetime motvirket av negeret varighet |
x - y |
datetime |
datetime |
Varighet mellom datetimes |
x - y |
duration |
duration |
Differanse for varigheter |
x * y |
duration |
number |
N ganger en varighet |
x * y |
number |
duration |
N ganger en varighet |
x / y |
duration |
number |
Brøk av en varighet |
Den opprinnelige typen varighetsverdier er den innebygde typen duration
.
En tekstverdi representerer en sekvens med Unicode-tegn. Tekstverdier har en litteral form som samsvarer med følgende grammatikk:
_text-litteral:
"
tekst-litteral-tegnvelger "
tekst-litterale tegn:
tekst-litteral-tegn tekst-litteral-tegnvelger
tekst-litteral-tegn:
enkelttekst-tegn
tegn-escape-sekvens
dobbelt-sitat-escape-sekvens
enkeltteksttegn:
Alle tegn unntatt "
(U+0022
) eller #
(U+0023
) etterfulgt av (
(U+0028
)
dobbelt-sitat-escape-sekvens:
""
(U+0022
, U+0022
)
Følgende er et eksempel på en tekstverdi :
"ABC" // the text value ABC
Følgende operatorer er definert for tekstverdier :
Operator | Resultat |
---|---|
x = y |
Equal |
x <> y |
Not equal |
x >= y |
Større enn eller lik |
x > y |
Større enn |
x < y |
Mindre enn |
x <= y |
Mindre enn eller lik |
x & y |
Sammenkobling |
x ?? y |
Coalesce |
Den opprinnelige typen tekstverdier er den innebygde typen text
.
En binær verdi representerer en sekvens med byte.
Selv om det ikke finnes noen litteral syntaks for binære verdier, angis det flere standard bibliotekfunksjoner for å konstruere dem. Binære verdier kan også konstrueres ved hjelp av den innebygde funksjonen #binary
.
Følgende eksempel konstruerer en binær verdi fra en liste over byte:
#binary( {0x00, 0x01, 0x02, 0x03} )
Følgende operatorer er definert for binære verdier:
Operator | Resultat |
---|---|
x = y |
Equal |
x <> y |
Not equal |
x >= y |
Større enn eller lik |
x > y |
Større enn |
x < y |
Mindre enn |
x <= y |
Mindre enn eller lik |
x ?? y |
Coalesce |
Den opprinnelige typen binære verdier er den innebygde binærtypen.
En listeverdi er en verdi som produserer en sekvens med verdier når den nummereres. En verdi som produseres av en liste, kan inneholde alle typer verdier, inkludert en liste. Lister kan konstrueres ved hjelp av initialiseringssyntaksen, som følger:
listeuttrykk:
{ item-listopt }
elementliste:
vare
elementelementliste ,
vare:
uttrykk
uttrykksuttrykk..
Følgende er et eksempel på et listeuttrykk som definerer en liste med tre tekstverdier: "A"
, "B"
og "C"
.
{"A", "B", "C"}
Verdien "A"
er det første elementet i listen, og verdien "C"
er det siste elementet i listen.
- Elementene i en liste evalueres ikke før de åpnes.
- Selv om listeverdier som er konstruert ved hjelp av listesyntaksen, produserer elementer i den rekkefølgen de vises i elementlisten, kan lister som returneres fra bibliotekfunksjoner, produsere et annet sett eller et annet antall verdier hver gang de nummereres.
Hvis du vil inkludere en sekvens med heltall i en liste, a..b
kan skjemaet brukes:
{ 1, 5..9, 11 } // { 1, 5, 6, 7, 8, 9, 11 }
Antall elementer i en liste, kjent som listeantallet, kan bestemmes ved hjelp av List.Count
funksjonen.
List.Count({true, false}) // 2
List.Count({}) // 0
En liste kan effektivt ha et uendelig antall elementer. List.Count
for slike lister er ikke definert og kan enten oppstå en feil eller ikke avsluttes.
Hvis en liste ikke inneholder noen elementer, kalles den en tom liste. En tom liste skrives som:
{} // empty list
Følgende operatorer er definert for lister:
Operator | Resultat |
---|---|
x = y |
Equal |
x <> y |
Not equal |
x & y |
Concatenate |
x ?? y |
Coalesce |
Eksempel:
{1, 2} & {3, 4, 5} // {1, 2, 3, 4, 5}
{1, 2} = {1, 2} // true
{2, 1} <> {1, 2} // true
Den opprinnelige typen listeverdier er den innebygde typen list
, som angir en elementtype any
for .
En postverdi er en ordnet sekvens med felt. Et felt består av et feltnavn, som er en tekstverdi som unikt identifiserer feltet i posten, og en feltverdi. Feltverdien kan være en hvilken som helst type verdi, inkludert post. Poster kan konstrueres ved hjelp av initialiseringssyntaks, som følger:
postuttrykk:
[
velger feltliste ]
feltliste:
felt
feltfeltliste,
felt:
feltnavnuttrykk=
feltnavn:
generalisert identifikator
quoted-identifier
Følgende eksempel konstruerer en post med et felt med navnet x
verdi 1
, og et felt med navnet y
verdi 2
.
[ x = 1, y = 2 ]
Følgende eksempel konstruerer en post med a
et felt kalt en nestet postverdi. Den nestede posten har et felt med navnet b
verdi 2
.
[ a = [ b = 2 ] ]
Følgende gjelder når du evaluerer et postuttrykk:
Uttrykket som er tilordnet hvert feltnavn, brukes til å bestemme verdien for det tilknyttede feltet.
Hvis uttrykket som er tilordnet et feltnavn, produserer en verdi når det evalueres, blir dette verdien for feltet i den resulterende posten.
Hvis uttrykket som er tilordnet et feltnavn, oppstår en feil når det evalueres, registreres det faktum at en feil ble utløst med feltet sammen med feilverdien som ble opphøyd. Etterfølgende tilgang til dette feltet vil føre til at en feil utløses på nytt med den registrerte feilverdien.
Uttrykket evalueres i et miljø som det overordnede miljøet, bare med variabler som er slått sammen, som tilsvarer verdien for hvert felt i posten, bortsett fra det som initialiseres.
En verdi i en post evalueres ikke før det tilsvarende feltet er åpnet.
En verdi i en post evalueres maksimalt én gang.
Resultatet av uttrykket er en postverdi med en tom metadatapost.
Rekkefølgen på feltene i posten defineres av rekkefølgen de vises i postinitialiserer-uttrykket.
Hvert feltnavn som er angitt, må være unikt i posten, eller det er en feil. Navn sammenlignes ved hjelp av en ordenstallsammenligning.
[ x = 1, x = 2 ] // error: field names must be unique
[ X = 1, x = 2 ] // OK
En post uten felt kalles en tom post, og skrives som følger:
[] // empty record
Selv om rekkefølgen på feltene i en post ikke er viktig når du åpner et felt eller sammenligner to poster, er det viktig i andre kontekster, for eksempel når feltene i en post nummereres.
De samme to postene gir forskjellige resultater når feltene hentes:
Record.FieldNames([ x = 1, y = 2 ]) // [ "x", "y" ]
Record.FieldNames([ y = 1, x = 2 ]) // [ "y", "x" ]
Antall felt i en post kan bestemmes ved hjelp av Record.FieldCount
funksjonen. Eksempel:
Record.FieldCount([ x = 1, y = 2 }) // 2
Record.FieldCount([]) // 0
I tillegg til å bruke syntaksen [ ]
for postinitialisering, kan poster konstrueres fra en liste over verdier, og en liste over feltnavn eller en oppføringstype. Eksempel:
Record.FromList({1, 2}, {"a", "b"})
Ovennevnte tilsvarer:
[ a = 1, b = 2 ]
Følgende operatorer er definert for postverdier:
Operator | Resultat |
---|---|
x = y |
Equal |
x <> y |
Not equal |
x & y |
Flett |
x ?? y |
Coalesce |
Eksemplene nedenfor illustrerer operatorene ovenfor. Vær oppmerksom på at postfletting bruker feltene fra høyre operand til å overstyre felt fra venstre operand, hvis det skulle være en overlapping i feltnavn.
[ a = 1, b = 2 ] & [ c = 3 ] // [ a = 1, b = 2, c = 3 ]
[ a = 1, b = 2 ] & [ a = 3 ] // [ a = 3, b = 2 ]
[ a = 1, b = 2 ] = [ b = 2, a = 1 ] // true
[ a = 1, b = 2, c = 3 ] <> [ a = 1, b = 2 ] // true
Den opprinnelige typen postverdier er den innebygde typen record
, som angir en åpen tom liste over felt.
En tabellverdi er en ordnet sekvens med rader. En rad er en ordnet sekvens med kolonneverdier. Tabellens type bestemmer lengden på alle radene i tabellen, navnene på tabellens kolonner, typene for tabellens kolonner og strukturen til tabellens nøkler (hvis noen).
Selv om det ikke finnes noen litteral syntaks for tabeller, angis det flere standard bibliotekfunksjoner for å konstruere dem. Tabeller kan også konstrueres ved hjelp av den innebygde funksjonen #table
.
Følgende eksempel konstruerer en tabell fra en liste over kolonnenavn og en liste over rader. Den resulterende tabellen vil inneholde to kolonner type any
med og tre rader.
#table({"x", "x^2"}, {{1,1}, {2,4}, {3,9}})
#table
kan også brukes til å angi en fullstendig tabelltype:
#table(
type table [Digit = number, Name = text],
{{1,"one"}, {2,"two"}, {3,"three"}}
)
Her har den nye tabellverdien en tabelltype som angir kolonnenavn og kolonnetyper.
Følgende operatorer er definert for tabellverdier:
Operator | Resultat |
---|---|
x = y |
Equal |
x <> y |
Not equal |
x & y |
Sammenkobling |
x ?? y |
Coalesce |
Sammenkobling av tabell justerer kolonner med samme navn og fylles ut null
for kolonner som bare vises i én av operandtabellene. Følgende eksempel illustrerer sammenkobling av tabeller:
#table({"A","B"}, {{1,2}})
& #table({"B","C"}, {{3,4}})
A | B | C |
---|---|---|
1 |
2 |
null |
null |
3 |
4 |
Den opprinnelige typen tabellverdier er en egendefinert tabelltype (avledet fra den innebygde typen table
) som viser kolonnenavnene, angir at alle kolonnetyper skal være noen, og har ingen nøkler. (Gå til Tabelltyper for detaljer om tabelltyper.)
En funksjonsverdi er en verdi som tilordner et sett med argumenter til én enkelt verdi. Detaljene for funksjonsverdier er beskrevet i Funksjoner.
En typeverdi er en verdi som klassifiserer andre verdier. Detaljene for typeverdier er beskrevet i Typer.