Wartości
Wartość to dane generowane przez obliczanie wyrażenia. W tej sekcji opisano rodzaje wartości w języku M. Każdy rodzaj wartości jest skojarzony ze składnią literału, zestawem wartości tego rodzaju, zestawem operatorów zdefiniowanych w tym zestawie wartości i typem wewnętrznym przypisanym do nowo skonstruowanych wartości.
Rodzaj | Literal |
---|---|
Null | null |
Logiczny | true false |
Liczba | 0 1 -1 1.5 2.3e-5 |
Czas | #time(09,15,00) |
Data | #date(2013,02,26) |
Data/godzina | #datetime(2013,02,26, 09,15,00) |
DateTimeZone | #datetimezone(2013,02,26, 09,15,00, 09,00) |
Czas trwania | #duration(0,1,30,0) |
Tekst | "hello" |
Dwójkowy | #binary("AQID") |
Lista | {1, 2, 3} |
Nagraj | [ A = 1, B = 2 ] |
Tabela | #table({"X","Y"},{{0,1},{1,0}}) |
Funkcja | (x) => x + 1 |
Type | type { number } type table [ A = any, B = text ] |
W poniższych sekcjach szczegółowo opisano każdy rodzaj wartości. Typy i deskrypcja typów są definiowane formalnie w typach. Wartości funkcji są definiowane w usłudze Functions. W poniższych sekcjach wymieniono operatory zdefiniowane dla każdego rodzaju wartości i podano przykłady. Pełna definicja semantyki operatorów jest następująca w temacie Operatory.
Wartość null jest używana do reprezentowania braku wartości lub wartości nieokreślonego lub nieznanego stanu. Wartość null jest zapisywana przy użyciu literału null
. Następujące operatory są definiowane dla wartości null:
Operator | Result |
---|---|
x > y |
Większe niż |
x >= y |
Większe niż lub równe |
x < y |
Mniejsze niż |
x <= y |
Mniejsze niż lub równe |
x = y |
Equal |
x <> y |
Not equal |
x ?? y |
Coalesce |
Natywnym typem null
wartości jest typ null
wewnętrzny .
Wartość logiczna jest używana w operacjach logicznych ma wartość true lub false. Wartość logiczna jest zapisywana przy użyciu literałów true
i false
. Następujące operatory są definiowane dla wartości logicznych:
Operator | Result |
---|---|
x > y |
Większe niż |
x >= y |
Większe niż lub równe |
x < y |
Mniejsze niż |
x <= y |
Mniejsze niż lub równe |
x = y |
Equal |
x <> y |
Not equal |
x or y |
Warunkowa logiczna OR |
x ?? y |
Coalesce |
x and y |
Warunkowe logiczne AND |
not x |
Not logiczny |
Natywnym typem obu wartości logicznych (true
i false
) jest typ logical
wewnętrzny .
Wartość liczbowa jest używana na potrzeby operacji liczbowych i arytmetycznych. Poniżej przedstawiono przykłady literałów liczbowych:
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)
Liczba jest reprezentowana z co najmniej dokładnością podwójnej (ale może zachować większą precyzję). Podwójna reprezentacja jest zgodna ze standardem IEEE 64-bitowej podwójnej precyzji dla arytmetyki binarnej zmiennoprzecinkowe zdefiniowanej w [IEEE 754-2008]. (Podwójna reprezentacja ma przybliżony zakres dynamiczny z zakresu od 5,0 x 10324 do 1,7 x 10 308 z dokładnością 15–16 cyfr).
Następujące wartości specjalne są również uważane za wartości liczbowe :
Zero dodatnie i zero ujemne. W większości sytuacji dodatnie zero i zero ujemne zachowują się identycznie jak prosta wartość zero, ale niektóre operacje rozróżniają te dwie wartości.
Nieskończoność dodatnia (
#infinity
) i nieskończoność ujemna (-#infinity
). Liczba niedokończona jest generowana przez takie operacje, jak dzielenie liczby niezerowej przez zero. Na przykład1.0 / 0.0
daje dodatnią nieskończoność i-1.0 / 0.0
daje nieskończoność ujemną.Wartość Not-a-Number (
#nan
), często skracana wartość NaN. Sieci NaN są generowane przez nieprawidłowe operacje zmiennoprzecinkowe, takie jak dzielenie zera przez zero.
Operacje matematyczne binarne są wykonywane przy użyciu precyzji. Precyzja określa domenę, do której są zaokrąglane operandy, oraz domenę, w której wykonywana jest operacja. W przypadku braku jawnie określonej precyzji takie operacje są wykonywane przy użyciu podwójnej precyzji.
Jeśli wynik operacji matematycznej jest zbyt mały dla formatu docelowego, wynik operacji staje się dodatni zero lub zero ujemne.
Jeśli wynik operacji matematycznej jest zbyt duży dla formatu docelowego, wynik operacji staje się dodatnią nieskończonością lub nieskończonością ujemną.
Jeśli operacja matematyczna jest nieprawidłowa, wynik operacji staje się nazwą NaN.
Jeśli jeden lub oba operandy operacji zmiennoprzecinkowych to NaN, wynik operacji staje się NaN.
Następujące operatory są definiowane dla wartości liczbowych:
Operator | Result |
---|---|
x > y |
Większe niż |
x >= y |
Większe niż lub równe |
x < y |
Mniejsze niż |
x <= y |
Mniejsze niż lub równe |
x = y |
Equal |
x <> y |
Not equal |
x + y |
Sum |
x - y |
Różnica |
x * y |
Rezultat |
x / y |
Iloraz |
x ?? y |
Coalesce |
+x |
Jednoargumentowy plus |
-x |
Negacja |
Natywnym typem wartości liczbowych jest typ number
wewnętrzny .
Wartość godziny przechowuje nieprzezroczystą reprezentację godziny dnia. Czas jest zakodowany jako liczba kleszczy od północy, która liczy liczbę 100-nanosekundowych kleszczy, które upłynęły na zegarze 24-godzinnym. Maksymalna liczba kleszczy od północy odpowiada 23:59:59.9999999 godzin.
Chociaż nie ma składni literału dla czasów, do ich konstruowania jest kilka standardowych funkcji biblioteki. Czasy mogą być również konstruowane przy użyciu funkcji #time
wewnętrznej :
#time(hour, minute, second)
Zostanie zgłoszony następujący kod przyczyny Expression.Error
lub błąd:
0 ≤ godzinę ≤ 24
0 ≤ minutę ≤ 59
0 ≤ sekundy ≤ 59
Ponadto, jeśli godzina = 24, minuta i sekunda muszą być zerowe.
Następujące operatory są definiowane dla wartości czasu:
Operator | Result |
---|---|
x = y |
Equal |
x <> y |
Not equal |
x >= y |
Większe niż lub równe |
x > y |
Większe niż |
x < y |
Mniejsze niż |
x <= y |
Mniejsze niż lub równe |
x ?? y |
Coalesce |
Następujące operatory zezwalają na datę jednego lub obu operandów:
Operator | Lewy operand | Prawy operand | Znaczenie |
---|---|---|---|
x + y |
time |
duration |
Przesunięcie daty według czasu trwania |
x + y |
duration |
time |
Przesunięcie daty według czasu trwania |
x - y |
time |
duration |
Przesunięcie daty przez negowany czas trwania |
x - y |
time |
time |
Czas trwania między datami |
x & y |
date |
time |
Scalona data/godzina |
Natywnym typem wartości czasu jest typ time
wewnętrzny .
Wartość daty przechowuje nieprzezroczystą reprezentację określonego dnia. Data jest kodowana jako liczba dni od epoki, począwszy od 1 stycznia 0001 r. w kalendarzu gregoriańskim. Maksymalna liczba dni od epoki jest 3652058 odpowiadająca 31 grudnia 9999 r.
Chociaż nie ma składni literału dat, do ich konstruowania jest kilka standardowych funkcji biblioteki. Daty mogą być również konstruowane przy użyciu funkcji #date
wewnętrznej :
#date(year, month, day)
Zostanie zgłoszony następujący kod przyczyny Expression.Error
lub błąd:
1 rok ≤ ≤ 9999
1 ≤ miesiąc ≤ 12
1 ≤ dzień ≤ 31
Ponadto dzień musi być prawidłowy dla wybranego miesiąca i roku.
Następujące operatory są definiowane dla wartości daty:
Operator | Result |
---|---|
x = y |
Equal |
x <> y |
Not equal |
x >= y |
Większe niż lub równe |
x > y |
Większe niż |
x < y |
Mniejsze niż |
x <= y |
Mniejsze niż lub równe |
x ?? y |
Coalesce |
Następujące operatory zezwalają na datę jednego lub obu operandów:
Operator | Lewy operand | Prawy operand | Znaczenie |
---|---|---|---|
x + y |
date |
duration |
Przesunięcie daty według czasu trwania |
x + y |
duration |
date |
Przesunięcie daty według czasu trwania |
x - y |
date |
duration |
Przesunięcie daty przez negowany czas trwania |
x - y |
date |
date |
Czas trwania między datami |
x & y |
date |
time |
Scalona data/godzina |
Natywnym typem wartości daty jest typ date
wewnętrzny .
Wartość daty/godziny zawiera zarówno datę, jak i godzinę.
Chociaż nie ma składni literału dla daty/godziny, do ich konstruowania jest kilka standardowych funkcji biblioteki. Daty/godziny można również skonstruować przy użyciu funkcji #datetime
wewnętrznej :
#datetime(year, month, day, hour, minute, second)
Następujące elementy muszą zostać wstrzymane lub zostanie zgłoszony błąd z kodem przyczyny Expression.Error: 1 ≤ roku ≤ 9999
1 ≤ miesiąc ≤ 12
1 ≤ dzień ≤ 31
0 ≤ godzinę ≤ 23
0 ≤ minutę ≤ 59
0 ≤ sekundy ≤ 59
Ponadto dzień musi być prawidłowy dla wybranego miesiąca i roku.
Następujące operatory są definiowane dla wartości daty/godziny:
Operator | Result |
---|---|
x = y |
Equal |
x <> y |
Not equal |
x >= y |
Większe niż lub równe |
x > y |
Większe niż |
x < y |
Mniejsze niż |
x <= y |
Mniejsze niż lub równe |
x ?? y |
Coalesce |
Następujące operatory pozwalają jednemu lub obu operandom być data/godzina:
Operator | Lewy operand | Prawy operand | Znaczenie |
---|---|---|---|
x + y |
datetime |
duration |
Przesunięcie daty/godziny według czasu trwania |
x + y |
duration |
datetime |
Przesunięcie daty/godziny według czasu trwania |
x - y |
datetime |
duration |
Przesunięcie daty/godziny przez negowany czas trwania |
x - y |
datetime |
datetime |
Czas trwania między datami/godzinami |
Natywnym typem wartości daty/godziny jest typ datetime
wewnętrzny .
Wartość datetimezone zawiera datę/godzinę i strefę czasową. Strefa czasowa jest kodowana jako liczba minut przesunięcia od czasu UTC, który zlicza liczbę minut, przez jaką część godziny daty/godziny powinna zostać przesunięty z uniwersalnego czasu koordynowanego (UTC). Minimalna liczba minut przesunięcia od czasu UTC wynosi -840, reprezentując przesunięcie UTC o wartości -14:00 lub czternaście godzin wcześniej niż UTC. Maksymalna liczba minut przesunięcia z czasu UTC wynosi 840, co odpowiada przesuniętemu czasowi UTC 14:00.
Chociaż nie ma składni literału dla stref daty/godziny, do ich konstruowania jest kilka standardowych funkcji biblioteki. Strefy daty/godziny mogą być również konstruowane przy użyciu funkcji #datetimezone
wewnętrznej :
#datetimezone(
year, month, day,
hour, minute, second,
offset-hours, offset-minutes)
Zostanie zgłoszony następujący kod przyczyny Expression.Error
lub błąd:
1 rok ≤ ≤ 9999
1 ≤ miesiąc ≤ 12
1 ≤ dzień ≤ 31
0 ≤ godzinę ≤ 23
0 ≤ minutę ≤ 59
0 ≤ sekundy ≤ 59
-14 ≤ godzin przesunięcia ≤ 14
-59 ≤ minut przesunięcia ≤ 59
Ponadto dzień musi być prawidłowy dla wybranego miesiąca i roku, a jeśli godziny przesunięcia = 14, przesunięcie minut <= 0 i, jeśli przesunięcie godzin = -14, a następnie przesunięcie minut >= 0.
Następujące operatory są definiowane dla wartości daty/godziny/strefy czasowej:
Operator | Result |
---|---|
x = y |
Equal |
x <> y |
Not equal |
x >= y |
Większe niż lub równe |
x > y |
Większe niż |
x < y |
Mniejsze niż |
x <= y |
Mniejsze niż lub równe |
x ?? y |
Coalesce |
Następujące operatory zezwalają jednemu lub obu operandom na datę/strefę czasową:
Operator | Lewy operand | Prawy operand | Znaczenie |
---|---|---|---|
x + y |
datetimezone |
duration |
Przesunięcie daty/strefy czasowej według czasu trwania |
x + y |
duration |
datetimezone |
Przesunięcie daty/strefy czasowej według czasu trwania |
x - y |
datetimezone |
duration |
Przesunięcie daty/strefy czasowej przez negowany czas trwania |
x - y |
datetimezone |
datetimezone |
Czas trwania między strefami data/godzina |
Natywnym typem wartości datetimezone jest typ datetimezone
wewnętrzny .
Wartość czasu trwania przechowuje nieprzezroczystą reprezentację odległości między dwoma punktami na osi czasu mierzonych 100-nanosekundowych kleszczy. Wielkość czasu trwania może być dodatnia lub ujemna, a wartości dodatnie oznaczają postęp do przodu w czasie i wartości ujemne oznaczające postęp wstecz w czasie. Minimalna wartość, którą można przechowywać w czasie trwania , wynosi -9 223 372 036 854 775 808 kleszczy lub 10 675 199 dni 2 godziny 48 minut 05,4775808 sekund w czasie. Maksymalna wartość, którą można przechowywać w czasie trwania , wynosi 9223 372 036 854 775 807 kleszczy lub 10 675 199 dni 2 godziny 48 minut 05,4775807 sekund w czasie.
Chociaż nie ma składni literału dla czasów trwania, do ich konstruowania jest kilka standardowych funkcji biblioteki. Czasy trwania mogą być również konstruowane przy użyciu funkcji #duration
wewnętrznej :
#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
Następujące operatory są definiowane dla wartości czasu trwania:
Operator | Result |
---|---|
x = y |
Equal |
x <> y |
Not equal |
x >= y |
Większe niż lub równe |
x > y |
Większe niż |
x < y |
Mniejsze niż |
x <= y |
Mniejsze niż lub równe |
x ?? y |
Coalesce |
Ponadto następujące operatory zezwalają jednemu lub obu operandom na wartość czasu trwania:
Operator | Lewy operand | Prawy operand | Znaczenie |
---|---|---|---|
x + y |
datetime |
duration |
Przesunięcie daty/godziny według czasu trwania |
x + y |
duration |
datetime |
Przesunięcie daty/godziny według czasu trwania |
x + y |
duration |
duration |
Suma czasów trwania |
x - y |
datetime |
duration |
Przesunięcie daty/godziny przez negowany czas trwania |
x - y |
datetime |
datetime |
Czas trwania między datami/godzinami |
x - y |
duration |
duration |
Różnica czasu trwania |
x * y |
duration |
number |
N razy czas trwania |
x * y |
number |
duration |
N razy czas trwania |
x / y |
duration |
number |
Ułamek czasu trwania |
Natywnym typem wartości czasu trwania jest typ duration
wewnętrzny .
Wartość tekstowa reprezentuje sekwencję znaków Unicode. Wartości tekstowe mają postać literału zgodną z następującą gramatyką:
literał _text:
"
wybór znakówliterałów tekstowych "
znaki tekstowe literału:
Wyrażenie zgody na zamianę znakówtekstowych literałów tekstowych
znak-literał-tekstu:
jednotekstowy znak
znak-ucieczka-sekwencja
podwójna sekwencja ucieczki cudzysłowu
jednotekstowy znak:
Dowolny znak z wyjątkiem "
() lub #
(), po którym (
następuje (U+0023
U+0028
)U+0022
double-quote-escape-sequence:
""
(U+0022
, U+0022
)
Poniżej przedstawiono przykład wartości tekstowej:
"ABC" // the text value ABC
Następujące operatory są definiowane dla wartości tekstowych :
Operator | Result |
---|---|
x = y |
Equal |
x <> y |
Not equal |
x >= y |
Większe niż lub równe |
x > y |
Większe niż |
x < y |
Mniejsze niż |
x <= y |
Mniejsze niż lub równe |
x & y |
Łączenie |
x ?? y |
Coalesce |
Natywnym typem wartości tekstowych jest typ text
wewnętrzny .
Wartość binarna reprezentuje sekwencję bajtów.
Chociaż nie ma składni literału dla wartości binarnych, do ich konstruowania jest kilka standardowych funkcji biblioteki. Wartości binarne mogą być również konstruowane przy użyciu funkcji #binary
wewnętrznej .
Poniższy przykład tworzy wartość binarną z listy bajtów:
#binary( {0x00, 0x01, 0x02, 0x03} )
Następujące operatory są definiowane na wartościach binarnych :
Operator | Result |
---|---|
x = y |
Equal |
x <> y |
Not equal |
x >= y |
Większe niż lub równe |
x > y |
Większe niż |
x < y |
Mniejsze niż |
x <= y |
Mniejsze niż lub równe |
x ?? y |
Coalesce |
Natywnym typem wartości binarnych jest plik binarny typu wewnętrznego.
Wartość listy to wartość , która tworzy sekwencję wartości podczas wyliczania. Wartość wygenerowana przez listę może zawierać dowolny rodzaj wartości, w tym listę. Listy można tworzyć przy użyciu składni inicjowania w następujący sposób:
wyrażenie-listy:
{ item-listopt }
lista elementów:
element
lista elementów ,
przedmiot:
wyrażenie
wyrażenie wyrażenia..
Poniżej przedstawiono przykład wyrażenia list definiującego listę z trzema wartościami tekstowymi: "A"
, "B"
i "C"
.
{"A", "B", "C"}
Wartość "A"
jest pierwszym elementem na liście, a wartość "C"
jest ostatnim elementem na liście.
- Elementy listy nie są oceniane do momentu uzyskania dostępu do nich.
- Podczas gdy wartości listy tworzone przy użyciu składni listy będą generować elementy w kolejności, w której są wyświetlane na liście elementów, ogólnie listy zwracane z funkcji biblioteki mogą tworzyć inny zestaw lub inną liczbę wartości za każdym razem, gdy są wyliczane.
Aby dołączyć sekwencję liczb całkowitych na liście, a..b
można użyć formularza:
{ 1, 5..9, 11 } // { 1, 5, 6, 7, 8, 9, 11 }
Liczbę elementów na liście, znanej jako liczba list, można określić przy użyciu List.Count
funkcji .
List.Count({true, false}) // 2
List.Count({}) // 0
Lista może skutecznie mieć nieskończoną liczbę elementów; List.Count
dla takich list jest niezdefiniowany i może zgłosić błąd lub nie zakończyć.
Jeśli lista nie zawiera żadnych elementów, jest nazywana pustą listą. Pusta lista jest zapisywana jako:
{} // empty list
Następujące operatory są definiowane dla list:
Operator | Result |
---|---|
x = y |
Equal |
x <> y |
Not equal |
x & y |
Concatenate |
x ?? y |
Coalesce |
Na przykład:
{1, 2} & {3, 4, 5} // {1, 2, 3, 4, 5}
{1, 2} = {1, 2} // true
{2, 1} <> {1, 2} // true
Natywnym typem wartości listy jest typ list
wewnętrzny , który określa typ elementu .any
Wartość rekordu to uporządkowana sekwencja pól. Pole składa się z nazwy pola, czyli wartości tekstowej, która unikatowo identyfikuje pole w rekordzie i wartość pola. Wartość pola może być dowolną wartością, w tym rekordem. Rekordy można tworzyć przy użyciu składni inicjowania w następujący sposób:
wyrażenie-rekordu:
[
wybór listypól ]
lista-pól:
pole
pole ,
listy pól
pole:
wyrażenie nazwy=
pola
nazwa-pola:
uogólniony identyfikator
identyfikator cytowany
Poniższy przykład konstruuje rekord z polem o nazwie x
z wartością 1
i polem o nazwie z y
wartością 2
.
[ x = 1, y = 2 ]
Poniższy przykład tworzy rekord z a
polem o nazwie a z zagnieżdżoną wartością rekordu. Zagnieżdżony rekord ma pole o nazwie b
z wartością 2
.
[ a = [ b = 2 ] ]
Podczas obliczania wyrażenia rekordu są przechowywane następujące zasady:
Wyrażenie przypisane do każdej nazwy pola służy do określania wartości skojarzonego pola.
Jeśli wyrażenie przypisane do nazwy pola generuje wartość podczas obliczania, staje się to wartością pola rekordu wynikowego.
Jeśli wyrażenie przypisane do nazwy pola zgłasza błąd podczas oceny, oznacza to, że zgłoszono błąd, jest rejestrowany z polem wraz z wartością błędu, która została zgłoszona. Kolejny dostęp do tego pola spowoduje ponowne wywołanie błędu z wartością zarejestrowanego błędu.
Wyrażenie jest obliczane w środowisku takim jak środowisko nadrzędne tylko ze zmiennymi scalanymi w tym, które odpowiadają wartości każdego pola rekordu, z wyjątkiem tego, który jest inicjowany.
Wartość w rekordzie nie jest obliczana do momentu uzyskania dostępu do odpowiedniego pola.
Wartość w rekordzie jest obliczana co najwyżej raz.
Wynikiem wyrażenia jest wartość rekordu z pustym rekordem metadanych.
Kolejność pól w rekordzie jest definiowana przez kolejność, która jest wyświetlana w wyrażeniu-inicjatora rekordu.
Każda określona nazwa pola musi być unikatowa w rekordzie lub jest błędem. Nazwy są porównywane przy użyciu porównania porządkowego.
[ x = 1, x = 2 ] // error: field names must be unique
[ X = 1, x = 2 ] // OK
Rekord bez pól jest nazywany pustym rekordem i jest zapisywany w następujący sposób:
[] // empty record
Chociaż kolejność pól rekordu nie jest znacząca podczas uzyskiwania dostępu do pola lub porównywania dwóch rekordów, jest ona znacząca w innych kontekstach, takich jak wyliczenie pól rekordu.
Te same dwa rekordy generują różne wyniki, gdy pola są uzyskiwane:
Record.FieldNames([ x = 1, y = 2 ]) // [ "x", "y" ]
Record.FieldNames([ y = 1, x = 2 ]) // [ "y", "x" ]
Liczbę pól w rekordzie można określić przy użyciu Record.FieldCount
funkcji . Na przykład:
Record.FieldCount([ x = 1, y = 2 }) // 2
Record.FieldCount([]) // 0
Oprócz używania składni [ ]
inicjowania rekordów można tworzyć rekordy z listy wartości oraz listę nazw pól lub typu rekordu. Na przykład:
Record.FromList({1, 2}, {"a", "b"})
Powyższe wartości są równoważne:
[ a = 1, b = 2 ]
Następujące operatory są definiowane dla wartości rekordów:
Operator | Result |
---|---|
x = y |
Equal |
x <> y |
Not equal |
x & y |
Scal |
x ?? y |
Coalesce |
Poniższe przykłady ilustrują powyższe operatory. Należy pamiętać, że scalanie rekordów używa pól z prawego operandu, aby zastąpić pola z lewego operandu, jeśli nazwy pól nakładają się na siebie.
[ 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
Natywnym typem wartości rekordów jest typ record
wewnętrzny , który określa otwartą pustą listę pól.
Wartość tabeli jest uporządkowaną sekwencją wierszy. Wiersz to uporządkowana sekwencja wartości kolumn. Typ tabeli określa długość wszystkich wierszy w tabeli, nazwy kolumn tabeli, typy kolumn tabeli oraz strukturę kluczy tabeli (jeśli istnieje).
Chociaż nie ma składni literału dla tabel, do ich konstruowania jest kilka standardowych funkcji biblioteki. Tabele mogą być również tworzone przy użyciu funkcji #table
wewnętrznej .
Poniższy przykład tworzy tabelę z listy nazw kolumn i listy wierszy. Wynikowa tabela będzie zawierać dwie kolumny type any
i trzy wiersze.
#table({"x", "x^2"}, {{1,1}, {2,4}, {3,9}})
#table
Można również użyć do określenia pełnego typu tabeli:
#table(
type table [Digit = number, Name = text],
{{1,"one"}, {2,"two"}, {3,"three"}}
)
W tym miejscu nowa wartość tabeli ma typ tabeli, który określa nazwy kolumn i typy kolumn.
Następujące operatory są definiowane dla wartości tabeli:
Operator | Result |
---|---|
x = y |
Equal |
x <> y |
Not equal |
x & y |
Łączenie |
x ?? y |
Coalesce |
Łączenie tabel wyrównuje kolumny o podobnych nazwach i wypełnia null
kolumny wyświetlane tylko w jednej z tabel operandu. Poniższy przykład ilustruje łączenie tabeli:
#table({"A","B"}, {{1,2}})
& #table({"B","C"}, {{3,4}})
A | B | C |
---|---|---|
1 |
2 |
null |
null |
3 |
4 |
Natywnym typem wartości tabeli jest niestandardowy typ tabeli (pochodzący z typu table
wewnętrznego ), który zawiera listę nazw kolumn, określa wszystkie typy kolumn jako dowolne i nie ma kluczy. (Przejdź do Typy tabel zawierające szczegółowe informacje na temat typów tabel).
Wartość funkcji to wartość, która mapuje zestaw argumentów na pojedynczą wartość. Szczegółowe informacje o wartościach funkcji opisano w temacie Functions.
Wartość typu to wartość, która klasyfikuje inne wartości. Szczegóły wartości typów opisano w temacie Typy.