Értékek
Az érték egy kifejezés kiértékelésével előállított adat. Ez a szakasz az M nyelv értékeit ismerteti. Minden értéktípushoz tartozik egy literális szintaxis, egy ilyen típusú értékek készlete, az adott értékkészleten definiált operátorok készlete, valamint az újonnan létrehozott értékekhez írt belső típus.
Erőforrás | Betű szerinti |
---|---|
Nulla | null |
Logikus | true false |
Szám | 0 1 -1 1.5 2.3e-5 |
Idő | #time(09,15,00) |
Dátum | #date(2013,02,26) |
DateTime | #datetime(2013,02,26, 09,15,00) |
DateTimeZone | #datetimezone(2013,02,26, 09,15,00, 09,00) |
Időtartam | #duration(0,1,30,0) |
Szöveg | "hello" |
Bináris | #binary("AQID") |
Lista | {1, 2, 3} |
Rekord | [ A = 1, B = 2 ] |
Tábla | #table({"X","Y"},{{0,1},{1,0}}) |
Függvény | (x) => x + 1 |
Típus | type { number } type table [ A = any, B = text ] |
Az alábbi szakaszok részletesen ismertetik az egyes értéktípusokat. A típusok és a típusleírók formálisan a típusok között vannak definiálva. A függvényértékek a Functionsben vannak definiálva. Az alábbi szakaszok felsorolják az egyes értékfajtákhoz definiált operátorokat, és példákat mutatnak be. Az operátor szemantikájának teljes definíciója az Operátorok területen található.
A null érték egy érték hiányának, illetve határozatlan vagy ismeretlen állapotú értéknek a megjelenítésére szolgál. A függvény null értéket ír a literál null
használatával. A null értékekhez a következő operátorok vannak definiálva:
Operátor | Eredmény |
---|---|
x > y |
Nagyobb mint |
x >= y |
Nagyobb vagy egyenlő |
x < y |
Kisebb mint |
x <= y |
Kisebb vagy egyenlő |
x = y |
Equal |
x <> y |
Nem egyenlő |
x ?? y |
Coalesce |
Az érték natív típusa null
a belső típus null
.
Logikai érték a logikai műveletekhez igaz vagy hamis értékkel rendelkezik. A logikai érték a literálok true
és false
a . A logikai értékekhez a következő operátorok vannak definiálva:
Operátor | Eredmény |
---|---|
x > y |
Nagyobb mint |
x >= y |
Nagyobb vagy egyenlő |
x < y |
Kisebb mint |
x <= y |
Kisebb vagy egyenlő |
x = y |
Equal |
x <> y |
Nem egyenlő |
x or y |
Feltételes logikai VAGY |
x ?? y |
Coalesce |
x and y |
Feltételes logikai ÉS |
not x |
Logikai NEM |
A logikai értékek (true
és false
) natív típusa a belső típus logical
.
Numerikus és aritmetikai műveletekhez számértéket használunk. Az alábbi példák számkonstansokra mutatnak be példákat:
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)
Egy szám legalább a dupla pontosságával jelenik meg (de nagyobb pontosságot is megtarthat). A kettős ábrázolás egybeesik az [IEEE 754-2008]-ban definiált bináris lebegőpontos aritmetika IEEE 64 bites dupla pontosságú szabványával. (A A kettős ábrázolás körülbelül 5,0 x 10324 és 1,7 x 10308 közötti dinamikus tartományt biztosít 15-16 számjegy pontossággal.)
A következő különleges értékek számértéknek is tekinthetők:
Pozitív nulla és negatív nulla. A legtöbb esetben a pozitív nulla és a negatív nulla ugyanúgy viselkedik, mint az egyszerű nulla érték, de bizonyos műveletek megkülönböztetik a kettőt.
Pozitív végtelen (
#infinity
) és negatív végtelen (-#infinity
). A végteleneket olyan műveletek állítják elő, mint a nem nulla szám nullával való osztása. Például1.0 / 0.0
pozitív végtelent ad, és-1.0 / 0.0
negatív végtelent ad.A Nem-a-Szám érték (
#nan
), gyakran rövidítve NaN. A naN-okat érvénytelen lebegőpontos műveletek állítják elő, például a nullát nullával osztják el.
A bináris matematikai műveleteket pontosság használatával hajtjuk végre. A pontosság határozza meg azt a tartományt, amelyre az operandusok kerekítve vannak, és azt a tartományt, amelyben a műveletet végrehajtják. Explicit pontosság hiányában az ilyen műveleteket dupla pontosság használatával hajtják végre.
Ha egy matematikai művelet eredménye túl kicsi a célformátumhoz, a művelet eredménye pozitív nulla vagy negatív nulla lesz.
Ha egy matematikai művelet eredménye túl nagy a célformátumhoz, a művelet eredménye pozitív végtelenné vagy negatív végtelenné válik.
Ha egy matematikai művelet érvénytelen, a művelet eredménye NaN lesz.
Ha egy lebegőpontos művelet egyik vagy mindkét operandusa NaN, a művelet eredménye NaN lesz.
A számértékekhez a következő operátorok vannak definiálva:
Operátor | Eredmény |
---|---|
x > y |
Nagyobb mint |
x >= y |
Nagyobb vagy egyenlő |
x < y |
Kisebb mint |
x <= y |
Kisebb vagy egyenlő |
x = y |
Equal |
x <> y |
Nem egyenlő |
x + y |
Sum |
x - y |
Eltérés |
x * y |
Termék |
x / y |
Hányados |
x ?? y |
Coalesce |
+x |
Unary plus |
-x |
Tagadás |
A számértékek natív típusa a belső típus number
.
Az időértékek a napidő átlátszatlan ábrázolását tárolják. Az idő éjfél óta a kullancsok számaként van kódolva, ami a 24 órás idő alatt eltelt 100 nanoszekundumos kullancsok számát számítja. Az éjfél óta engedélyezett kullancsok maximális száma 23:59:59.99999999 óra.
Bár az időkhöz nincs konstans szintaxis, több szabványos kódtárfüggvény is rendelkezésre áll az összeállításukhoz. Az időpontok a belső függvény #time
használatával is létrehozhatók:
#time(hour, minute, second)
A következőknek meg kell tartaniuk, vagy hiba lép fel az okkóddal Expression.Error
:
0 ≤ óra ≤ 24
0 ≤ perc ≤ 59
0 ≤ második ≤ 59
Ezenkívül, ha óra = 24, akkor a percnek és a másodpercnek nullának kell lennie.
Az időértékekhez a következő operátorok vannak definiálva:
Operátor | Eredmény |
---|---|
x = y |
Equal |
x <> y |
Nem egyenlő |
x >= y |
Nagyobb vagy egyenlő |
x > y |
Nagyobb mint |
x < y |
Kisebb mint |
x <= y |
Kisebb vagy egyenlő |
x ?? y |
Coalesce |
A következő operátorok lehetővé teszik, hogy az egyik vagy mindkét operandus dátum legyen:
Operátor | Bal operandus | Jobb operandus | Értelmezés |
---|---|---|---|
x + y |
time |
duration |
Dátum eltolása időtartam szerint |
x + y |
duration |
time |
Dátum eltolása időtartam szerint |
x - y |
time |
duration |
Dátum eltolása nem módosított időtartammal |
x - y |
time |
time |
Dátumok közötti időtartam |
x & y |
date |
time |
Egyesített dátum/idő |
Az időértékek natív típusa a belső típus time
.
A dátumértékek egy adott nap átlátszatlan ábrázolását tárolják. A dátumot a korszak óta eltelt napok számaként kódoljuk, a Gergely-naptárban 0001. január 1-től kezdődően. A korszak óta eltelt napok maximális száma 3652058, amely 9999. december 31-nek felel meg.
Bár a dátumok nem konstans szintaxist adnak meg, több szabványos kódtárfüggvény is rendelkezésre áll az összeállításukhoz. A dátumok a belső függvény #date
használatával is létrehozhatók:
#date(year, month, day)
A következőknek meg kell tartaniuk, vagy hiba lép fel az okkóddal Expression.Error
:
1 ≤ év ≤ 9999
1 ≤ hónap ≤ 12
1 ≤ nap ≤ 31
Emellett a napnak érvényesnek kell lennie a kiválasztott hónapra és évre.
A dátumértékekhez a következő operátorok vannak definiálva:
Operátor | Eredmény |
---|---|
x = y |
Equal |
x <> y |
Nem egyenlő |
x >= y |
Nagyobb vagy egyenlő |
x > y |
Nagyobb mint |
x < y |
Kisebb mint |
x <= y |
Kisebb vagy egyenlő |
x ?? y |
Coalesce |
A következő operátorok lehetővé teszik, hogy az egyik vagy mindkét operandus dátum legyen:
Operátor | Bal operandus | Jobb operandus | Értelmezés |
---|---|---|---|
x + y |
date |
duration |
Dátum eltolása időtartam szerint |
x + y |
duration |
date |
Dátum eltolása időtartam szerint |
x - y |
date |
duration |
Dátum eltolása nem módosított időtartammal |
x - y |
date |
date |
Dátumok közötti időtartam |
x & y |
date |
time |
Egyesített dátum/idő |
A dátumértékek natív típusa a belső típus date
.
A dátum/idő érték dátumot és időt is tartalmaz.
Bár a dátumidőkhöz nincs konstans szintaxis, a rendszer számos szabványos kódtárfüggvényt biztosít az összeállításukhoz. A datetime-ok a belső függvény #datetime
használatával is létrehozhatók:
#datetime(year, month, day, hour, minute, second)
A kifejezés.hiba okkóddal a következőnek kell tartania vagy hibát kell tartalmaznia: 1 ≤ év ≤ 9999
1 ≤ hónap ≤ 12
1 ≤ nap ≤ 31
0 ≤ óra ≤ 23
0 ≤ perc ≤ 59
0 ≤ második ≤ 59
Emellett a napnak érvényesnek kell lennie a kiválasztott hónapra és évre.
A dátum/idő értékekhez a következő operátorok vannak definiálva:
Operátor | Eredmény |
---|---|
x = y |
Equal |
x <> y |
Nem egyenlő |
x >= y |
Nagyobb vagy egyenlő |
x > y |
Nagyobb mint |
x < y |
Kisebb mint |
x <= y |
Kisebb vagy egyenlő |
x ?? y |
Coalesce |
A következő operátorok lehetővé teszik, hogy az egyik vagy mindkét operandus dátumidő legyen:
Operátor | Bal operandus | Jobb operandus | Értelmezés |
---|---|---|---|
x + y |
datetime |
duration |
Dátum/idő eltolás időtartam szerint |
x + y |
duration |
datetime |
Dátum/idő eltolás időtartam szerint |
x - y |
datetime |
duration |
Dátum/idő eltolás negatív időtartammal |
x - y |
datetime |
datetime |
Dátum/idő közötti időtartam |
A datetime értékek natív típusa a belső típus datetime
.
A datetimezone érték dátumot és időzónát tartalmaz. Az időzónák az UTC-től számított percek számának eltolásaként lesznek kódolva, amely megszámolja, hogy a dátumidő időrészét hány percnek kell eltolnia az egyetemes koordinált időtől (UTC). Az UTC-től minimálisan eltolt percek száma -840, amely -14:00 utc-eltolást vagy az UTC-nél tizennély órával korábbi UTC-eltolást jelent. Az UTC-től eltolt percek maximális száma 840, amely 14:00 UTC-eltolásnak felel meg.
Bár a datetimezoneshez nincs konstansszintaxis, a rendszer számos szabványos kódtárfüggvényt biztosít az összeállításukhoz. A datetimezonok a belső függvény #datetimezone
használatával is létrehozhatók:
#datetimezone(
year, month, day,
hour, minute, second,
offset-hours, offset-minutes)
A következőknek meg kell tartaniuk, vagy hiba lép fel az okkóddal Expression.Error
:
1 ≤ év ≤ 9999
1 ≤ hónap ≤ 12
1 ≤ nap ≤ 31
0 ≤ óra ≤ 23
0 ≤ perc ≤ 59
0 ≤ második ≤ 59
-14 ≤ eltolási idő ≤ 14
-59 ≤ eltolási perc ≤ 59
Ezenkívül a napnak érvényesnek kell lennie a kiválasztott hónapra és évre, és ha eltolás-óra = 14, akkor eltolás-perc <= 0, és ha eltolás-óra = -14, akkor eltolási perc >= 0.
A datetimezone értékekhez a következő operátorok vannak definiálva:
Operátor | Eredmény |
---|---|
x = y |
Equal |
x <> y |
Nem egyenlő |
x >= y |
Nagyobb vagy egyenlő |
x > y |
Nagyobb mint |
x < y |
Kisebb mint |
x <= y |
Kisebb vagy egyenlő |
x ?? y |
Coalesce |
A következő operátorok lehetővé teszik, hogy az egyik vagy mindkét operandus dátum/időzón legyen:
Operátor | Bal operandus | Jobb operandus | Értelmezés |
---|---|---|---|
x + y |
datetimezone |
duration |
Datetimezone eltolás időtartam szerint |
x + y |
duration |
datetimezone |
Datetimezone eltolás időtartam szerint |
x - y |
datetimezone |
duration |
Datetimezone eltolása nem meghatározott időtartammal |
x - y |
datetimezone |
datetimezone |
Dátum/időzónák közötti időtartam |
A datetimezone értékek natív típusa a belső típus datetimezone
.
Az időtartamértékek egy 100 nanoszekundumos idővonal két pontja közötti távolság átlátszatlan ábrázolását tárolják. Az időtartam nagysága lehet pozitív vagy negatív, a pozitív értékek pedig az előrehaladás előrehaladtát jelzik az időben, a negatív értékek pedig az idő előrehaladtával. Az időtartamban tárolható minimális érték -9 223 372 036 854 775 808 kullancs, vagy 10 675 199 nap 2 óra 48 perc 05.4775808 másodperc hátrafelé az időben. Az időtartamban tárolható maximális érték 9 223 372 036 854 775 807 kullancs, vagy 10 675 199 nap 2 óra 48 perc 05.4775807 másodperces időrés.
Bár az időtartamok nem konstans szintaxist adnak meg, a rendszer számos szabványos kódtárfüggvényt biztosít az összeállításukhoz. Az időtartamok a belső függvény #duration
használatával is létrehozhatók:
#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
Az időtartamértékeken a következő operátorok vannak definiálva:
Operátor | Eredmény |
---|---|
x = y |
Equal |
x <> y |
Nem egyenlő |
x >= y |
Nagyobb vagy egyenlő |
x > y |
Nagyobb mint |
x < y |
Kisebb mint |
x <= y |
Kisebb vagy egyenlő |
x ?? y |
Coalesce |
Emellett a következő operátorok lehetővé teszik, hogy az egyik vagy mindkét operandusuk időtartamérték legyen:
Operátor | Bal operandus | Jobb operandus | Értelmezés |
---|---|---|---|
x + y |
datetime |
duration |
Dátum/idő eltolás időtartam szerint |
x + y |
duration |
datetime |
Dátum/idő eltolás időtartam szerint |
x + y |
duration |
duration |
Időtartamok összege |
x - y |
datetime |
duration |
Dátum/idő eltolás negatív időtartammal |
x - y |
datetime |
datetime |
Dátum/idő közötti időtartam |
x - y |
duration |
duration |
Időtartamok különbsége |
x * y |
duration |
number |
Időtartam n-szerese |
x * y |
number |
duration |
Időtartam n-szerese |
x / y |
duration |
number |
Időtartam töredéke |
Az időtartamértékek natív típusa a belső típus duration
.
A szöveges érték Unicode-karakterek sorozatát jelöli. A szöveges értékek a következő nyelvhelyességnek megfelelő konstans formátumúak:
_text-literál:
"
szövegkonstans karakterekopt "
szövegkonstans karakterek:
szöveg-literál-karakter szöveg-literál-karakteropt
szövegkonstans karakter:
egy szöveges karakter
karakter-escape-sequence
dupla idézőjel-escape-sequence
egy szöveges karakter:
Bármely karakter, kivéve "
(U+0022
) vagy #
(U+0023
) után (
(U+0028
)
dupla idézőjel-escape-sorozat:
""
(U+0022
, U+0022
)
Az alábbi példa egy szöveges értékre mutat be:
"ABC" // the text value ABC
A szövegértékeken a következő operátorok vannak definiálva:
Operátor | Eredmény |
---|---|
x = y |
Equal |
x <> y |
Nem egyenlő |
x >= y |
Nagyobb vagy egyenlő |
x > y |
Nagyobb mint |
x < y |
Kisebb mint |
x <= y |
Kisebb vagy egyenlő |
x & y |
Összeláncolás |
x ?? y |
Coalesce |
A szöveges értékek natív típusa a belső típus text
.
A bináris értékek bájtok sorozatát jelölik.
Bár a bináris értékekhez nincs konstans szintaxis, a rendszer számos szabványos kódtárfüggvényt biztosít az összeállításukhoz. A bináris értékek a belső függvény #binary
használatával is létrehozhatók.
Az alábbi példa bináris értéket hoz létre bájtok listájából:
#binary( {0x00, 0x01, 0x02, 0x03} )
A bináris értékeken a következő operátorok vannak definiálva:
Operátor | Eredmény |
---|---|
x = y |
Equal |
x <> y |
Nem egyenlő |
x >= y |
Nagyobb vagy egyenlő |
x > y |
Nagyobb mint |
x < y |
Kisebb mint |
x <= y |
Kisebb vagy egyenlő |
x ?? y |
Coalesce |
A bináris értékek natív típusa a belső bináris típus.
A listaérték olyan érték, amely számbavételkor értéksorozatot hoz létre. A listák által előállított értékek bármilyen értéket tartalmazhatnak, beleértve a listát is. A listák az inicializálási szintaxissal hozhatók létre az alábbiak szerint:
listakifejezés:
{ item-listopt }
elemlista:
cikk
elemlista ,
cikk:
kifejezés
kifejezés..
Az alábbi példa egy listakifejezésre , amely egy három szöveges értékkel rendelkező listát határoz meg: "A"
, "B"
és "C"
.
{"A", "B", "C"}
Az érték "A"
a lista első eleme, az érték "C"
pedig a lista utolsó eleme.
- A lista elemei csak a hozzáférésük után lesznek kiértékelve.
- Bár a listaszintaxis használatával létrehozott listaértékek elemeket hoznak létre az elemlistában megjelenő sorrendben, a kódtárfüggvényekből visszaadott listák általában eltérő készletet vagy eltérő számú értéket eredményeznek minden egyes számbavételkor.
Ha egész számsorozatot szeretne felvenni egy listába, az a..b
űrlap a következő módon használható:
{ 1, 5..9, 11 } // { 1, 5, 6, 7, 8, 9, 11 }
A lista elemeinek száma( más néven listaszám) a List.Count
függvény használatával határozható meg.
List.Count({true, false}) // 2
List.Count({}) // 0
A listák gyakorlatilag végtelen számú elemből állhatnak; List.Count
az ilyen listák nem definiáltak, és vagy hibát jeleznek, vagy nem fejeződnek be.
Ha egy lista nem tartalmaz elemeket, akkor üres listának nevezzük. Az üres lista a következőképpen íródik:
{} // empty list
A listákhoz a következő operátorok vannak definiálva:
Operátor | Eredmény |
---|---|
x = y |
Equal |
x <> y |
Nem egyenlő |
x & y |
Concatenate |
x ?? y |
Coalesce |
Példa:
{1, 2} & {3, 4, 5} // {1, 2, 3, 4, 5}
{1, 2} = {1, 2} // true
{2, 1} <> {1, 2} // true
A listaértékek natív típusa a belső típus list
, amely az elem típusát any
adja meg.
A rekordérték a mezők rendezett sorozata. A mező egy mezőnévből áll, amely egy szöveges érték, amely egyedileg azonosítja a rekordon belüli mezőt, és egy mezőértéket. A mező értéke bármilyen típusú lehet, beleértve a rekordot is. A rekordok inicializálási szintaxissal hozhatók létre, az alábbiak szerint:
rekordkifejezés:
[
mezőlistaopt ]
mezőlista:
mező
mezőlista,
mező:
mezőnév=
kifejezés
mezőnév:
generalized-identifier
idézett azonosító
Az alábbi példa egy értéket tartalmazó x
mezővel és egy értékkel 1
2
elnevezett y
mezővel rendelkező rekordot hoz létre.
[ x = 1, y = 2 ]
Az alábbi példa egy beágyazott rekordértékkel rendelkező mezővel rendelkező a
rekordot hoz létre. A beágyazott rekordban egy érték 2
nevű b
mező található.
[ a = [ b = 2 ] ]
Rekordkifejezések kiértékelésekor a következők érvényesek:
Az egyes mezőnevekhez rendelt kifejezés a társított mező értékének meghatározására szolgál.
Ha a mezőnévhez rendelt kifejezés kiértékelésekor értéket hoz létre, akkor ez lesz az eredményül kapott rekord mezőjének értéke.
Ha a mezőnévhez rendelt kifejezés hibát jelez a kiértékeléskor, akkor a rendszer rögzíti a hibát a mezővel együtt, valamint a felmerült hibaértéket. A mező későbbi elérése hibát okoz a rögzített hibaértékkel.
A kifejezés kiértékelése a szülőkörnyezethez hasonló környezetben csak olyan változókkal történik, amelyek a rekord minden mezőjének értékének felelnek meg, kivéve az inicializálandót.
A rekordban lévő értékeket a program csak a megfelelő mező eléréséig értékeli ki.
A rekordban lévő értékek kiértékelése legfeljebb egyszer történik.
A kifejezés eredménye egy üres metaadatrekordot tartalmazó rekordérték.
A rekordon belüli mezők sorrendjét a rekord-initializer-kifejezésben megjelenő sorrend határozza meg.
Minden megadott mezőnévnek egyedinek kell lennie a rekordon belül, vagy hiba. A nevek összehasonlítása sorszámos összehasonlítással történik.
[ x = 1, x = 2 ] // error: field names must be unique
[ X = 1, x = 2 ] // OK
A mezők nélküli rekordokat üres rekordnak nevezzük, és a következőképpen íródik:
[] // empty record
Bár egy rekord mezőinek sorrendje nem jelentős egy mező elérésekor vagy két rekord összehasonlításakor, más kontextusokban is jelentős, például a rekord mezőinek számbavételekor.
Ugyanez a két rekord eltérő eredményeket ad a mezők lekértésekor:
Record.FieldNames([ x = 1, y = 2 ]) // [ "x", "y" ]
Record.FieldNames([ y = 1, x = 2 ]) // [ "y", "x" ]
A rekord mezőinek száma a Record.FieldCount
függvény használatával határozható meg. Példa:
Record.FieldCount([ x = 1, y = 2 }) // 2
Record.FieldCount([]) // 0
A rekord inicializálási szintaxisa [ ]
mellett a rekordok értéklistából, mezőnevekből vagy rekordtípusból is létrehozhatóak. Példa:
Record.FromList({1, 2}, {"a", "b"})
A fentiek egyenértékűek a következő értékeket:
[ a = 1, b = 2 ]
A rekordértékekhez a következő operátorok vannak definiálva:
Operátor | Eredmény |
---|---|
x = y |
Equal |
x <> y |
Nem egyenlő |
x & y |
Összefűzés |
x ?? y |
Coalesce |
Az alábbi példák a fenti operátorokat szemléltetik. Vegye figyelembe, hogy a rekordegyesítés a jobb operandus mezőit használja a bal operandus mezőinek felülbírálásához, ha átfedés van a mezőnevekben.
[ 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
A rekordértékek natív típusa a belső típus record
, amely a mezők nyitott üres listáját adja meg.
A táblaérték a sorok rendezett sorozata. A sor oszlopértékek rendezett sorozata. A táblázat típusa határozza meg a tábla összes sorának hosszát, a tábla oszlopainak nevét, a tábla oszlopainak típusait és a tábla kulcsainak szerkezetét (ha van ilyen).
Bár a táblákhoz nincs konstans szintaxis, a rendszer számos szabványos kódtárfüggvényt biztosít az összeállításukhoz. A táblák a belső függvény #table
használatával is létrehozhatók.
Az alábbi példa egy táblázatot hoz létre az oszlopnevek és a sorok listájából. Az eredményként kapott táblázat két oszlopot type any
és három sort tartalmaz.
#table({"x", "x^2"}, {{1,1}, {2,4}, {3,9}})
#table
teljes táblázattípus megadására is használható:
#table(
type table [Digit = number, Name = text],
{{1,"one"}, {2,"two"}, {3,"three"}}
)
Itt az új táblaérték táblázattípussal rendelkezik, amely oszlopneveket és oszloptípusokat határoz meg.
A táblaértékekhez a következő operátorok vannak definiálva:
Operátor | Eredmény |
---|---|
x = y |
Equal |
x <> y |
Nem egyenlő |
x & y |
Összeláncolás |
x ?? y |
Coalesce |
A táblázatösszefűzés a hasonló nevű oszlopokat igazítja, és kitölti null
azokat az oszlopokat, amelyek csak az egyik operandus táblában jelennek meg. Az alábbi példa táblázatösszefűzést szemléltet:
#table({"A","B"}, {{1,2}})
& #table({"B","C"}, {{3,4}})
A | h | C |
---|---|---|
1 |
2 |
null |
null |
3 |
4 |
A táblaértékek natív típusa egy egyéni táblatípus (amely a belső típusból table
származik), amely felsorolja az oszlopneveket, megadja az összes oszloptípust, és nincs kulcsa. (Ugrás a Táblázattípusok a táblázattípusok részleteihez.)
A függvényértékek olyan értékek, amelyek argumentumokat képeznek le egyetlen értékre. A függvényértékek részleteit a Functions ismerteti.
A típusérték olyan érték, amely más értékeket sorol be. A típusértékek részleteit a Típusok című témakörben találja.