Een waarde is gegevens die worden geproduceerd door een expressie te evalueren. In deze sectie worden de soorten waarden in de M-taal beschreven. Elk type waarde wordt gekoppeld aan een letterlijke syntaxis, een set waarden die van dat type zijn, een set operators die zijn gedefinieerd voor die set waarden en een intrinsiek type dat is toegewezen aan nieuw samengestelde waarden.
Soort
Literal
Null
null
Logisch
truefalse
Nummer
01-11.52.3e-5
Tijd
#time(09,15,00)
Datum
#date(2013,02,26)
Datum/tijd
#datetime(2013,02,26, 09,15,00)
DateTimeZone
#datetimezone(2013,02,26, 09,15,00, 09,00)
Duur
#duration(0,1,30,0)
Text
"hello"
Binair
#binary("AQID")
Lijst
{1, 2, 3}
Record
[ A = 1, B = 2 ]
Tabel
#table({"X","Y"},{{0,1},{1,0}})
Functie
(x) => x + 1
Type
type { number }type table [ A = any, B = text ]
In de volgende secties wordt elk waardetype gedetailleerd beschreven. Typen en type-ascriptie worden formeel gedefinieerd in Typen. Functiewaarden worden gedefinieerd in Functions. De volgende secties bevatten de operators die zijn gedefinieerd voor elk waardetype en geven voorbeelden. De volledige definitie van operatorsemantiek volgt in Operators.
Null
Een null-waarde wordt gebruikt om de afwezigheid van een waarde of een waarde met onbepaalde of onbekende status aan te geven. Een null-waarde wordt geschreven met behulp van de letterlijke waarde null. De volgende operators zijn gedefinieerd voor null-waarden:
Operator
Resultaat
x > y
Groter dan
x >= y
Groter dan of gelijk aan
x < y
Kleiner dan
x <= y
Kleiner dan of gelijk aan
x = y
Equal
x <> y
Not equal
x ?? y
Coalesce
Het systeemeigen type van de null waarde is het intrinsieke type null.
Logisch
Een logische waarde wordt gebruikt voor Booleaanse bewerkingen met de waarde waar of onwaar. Een logische waarde wordt geschreven met behulp van de letterlijke waarden true en false. De volgende operators zijn gedefinieerd voor logische waarden:
Operator
Resultaat
x > y
Groter dan
x >= y
Groter dan of gelijk aan
x < y
Kleiner dan
x <= y
Kleiner dan of gelijk aan
x = y
Equal
x <> y
Not equal
x or y
Voorwaardelijk logisch OF
x ?? y
Coalesce
x and y
Voorwaardelijke logische AND
not x
Logische NOT
Het systeemeigen type van zowel logische waarden (true als false) is het intrinsieke type logical.
Aantal
Een getalwaarde wordt gebruikt voor numerieke en rekenkundige bewerkingen. Hier volgen enkele voorbeelden van letterlijke getallen:
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)
Een getal wordt weergegeven met ten minste de precisie van een double (maar kan meer precisie behouden). De dubbele weergave is congruent met de IEEE 64-bits dubbele precisiestandaard voor binaire drijvende kommaberekeningen die zijn gedefinieerd in [IEEE 754-2008]. (De Dubbele weergave heeft een dynamisch bereik van 5,0 x 10324 tot 1,7 x 10308 met een precisie van 15-16 cijfers.)
De volgende speciale waarden worden ook beschouwd als getalwaarden :
Positieve oneindigheid (#infinity) en negatieve oneindigheid (-#infinity). Infinities worden geproduceerd door bewerkingen zoals het delen van een niet-nulgetal door nul. Levert bijvoorbeeld 1.0 / 0.0 positieve oneindigheid op en -1.0 / 0.0 geeft negatieve oneindigheid als resultaat.
De waarde Not-a-Number (#nan), vaak afgekort NaN. NaN's worden geproduceerd door ongeldige drijvendekommabewerkingen, zoals nul delen door nul.
Binaire wiskundige bewerkingen worden uitgevoerd met behulp van een precisie. De precisie bepaalt het domein waarop de operanden worden afgerond en het domein waarin de bewerking wordt uitgevoerd. Als er geen expliciet opgegeven precisie is, worden dergelijke bewerkingen uitgevoerd met dubbele precisie.
Als het resultaat van een wiskundige bewerking te klein is voor de doelindeling, wordt het resultaat van de bewerking positief nul of negatief nul.
Als het resultaat van een wiskundige bewerking te groot is voor de doelindeling, wordt het resultaat van de bewerking positief oneindig of negatief oneindig.
Als een wiskundige bewerking ongeldig is, wordt het resultaat van de bewerking NaN.
Als een of beide operanden van een drijvendekommabewerking NaN zijn, wordt het resultaat van de bewerking NaN.
De volgende operators zijn gedefinieerd voor getalwaarden:
Operator
Resultaat
x > y
Groter dan
x >= y
Groter dan of gelijk aan
x < y
Kleiner dan
x <= y
Kleiner dan of gelijk aan
x = y
Equal
x <> y
Not equal
x + y
Sum
x - y
Verschil
x * y
Product
x / y
Quotiënt
x ?? y
Coalesce
+x
Unary plus
-x
Negatie
Het systeemeigen type getalwaarden is het intrinsieke type number.
Tijd
Een tijdwaarde slaat een ondoorzichtige weergave van het tijdstip van de dag op. Een tijd wordt gecodeerd als het aantal tikken sinds middernacht, waarmee het aantal tikken van 100 nanoseconden wordt geteld die zijn verstreken op een 24-uursklok. Het maximum aantal tikken sinds middernacht komt overeen met 23:59:59.999999999 uur.
Hoewel er geen letterlijke syntaxis is voor tijden, worden er verschillende standaardbibliotheekfuncties geboden om ze samen te stellen. Tijden kunnen ook worden samengesteld met behulp van de intrinsieke functie #time:
#time(hour, minute, second)
Het volgende moet worden opgeslagen of er wordt een fout met redencode Expression.Error gegenereerd:
0 ≤ uur ≤ 24
0 ≤ minuut ≤ 59
0 ≤ tweede ≤ 59
Bovendien, als uur = 24, moet minuut en seconde nul zijn.
De volgende operators zijn gedefinieerd voor tijdwaarden:
Operator
Resultaat
x = y
Equal
x <> y
Not equal
x >= y
Groter dan of gelijk aan
x > y
Groter dan
x < y
Kleiner dan
x <= y
Kleiner dan of gelijk aan
x ?? y
Coalesce
Met de volgende operators kunnen een of beide operanden een datum zijn:
Operator
Linkeroperand
Rechteroperand
Betekenis
x + y
time
duration
Datumverschil per duur
x + y
duration
time
Datumverschil per duur
x - y
time
duration
Datumverschil per ontkende duur
x - y
time
time
Duur tussen datums
x & y
date
time
Samengevoegde datum/tijd
Het systeemeigen type tijdwaarden is het intrinsieke type time.
Datum
Een datumwaarde slaat een ondoorzichtige weergave van een specifieke dag op. Een datum wordt gecodeerd als een aantal dagen sinds het tijdvak, beginnend vanaf 1 januari 0001 gemeenschappelijk tijdperk op de Gregoriaanse kalender. Het maximum aantal dagen sinds de periode is 3652058, dat overeenkomt met 31 december 9999.
Hoewel er geen letterlijke syntaxis voor datums is, worden er verschillende standaardbibliotheekfuncties geboden om ze samen te stellen. Datums kunnen ook worden samengesteld met behulp van de intrinsieke functie #date:
#date(year, month, day)
Het volgende moet worden opgeslagen of er wordt een fout met redencode Expression.Error gegenereerd:
1 ≤ jaar ≤ 9999
1 ≤ maand ≤ 12
1 ≤ dag ≤ 31
Bovendien moet de dag geldig zijn voor de gekozen maand en het jaar.
De volgende operators zijn gedefinieerd voor datumwaarden:
Operator
Resultaat
x = y
Equal
x <> y
Not equal
x >= y
Groter dan of gelijk aan
x > y
Groter dan
x < y
Kleiner dan
x <= y
Kleiner dan of gelijk aan
x ?? y
Coalesce
Met de volgende operators kunnen een of beide operanden een datum zijn:
Operator
Linkeroperand
Rechteroperand
Betekenis
x + y
date
duration
Datumverschil per duur
x + y
duration
date
Datumverschil per duur
x - y
date
duration
Datumverschil per ontkende duur
x - y
date
date
Duur tussen datums
x & y
date
time
Samengevoegde datum/tijd
Het systeemeigen type datumwaarden is het intrinsieke type date.
Datum en tijd
Een datum/tijd-waarde bevat zowel een datum als een tijd.
Hoewel er geen letterlijke syntaxis is voor datum/tijd, worden er verschillende standaardbibliotheekfuncties geboden om ze samen te stellen. Datum/tijd kan ook worden samengesteld met behulp van de intrinsieke functie #datetime:
#datetime(year, month, day, hour, minute, second)
Het volgende moet een fout met de redencode Expression.Error bevatten: 1 ≤ jaar ≤ 9999
1 ≤ maand ≤ 12
1 ≤ dag ≤ 31
0 ≤ uur ≤ 23
0 ≤ minuut ≤ 59
0 ≤ tweede ≤ 59
Bovendien moet de dag geldig zijn voor de gekozen maand en het jaar.
De volgende operators zijn gedefinieerd voor datum/tijd-waarden:
Operator
Resultaat
x = y
Equal
x <> y
Not equal
x >= y
Groter dan of gelijk aan
x > y
Groter dan
x < y
Kleiner dan
x <= y
Kleiner dan of gelijk aan
x ?? y
Coalesce
Met de volgende operators kunnen een of beide operanden een datum/tijd zijn:
Operator
Linkeroperand
Rechteroperand
Betekenis
x + y
datetime
duration
Datum/tijd-verschuiving op duur
x + y
duration
datetime
Datum/tijd-verschuiving op duur
x - y
datetime
duration
Datum/tijd-verschuiving op negatieve duur
x - y
datetime
datetime
Duur tussen datum/tijd
Het systeemeigen type datum/tijd-waarden is het intrinsieke type datetime.
DateTimeZone
Een datum/tijdzone-waarde bevat een datum/tijd en een tijdzone. Een tijdzone wordt gecodeerd als een aantal minuten offset van UTC, waarmee het aantal minuten wordt geteld dat het tijdgedeelte van de datum/tijd moet worden verschoven van Universal Coordinated Time (UTC). Het minimumaantal minuten dat wordt verschoven van UTC is -840, die een UTC-offset van -14:00 of veertien uur eerder dan UTC vertegenwoordigt. Het maximum aantal minuten dat wordt verschoven van UTC is 840, wat overeenkomt met een UTC-offset van 14:00 uur.
Hoewel er geen letterlijke syntaxis is voor datum/tijdzones, worden er verschillende standaardbibliotheekfuncties geboden om ze samen te stellen. Datetimezones kunnen ook worden samengesteld met behulp van de intrinsieke functie #datetimezone:
Bovendien moet de dag geldig zijn voor de gekozen maand en het jaar en, als offseturen = 14, dan offsetminuten <= 0 en, als offseturen = -14, dan offsetminuten >= 0.
De volgende operators zijn gedefinieerd voor datum/tijdzone-waarden:
Operator
Resultaat
x = y
Equal
x <> y
Not equal
x >= y
Groter dan of gelijk aan
x > y
Groter dan
x < y
Kleiner dan
x <= y
Kleiner dan of gelijk aan
x ?? y
Coalesce
Met de volgende operators kunnen een of beide operanden een datum/tijdzone zijn:
Operator
Linkeroperand
Rechteroperand
Betekenis
x + y
datetimezone
duration
Offset van datum/tijdzone op duur
x + y
duration
datetimezone
Offset van datum/tijdzone op duur
x - y
datetimezone
duration
Datum/tijdzone-offset op negated duration
x - y
datetimezone
datetimezone
Duur tussen datum/tijdzones
Het systeemeigen type datum/tijdzone-waarden is het intrinsieke type datetimezone.
Duur
Een duurwaarde slaat een ondoorzichtige weergave op van de afstand tussen twee punten op een tijdlijn met 100 nanoseconden. De grootte van een duur kan positief of negatief zijn, met positieve waarden die de voortgang in tijd aandukken en negatieve waarden die de voortgang achterwaarts in de tijd aandukken. De minimumwaarde die in een duur kan worden opgeslagen, is -9.223.372.036.854.775.808 tikken of 10.675.199 dagen 2 uur 48 minuten 05,4775808 seconden achteruit in de tijd. De maximumwaarde die in een duur kan worden opgeslagen, is 9.223.372.036.854.775.807 tikken of 10.675.199 dagen 2 uur 48 minuten 05,4775807 seconden vooruit in de tijd.
Hoewel er geen letterlijke syntaxis is voor duur, worden er verschillende standaardbibliotheekfuncties geboden om ze samen te stellen. Duur kan ook worden samengesteld met behulp van de intrinsieke functie #duration:
De volgende operators zijn gedefinieerd voor duurwaarden:
Operator
Resultaat
x = y
Equal
x <> y
Not equal
x >= y
Groter dan of gelijk aan
x > y
Groter dan
x < y
Kleiner dan
x <= y
Kleiner dan of gelijk aan
x ?? y
Coalesce
Bovendien staan de volgende operators toe dat een of beide operanden een duurwaarde zijn:
Operator
Linkeroperand
Rechteroperand
Betekenis
x + y
datetime
duration
Datum/tijd-verschuiving op duur
x + y
duration
datetime
Datum/tijd-verschuiving op duur
x + y
duration
duration
Som van duur
x - y
datetime
duration
Datum/tijd-verschuiving op negatieve duur
x - y
datetime
datetime
Duur tussen datum/tijd
x - y
duration
duration
Verschil in duur
x * y
duration
number
N keer een duur
x * y
number
duration
N keer een duur
x / y
duration
number
Fractie van een duur
Het systeemeigen type duurwaarden is het intrinsieke type duration.
Sms verzenden
Een tekstwaarde vertegenwoordigt een reeks Unicode-tekens. Tekstwaarden hebben een letterlijke vorm die voldoet aan de volgende grammatica:
_text letterlijk: "opt voor tekst-letterlijke tekens" letterlijke tekst:
tekst-letterlijk-teken-letterlijk-tekenskiezen
tekst-letterlijk-teken:
één tekstteken
teken-escape-reeks
double-quote-escape-sequence
enkel tekstteken:
Elk teken behalve " (U+0022) of # (U+0023) gevolgd door ( (U+0028) double-quote-escape-sequence: "" (U+0022, U+0022)
Hier volgt een voorbeeld van een tekstwaarde :
"ABC" // the text value ABC
De volgende operators zijn gedefinieerd voor tekstwaarden :
Operator
Resultaat
x = y
Equal
x <> y
Not equal
x >= y
Groter dan of gelijk aan
x > y
Groter dan
x < y
Kleiner dan
x <= y
Kleiner dan of gelijk aan
x & y
Samenvoegen
x ?? y
Coalesce
Het systeemeigen type tekstwaarden is het intrinsieke type text.
Binary
Een binaire waarde vertegenwoordigt een reeks bytes.
Hoewel er geen letterlijke syntaxis voor binaire waarden is, worden er verschillende standaardbibliotheekfuncties geboden om ze samen te stellen. Binaire waarden kunnen ook worden samengesteld met behulp van de intrinsieke functie #binary.
In het volgende voorbeeld wordt een binaire waarde samengesteld uit een lijst met bytes:
#binary( {0x00, 0x01, 0x02, 0x03} )
De volgende operators zijn gedefinieerd voor binaire waarden:
Operator
Resultaat
x = y
Equal
x <> y
Not equal
x >= y
Groter dan of gelijk aan
x > y
Groter dan
x < y
Kleiner dan
x <= y
Kleiner dan of gelijk aan
x ?? y
Coalesce
Het systeemeigen type binaire waarden is het intrinsieke type binair.
List
Een lijstwaarde is een waarde die een reeks waarden produceert wanneer deze wordt opgesomd. Een waarde die door een lijst wordt geproduceerd, kan elk soort waarde bevatten, inclusief een lijst. Lijsten kunnen als volgt worden samengesteld met behulp van de initialisatiesyntaxis:
Hier volgt een voorbeeld van een lijstexpressie waarmee een lijst met drie tekstwaarden wordt gedefinieerd: "A", "B"en "C".
{"A", "B", "C"}
De waarde "A" is het eerste item in de lijst en de waarde "C" is het laatste item in de lijst.
De items van een lijst worden pas geëvalueerd wanneer ze worden geopend.
Terwijl lijstwaarden die zijn samengesteld met behulp van de syntaxis van de lijst, items produceren in de volgorde waarin ze worden weergegeven in de itemlijst, kunnen lijsten die worden geretourneerd uit bibliotheekfuncties een andere set of een ander aantal waarden produceren telkens wanneer ze worden geïnventariseerd.
Als u een reeks gehele getallen in een lijst wilt opnemen, kan het a..b formulier worden gebruikt:
{ 1, 5..9, 11 } // { 1, 5, 6, 7, 8, 9, 11 }
Het aantal items in een lijst, ook wel het aantal lijsten genoemd, kan worden bepaald met behulp van de List.Count functie.
Een lijst kan in feite een oneindig aantal items bevatten; List.Count voor dergelijke lijsten is niet gedefinieerd en kan een fout veroorzaken of niet worden beëindigd.
Als een lijst geen items bevat, wordt deze een lege lijst genoemd. Een lege lijst wordt geschreven als:
{} // empty list
De volgende operators zijn gedefinieerd voor lijsten:
Het systeemeigen type lijstwaarden is het intrinsieke type list, waarmee een itemtype wordt anyopgegeven.
Opnemen
Een recordwaarde is een geordende reeks velden. Een veld bestaat uit een veldnaam, een tekstwaarde die het veld in de record uniek identificeert en een veldwaarde. De veldwaarde kan elk type waarde zijn, inclusief record. Records kunnen als volgt worden samengesteld met behulp van initialisatiesyntaxis:
record-expression: [opt voorlijst met velden] lijst met velden:
veld
veldveldlijst,
veld:
veldnaamexpressie=
veldnaam:
gegeneraliseerde id
id tussen aan/ uit
In het volgende voorbeeld wordt een record samengesteld met een veld met de naam x waarde 1en een veld met de naam y waarde 2.
[ x = 1, y = 2 ]
In het volgende voorbeeld wordt een record gemaakt met een veld met a de naam a met een geneste recordwaarde. De geneste record heeft een veld met de naam b waarde 2.
[ a = [ b = 2 ] ]
Het volgende geldt voor het evalueren van een recordexpressie:
De expressie die aan elke veldnaam is toegewezen, wordt gebruikt om de waarde van het gekoppelde veld te bepalen.
Als de expressie die is toegewezen aan een veldnaam een waarde produceert wanneer deze wordt geëvalueerd, wordt dat de waarde van het veld van de resulterende record.
Als de expressie die is toegewezen aan een veldnaam een fout genereert wanneer deze wordt geëvalueerd, wordt het feit dat er een fout is gegenereerd, vastgelegd met het veld, samen met de foutwaarde die is gegenereerd. Bij volgende toegang tot dat veld wordt een fout opnieuw gegenereerd met de vastgelegde foutwaarde.
De expressie wordt geëvalueerd in een omgeving zoals de bovenliggende omgeving, alleen met variabelen die overeenkomen met de waarde van elk veld van de record, behalve de omgeving die wordt geïnitialiseerd.
Een waarde in een record wordt pas geëvalueerd als het bijbehorende veld wordt geopend.
Een waarde in een record wordt maximaal één keer geëvalueerd.
Het resultaat van de expressie is een recordwaarde met een lege metagegevensrecord.
De volgorde van de velden in de record wordt gedefinieerd door de volgorde die ze weergeven in de record-initializer-expression.
Elke veldnaam die is opgegeven, moet uniek zijn binnen de record of is een fout. Namen worden vergeleken met behulp van een rangtelvergelijking.
[ x = 1, x = 2 ] // error: field names must be unique
[ X = 1, x = 2 ] // OK
Een record zonder velden wordt een lege record genoemd en wordt als volgt geschreven:
[] // empty record
Hoewel de volgorde van de velden van een record niet significant is bij het openen van een veld of het vergelijken van twee records, is het belangrijk in andere contexten, zoals wanneer de velden van een record worden geïnventariseerd.
Dezelfde twee records produceren verschillende resultaten wanneer de velden worden verkregen:
Record.FieldNames([ x = 1, y = 2 ]) // [ "x", "y" ]
Record.FieldNames([ y = 1, x = 2 ]) // [ "y", "x" ]
Het aantal velden in een record kan worden bepaald met behulp van de Record.FieldCount functie. Voorbeeld:
Record.FieldCount([ x = 1, y = 2 }) // 2
Record.FieldCount([]) // 0
Naast het gebruik van de syntaxis [ ]van de record initialisatie kunnen records worden samengesteld uit een lijst met waarden en een lijst met veldnamen of een recordtype. Voorbeeld:
Record.FromList({1, 2}, {"a", "b"})
Het bovenstaande is gelijk aan:
[ a = 1, b = 2 ]
De volgende operators zijn gedefinieerd voor recordwaarden:
Operator
Resultaat
x = y
Equal
x <> y
Not equal
x & y
Samenvoeging
x ?? y
Coalesce
In de volgende voorbeelden ziet u de bovenstaande operators. Bij recordsamenvoeging worden de velden van de rechteroperand gebruikt om velden uit de linkeroperand te overschrijven, mocht er sprake zijn van een overlapping in veldnamen.
[ 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
Het systeemeigen type recordwaarden is het intrinsieke type record, waarmee een geopende lege lijst met velden wordt opgegeven.
Tabel
Een tabelwaarde is een geordende reeks rijen. Een rij is een geordende reeks kolomwaarden. Het type tabel bepaalt de lengte van alle rijen in de tabel, de namen van de kolommen van de tabel, de typen kolommen van de tabel en de structuur van de sleutels van de tabel (indien van toepassing).
Hoewel er geen letterlijke syntaxis voor tabellen is, worden er verschillende standaardbibliotheekfuncties geboden om ze samen te stellen. Tabellen kunnen ook worden samengesteld met behulp van de intrinsieke functie #table.
In het volgende voorbeeld wordt een tabel samengesteld uit een lijst met kolomnamen en een lijst met rijen. De resulterende tabel bevat twee kolommen van type any en drie rijen.
#table({"x", "x^2"}, {{1,1}, {2,4}, {3,9}})
#table kan ook worden gebruikt om een volledig tabeltype op te geven:
#table(
type table [Digit = number, Name = text],
{{1,"one"}, {2,"two"}, {3,"three"}}
)
Hier heeft de nieuwe tabelwaarde een tabeltype waarmee kolomnamen en kolomtypen worden opgegeven.
De volgende operators zijn gedefinieerd voor tabelwaarden:
Operator
Resultaat
x = y
Equal
x <> y
Not equal
x & y
Samenvoegen
x ?? y
Coalesce
Tabelsamenvoeging lijnt like-named kolommen uit en vult null in voor kolommen die slechts in één van de operandtabellen worden weergegeven. In het volgende voorbeeld ziet u tabelsamenvoeging:
Het systeemeigen type tabelwaarden is een aangepast tabeltype (afgeleid van het intrinsieke type table) waarin de kolomnamen worden vermeld, waarmee alle kolomtypen worden opgegeven die moeten worden opgegeven en geen sleutels hebben. (Ga naar Tabeltypen voor meer informatie over tabeltypen.)
Functie
Een functiewaarde is een waarde waarmee een set argumenten wordt toegewezen aan één waarde. De details van functiewaarden worden beschreven in Functions.
Type
Een typewaarde is een waarde die andere waarden classificeert. De details van typewaarden worden beschreven in Typen.
Do you want to learn about table types in Business Central? In this module, you'll learn about the different functional table types and their specific characteristics, such as special fields, properties, and linked pages.