Hodnoty
Hodnota sú údaje vytvorené vyhodnotením výrazu. Táto časť popisuje druhy hodnôt v jazyku M. Každý druh hodnoty je priradený k literálovej syntaxi, množine hodnôt, ktoré sú tohto druhu, množine operátorov definovaných na tejto množine hodnôt a vnútornému typu priradenému novým vytvoreným hodnotám.
Láskavý | Doslovný |
---|---|
Nula | null |
Logický | true false |
Číslo | 0 1 -1 1.5 2.3e-5 |
Čas | #time(09,15,00) |
Dátum | #date(2013,02,26) |
Dátum a čas | #datetime(2013,02,26, 09,15,00) |
DateTimeZone (Dátum a časové pásmo) | #datetimezone(2013,02,26, 09,15,00, 09,00) |
Trvanie | #duration(0,1,30,0) |
Text | "hello" |
Binárny | #binary("AQID") |
Zoznam | {1, 2, 3} |
Rekord | [ A = 1, B = 2 ] |
Table | #table({"X","Y"},{{0,1},{1,0}}) |
Funkcia | (x) => x + 1 |
Typ | type { number } type table [ A = any, B = text ] |
Nasledujúce časti sa podrobne zaoberajú jednotlivými druhmi hodnôt. Typy a pripísanie typu sú formálne definované v časti Typy. Hodnoty funkcie sú definované v časti Funkcie. Nasledujúce časti obsahujú zoznam operátorov definovaných pre každý druh hodnoty a uvádzajú príklady. Celá definícia sémantiky operátora nasleduje v časti Operátory.
Hodnota null sa používa na znázornenie absencie hodnoty, alebo hodnoty neurčitého alebo neznámeho stavu. Hodnota null sa zapisuje pomocou literálu null
. Pre hodnoty null sú definované nasledujúce operátory:
Operátor | Result |
---|---|
x > y |
Väčšie než |
x >= y |
Väčšie alebo rovné |
x < y |
Menšie než |
x <= y |
Menšie ako alebo rovná sa |
x = y |
Equal |
x <> y |
Nerovná sa |
x ?? y |
Coalesce |
Natívny typ null
hodnoty je vnútorný typ null
.
Logická hodnota sa používa pre booleovské operácie a má hodnotu true alebo false. Logická hodnota sa zapisuje pomocou literálov true
a false
. Pre logické hodnoty sú definované nasledujúce operátory:
Operátor | Result |
---|---|
x > y |
Väčšie než |
x >= y |
Väčšie alebo rovné |
x < y |
Menšie než |
x <= y |
Menšie ako alebo rovná sa |
x = y |
Equal |
x <> y |
Nerovná sa |
x or y |
Podmienkový logický operátor OR |
x ?? y |
Coalesce |
x and y |
Podmienkový logický operátor AND |
not x |
Logický operátor NOT |
Natívny typ obidvoch logických hodnôt (true
a false
) je vnútorný typ logical
.
Na numerické a aritmetické operácie sa používa číselná hodnota . Nižšie sú uvedené príklady číselných literálov:
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)
Číslo je zastúpené aspoň s presnosťou Double (ale môže si zachovať väčšiu presnosť). Vyjadrenie Double sa zhoduje s dvojitou presnosťou 64-bitov IEEE pre binárnu aritmetiku s pohyblivou rádovou čiarkou definovanou v norme [IEEE 754-2008]. (The Dvojité vyjadrenie má približný dynamický rozsah 5,0 x 10324 až 1,7 x 10308 s presnosťou na 15 až 16 číslic.)
Za číselné hodnoty sa považujú aj nasledujúce špeciálne hodnoty:
Kladná nula a záporná nula. Vo väčšine prípadov sa kladná nula a záporná nula správajú rovnako ako jednoduchá hodnota nula, ale určité operácie ich rozlišujú.
Kladné nekonečno (
#infinity
) a záporné nekonečno (-#infinity
). Nekonečnosti sa vytvárajú operáciami ako delenie nenulového čísla nulou. Napríklad prináša1.0 / 0.0
kladné nekonečno a-1.0 / 0.0
prináša záporné nekonečno.Hodnota nie-je-číslo (
#nan
) často skrátene NaN. Hodnoty NaN sa vytvárajú podľa neplatných operácií s pohyblivou rádovou čiarkou, ako je napríklad delenie nuly nulou.
Binárne matematické operácie sa vykonávajú pomocou presnosti. Presnosť určuje doménu, na ktorú sa zaokrúhľujú operandy, a doménu, v ktorej sa vykonáva operácia. Pri absencii explicitne špecifikovanej presnosti sa takéto operácie vykonávajú s použitím dvojitej presnosti.
Ak je výsledok matematickej operácie príliš malý pre cieľový formát, výsledok operácie sa stane kladnou nulou alebo zápornou nulou.
Ak je výsledok matematickej operácie príliš veľký pre cieľový formát, výsledok operácie sa stane kladným nekonečnom alebo záporným nekonečnom.
Ak je matematická operácia neplatná, výsledok operácie sa stane NaN.
Ak je jeden alebo obidva operandy operácie s pohyblivou rádovou čiarkou sú NaN, výsledok operácie sa stane NaN.
Pre číselné hodnoty sú definované nasledujúce operátory:
Operátor | Result |
---|---|
x > y |
Väčšie než |
x >= y |
Väčšie alebo rovné |
x < y |
Menšie než |
x <= y |
Menšie ako alebo rovná sa |
x = y |
Equal |
x <> y |
Nerovná sa |
x + y |
Súčet |
x - y |
Rozdiel |
x * y |
Produkt |
x / y |
Kvocient |
x ?? y |
Coalesce |
+x |
Unárne plus |
-x |
Negácia |
Natívny typ číselných hodnôt je vnútorný typ number
.
Časová hodnota ukladá nepriehľadné vyjadrenie dennej doby. Čas je kódovaný ako počet impulzov od polnoci, čo sa počíta ako počet 100-nanosekundových impulzov, ktoré uplynuli v 24-hodinovom čase. Maximálny počet impulzov od polnoci zodpovedá 23:59:59.99999999 hod.
Hoci na čas neexistuje žiadna literálová syntax, na ich vytvorenie je k dispozícii niekoľko štandardných funkcií knižnice. Časy možno vytvárať aj pomocou vnútornej funkcie #time
:
#time(hour, minute, second)
Musí existovať nasledujúce, inak sa vyvolá chyba s kódom Expression.Error
príčiny :
0 ≤ hodina ≤ 24
0 ≤ minúta ≤ 59
0 ≤ druhý ≤ 59
Okrem toho, ak hodina = 24, minúta a sekunda musia byť nula.
Pre časové hodnoty sú definované nasledujúce operátory:
Operátor | Result |
---|---|
x = y |
Equal |
x <> y |
Nerovná sa |
x >= y |
Väčšie alebo rovné |
x > y |
Väčšie než |
x < y |
Menšie než |
x <= y |
Menšie ako alebo rovná sa |
x ?? y |
Coalesce |
Nasledujúce operátory povoľujú, aby jeden alebo obidva ich operandy boli dátum:
Operátor | Ľavý operand | Pravý operand | Význam |
---|---|---|---|
x + y |
time |
duration |
Posun dátumu podľa trvania |
x + y |
duration |
time |
Posun dátumu podľa trvania |
x - y |
time |
duration |
Posun dátumu podľa negovaného trvania |
x - y |
time |
time |
Trvanie medzi dátumami |
x & y |
date |
time |
Zlúčený dátum a čas |
Natívny typ časových hodnôt je vnútorný typ time
.
Dátumová hodnota ukladá nepriehľadné vyjadrenie konkrétneho dňa. Dátum je kódovaný ako počet dní od epochy, počnúc 1. januárom 0001 bežnej éry v gregoriánskom kalendári. Maximálny počet dní od epochy je 3652058, čo zodpovedá 31. decembru 9999.
Hoci pre dátumy neexistuje žiadna literálová syntax, na ich vytvorenie je k dispozícii niekoľko štandardných funkcií knižnice. Dátumy možno vytvárať aj pomocou vnútornej funkcie #date
:
#date(year, month, day)
Musí existovať nasledujúce, inak sa vyvolá chyba s kódom Expression.Error
príčiny :
1 ≤ rok ≤ 9 999
1 ≤ mesiac ≤ 12
1 ≤ deň ≤ 31
Okrem toho musí deň byť platný pre zvolený mesiac a rok.
Pre dátumové hodnoty sú definované nasledujúce operátory:
Operátor | Result |
---|---|
x = y |
Equal |
x <> y |
Nerovná sa |
x >= y |
Väčšie alebo rovné |
x > y |
Väčšie než |
x < y |
Menšie než |
x <= y |
Menšie ako alebo rovná sa |
x ?? y |
Coalesce |
Nasledujúce operátory povoľujú, aby jeden alebo obidva ich operandy boli dátum:
Operátor | Ľavý operand | Pravý operand | Význam |
---|---|---|---|
x + y |
date |
duration |
Posun dátumu podľa trvania |
x + y |
duration |
date |
Posun dátumu podľa trvania |
x - y |
date |
duration |
Posun dátumu podľa negovaného trvania |
x - y |
date |
date |
Trvanie medzi dátumami |
x & y |
date |
time |
Zlúčený dátum a čas |
Natívny typ dátumových hodnôt je vnútorný typ date
.
Dátumová a časová hodnota obsahuje dátum aj čas.
Hoci pre datetime neexistuje žiadna literálová syntax, na ich vytvorenie je k dispozícii niekoľko štandardných funkcií knižnice. Datetimes možno tiež vytvárať pomocou vnútornej funkcie #datetime
:
#datetime(year, month, day, hour, minute, second)
Musí existovať nasledujúce, inak sa vyvolá chyba s kódom príčiny Expression.Error: 1 ≤ rok ≤ 9999
1 ≤ mesiac ≤ 12
1 ≤ deň ≤ 31
0 ≤ hodina ≤ 23
0 ≤ minúta ≤ 59
0 ≤ druhý ≤ 59
Okrem toho musí deň byť platný pre zvolený mesiac a rok.
Pre hodnoty dátumu a času sú definované nasledujúce operátory:
Operátor | Result |
---|---|
x = y |
Equal |
x <> y |
Nerovná sa |
x >= y |
Väčšie alebo rovné |
x > y |
Väčšie než |
x < y |
Menšie než |
x <= y |
Menšie ako alebo rovná sa |
x ?? y |
Coalesce |
Nasledujúce operátory povoľujú, aby jeden alebo obidva ich operandy boli datetime:
Operátor | Ľavý operand | Pravý operand | Význam |
---|---|---|---|
x + y |
datetime |
duration |
Posun hodnoty datetime podľa trvania |
x + y |
duration |
datetime |
Posun hodnoty datetime podľa trvania |
x - y |
datetime |
duration |
Posun hodnoty datetime podľa negovaného trvania |
x - y |
datetime |
datetime |
Trvanie medzi hodnotami datetime |
Natívny typ dátumo-časových hodnôt je vnútorný typ datetime
.
Hodnota datetimezone obsahuje dátum-čas a časové pásmo. Časové pásmo je kódované ako počet minútového posunu od UTC, ktorý počíta počet minút, koľko by mala byť časová časť hodnoty datetime posunutá od Univerzálneho koordinovaného času (UTC). Minimálny počet minútového posunu od UTC je -840, čo predstavuje posun od UTC -14:00 alebo o štrnásť hodín skôr ako UTC. Maximálny počet minút posunu od UTC je 840, čo zodpovedá posunu od UTC hodnoty 14:00.
Hoci pre datetimezone neexistuje žiadna literálová syntax, na ich vytvorenie je k dispozícii niekoľko štandardných funkcií knižnice. Datetimezones možno tiež vytvárať pomocou vnútornej funkcie #datetimezone
:
#datetimezone(
year, month, day,
hour, minute, second,
offset-hours, offset-minutes)
Musí existovať nasledujúce, inak sa vyvolá chyba s kódom Expression.Error
príčiny :
1 ≤ rok ≤ 9 999
1 ≤ mesiac ≤ 12
1 ≤ deň ≤ 31
0 ≤ hodina ≤ 23
0 ≤ minúta ≤ 59
0 ≤ druhý ≤ 59
-14 ≤ hodín časového posunu ≤ 14
-59 ≤ minút časového posunu ≤ 59
Okrem toho musí deň byť platný pre zvolený mesiac a rok, a ak offset-hours = 14, potom minúty <časového posunu = 0, a ak hodiny časového posunu = -14, potom minúty >časového posunu = 0.
Pre hodnoty datetimezone sú definované nasledujúce operátory:
Operátor | Result |
---|---|
x = y |
Equal |
x <> y |
Nerovná sa |
x >= y |
Väčšie alebo rovné |
x > y |
Väčšie než |
x < y |
Menšie než |
x <= y |
Menšie ako alebo rovná sa |
x ?? y |
Coalesce |
Nasledujúce operátory povoľujú, aby jeden alebo obidva ich operandy boli datetimezone:
Operátor | Ľavý operand | Pravý operand | Význam |
---|---|---|---|
x + y |
datetimezone |
duration |
Posun hodnoty datetimezone podľa trvania |
x + y |
duration |
datetimezone |
Posun hodnoty datetimezone podľa trvania |
x - y |
datetimezone |
duration |
Posun hodnoty datetimezone podľa negovaného trvania |
x - y |
datetimezone |
datetimezone |
Trvanie medzi hodnotami datetimezone |
Natívny typ hodnôt datetimezone je vnútorný typ datetimezone
.
Hodnota trvania ukladá nepriehľadné vyjadrenie vzdialenosti medzi dvomi bodmi na časovej osi meranej 100-nanosekudnými impulzmi. Rozsah trvania môže byť kladný alebo záporný, pričom kladné hodnoty označujú postup dopredu v čase a záporné hodnoty označujú postup dozadu v čase. Minimálna hodnota, ktorú možno uložiť v hodnote trvania je -9 223 372 036 854 775 808 impulzov alebo 10 675 199 dní, 2 hodiny, 48 minút, 05,4775808 sekundy dozadu v čase. Maximálna hodnota, ktorú možno uložiť v hodnote trvania je 9 223 372 036 854 775 807 impulzov alebo 10 675 199 dní, 2 hodiny, 48 minút, 05,4775807 sekundy dopredu v čase.
Hoci na trvania neexistuje žiadna literálová syntax, na ich vytvorenie je k dispozícii niekoľko štandardných funkcií knižnice. Trvania možno vytvárať aj pomocou vnútornej funkcie #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
Pre hodnoty trvania sú definované nasledujúce operátory:
Operátor | Result |
---|---|
x = y |
Equal |
x <> y |
Nerovná sa |
x >= y |
Väčšie alebo rovné |
x > y |
Väčšie než |
x < y |
Menšie než |
x <= y |
Menšie ako alebo rovná sa |
x ?? y |
Coalesce |
Okrem toho nasledujúce operátory umožňujú, aby jeden alebo obidva ich operandy mali hodnotu trvania:
Operátor | Ľavý operand | Pravý operand | Význam |
---|---|---|---|
x + y |
datetime |
duration |
Posun hodnoty datetime podľa trvania |
x + y |
duration |
datetime |
Posun hodnoty datetime podľa trvania |
x + y |
duration |
duration |
Súčet trvaní |
x - y |
datetime |
duration |
Posun hodnoty datetime podľa negovaného trvania |
x - y |
datetime |
datetime |
Trvanie medzi hodnotami datetime |
x - y |
duration |
duration |
Rozdiel trvaní |
x * y |
duration |
number |
N časy a trvanie |
x * y |
number |
duration |
N časy a trvanie |
x / y |
duration |
number |
Zlomok trvania |
Natívny typ hodnôt trvania je vnútorný typ duration
.
Textová hodnota predstavuje postupnosť znakov Unicode. Textové hodnoty majú literálový tvar zodpovedajúci nasledujúcej gramatike:
_text literál:
"
opt text-literal-characters "
text-literal-characters:
text-literal-character text-literal-charactersopt
text-literal-character:
single-text-character
sekvencia koncového znaku
dvojitá úvodzovka-úniková postupnosť
single-text-character:
Ľubovoľný znak okrem "
(U+0022
) alebo #
(U+0023
), za ktorým (
nasleduje (U+0028
)
dvojitá úvodzovka-úniková postupnosť:
""
(U+0022
, U+0022
)
Toto je príklad textovej hodnoty:
"ABC" // the text value ABC
Pre textové hodnoty sú definované nasledujúce operátory:
Operátor | Result |
---|---|
x = y |
Equal |
x <> y |
Nerovná sa |
x >= y |
Väčšie alebo rovné |
x > y |
Väčšie než |
x < y |
Menšie než |
x <= y |
Menšie ako alebo rovná sa |
x & y |
Zreťazenie |
x ?? y |
Coalesce |
Natívny typ textových hodnôt je vnútorný typ text
.
Binárna hodnota predstavuje postupnosť bajtov.
Hoci pre binárne hodnoty neexistuje žiadna literálová syntax, na ich vytvorenie je k dispozícii niekoľko štandardných funkcií knižnice. Binárne hodnoty možno vytvárať aj pomocou vnútornej funkcie #binary
.
V nasledujúcom príklade sa vytvorí binárna hodnota zo zoznamu bajtov:
#binary( {0x00, 0x01, 0x02, 0x03} )
Pre binárne hodnoty sú definované nasledujúce operátory:
Operátor | Result |
---|---|
x = y |
Equal |
x <> y |
Nerovná sa |
x >= y |
Väčšie alebo rovné |
x > y |
Väčšie než |
x < y |
Menšie než |
x <= y |
Menšie ako alebo rovná sa |
x ?? y |
Coalesce |
Natívny typ binárnych hodnôt je vnútorný typ binárne.
Hodnota zoznamu je hodnota, ktorá pri vyčíslení vytvára postupnosť hodnôt. Hodnota vytvorená zoznamom môže obsahovať ľubovoľný druh hodnoty vrátane zoznamu. Zoznamy možno vytvárať pomocou inicializačnej syntaxe nasledovne:
list-expression:
{ item-listopt }
item-list:
položka
item ,
item-list
položka:
výraz
výraz (expression)..
Toto je príklad list-expression , ktorý definuje zoznam s tromi textovými hodnotami: "A"
, "B"
a "C"
.
{"A", "B", "C"}
Hodnota "A"
je prvou položkou v zozname a hodnota "C"
je poslednou položkou v zozname.
- Položky zoznamu sa nevyhodnocujú, kým sa k nim nepristupuje.
- Zatiaľ čo zoznam hodnôt vytvorený pomocou syntaxe zoznamu bude vytvárať položky v poradí, v akom sa zobrazujú v hodnote item-list, vo všeobecnosti môžu zoznamy vrátené z funkcií knižnice pri každom vyčíslení vytvoriť inú množinu alebo iný počet hodnôt.
Ak chcete do zoznamu zahrnúť postupnosť celých čísel, a..b
môžete použiť tvar:
{ 1, 5..9, 11 } // { 1, 5, 6, 7, 8, 9, 11 }
Počet položiek v zozname, ktorý sa označuje ako počet v zozname, možno určiť pomocou List.Count
funkcie .
List.Count({true, false}) // 2
List.Count({}) // 0
Zoznam môže reálne mať nekonečný počet položiek; List.Count
pre takéto zoznamy nie je definované a môže buď vyvolať chybu, alebo sa neukončí.
Ak zoznam neobsahuje žiadne položky, nazýva sa prázdny zoznam. Prázdny zoznam sa zapíše ako:
{} // empty list
Pre zoznamy sú definované nasledujúce operátory:
Operátor | Result |
---|---|
x = y |
Equal |
x <> y |
Nerovná sa |
x & y |
Concatenate |
x ?? y |
Coalesce |
Napríklad:
{1, 2} & {3, 4, 5} // {1, 2, 3, 4, 5}
{1, 2} = {1, 2} // true
{2, 1} <> {1, 2} // true
Natívny typ hodnôt zoznamu je vnútorný typ list
, ktorý určuje typ any
položky .
Hodnota záznamu je zoradená postupnosť polí. Pole pozostáva z názvu poľa, čo je textová hodnota, ktorá jednoznačne identifikuje pole v zázname, a hodnoty poľa. Hodnota poľa môže byť ľubovoľný druh hodnoty vrátane záznamu. Záznamy možno vytvárať pomocou inicializačnej syntaxe nasledovne:
record-expression:
[
opt field-list ]
field-list:
pole
field ,
field-list
pole:
field-name =
expression
field-name:
generalized-identifier
quoted-identifier
V nasledujúcom príklade sa vytvorí záznam s poľom s názvom x
s hodnotou 1
a s poľom s názvom y
s hodnotou 2
.
[ x = 1, y = 2 ]
V nasledujúcom príklade sa vytvorí záznam s poľom s a
názvom s hodnotou vnoreného záznamu. Vnorený záznam obsahuje pole s názvom b
s hodnotou 2
.
[ a = [ b = 2 ] ]
Pri vyhodnocovaní výrazu záznamu platí:
Výraz priradený ku každému názvu poľa sa použije na určenie hodnoty priradeného poľa.
Ak výraz priradený k názvu poľa vytvorí pri vyhodnotení hodnotu, potom sa táto hodnota stane hodnotou poľa výsledného záznamu.
Ak výraz priradený k názvu poľa vyvolá pri vyhodnocovaní chybu, potom sa chyba zaznamená s poľom spolu s chybou, ktorá bola vyvolaná. Následný prístup k danmu poľu spôsobí, že sa znova vyskytne chyba so zaznamenanou chybou.
Výraz sa vyhodnocuje v prostredí, ako je napríklad nadradené prostredie, pričom sa zlúčia iba premenné, ktoré zodpovedajú hodnote každého poľa záznamu, okrem práve inicializovaného poľa.
Hodnota v zázname sa nevyhodnotí, kým sa nepristupuje k zodpovedajúcemu poľu.
Hodnota v zázname sa vyhodnotí najviac raz.
Výsledkom výrazu je hodnota záznamu s prázdnym záznamom metaúdajov.
Poradie polí v zázname je definované poradím, v akom sa zobrazujú v record-initializer-expression.
Každý zadaný názov poľa musí byť v zázname jednoznačný, inak nastane chyba. Mená sa porovnávajú pomocou radového porovnania.
[ x = 1, x = 2 ] // error: field names must be unique
[ X = 1, x = 2 ] // OK
Záznam bez polí sa nazýva prázdny záznam a je zapísaný takto:
[] // empty record
Hoci poradie polí záznamu nie je pri prístupe k poľu alebo porovnávaní dvoch záznamov dôležité, je to dôležité v iných kontextoch, napríklad v prípade vyčíslenia polí záznamu.
Rovnaké dva záznamy vytvoria pri získaní polí rôzne výsledky:
Record.FieldNames([ x = 1, y = 2 ]) // [ "x", "y" ]
Record.FieldNames([ y = 1, x = 2 ]) // [ "y", "x" ]
Počet polí v zázname možno určiť pomocou Record.FieldCount
funkcie . Napríklad:
Record.FieldCount([ x = 1, y = 2 }) // 2
Record.FieldCount([]) // 0
Okrem použitia inicializačnej syntaxe [ ]
záznamu možno záznamy vytvárať zo zoznamu hodnôt a zoznamu názvov polí alebo typu záznamu. Napríklad:
Record.FromList({1, 2}, {"a", "b"})
Vyššie uvedené je ekvivalent:
[ a = 1, b = 2 ]
Pre hodnoty záznamu sú definované nasledujúce operátory:
Operátor | Result |
---|---|
x = y |
Equal |
x <> y |
Nerovná sa |
x & y |
Zlúčenie |
x ?? y |
Coalesce |
Nasledujúce príklady ilustrujú vyššie uvedené operátory. Všimnite si, že pri zlúčení záznamov sa pomocou polí z pravého operandu prepíšu polia z ľavého operandu, ak by sa v názvoch polí prekrývali.
[ 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
Natívny typ hodnôt záznamu je vnútorný typ record
, ktorý určuje otvorený prázdny zoznam polí.
Hodnota tabuľky je zoradená postupnosť riadkov. Riadok je zoradená postupnosť hodnôt stĺpcov. Typ tabuľky určuje dĺžku všetkých riadkov v tabuľke, názvy stĺpcov tabuľky, typy stĺpcov tabuľky a štruktúru kľúčov tabuľky (ak existujú).
Hoci pre tabuľky neexistuje žiadna literálová syntax, na ich vytvorenie je k dispozícii niekoľko štandardných funkcií knižnice. Tabuľky možno tiež vytvárať pomocou vnútornej funkcie #table
.
V nasledujúcom príklade sa vytvorí tabuľka zo zoznamu názvov stĺpcov a zo zoznamu riadkov. Výsledná tabuľka bude obsahovať dva stĺpce type any
a tri riadky.
#table({"x", "x^2"}, {{1,1}, {2,4}, {3,9}})
#table
možno použiť aj na zadanie úplného typu tabuľky:
#table(
type table [Digit = number, Name = text],
{{1,"one"}, {2,"two"}, {3,"three"}}
)
Tu nová hodnota tabuľky obsahuje typ tabuľky, ktorý určuje názvy stĺpcov a typy stĺpcov.
Pre hodnoty tabuľky sú definované nasledujúce operátory:
Operátor | Result |
---|---|
x = y |
Equal |
x <> y |
Nerovná sa |
x & y |
Zreťazenie |
x ?? y |
Coalesce |
Zreťazenie tabuľky zarovná stĺpce s like-named a vyplní pre stĺpce null
, ktoré sa zobrazujú iba v jednej z tabuliek operandov. V nasledujúcom príklade je znázornené zreťazenie tabuľky:
#table({"A","B"}, {{1,2}})
& #table({"B","C"}, {{3,4}})
A | B | C |
---|---|---|
1 |
2 |
null |
null |
3 |
4 |
Natívny typ hodnôt tabuľky je vlastný typ tabuľky (odvodený od vnútorného typu table
), ktorý uvádza názvy stĺpcov, určuje všetky typy stĺpcov ako ľubovoľné, a nemá žiadne kľúče. (Prejdite na lokalitu Typy tabuľky pre podrobnosti o typoch tabuľky.)
Hodnota funkcie je hodnota, ktorá mapuje množinu argumentov na jednu hodnotu. Podrobnosti o hodnotách funkcie sú popísané v téme Funkcie.
Hodnota typu je hodnota, ktorá klasifikuje iné hodnoty. Podrobnosti o hodnotách typu sú popísané v časti Typy.