Zachowanie operatora
W tej sekcji zdefiniowano zachowanie różnych operatorów języka M.
Gdy wyrażenie zawiera wiele operatorów, pierwszeństwo operatorów kontroluje kolejność oceniania poszczególnych operatorów. Na przykład wyrażenie x + y * z
jest oceniane jako x + (y * z)
, ponieważ *
operator ma wyższy priorytet niż operator binarny +
. Pierwszeństwo operatora jest ustanawiane przez definicję jego skojarzonej produkcji gramatycznej. Na przykład wyrażenie-addytywne składa się z sekwencji wyrażenia mnożenia rozdzielanego +
operatorami lub -
, dając operatorom +
i -
niższe pierwszeństwo niż *
operatory i /
.
Środowisko produkcyjne wyrażeń nawiasów może służyć do zmiany domyślnej kolejności pierwszeństwa.
wyrażenie-nawiasowe:
(
wyrażenie)
Na przykład:
1 + 2 * 3 // 7
(1 + 2) * 3 // 9
W poniższej tabeli podsumowano operatory języka M z listą kategorii operatorów w kolejności od najwyższego do najniższego. Operatory w tej samej kategorii mają równe pierwszeństwo.
Kategoria | Expression | opis |
---|---|---|
Podstawowe |
i @ i |
Wyrażenie identyfikatora |
(x) | Wyrażenie nawiasowe | |
x[i] | Lookup | |
x{y} | Dostęp do elementów | |
x(...) | Wywołanie funkcji | |
{x, y, ...} | Inicjowanie listy | |
[ i = x, ... ] | Inicjowanie rekordów | |
... | Nie zaimplementowano | |
Jednoargumentowy | + x | Tożsamość |
- x | Negacja | |
not
x |
Logiczna negacja | |
Metadane |
xmeta y |
Kojarzenie metadanych |
Multiplikatywne | x * y | Mnożenie |
x / y | Dział | |
Dodatek | x + y | Dodatek |
x - y | Odejmowanie | |
Relacyjne | x< y | Mniejsze niż |
x > y | Większe niż | |
x<= y | Mniejsze niż lub równe | |
x >= y | Większe niż lub równe | |
Równość | x = y | Równe |
x<> y | Not equal | |
Aseracja typu |
xas y |
Jest zgodnym typem pierwotnym dopuszczanym wartości null lub błędem |
Zgodność typu |
xis y |
Testowanie, czy zgodny typ pierwotny dopuszczany do wartości null |
AND logiczne |
xand y |
Połączenie zwarciem |
OR logiczne |
xor y |
Odłączenie od obwodu |
Coalesce |
x?? y |
Operator łączenia wartości null |
Każda wartość ma skojarzona wartość rekordu, która może zawierać dodatkowe informacje o wartości. Ten rekord jest określany jako rekord metadanych dla wartości. Rekord metadanych może być skojarzony z dowolną wartością, nawet null
. Wynikiem takiego skojarzenia jest nowa wartość z podanymi metadanymi.
Rekord metadanych jest zwykłym rekordem i może zawierać dowolne pola i wartości, które mogą zawierać zwykły rekord i sam zawiera rekord metadanych. Kojarzenie rekordu metadanych z wartością jest "nieinwazyjne". Nie zmienia ona zachowania wartości w ocenach z wyjątkiem tych, które jawnie sprawdzają rekordy metadanych.
Każda wartość ma domyślny rekord metadanych, nawet jeśli nie został określony. Domyślny rekord metadanych jest pusty. W poniższych przykładach pokazano uzyskiwanie dostępu do rekordu metadanych wartości tekstowej przy użyciu standardowej Value.Metadata
funkcji biblioteki:
Value.Metadata( "Mozart" ) // []
Rekordy metadanych zazwyczaj nie są zachowywane , gdy wartość jest używana z operatorem lub funkcją tworzącą nową wartość. Jeśli na przykład dwie wartości tekstowe są łączone przy użyciu &
operatora, metadane wynikowej wartości tekstowej są pustym rekordem []
. Następujące wyrażenia są równoważne:
"Amadeus " & ("Mozart" meta [ Rating = 5 ])
"Amadeus " & "Mozart"
Standardowe funkcje Value.RemoveMetadata
biblioteki i Value.ReplaceMetadata
mogą służyć do usuwania wszystkich metadanych z wartości i zastępowania metadanych wartości (zamiast scalania metadanych z prawdopodobnie istniejącymi metadanymi).
Jedynym operatorem, który zwraca wyniki przenoszące metadane, jest operator meta.
Wartości mogą być cykliczne. Na przykład:
let l = {0, @l} in l
// {0, {0, {0, ... }}}
[A={B}, B={A}]
// [A = {{ ... }}, B = {{ ... }}]
Język M obsługuje cykliczne wartości, zachowując konstrukcję rekordów, list i tabel z opóźnieniem. Próba skonstruowania cyklicznej wartości, która nie korzysta z wtrąconych wartości ustrukturyzowanych z opóźnieniem, powoduje wystąpienie błędu:
[A=B, B=A]
// [A = Error.Record("Expression.Error",
// "A cyclic reference was encountered during evaluation"),
// B = Error.Record("Expression.Error",
// "A cyclic reference was encountered during evaluation"),
// ]
Niektóre operatory w języku M są definiowane przez rekursję strukturalną. Na przykład równość rekordów i list jest definiowana przez połączone równości odpowiednich pól rekordów i list elementów odpowiednio.
W przypadku wartości niecyklicznych zastosowanie rekursji strukturalnej daje skończone rozszerzenie wartości: współużytkowane wartości zagnieżdżone będą wielokrotnie przechodzine, ale proces rekursji zawsze kończy się.
Wartość cykliczna ma nieskończone rozszerzenie podczas stosowania rekursji strukturalnej. Semantyka języka M nie sprawia, że specjalne zakwaterowanie dla takich nieskończonych rozszerzeń — próba porównania cyklicznych wartości równości, na przykład, zwykle zabraknie zasobów i zakończy się wyjątkowo.
Operatory wyboru i projekcji umożliwiają wyodrębnianie danych z listy i wartości rekordów.
Wartość można wybrać z listy lub tabeli na podstawie pozycji zero opartej na tej liście lub tabeli przy użyciu wyrażenia-dostępu do elementu.
wyrażenie-dostępu do elementu:
wybór elementu
wybór opcjonalnego elementu
wybór elementu:
selektor elementów wyrażeń{
podstawowych}
wybór opcjonalnego elementu:
selektor elementów wyrażeń{
podstawowych} ?
selektor elementów:
wyrażenie
Wyrażenie-dostęp-do-elementu x{y}
zwraca:
W przypadku listy
x
i liczbyy
element listyx
na pozycjiy
. Pierwszy element listy jest uznawany za indeks porządkowy zera. Jeśli żądana pozycja nie istnieje na liście, zostanie zgłoszony błąd.W przypadku tabeli
x
i liczbyy
wiersz tabelix
w pozycjiy
. Pierwszy wiersz tabeli jest uznawany za indeks porządkowy o wartości zero. Jeśli żądana pozycja nie istnieje w tabeli, zostanie zgłoszony błąd.W przypadku tabeli
x
i rekorduy
wiersz tabelix
, który pasuje do wartości pól rekorduy
dla pól z nazwami pól, które pasują do odpowiednich nazw kolumn tabeli. Jeśli w tabeli nie ma unikatowego pasującego wiersza, zostanie zgłoszony błąd.
Na przykład:
{"a","b","c"}{0} // "a"
{1, [A=2], 3}{1} // [A=2]
{true, false}{2} // error
#table({"A","B"},{{0,1},{2,1}}){0} // [A=0,B=1]
#table({"A","B"},{{0,1},{2,1}}){[A=2]} // [A=2,B=1]
#table({"A","B"},{{0,1},{2,1}}){[B=3]} // error
#table({"A","B"},{{0,1},{2,1}}){[B=1]} // error
Wyrażenie-dostępu-elementu obsługuje również formularz , który zwraca x{y}?
wartość, gdy pozycja (lub dopasowanie) null
nie istnieje na liście lub tabeli y
.x
Jeśli istnieje wiele dopasowań dla y
elementu , błąd jest nadal zgłaszany.
Na przykład:
{"a","b","c"}{0}? // "a"
{1, [A=2], 3}{1}? // [A=2]
{true, false}{2}? // null
#table({"A","B"},{{0,1},{2,1}}){0}? // [A=0,B=1]
#table({"A","B"},{{0,1},{2,1}}){[A=2]}? // [A=2,B=1]
#table({"A","B"},{{0,1},{2,1}}){[B=3]}? // null
#table({"A","B"},{{0,1},{2,1}}){[B=1]}? // error
Dostęp do elementu nie wymusza oceny elementów listy ani tabel innych niż dostęp do elementu. Na przykład:
{ error "a", 1, error "c"}{1} // 1
{ error "a", error "b"}{1} // error "b"
Podczas oceniania operatora x{y}
dostępu do elementu są przechowywane następujące zasady:
Błędy zgłaszane podczas obliczania wyrażeń
x
luby
są propagowane.Wyrażenie
x
tworzy listę lub wartość tabeli.Wyrażenie
y
generuje wartość liczbową lub, jeślix
generuje wartość tabeli, wartość rekordu.Jeśli
y
generuje wartość liczbową, a wartośćy
jest ujemna, zostanie zgłoszony błąd z kodem"Expression.Error"
przyczyny.Jeśli
y
generuje wartość liczbową, a wartośćy
jest większa lub równa liczbiex
, zostanie zgłoszony błąd z kodem"Expression.Error"
przyczyny, chyba że zostanie użyty opcjonalny formularzx{y}?
operatora, w takim przypadku zwracana jest wartośćnull
.Jeśli
x
generuje wartość tabeli iy
generuje wartość rekordu i nie ma dopasowań dlay
elementu wx
pliku , zostanie zgłoszony błąd z kodem"Expression.Error"
przyczyny, chyba że zostanie użyty opcjonalny formularzx{y}?
operatora, w tym przypadku zwracana jest wartośćnull
.Jeśli
x
generuje wartość tabeli iy
generuje wartość rekordu i istnieje wiele dopasowań dlay
elementu wx
pliku , zostanie zgłoszony błąd z kodem"Expression.Error"
przyczyny.
Podczas procesu zaznaczenia elementu nie są oceniane żadne elementy innej x
niż pozycja y
. (W przypadku list lub tabel przesyłania strumieniowego elementy lub wiersze poprzedzające pozycję y
są pomijane, co może spowodować ich ocenę w zależności od źródła listy lub tabeli).
Wyrażenie-dostępu do pola służy do wybierania wartości z rekordu lub do projekcji rekordu lub tabeli do jednej z mniej pól lub kolumn, odpowiednio.
wyrażenie-dostępu do pola:
wybór pola
niejawne zaznaczenie pola docelowego
projekcja
niejawna projekcja docelowa
wybór pola:
selektor pól wyrażenia podstawowego
selektor pól:
selektor pola wymaganego
opcjonalny selektor pól
selektor-wymagane pole:
[
nazwa-pola]
opcjonalny selektor pól:
[
nazwa-pola] ?
nazwa-pola:
uogólniony identyfikator
identyfikator cytowany
niejawne zaznaczenie pola docelowego:
selektor pól
projekcja:
wyrażenie-podstawowe wymagane-projekcja
wyrażenie-podstawowe opcjonalne-projekcja
projekcja wymagana:
[
lista selektorów wymaganych ]
projekcja opcjonalna:
[
lista selektorów wymaganych ] ?
required-selector-list:
selektor pola wymaganego
selektor-wymagana lista-pól-selektor-pola,
niejawna projekcja docelowa:
projekcja wymagana
projekcja opcjonalna
Najprostszą formą dostępu do pól jest wymagany wybór pola. Używa operatora x[y]
do wyszukiwania pola w rekordzie według nazwy pola. Jeśli pole y
nie istnieje w pliku x
, zostanie zgłoszony błąd. Formularz x[y]?
jest używany do wykonywania opcjonalnego zaznaczenia pola i zwraca, null
jeśli żądane pole nie istnieje w rekordzie.
Na przykład:
[A=1,B=2][B] // 2
[A=1,B=2][C] // error
[A=1,B=2][C]? // null
Zbiorczy dostęp do wielu pól jest obsługiwany przez operatory dla wymaganych projekcji rekordów i opcjonalne projekcji rekordów. Operator x[[y1],[y2],...]
projektuje rekord do nowego rekordu z mniejszą liczbą pól (wybranych przez y1
, y2
, ...
). Jeśli wybrane pole nie istnieje, zostanie zgłoszony błąd.
x[[y1],[y2],...]?
Operator projektuje rekord do nowego rekordu z polami wybranymi przez y1
, y2
, ...
; jeśli brakuje pola, null
jest używany zamiast tego.
Na przykład:
[A=1,B=2][[B]] // [B=2]
[A=1,B=2][[C]] // error
[A=1,B=2][[B],[C]]? // [B=2,C=null]
Formularze [y]
i [y]?
są obsługiwane jako skrócone odwołanie do identyfikatora _
(podkreślenie). Następujące dwa wyrażenia są równoważne:
[A]
_[A]
Poniższy przykład ilustruje skróconą formę dostępu do pól:
let _ = [A=1,B=2] in [A] //1
Formularz [[y1],[y2],...]
i [[y1],[y2],...]?
są również obsługiwane jako skrót, a następujące dwa wyrażenia są podobnie równoważne:
[[A],[B]]
_[[A],[B]]
Skrócona forma jest szczególnie przydatna w połączeniu each
z skrótem, czyli sposobem wprowadzenia funkcji pojedynczego parametru o nazwie _
(aby uzyskać szczegółowe informacje, zobacz Uproszczone deklaracje). Razem te dwa skróty upraszczają typowe wyrażenia funkcjonalne o wyższej kolejności:
List.Select( {[a=1, b=1], [a=2, b=4]}, each [a] = [b])
// {[a=1, b=1]}
Powyższe wyrażenie jest równoważne następującemu bardziej tajemniczemu wyglądowi od dawna:
List.Select( {[a=1, b=1], [a=2, b=4]}, (_) => _[a] = _[b])
// {[a=1, b=1]}
Dostęp do pola nie wymusza oceny pól innych niż te, do których uzyskuje się dostęp. Na przykład:
[A=error "a", B=1, C=error "c"][B] // 1
[A=error "a", B=error "b"][B] // error "b"
Podczas oceniania operatora x[y]
dostępu do pola , x[y]?
, x[[y]]
lub x[[y]]?
są przechowywane następujące zasady:
Błędy zgłaszane podczas obliczania wyrażenia
x
są propagowane.Błędy zgłaszane podczas oceny pola
y
są trwale skojarzone z polemy
, a następnie propagowane. Każdy przyszły dostęp do polay
zgłosi identyczny błąd.Wyrażenie
x
generuje wartość rekordu lub tabeli albo zgłaszany jest błąd.Jeśli identyfikator
y
nazywa pole, które nie istnieje wx
pliku , zostanie zgłoszony błąd z kodem"Expression.Error"
przyczyny, chyba że zostanie użyty opcjonalny formularz...?
operatora, w takim przypadku zwracana jest wartośćnull
.
Podczas procesu dostępu do pól nie są oceniane żadne pola x
inne niż nazwane przez y
.
Rekord metadanych dla wartości jest zmieniany przy użyciu operatora meta (x meta y
).
wyrażenie-metadanych:
wyrażenie jednoargumentowe
jednoargumentowe wyrażenie-jednoargumentowemeta
Poniższy przykład tworzy wartość tekstową z rekordem metadanych przy użyciu operatora, a następnie uzyskuje dostęp do rekordu metadanych wynikowej wartości przy meta
użyciu polecenia Value.Metadata
:
Value.Metadata( "Mozart" meta [ Rating = 5 ] )
// [Rating = 5 ]
Value.Metadata( "Mozart" meta [ Rating = 5 ] )[Rating]
// 5
Podczas stosowania operatora x meta y
łączenia metadanych obowiązują następujące zasady:
Błędy zgłaszane podczas oceniania
x
wyrażeń luby
są propagowane.Wyrażenie
y
musi być rekordem lub jest zgłaszany błąd z kodem"Expression.Error"
przyczyny.Wynikowy rekord metadanych to
x
rekord metadanych scalony z elementemy
. (Semantyka scalania rekordów, zobacz Scalanie rekordów).Wynikowa wartość to wartość z
x
wyrażenia bez jego metadanych z dołączonym nowo obliczonym rekordem metadanych.
Standardowe funkcje Value.RemoveMetadata
biblioteki i Value.ReplaceMetadata
mogą służyć do usuwania wszystkich metadanych z wartości i zastępowania metadanych wartości (zamiast scalania metadanych z prawdopodobnie istniejącymi metadanymi). Następujące wyrażenia są równoważne:
x meta y
Value.ReplaceMetadata(x, Value.Metadata(x) & y)
Value.RemoveMetadata(x) meta (Value.Metadata(x) & y)
Operator=
, czy dwie wartości są równe. Operator<>
, czy dwie wartości nie są równe.
wyrażenie równości:
wyrażenie-relacyjne
wyrażenie-relacyjne=
wyrażenie-równości
wyrażenie-relacyjne<>
wyrażenie-równości
Na przykład:
1 = 1 // true
1 = 2 // false
1 <> 1 // false
1 <> 2 // true
null = true // false
null = null // true
Metadane nie są częścią porównania równości ani nierówności. Na przykład:
(1 meta [ a = 1 ]) = (1 meta [ a = 2 ]) // true
(1 meta [ a = 1 ]) = 1 // true
Podczas stosowania operatorów x = y
równości i x <> y
:
Błędy zgłaszane podczas oceniania
x
wyrażeń luby
są propagowane.Operator
=
ma wyniktrue
, jeśli wartości są równe ifalse
w przeciwnym razie.Operator
<>
ma wynikfalse
, jeśli wartości są równe itrue
w przeciwnym razie.Rekordy metadanych nie są uwzględniane w porównaniu.
Jeśli wartości generowane przez ocenę
x
wyrażeń iy
nie są tego samego rodzaju wartością, wartości nie są równe.Jeśli wartości generowane przez ocenę
x
wyrażenia iy
są tego samego rodzaju wartością, istnieją określone reguły określania, czy są równe, jak zdefiniowano poniżej.Następujące informacje są zawsze prawdziwe:
(x = y) = not (x <> y)
Operatory równości są definiowane dla następujących typów:
- Wartość
null
jest równa samej sobie.
null = null // true
null = true // false
null = false // false
- Wartości
true
logiczne ifalse
są równe tylko sobie. Na przykład:
true = true // true
false = false // true
true = false // false
true = 1 // false
Liczby są porównywane przy użyciu określonej precyzji:
Jeśli którakolwiek z liczb to
#nan
, liczby nie są takie same.Jeśli żadna liczba nie jest
#nan
wartością , liczby są porównywane przy użyciu bitowego porównania wartości liczbowej.#nan
jest jedyną wartością, która nie jest równa samej sobie.Na przykład:
1 = 1, // true
1.0 = 1 // true
2 = 1 // false
#nan = #nan // false
#nan <> #nan // true
Dwa czasy trwania są równe, jeśli reprezentują tę samą liczbę 100-nanosekundowych kleszczy.
Dwa razy są równe, jeśli wielkości ich części (godzina, minuta, sekunda) są równe.
Dwie daty są równe, jeśli wielkości ich części (rok, miesiąc, dzień) są równe.
Dwie daty/godziny są równe, jeśli wielkości ich części (rok, miesiąc, dzień, godzina, minuta, sekunda) są równe.
Dwie strefy daty/godziny są równe, jeśli odpowiadające im daty/godziny UTC są równe. Aby dotrzeć do odpowiedniej daty/godziny UTC, przesunięcie godzin/minut jest odejmowane od składnika datetime strefy czasowej daty/godziny.
Dwie wartości tekstowe są równe, jeśli używasz porządkowego, wrażliwego na wielkość liter, porównania bez uwzględniania kultury mają taką samą długość i równe znaki w odpowiednich pozycjach.
Dwie wartości listy są równe, jeśli wszystkie następujące wartości są prawdziwe:
Obie listy zawierają taką samą liczbę elementów.
Wartości każdego elementu odpowiadającego pozycji na listach są równe. Oznacza to, że nie tylko listy muszą zawierać równe elementy, elementy muszą być w tej samej kolejności.
Na przykład:
{1, 2} = {1, 2} // true {2, 1} = {1, 2} // false {1, 2, 3} = {1, 2} // false
Dwa rekordy są równe, jeśli wszystkie następujące rekordy są prawdziwe:
Liczba pól jest taka sama.
Każda nazwa pola jednego rekordu jest również obecna w drugim rekordzie.
Wartość każdego pola jednego rekordu jest równa polu o podobnej nazwie w drugim rekordzie.
Na przykład:
[ A = 1, B = 2 ] = [ A = 1, B = 2 ] // true [ B = 2, A = 1 ] = [ A = 1, B = 2 ] // true [ A = 1, B = 2, C = 3 ] = [ A = 1, B = 2 ] // false [ A = 1 ] = [ A = 1, B = 2 ] // false
Dwie tabele są równe, jeśli wszystkie z następujących wartości są prawdziwe:
Liczba kolumn jest taka sama.
Każda nazwa kolumny w jednej tabeli jest również obecna w drugiej tabeli.
Liczba wierszy jest taka sama.
Każdy wiersz ma równe wartości w odpowiednich komórkach.
Na przykład:
#table({"A","B"},{{1,2}}) = #table({"A","B"},{{1,2}}) // true #table({"A","B"},{{1,2}}) = #table({"X","Y"},{{1,2}}) // false #table({"A","B"},{{1,2}}) = #table({"B","A"},{{2,1}}) // true
Wartość funkcji jest równa samej sobie, ale może być równa innej wartości funkcji lub może nie być równa innej wartości funkcji. Jeśli dwie wartości funkcji są traktowane jako równe, będą zachowywać się identycznie po wywołaniu.
Dwie podane wartości funkcji zawsze będą miały taką samą relację równości.
Wartość typu jest równa sobie, ale może lub nie może być równa innej wartości typu. Jeśli dwie wartości typu są traktowane jako równe, będą zachowywać się identycznie podczas wykonywania zapytań o zgodność.
Dwie podane wartości typu zawsze będą miały taką samą relację równości.
Operatory <
, >
, <=
i >=
są nazywane operatorami relacyjnymi.
wyrażenie-relacyjne:
wyrażenie-addytywne
wyrażenie-addytywne wyrażenie-relacyjne<
wyrażenie-addytywne wyrażenie-relacyjne>
wyrażenie-addytywne wyrażenie-relacyjne<=
wyrażenie-addytywne wyrażenie-relacyjne>=
Te operatory służą do określania względnej relacji porządkowania między dwiema wartościami, jak pokazano w poniższej tabeli:
Operacja | Result |
---|---|
x < y |
true jeśli x wartość jest mniejsza niż y , false w przeciwnym razie |
x > y |
true jeśli x wartość jest większa niż y , false w przeciwnym razie |
x <= y |
true jeśli x wartość jest mniejsza lub równa y , false w przeciwnym razie |
x >= y |
true jeśli x wartość jest większa lub równa y , false w przeciwnym razie |
Na przykład:
0 <= 1 // true
null < 1 // null
null <= null // null
"ab" < "abc" // true
#nan >= #nan // false
#nan <= #nan // false
Podczas obliczania wyrażenia zawierającego operatory relacyjne obowiązują następujące zasady:
Błędy zgłaszane podczas oceniania
x
wyrażeń operandu luby
są propagowane.Wartości generowane przez ocenę zarówno wyrażeń, jak
x
iy
muszą być wartościami binarnymi, data/godzina, data/godzina, strefa czasowa, czas trwania, logiczny, liczba, wartość null, tekst lub godzina. W przeciwnym razie jest zgłaszany błąd z kodem"Expression.Error"
przyczyny.Oba operandy muszą być tego samego rodzaju wartością lub
null
. W przeciwnym razie jest zgłaszany błąd z kodem"Expression.Error"
przyczyny.Jeśli oba operandy to
null
, wynikiem jestnull
wartość .Dwa pliki binarne są porównywane bajtami bajtów.
Dwie daty są porównywane przez porównanie ich części roku i, jeśli są równe, ich części miesiąca i, jeśli są równe, ich części dnia.
Dwie daty/godziny są porównywane przez porównanie ich części roku i, jeśli są równe, ich części miesiąca i, jeśli są równe, ich części dnia i, jeśli są równe, ich części godzin i, jeśli są równe, ich części minut i, jeśli są równe, ich drugie części.
Dwie strefy daty/godziny są porównywane przez normalizację ich do czasu UTC przez odjęcie przesunięcia godzin/minuty, a następnie porównanie ich składników daty/godziny.
Dwa czasy trwania są porównywane zgodnie z całkowitą liczbą 100-nanosekundowych kleszczy, które reprezentują.
Dwa logicznie są porównywane w taki sposób, że
true
jest uważany za większy niżfalse
.Dwie liczby
x
iy
są porównywane zgodnie z regułami standardu IEEE 754:Jeśli jeden z operandów to
#nan
, wynik dotyczyfalse
wszystkich operatorów relacyjnych.Jeśli żaden operand nie ma
#nan
wartości , operatory porównują wartości dwóch operandów zmiennoprzecinkowych w odniesieniu do kolejności-∞ < -max < ... < -min < -0.0 = +0.0 < +min < ... < +max < +∞
, w której wartości minimalne i maksymalne są najmniejszymi i największymi dodatnimi wartościami skończonymi, które mogą być reprezentowane. Nazwy M dla -∞ i +∞ to-#infinity
i#infinity
.Istotne skutki tego porządkowania są następujące:
Wartości ujemne i dodatnie są traktowane jako równe.
Wartość jest traktowana
-#infinity
jako mniejsza niż wszystkie inne wartości liczbowe, ale równa innej-#infinity
wartości .Wartość jest uznawana
#infinity
za większą niż wszystkie inne wartości liczbowe, ale równą innej#infinity
wartości .
Dwa teksty są porównywane przy użyciu porządkowego znaku po znaku, z uwzględnieniem wielkości liter, porównania bez uwzględniania kultury.
Dwa razy są porównywane przez porównanie ich części godzin i, jeśli są równe, ich części minut i, jeśli są równe, ich drugiej części.
Operatory and
i or
są nazywane operatorami logicznymi warunkowych.
wyrażenie logiczne lub wyrażenie:
wyrażenie logiczne i
wyrażenie logiczne i wyrażenieor
logiczne lub wyrażenie
wyrażenie logiczne i wyrażenie:
is-expression
wyrażenie-is-logical-and-expressionand
Operator or
zwraca wartość true
, gdy co najmniej jeden z jego operandów to true
. Prawy operand jest oceniany, jeśli i tylko wtedy, gdy lewy operand nie true
jest .
Operator and
zwraca wartość false
, gdy co najmniej jeden z jego operandów to false
. Prawy operand jest oceniany, jeśli i tylko wtedy, gdy lewy operand nie false
jest .
Poniżej przedstawiono tabele prawdy dla or
operatorów i and
z wynikiem oceny wyrażenia lewego operandu na osi pionowej i wyniku oceny prawego wyrażenia operandu na osi poziomej.
and |
true |
false |
null |
error |
---|---|---|---|---|
true |
true |
false |
null |
error |
false |
false |
false |
false |
false |
null |
null |
false |
null |
error |
error |
error |
error |
error |
error |
or |
true |
false |
null |
error |
---|---|---|---|---|
or |
true |
false |
null |
error |
true |
true |
true |
true |
true |
false |
true |
false |
null |
error |
null |
true |
null |
null |
error |
error |
error |
error |
error |
error |
Podczas obliczania wyrażenia zawierającego warunkowe operatory logiczne są przechowywane następujące zasady:
Błędy zgłaszane podczas oceniania
x
wyrażeń luby
są propagowane.Warunkowe operatory logiczne są definiowane dla typów
logical
inull
. Jeśli wartości operandu nie są tego typu, zostanie zgłoszony błąd z kodem"Expression.Error"
przyczyny.Wynik jest wartością logiczną.
W wyrażeniu lub wyrażenie zostanie obliczone, jeśli i tylko wtedy, gdy
x
nie zostanie obliczona wartośćy
.y
x
true
W wyrażeniu i wyrażenie zostanie obliczone, jeśli i tylko wtedy, gdy
x
nie zostanie obliczona wartośćy
.y
x
false
Dwie ostatnie właściwości dają warunkowym operatorom logicznym ich "warunkowe" kwalifikacje; właściwości określane również jako "zwarcie". Te właściwości są przydatne do pisania kompaktowych predykatów chronionych. Na przykład następujące wyrażenia są równoważne:
d <> 0 and n/d > 1 if d <> 0 then n/d > 1 else false
Operatory +
, -
*
i /
to operatory arytmetyczne.
wyrażenie-addytywne:
wyrażenie mnożenia
wyrażenie-add-expression+
mnożenia wyrażenie-
wyrażenie-add-expression-
mnożenia wyrażenie-
wyrażenie-mnożenia:
metadata- expression
wyrażenie-metadanych wyrażenie-mnożenia*
wyrażenie-metadanych wyrażenie-mnożenia/
Liczby w języku M są przechowywane przy użyciu różnych reprezentacji, aby zachować jak najwięcej informacji o liczbach pochodzących z różnych źródeł. Liczby są konwertowane tylko z jednej reprezentacji na inną zgodnie z potrzebami przez operatory zastosowane do nich. Dwie precyzje są obsługiwane w języku M:
Dokładność | semantyka |
---|---|
Precision.Decimal |
128-bitowa reprezentacja dziesiętna z zakresem ±1,0 x 10–28 do ±7,9 x 1028 i 28–29 cyfr znaczących. |
Precision.Double |
Reprezentacja naukowa przy użyciu mantissa i wykładnika; jest zgodny z 64-bitową dwuwymiarową precyzją standardu arytmetycznego IEEE 754 IEEE 754-2008. |
Operacje arytmetyczne są wykonywane przez wybranie dokładności, przekonwertowanie obu operandów na tę precyzję (w razie potrzeby), a następnie wykonanie rzeczywistej operacji, a na koniec zwrócenie liczby w wybranej precyzji.
Wbudowane operatory arytmetyczne (+
, -
, *
, /
) używają podwójnej precyzji. Standardowe funkcje biblioteki (Value.Add
, Value.Subtract
, Value.Multiply
, Value.Divide
) mogą służyć do żądania tych operacji przy użyciu określonego modelu precyzji.
Nie jest możliwe przepełnienie liczbowe:
#infinity
lub-#infinity
reprezentują wartości wielkości zbyt dużych, aby były reprezentowane.Nie jest możliwe żadne niedopełnienie liczbowe:
0
i-0
reprezentuje wartości wielkości zbyt małych, aby były reprezentowane.Wartość
#nan
specjalna IEEE 754 (NaN — Not a Number) jest używana do pokrycia arytmetycznie nieprawidłowych przypadków, takich jak podział zera o zero.Konwersja z liczby dziesiętnej na podwójną jest wykonywana przez zaokrąglanie liczb dziesiętnych do najbliższej równoważnej podwójnej wartości.
Konwersja z podwójnej na dziesiętną jest wykonywana przez zaokrąglanie podwójnych liczb do najbliższej równoważnej wartości dziesiętnej i, w razie potrzeby, przepełnianie wartości lub
#infinity
-#infinity
.
Interpretacja operatora dodawania (x + y
) zależy od rodzaju wartości obliczonych wyrażeń x i y w następujący sposób:
x | t | Result | Interpretacja |
---|---|---|---|
type number |
type number |
type number |
Suma liczbowa |
type number |
null |
null |
|
null |
type number |
null |
|
type duration |
type duration |
type duration |
Suma liczbowa wielkości |
type duration |
null |
null |
|
null |
type duration |
null |
|
type
data/godzina |
type duration |
type
data/godzina |
Przesunięcie daty/godziny według czasu trwania |
type duration |
type
data/godzina |
type
data/godzina |
|
type
data/godzina |
null |
null |
|
null |
type
data/godzina |
null |
W tabeli type
data/godzina oznacza dowolną wartość type date
, type datetime
, type datetimezone
lub type time
. Podczas dodawania czasu trwania i wartości typu data/godzina wynikowa wartość jest tego samego typu.
W przypadku innych kombinacji wartości niż wymienione w tabeli jest zgłaszany błąd z kodem "Expression.Error"
przyczyny. Każda kombinacja jest omówiona w poniższych sekcjach.
Błędy zgłaszane podczas oceniania dowolnego operandu są propagowane.
Suma dwóch liczb jest obliczana przy użyciu operatora dodawania, tworząc liczbę.
Na przykład:
1 + 1 // 2
#nan + #infinity // #nan
Operator +
dodawania liczb używa podwójnej precyzji. Funkcja biblioteki Value.Add
standardowej może służyć do określania dokładności dziesiętnej. Podczas obliczania sumy liczb są przechowywane następujące warunki:
Suma w podwójnej precyzji jest obliczana zgodnie z regułami 64-bitowych dwuprecyzji dwuprecyzji IEEE 754 arytmetyczne IEEE 754-2008. W poniższej tabeli wymieniono wyniki wszystkich możliwych kombinacji wartości niezerowych, zer, nieskończoności i wartości NaN. W tabeli
x
iy
są wartościami niezerowymi iz
są wynikiemx + y
. Jeślix
iy
mają taką samą wielkość, ale przeciwległe znaki,z
jest dodatnie zero. Jeślix + y
jest zbyt duży, aby być reprezentowany w typie docelowym,z
jest nieskończoność z tym samym znakiem cox + y
.+ t +0 0– +∞ -∞ NaN x z x x +∞ -∞ NaN +0 t +0 +0 +∞ -∞ NaN -0 t +0 0– +∞ -∞ NaN +∞ +∞ +∞ +∞ +∞ NaN NaN -∞ -∞ -∞ -∞ NaN -∞ NaN Nan NaN NaN NaN NaN NaN NaN Suma w precyzji dziesiętnej jest obliczana bez utraty precyzji. Skala wyniku jest większa od skali dwóch operandów.
Suma dwóch czasów trwania to czas trwania reprezentujący sumę liczby 100nanosecond kleszczy reprezentowanych przez czasy trwania. Na przykład:
#duration(2,1,0,15.1) + #duration(0,1,30,45.3)
// #duration(2, 2, 31, 0.4)
Data/godzina i czas trwania mogą być dodawane do x
obliczania nowej y
x + y
godziny, której odległość od x
na osi czasu liniowego jest dokładnie wielkością y
.
W tym miejscu data/godzina oznacza dowolną wartość Date
, DateTime
lub DateTimeZone
Time
, a wynik inny niż null będzie tego samego typu. Przesunięcie daty/godziny według czasu trwania może być obliczane w następujący sposób:
Jeśli określono wartość daty/godziny od czasu epoki, utwórz nową datę/godzinę z następującymi elementami informacji:
Oblicz nowe dni od epoki równoważnej podzieleniu wielkości y przez liczbę 100-nanosekundowych kleszczy w okresie 24-godzinnym, obcinając część dziesiętną wyniku i dodając tę wartość do dni x od epoki.
Oblicz nowe kleszcze od północy równoważne do dodania wielkości y do kleszczy x od północy, modulo liczbę 100-nanosekundowych kleszczy w okresie 24-godzinnym. Jeśli x nie określa wartości dla znaczników od północy, przyjmuje się wartość 0.
Skopiuj wartość x dla przesunięcia minut z utc bez zmian.
Jeśli wartość daty/godziny od czasu epoki jest nieokreślona, utwórz nową datę/godzinę z określonymi następującymi elementami informacji:
Oblicz nowe kleszcze od północy równoważne do dodania wielkości y do kleszczy x od północy, modulo liczbę 100-nanosekundowych kleszczy w okresie 24-godzinnym. Jeśli x nie określa wartości dla znaczników od północy, przyjmuje się wartość 0.
Skopiuj wartości x dla dni od epoki i minut przesunięcia z czasu UTC bez zmian.
W poniższych przykładach pokazano obliczanie bezwzględnej sumy czasowej, gdy data/godzina określa dni od epoki:
#date(2010,05,20) + #duration(0,8,0,0)
//#datetime( 2010, 5, 20, 8, 0, 0 )
//2010-05-20T08:00:00
#date(2010,01,31) + #duration(30,08,0,0)
//#datetime(2010, 3, 2, 8, 0, 0)
//2010-03-02T08:00:00
#datetime(2010,05,20,12,00,00,-08) + #duration(0,04,30,00)
//#datetime(2010, 5, 20, 16, 30, 0, -8, 0)
//2010-05-20T16:30:00-08:00
#datetime(2010,10,10,0,0,0,0) + #duration(1,0,0,0)
//#datetime(2010, 10, 11, 0, 0, 0, 0, 0)
//2010-10-11T00:00:00+00:00
W poniższym przykładzie pokazano obliczanie przesunięcia daty/godziny według czasu trwania dla danego czasu:
#time(8,0,0) + #duration(30,5,0,0)
//#time(13, 0, 0)
//13:00:00
Interpretacja operatora odejmowania (x - y
) zależy od rodzaju wartości obliczonych wyrażeń x
i y
, w następujący sposób:
x | Y | Result | Interpretacja |
---|---|---|---|
type number |
type number |
type number |
Różnica liczbowa |
type number |
null |
null |
|
null |
type number |
null |
|
type duration |
type duration |
type duration |
Różnica liczbowa wielkości |
type duration |
null |
null |
|
null |
type duration |
null |
|
type
data/godzina |
type
data/godzina |
type duration |
Czas trwania między datami/godzinami |
type
data/godzina |
type duration |
type
data/godzina |
Przesunięcie daty/godziny przez negowany czas trwania |
type
data/godzina |
null |
null |
|
null |
type
data/godzina |
null |
W tabeli type
data/godzina oznacza dowolną wartość type date
, type datetime
, type datetimezone
lub type time
. W przypadku odejmowania czasu trwania od wartości typu data/godzina wynikowa wartość jest tego samego typu.
W przypadku innych kombinacji wartości niż wymienione w tabeli jest zgłaszany błąd z kodem "Expression.Error"
przyczyny. Każda kombinacja jest omówiona w poniższych sekcjach.
Błędy zgłaszane podczas oceniania dowolnego operandu są propagowane.
Różnica między dwiema liczbami jest obliczana przy użyciu operatora odejmowania, tworząc liczbę. Na przykład:
1 - 1 // 0
#nan - #infinity // #nan
Operator -
odejmowania liczb używa podwójnej precyzji. Funkcja biblioteki Value.Subtract
standardowej może służyć do określania dokładności dziesiętnej. Podczas obliczania różnicy liczb są przechowywane następujące elementy:
Różnica w podwójnej precyzji jest obliczana zgodnie z regułami 64-bitowej binarnej podwójnej precyzji IEEE 754 arytmetyczne IEEE 754-2008. W poniższej tabeli wymieniono wyniki wszystkich możliwych kombinacji wartości niezerowych, zer, nieskończoności i wartości NaN. W tabeli
x
iy
są wartościami niezerowymi iz
są wynikiemx - y
. Jeślix
iy
są równe,z
jest dodatnie zero. Jeślix - y
jest zbyt duży, aby być reprezentowany w typie docelowym,z
jest nieskończoność z tym samym znakiem cox - y
.- t +0 0– +∞ -∞ NaN x z x x -∞ +∞ NaN +0 -y +0 +0 -∞ +∞ NaN -0 -y 0– +0 -∞ +∞ NaN +∞ +∞ +∞ +∞ NaN +∞ NaN -∞ -∞ -∞ -∞ -∞ NaN NaN Nan NaN NaN NaN NaN NaN NaN Różnica w precyzji dziesiętnej jest obliczana bez utraty precyzji. Skala wyniku jest większa od skali dwóch operandów.
Różnica dwóch czasów trwania to czas trwania reprezentujący różnicę między liczbą 100-nanosekundowych kleszczy reprezentowanych przez każdy czas trwania. Na przykład:
#duration(1,2,30,0) - #duration(0,0,0,30.45)
// #duration(1, 2, 29, 29.55)
Data /godzinax
i czas trwania y
mogą być odejmowane przy użyciu funkcji x - y
obliczania nowej daty/godziny.
W tym miejscu data/godzina oznacza dowolną wartość date
, datetime
, datetimezone
lub time
. Wynikowa data/godzina ma odległość od x
osi czasu liniowej, która jest dokładnie wielkością y
, w kierunku przeciwnym od znaku y
. Odejmowanie dodatnich czasów trwania daje wyniki, które są wstecz w czasie względem x
, podczas odjęcie wartości ujemnych daje wyniki, które są przekazywane w czasie.
#date(2010,05,20) - #duration(00,08,00,00)
//#datetime(2010, 5, 19, 16, 0, 0)
//2010-05-19T16:00:00
#date(2010,01,31) - #duration( 30,08,00,00)
//#datetime(2009, 12, 31, 16, 0, 0)
//2009-12-31T16:00:00
Dwie daty/godzinyt
i u
mogą być odejmowane przy użyciu funkcji t - u
obliczania czasu trwania między nimi.
W tym miejscu data/godzina oznacza dowolną wartość date
, datetime
, datetimezone
lub time
. Czas trwania generowany przez odjęcie u
od t
elementu musi być zwracany t
po dodaniu do u
elementu .
#date(2010,01,31) - #date(2010,01,15)
// #duration(16,00,00,00)
// 16.00:00:00
#date(2010,01,15)- #date(2010,01,31)
// #duration(-16,00,00,00)
// -16.00:00:00
#datetime(2010,05,20,16,06,00,-08,00) -
#datetime(2008,12,15,04,19,19,03,00)
// #duration(521,22,46,41)
// 521.22:46:41
Odejmowanie t - u
w przypadku u > t
ujemnego czasu trwania:
#time(01,30,00) - #time(08,00,00)
// #duration(0, -6, -30, 0)
Podczas odejmowania dwóch dat/godzin przy użyciu polecenia t - u
:
- u + (t - u) = t
Interpretacja operatora mnożenia (x * y
) zależy od rodzaju wartości obliczonych wyrażeń x i y w następujący sposób:
X | Y | Result | Interpretacja |
---|---|---|---|
type number |
type number |
type number |
Produkt liczbowy |
type number |
null |
null |
|
null |
type number |
null |
|
type duration |
type number |
type duration |
Wielokrotność czasu trwania |
type number |
type duration |
type duration |
Wielokrotność czasu trwania |
type duration |
null |
null |
|
null |
type duration |
null |
W przypadku innych kombinacji wartości niż wymienione w tabeli jest zgłaszany błąd z kodem "Expression.Error"
przyczyny. Każda kombinacja jest omówiona w poniższych sekcjach.
Błędy zgłaszane podczas oceniania dowolnego operandu są propagowane.
Produkt dwóch liczb jest obliczany przy użyciu operatora mnożenia, tworząc liczbę. Na przykład:
2 * 4 // 8
6 * null // null
#nan * #infinity // #nan
Operator *
mnożenia liczb używa podwójnej precyzji. Funkcja biblioteki Value.Multiply
standardowej może służyć do określania dokładności dziesiętnej. Podczas obliczania produktu liczb następujące elementy są przechowywane:
Produkt w podwójnej precyzji jest obliczany zgodnie z regułami 64-bitowej podwójnej precyzji binarnej IEEE 754 arytmetyczne IEEE 754-2008. W poniższej tabeli wymieniono wyniki wszystkich możliwych kombinacji wartości niezerowych, zer, nieskończoności i wartości NaN. W tabeli
x
iy
są dodatnimi wartościami skończonymi.z
jest wynikiem .x * y
Jeśli wynik jest zbyt duży dla typu docelowego,z
jest nieskończoność. Jeśli wynik jest za mały dla typu docelowego,z
ma wartość zero.* +y -y +0 0– +∞ -∞ NaN +x +z -z +0 0– +∞ -∞ NaN -x -z +z 0– +0 -∞ +∞ NaN +0 +0 0– +0 0– NaN NaN NaN -0 0– +0 0– +0 NaN NaN NaN +∞ +∞ -∞ NaN NaN +∞ -∞ NaN -∞ -∞ +∞ NaN NaN -∞ +∞ NaN Nan NaN NaN NaN NaN NaN NaN NaN Produkt w precyzji dziesiętnej jest obliczany bez utraty precyzji. Skala wyniku jest większa od skali dwóch operandów.
Iloczyn czasu trwania i liczby to czas trwania reprezentujący liczbę 100nanosecond kleszczy reprezentowanych przez operand czasu trwania w operand liczbie. Na przykład:
#duration(2,1,0,15.1) * 2
// #duration(4, 2, 0, 30.2)
Interpretacja operatora dzielenia (x / y
) zależy od rodzaju wartości obliczonych wyrażeń x
i y
, w następujący sposób:
X | Y | Result | Interpretacja |
---|---|---|---|
type number |
type number |
type number |
Iloraz liczbowy |
type number |
null |
null |
|
null |
type number |
null |
|
type duration |
type number |
type duration |
Ułamek czasu trwania |
type duration |
type duration |
type number |
Iloraz liczbowy czasu trwania |
type duration |
null |
null |
|
null |
type duration |
null |
W przypadku innych kombinacji wartości niż wymienione w tabeli jest zgłaszany błąd z kodem "Expression.Error"
przyczyny. Każda kombinacja jest omówiona w poniższych sekcjach.
Błędy zgłaszane podczas oceniania dowolnego operandu są propagowane.
Iloraz dwóch liczb jest obliczany przy użyciu operatora dzielenia, tworząc liczbę. Na przykład:
8 / 2 // 4
8 / 0 // #infinity
0 / 0 // #nan
0 / null // null
#nan / #infinity // #nan
Operator /
dzielenia liczb używa podwójnej precyzji. Funkcja Value.Divide
biblioteki standardowej może służyć do określania dokładności dziesiętnej. Podczas obliczania ilorazu liczb są przechowywane następujące elementy:
Iloraz w podwójnej precyzji jest obliczany zgodnie z regułami 64-bitowej podwójnej precyzji binarnej IEEE 754 arytmetyczne IEEE 754-2008. W poniższej tabeli wymieniono wyniki wszystkich możliwych kombinacji wartości niezerowych, zer, nieskończoności i wartości NaN. W tabeli
x
iy
są dodatnimi wartościami skończonymi.z
jest wynikiem .x / y
Jeśli wynik jest zbyt duży dla typu docelowego,z
jest nieskończoność. Jeśli wynik jest za mały dla typu docelowego,z
ma wartość zero./ +y -y +0 0– +∞ -∞ NaN +x +z -z +∞ -∞ +0 0– NaN -x -z +z -∞ +∞ 0– +0 NaN +0 +0 0– NaN NaN +0 0– NaN -0 0– +0 NaN NaN 0– +0 NaN +∞ +∞ -∞ +∞ -∞ NaN NaN NaN -∞ -∞ +∞ -∞ +∞ NaN NaN NaN Nan NaN NaN NaN NaN NaN NaN NaN Suma w precyzji dziesiętnej jest obliczana bez utraty precyzji. Skala wyniku jest większa od skali dwóch operandów.
Iloraz dwóch czasów trwania jest liczbą reprezentującą iloraz liczby 100nanosecond kleszczy reprezentowanych przez czasy trwania. Na przykład:
#duration(2,0,0,0) / #duration(0,1,30,0)
// 32
Iloraz czasu trwania x
i liczby y
to czas trwania reprezentujący iloraz liczby 100-nanosekundowych kleszczy reprezentowanych przez czas trwania x
i liczbę y
. Na przykład:
#duration(2,0,0,0) / 32
// #duration(0,1,30,0)
Operator kombinacji (x & y
) jest definiowany w następujących rodzajach wartości:
X | Y | Result | Interpretacja |
---|---|---|---|
type text |
type text |
type text |
Łączenie |
type text |
null |
null |
|
null |
type text |
null |
|
type date |
type time |
type datetime |
Scal |
type date |
null |
null |
|
null |
type time |
null |
|
type list |
type list |
type list |
Łączenie |
type record |
type record |
type record |
Scal |
type table |
type table |
type table |
Łączenie |
Dwa tekst, dwie listy lub dwie wartości tabeli można połączyć przy użyciu polecenia x & y
.
Poniższy przykład ilustruje łączenie wartości tekstowych:
"AB" & "CDE" // "ABCDE"
Poniższy przykład ilustruje łączenie list:
{1, 2} & {3} // {1, 2, 3}
Podczas łączenia dwóch wartości przy użyciu polecenia x & y
:
Błędy zgłaszane podczas oceniania
x
wyrażeń luby
są propagowane.Brak propagacji błędu, jeśli element
x
alboy
zawiera błąd.Wynikiem łączenia dwóch wartości tekstowych jest wartość tekstowa zawierająca wartość x natychmiast po y. Jeśli jeden z operandów ma wartość null, a drugi jest wartością tekstową, wynik ma wartość null.
Wynikiem łączenia dwóch list jest lista zawierająca wszystkie elementy,
x
po których następuje wszystkie elementy elementuy
.Wynikiem łączenia dwóch tabel jest tabela zawierająca związek dwóch kolumn tabeli operandu. Kolejność
x
kolumn jest zachowywana, a następnie kolumny wyświetlane tylko wy
pliku , zachowując ich względną kolejność. W przypadku kolumn wyświetlanych tylko w jednym z operandównull
służy do wypełniania wartości komórek dla drugiego operandu.
Dwa rekordy można scalić przy użyciu metody x & y
, tworząc rekord zawierający pola z obu x
y
i .
Poniższe przykłady ilustrują scalanie rekordów:
[ x = 1 ] & [ y = 2 ] // [ x = 1, y = 2 ]
[ x = 1, y = 2 ] & [ x = 3, z = 4 ] // [ x = 3, y = 2, z = 4 ]
Następujące blokady są przechowywane podczas scalania dwóch rekordów przy użyciu polecenia x + y
:
Błędy zgłaszane podczas oceniania
x
wyrażeń luby
są propagowane.Jeśli pole pojawi się zarówno w , jak
x
iy
, zostanie użyta wartość zy
.Kolejność pól w rekordzie wynikowym to pole typu
x
, a po nim polay
, które nie są częściąx
elementu , w tej samej kolejności, w której są wyświetlane wy
.Scalanie rekordów nie powoduje oceny wartości.
Nie jest zgłaszany żaden błąd, ponieważ pole zawiera błąd.
Wynik jest rekordem.
Datę można scalić z godziną x
przy użyciu metody y
, tworząc datęx & y
/godzinę, która łączy części z obu x
elementów i y
.
Poniższy przykład ilustruje scalanie daty i godziny:
#date(2013,02,26) & #time(09,17,00)
// #datetime(2013,02,26,09,17,00)
Następujące blokady są przechowywane podczas scalania dwóch rekordów przy użyciu polecenia x + y
:
Błędy zgłaszane podczas oceniania
x
wyrażeń luby
są propagowane.Wynik jest datą/godziną.
Operatory +
, -
i not
są operatorami jednoargumentowymi.
jednoargumentowe wyrażenie:
wyrażenie-typ
+
wyrażenie jednoargumentowe
-
wyrażenie jednoargumentowe
not
wyrażenie jednoargumentowe
Jednoargumentowy operator plus (+x
) jest zdefiniowany dla następujących rodzajów wartości:
X | Result | Interpretacja |
---|---|---|
type number |
type number |
Jednoargumentowy plus |
type duration |
type duration |
Jednoargumentowy plus |
null |
"null |
W przypadku innych wartości jest zgłaszany błąd z kodem "Expression.Error"
przyczyny.
Jednoargumentowy operator plus umożliwia +
zastosowanie znaku do wartości liczbowej, daty/godziny lub wartości null. Wynikiem jest ta sama wartość. Na przykład:
+ - 1 // -1
+ + 1 // 1
+ #nan // #nan
+ #duration(0,1,30,0) // #duration(0,1,30,0)
Podczas oceniania jednoargumentowego operatora +x
plus są przechowywane następujące warunki:
Błędy zgłaszane podczas oceny
x
są propagowane.Jeśli wynik oceny
x
nie jest wartością liczbową, zostanie zgłoszony błąd z kodem"Expression.Error"
przyczyny.
Jednoargumentowy operator minus (-x
) jest zdefiniowany dla następujących rodzajów wartości:
X | Result | Interpretacja |
---|---|---|
type number |
type number |
Negacja |
type duration |
type duration |
Negacja |
null |
null |
W przypadku innych wartości jest zgłaszany błąd z kodem "Expression.Error"
przyczyny.
Jednoargumentowy operator minus służy do zmiany znaku liczby lub czasu trwania. Na przykład:
- (1 + 1) // -2
- - 1 // 1
- - - 1 // -1
- #nan // #nan
- #infinity // -#infinity
- #duration(1,0,0,0) // #duration(-1,0,0,0)
- #duration(0,1,30,0) // #duration(0,-1,-30,0)
Podczas oceniania jednoargumentowego operatora -x
minus są przechowywane następujące elementy:
Błędy zgłaszane podczas oceny
x
są propagowane.Jeśli wyrażenie jest liczbą, wynikiem jest wartość liczbowa z wyrażenia
x
ze zmienionym znakiem. Jeśli wartość to NaN, wynik jest również wartością NaN.
Operator negacji logicznej (not
) jest definiowany dla następujących rodzajów wartości:
X | Result | Interpretacja |
---|---|---|
type logical |
type logical |
Negacja |
null |
null |
Ten operator oblicza operację logiczną not
dla danej wartości logicznej. Na przykład:
not true // false
not false // true
not (true and true) // false
Podczas oceniania operatora not x
negacji logicznej obowiązują następujące warunki:
Błędy zgłaszane podczas oceny
x
są propagowane.Wartość wygenerowana z obliczania wyrażenia x musi być wartością logiczną lub musi zostać zgłoszony błąd z kodem
"Expression.Error"
przyczyny. Jeśli wartość totrue
, wynik tofalse
. Jeśli operand mafalse
wartość , wynikiem jesttrue
.
Wynik jest wartością logiczną.
Operatory i is
są nazywane operatorami as
typów.
Operator x is y
zgodności typów jest zdefiniowany dla następujących typów wartości:
X | Y | Result |
---|---|---|
type any |
typ-pierwotny dopuszczany do wartości null | type logical |
Wyrażenie x is y
zwraca true
wartość , jeśli przypisany typ x
jest zgodny z elementem y
i zwraca false
wartość , jeśli przypisany typ x
jest niezgodny z y
.
y
musi być typu nullable-primitivetype.
is-expression:
as-expression
is-expressionis
nullable-primitive-type
typ-pierwotny dopuszczany do wartości null:
nullable
opt typ pierwotny
Zgodność typu, obsługiwana przez is
operatora, jest podzbiorem ogólnej zgodności typów i jest definiowana przy użyciu następujących reguł:
Jeśli
x
wartość ma wartość null, jest zgodna, jeśliy
jest typemany
, typem lub typemnull
dopuszczanym do wartości null.Jeśli
x
parametr ma wartość inną niż null, jeśli jest zgodny, jeśli typ pierwotny jestx
taki sam jaky
.
Następujące zasady są przechowywane podczas obliczania wyrażenia x is y
:
- Podczas oceniania wyrażenia
x
jest zgłaszany błąd.
Operator x as y
asercji typu jest definiowany dla następujących typów wartości:
X | Y | Result |
---|---|---|
type any |
typ-pierwotny dopuszczany do wartości null | type any |
Wyrażenie x as y
potwierdza, że wartość x
jest zgodna z y
operatorem is
. Jeśli nie jest zgodny, zostanie zgłoszony błąd.
y
musi być typem pierwotnym dopuszczalnym wartości null.
as-expression:
wyrażenie równości
as-expressionas
nullable-primitive-type
Wyrażenie x as y
jest oceniane w następujący sposób:
Wykonywane jest sprawdzanie
x is y
zgodności typów, a aseracja zwracax
niezmienione, jeśli test zakończy się pomyślnie.Jeśli sprawdzanie zgodności zakończy się niepowodzeniem, zostanie zgłoszony błąd z kodem
"Expression.Error"
przyczyny.
Przykłady:
1 as number // 1
"A" as number // error
null as nullable number // null
Następujące zasady są przechowywane podczas obliczania wyrażenia x as y
:
- Podczas oceniania wyrażenia
x
jest zgłaszany błąd.
Operator ??
połączenia zwraca wynik lewego operandu, jeśli nie ma wartości null, w przeciwnym razie zwróci wynik prawego operandu. Prawy operand jest obliczany, jeśli argument i tylko wtedy, gdy lewy operand ma wartość null.