Treinamento
Módulo
Executar operações básicas em números em C# - Training
Aprenda quais são os operadores e as técnicas usadas para executar operações matemáticas básicas em dados numéricos.
Não há mais suporte para esse navegador.
Atualize o Microsoft Edge para aproveitar os recursos, o suporte técnico e as atualizações de segurança mais recentes.
Esta seção define o comportamento dos vários operadores do M.
Quando uma expressão contém vários operadores, a precedência dos operadores controla a ordem na qual os operadores individuais são avaliados. Por exemplo, a expressão x + y * z
é avaliada como x + (y * z)
porque o operador *
tem precedência maior do que o operador binário +
. A precedência de um operador é estabelecida pela definição da sua produção de gramática associada. Por exemplo, uma expressão-aditiva consiste em uma sequência de produções de expressão-multiplicativa separadas por operadores +
ou -
, permitindo assim que os operadores +
e -
tenham mais precedências do que os operadores *
e /
.
A produção expressão-entre-parênteses pode ser usada para alterar a ordenação de precedência padrão.
expressão-entre-parênteses:
(
expressão)
Por exemplo:
1 + 2 * 3 // 7
(1 + 2) * 3 // 9
A tabela a seguir resume os operadores M, listando as categorias de operador em ordem de precedência, da mais alta para a mais baixa. Os operadores em uma mesma categoria têm precedência igual.
Categoria | Expressão | Descrição |
---|---|---|
Primária | i @i |
Expressão de identificador |
(x) | Expressão entre parênteses | |
x[i] | Lookup | |
x{y} | Acesso ao item | |
x(...) | Invocação de função | |
{x, y, ...} | Inicialização de lista | |
[ i = x, ... ] | Inicialização de registro | |
... | Não implementado | |
Unário | +x | Identity |
-x | Negação | |
not x |
Negação lógica | |
Metadados | xmeta y |
Associar metadados |
Multiplicativo | x * y | Multiplicação |
x / y | Divisão | |
Aditiva | x + y | Adição |
x - y | Subtração | |
Relacional | x< y | Menor que |
x > y | Maior que | |
x<= y | Inferior ou igual | |
x >= y | Maior ou igual | |
Igualitário | x = y | Igual |
x<> y | Diferente | |
Asserção de tipo | xas y |
É um tipo primitivo que permite valor nulo ou então resulta em erro |
Conformidade de tipo | xis y |
Testar se o tipo primitivo que permite valor nulo é compatível |
AND lógico | xand y |
Conjunção de curto-circuito |
OR lógico | xor y |
Disjunção de curto-circuito |
Coalesce | x?? y |
Operador de união nula |
Cada valor tem um valor de registro associado que pode conter informações adicionais sobre o valor. Esse registro é conhecido como o registro de metadados para um valor. Um registro de metadados pode ser associado a qualquer tipo de valor, mesmo null
. O resultado dessa associação é um novo valor com os metadados fornecidos.
Um registro de metadados é apenas um registro comum e pode conter os mesmos tipos de campos e valores que um registro regular, além de conter um registro de metadados. Associar um registro de metadados com um valor é uma ação "não intrusiva". Essa associação não altera o comportamento do valor em avaliações, exceto aqueles que inspecionam explicitamente os registros de metadados.
Cada valor tem um registro de metadados padrão, mesmo que um não tenha sido especificado. O registro de metadados padrão é vazio. Os exemplos a seguir mostram como acessar o registro de metadados de um valor de texto usando a função de biblioteca padrão Value.Metadata
:
Value.Metadata( "Mozart" ) // []
Os registros de metadados geralmente não são preservados quando um valor é usado com um operador ou função que cria um novo valor. Por exemplo, se dois valores de texto forem concatenados usando o operador &
, os metadados do valor de texto resultante serão o registro vazio []
. As seguintes expressões são equivalentes:
"Amadeus " & ("Mozart" meta [ Rating = 5 ])
"Amadeus " & "Mozart"
As funções de biblioteca padrão Value.RemoveMetadata
e Value.ReplaceMetadata
podem ser usadas para remover todos os metadados de um valor e para substituir os metadados de um valor (em vez de mesclar os metadados em metadados possivelmente existentes).
O único operador que retorna os resultados que contêm metadados é o operador meta.
Os valores podem ser cíclicos. Por exemplo:
let l = {0, @l} in l
// {0, {0, {0, ... }}}
[A={B}, B={A}]
// [A = {{ ... }}, B = {{ ... }}]
O M manipula valores cíclicos mantendo o processo de construção de registros, listas e tabelas lento. Uma tentativa de criar um valor cíclico que não se beneficie de valores estruturados lentos que tenham sofrido intervenção gera um erro:
[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"),
// ]
Alguns operadores no M são definidos pela recursão estrutural. Por exemplo, a igualdade de listas e registros é definida pela igualdade conjunta de listas de itens e campos de registro correspondentes, respectivamente.
Para valores não cíclicos, a aplicação da recursão estrutural produz uma expansão finita do valor: valores aninhados compartilhados são percorridos repetidamente, mas o processo de recursão sempre é encerrado.
Um valor cíclico tem uma expansão infinita ao aplicar a recursão estrutural. A semântica do M não faz acomodações especiais para tais expansões infinitas. Uma tentativa de comparar valores cíclicos para igualdade, por exemplo, normalmente ficará sem recursos e terminará de maneira excepcional.
Os operadores de seleção e projeção permitem que os dados sejam extraídos dos valores de lista e de registro.
Um valor pode ser selecionado de uma lista ou tabela com base na respectiva posição de base zero nessa lista ou tabela usando uma expressão-de-acesso-a-item.
expressão-de-acesso-ao-item:
seleção-de-item
seleção-de-item-opcional
seleção-de-item:
primary-expression{
item-selector}
seleção-de-item-opcional:
primary-expression{
item-selector} ?
seletor-de-item:
expressão
A expressão-de-acesso-a-itemx{y}
retorna:
Para obter uma lista x
e um número y
, o item da lista x
na posição y
. O primeiro item de uma lista é considerado como tendo um índice ordinal igual a zero. Se a posição solicitada não existir na lista, um erro será gerado.
Para uma tabela x
e um número y
, a linha da tabela x
na posição y
. A primeira linha de uma tabela é considerada como tendo um índice ordinal igual a zero. Se a posição solicitada não existir na tabela, um erro será gerado.
Para uma tabela x
e um registro y
, a linha da tabela x
que corresponde aos valores de campo do registro y
para campos com nomes de campo equivalentes aos nomes de coluna de tabela correspondentes. Se não houver nenhuma linha correspondente exclusiva na tabela, um erro será gerado.
Por exemplo:
{"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
A expressão-de-acesso-a-item também dá suporte ao formato x{y}?
, que retorna null
quando a posição (ou correspondência) y
não existe na lista ou na tabela x
. Se houver várias correspondências para y
, um erro ainda será gerado.
Por exemplo:
{"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
O acesso ao item não força a avaliação de itens de lista ou de tabela além daquela que está sendo acessada. Por exemplo:
{ error "a", 1, error "c"}{1} // 1
{ error "a", error "b"}{1} // error "b"
Os seguintes preceitos são válidos quando o operador x{y}
de acesso ao item é avaliado:
Erros gerados durante a avaliação das expressões x
ou y
são propagados.
A expressão x
produz uma lista ou um valor de tabela.
A expressão y
produz um valor de registro se x
produz um valor de tabela e, caso contrário, produz um valor numérico.
Se y
produzir um valor numérico e o valor de y
for negativo, um erro com o código de motivo "Expression.Error"
será gerado.
Se y
produzir um valor numérico e o valor de y
for maior ou igual à contagem de x
, um erro com o código de motivo "Expression.Error"
será gerado, a menos que o formato de operador opcional x{y}?
seja usado; nesse caso, o valor null
será retornado.
Se x
produz um valor de tabela e y
produz um valor de registro e não há correspondências para y
em x
, um erro com o código de motivo "Expression.Error"
é gerado, a menos que o formato de operador opcional x{y}?
seja usado; nesse caso, o valor null
é retornado.
Se x
produz um valor de tabela e y
produz um valor de registro e há várias correspondências para y
em x
, um erro com o código de motivo "Expression.Error"
é gerado.
Nenhum item em x
diferente daquele na posição y
é avaliado durante o processo de seleção de itens. (Para listas de streaming ou tabelas, os itens ou linhas que antecedem isso na posição y
são ignorados, o que pode fazer com que eles sejam avaliados, dependendo da origem da lista ou da tabela.)
A expressão-de-acesso-ao-campo é usada para selecionar um valor de um registro ou para projetar um registro ou uma tabela para um com menos campos ou colunas, respectivamente.
expressão-de-acesso-ao-campo:
seleção-de-campo
seleção-de-campo-de-destino-implícito
projeção
projeção-de-destino-implícito
seleção-de-campo:
expressão-primária seletor-de-campo
seletor-de-campo:
seletor-de-campo-obrigatório
seletor-de-campo-opcional
seletor-de-campo-obrigatório:
[
field-name]
seletor-de-campo-opcional:
[
field-name] ?
nome-do-campo:
identificador-generalizado
identificador-entre-aspas
seleção-de-campo-de-destino-implícito:
seletor-de-campo
projeção:
expressão-primária projeção-obrigatória
expressão-primária projeção-opcional
projeção-obrigatória:
[
required-selector-list]
projeção-opcional:
[
required-selector-list] ?
lista-de-seletores-obrigatórios:
seletor-de-campo-obrigatório
required-selector-list,
required-field-selector
projeção-de-destino-implícito:
projeção-obrigatória
projeção-opcional
A forma mais simples de acesso ao campo é a seleção de campo obrigatório. Ele usa o operador x[y]
para procurar um campo em um registro por nome de campo. Se o campo y
não existir em x
, um erro será gerado. O formato x[y]?
é usado para executar seleção de campo opcional e retorna null
se o campo solicitado não existe no registro.
Por exemplo:
[A=1,B=2][B] // 2
[A=1,B=2][C] // error
[A=1,B=2][C]? // null
O acesso coletivo de vários campos é compatível com os operadores para projeção de registro obrigatória e projeção de registro opcional. O operador x[[y1],[y2],...]
projeta o registro em um novo registro com menos campos (selecionados por y1
, y2
e ...
). Se um campo selecionado não existir, um erro será gerado. O operador x[[y1],[y2],...]?
projeta o registro para um novo registro com os campos selecionados por y1
, y2
e ...
; se um campo estiver ausente, null
será usado em seu lugar.
Por exemplo:
[A=1,B=2][[B]] // [B=2]
[A=1,B=2][[C]] // error
[A=1,B=2][[B],[C]]? // [B=2,C=null]
Os formatos [y]
e [y]?
são compatíveis como uma referência abreviada ao identificador _
(sublinhado). As duas expressões a seguir são equivalentes:
[A]
_[A]
O seguinte exemplo ilustra a forma abreviada de acesso ao campo:
let _ = [A=1,B=2] in [A] //1
Os formatos [[y1],[y2],...]
e [[y1],[y2],...]?
também são compatíveis como uma abreviação e as duas expressões a seguir são, pela mesma lógica, equivalentes:
[[A],[B]]
_[[A],[B]]
O formulário abreviado é particularmente útil em combinação com a abreviação each
, uma maneira de introduzir uma função de um único parâmetro nomeado _
(para obter detalhes, confira declarações simplificadas). Juntas, as duas abreviações simplificam as expressões funcionais comuns de ordem superior:
List.Select( {[a=1, b=1], [a=2, b=4]}, each [a] = [b])
// {[a=1, b=1]}
A expressão acima é equivalente à seguinte versão mais longa, que também parece de mais difícil compreensão:
List.Select( {[a=1, b=1], [a=2, b=4]}, (_) => _[a] = _[b])
// {[a=1, b=1]}
O acesso ao campo não força a avaliação de campos além daqueles que estão sendo acessados. Por exemplo:
[A=error "a", B=1, C=error "c"][B] // 1
[A=error "a", B=error "b"][B] // error "b"
Os seguintes preceitos são válidos quando um operador x[y]
, x[y]?
, x[[y]]
ou x[[y]]?
de acesso ao campo é avaliado:
Erros gerados durante a avaliação da expressão x
são propagados.
Os erros gerados durante a avaliação do campo y
são permanentemente associados ao campo y
e, em seguida, propagados. Qualquer acesso futuro ao campo y
vai gerar o erro idêntico.
A expressão x
produz um valor de registro ou de tabela ou resulta na geração de um erro.
Se o identificador y
nomeia um campo que não existe em x
, um erro com o código de motivo "Expression.Error"
é gerado, a menos que o formato de operador opcional ...?
seja usado; nesse caso, o valor null
é retornado.
Nenhum campo de x
exceto aquele nomeado por y
é avaliado durante o processo de acesso ao campo.
O registro de metadados para um valor é alterado usando o operador meta (x meta y
).
expressão-de-metadados:
{1>unary-expression<1}
unary-expressionmeta
unary-expression
O exemplo a seguir constrói um valor de texto com um registro de metadados usando o operador meta
e, em seguida, acessa o registro de metadados do valor resultante usando Value.Metadata
:
Value.Metadata( "Mozart" meta [ Rating = 5 ] )
// [Rating = 5 ]
Value.Metadata( "Mozart" meta [ Rating = 5 ] )[Rating]
// 5
Os seguintes preceitos são válidos ao aplicar o operador de combinação de metadados x meta y
:
Erros gerados ao avaliar as expressões x
ou y
são propagados.
A expressão y
precisa ser um registro, caso contrário, um erro com o código de motivo "Expression.Error"
é gerado.
O registro de metadados resultante é o registro de metadados de x
mesclado com y
. (Para obter a semântica de mesclagem de registros, confira Mesclagem de registros.)
O valor resultante é o valor da expressão x
, sem os respectivos metadados, com o registro de metadados recém-computado anexado.
As funções de biblioteca padrão Value.RemoveMetadata
e Value.ReplaceMetadata
podem ser usadas para remover todos os metadados de um valor e para substituir os metadados de um valor (em vez de mesclar os metadados em metadados possivelmente existentes). As seguintes expressões são equivalentes:
x meta y
Value.ReplaceMetadata(x, Value.Metadata(x) & y)
Value.RemoveMetadata(x) meta (Value.Metadata(x) & y)
O operador de igualdade=
é usado para determinar se dois valores são iguais. O operador de desigualdade<>
é usado para determinar se dois valores não são iguais.
expressão-de-igualdade:
relational-expression
relational-expression=
equality-expression
relational-expression<>
equality-expression
Por exemplo:
1 = 1 // true
1 = 2 // false
1 <> 1 // false
1 <> 2 // true
null = true // false
null = null // true
Os metadados não fazem parte da comparação de igualdade ou desigualdade. Por exemplo:
(1 meta [ a = 1 ]) = (1 meta [ a = 2 ]) // true
(1 meta [ a = 1 ]) = 1 // true
Os seguintes preceitos são válidos ao aplicar os operadores de igualdade x = y
e x <> y
:
Erros gerados ao avaliar as expressões x
ou y
são propagados.
O operador =
terá um resultado de true
se os valores forem iguais; caso contrário, o resultado será false
.
O operador <>
terá um resultado de false
se os valores forem iguais; caso contrário, o resultado será true
.
Os registros de metadados não são incluídos na comparação.
Se os valores produzidos pela avaliação das expressões x
e y
não forem do mesmo tipo de valor, os valores não serão iguais.
Se os valores produzidos pela avaliação da expressão x
e y
forem do mesmo tipo de valor, haverá regras específicas para determinar se eles são iguais, conforme definido abaixo.
Os seguintes preceitos são sempre verdadeiros:
(x = y) = not (x <> y)
Os operadores de igualdade são definidos para os seguintes tipos:
null
é igual apenas a ele mesmo. null = null // true
null = true // false
null = false // false
true
e false
são apenas iguais a eles mesmos. Por exemplo: true = true // true
false = false // true
true = false // false
true = 1 // false
Os números são comparados usando a precisão especificada:
Se um dos dois números for #nan
, os números não serão iguais.
Quando nenhum dos números é #nan
, eles são comparados usando uma comparação bit-a-bit do valor numérico.
#nan
é o único valor que não é igual a si mesmo.
Por exemplo:
1 = 1, // true
1.0 = 1 // true
2 = 1 // false
#nan = #nan // false
#nan <> #nan // true
Duas durações serão iguais se elas representarem o mesmo número de tiques de 100 nanossegundos.
Duas horas serão iguais se as magnitudes de suas partes (hora, minuto, segundo) forem iguais.
Duas datas serão iguais se as magnitudes de suas partes (ano, mês, dia) forem iguais.
Dois datetimes serão iguais se as magnitudes de suas partes (ano, mês, dia, hora, minuto, segundo) forem iguais.
Dois datetimezones serão iguais se os datetimes UTC correspondentes forem iguais. Para chegar ao datetime UTC correspondente, a diferença de horas/minutos é subtraída do componente datetime do datetimezone.
Dois valores de texto serão iguais se, ao usar uma comparação ordinal, com diferenciação de maiúsculas de minúsculas e sem diferenciação de cultura, eles tiverem o mesmo comprimento e caracteres iguais em posições correspondentes.
Dois valores de lista serão iguais se todas as condições a seguir forem verdadeiras:
As duas listas contêm o mesmo número de itens.
Os valores de cada item posicionalmente correspondente nas listas são iguais. Isso significa que não apenas as listas precisam conter itens iguais, os itens também precisam estar na mesma ordem.
Por exemplo:
{1, 2} = {1, 2} // true
{2, 1} = {1, 2} // false
{1, 2, 3} = {1, 2} // false
Dois registros serão iguais se todas as seguintes condições forem verdadeiras:
O número de campos é o mesmo.
Cada nome de campo de um registro também está presente no outro registro.
O valor de cada campo de um registro é igual ao campo com o mesmo nome presente no outro registro.
Por exemplo:
[ 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
Duas tabelas serão iguais se todas as condições a seguir forem verdadeiras:
O número de colunas é o mesmo.
Cada nome de coluna em uma tabela também está presente na outra tabela.
O número de linhas é o mesmo.
Cada linha tem valores iguais em células correspondentes.
Por exemplo:
#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
Um valor de função é igual a si mesmo, mas pode ou não ser igual a outro valor de função. Se dois valores de função forem considerados iguais, eles se comportarão de maneira idêntica quando invocados.
Dois valores de função fornecidos sempre terão a mesma relação de igualdade.
Um valor de tipo é igual a si mesmo, mas pode ou não ser igual a outro valor de tipo. Se dois valores de tipo forem considerados iguais, eles se comportarão de maneira idêntica quando consultados quanto à conformidade.
Dois valores de tipo fornecidos sempre terão a mesma relação de igualdade.
Os operadores <
, >
, <=
e >=
são chamados de operadores relacionais.
expressão-relacional:
additive-expression
additive-expression<
relational-expression
additive-expression>
relational-expression
additive-expression<=
relational-expression
additive-expression>=
relational-expression
Esses operadores são usados para determinar a relação de ordenação relativa entre dois valores, conforme mostrado na tabela a seguir:
Operação | Resultado |
---|---|
x < y |
true se x for menor que y , caso contrário, false |
x > y |
true se x for maior que y , caso contrário, false |
x <= y |
true se x for menor ou igual a y , caso contrário, false |
x >= y |
true se x for maior ou igual a y , caso contrário, false |
Por exemplo:
0 <= 1 // true
null < 1 // null
null <= null // null
"ab" < "abc" // true
#nan >= #nan // false
#nan <= #nan // false
Os seguintes preceitos são válidos ao avaliar uma expressão que contém os operadores relacionais:
Erros gerados ao avaliar as expressões de operando x
ou y
são propagados.
Os valores produzidos pela avaliação das expressões x
e y
devem ser um valor de binary, date, datetime, datetimezone, duration, logical, number, null, text ou time. Caso contrário, um erro com o código de motivo "Expression.Error"
é gerado.
Ambos os operandos devem ser do mesmo tipo de valor ou null
. Caso contrário, um erro com o código de motivo "Expression.Error"
é gerado.
Se um ou ambos os operandos forem null
, o resultado será o valor null
.
Dois binários são comparados por byte.
Para comparar duas datas, devemos comparar suas partes de ano; se forem iguais, suas partes de mês e, se forem iguais, suas partes de dia.
Para comparar dois datetimes, devemos comparar suas partes de ano; se forem iguais, suas partes de mês; se forem iguais, suas partes de dia; se forem iguais, suas partes de hora; se forem iguais, suas partes de minuto e, se forem iguais, suas partes de segundo.
Para comparar dois datetimezones, devemos normalizá-los para UTC, subtraindo a diferença de hora/minuto e, em seguida, comparando seus componentes datetime.
Duas durações serão comparadas de acordo com o número total de tiques de 100 nanossegundos que eles representarem.
Duas lógicas são comparadas de modo que true
é considerado maior que false
.
Dois números x
e y
são comparados de acordo com as regras do padrão IEEE 754:
Se um dos operandos for #nan
, o resultado será false
para todos os operadores relacionais.
Quando nenhum operando é #nan
, os operadores comparam os valores dos dois operandos de ponto flutuante em relação à ordenação -∞ < -max < ... < -min < -0.0 = +0.0 < +min < ... < +max < +∞
, em que mín e máx são os menores e maiores valores finitos positivos que podem ser representados. Os nomes para -∞ e +∞ na linguagem de fórmula M são -#infinity
e #infinity
.
Os efeitos notáveis dessa ordenação são:
Zeros negativos e positivos são considerados iguais.
Um valor -#infinity
é considerado menor que todos os outros valores numéricos, mas é igual a outro -#infinity
.
Um valor #infinity
é considerado maior que todos os outros valores numéricos, mas é igual a outro #infinity
.
Dois textos são comparados usando uma comparação ordinal de caractere por caractere, que diferencia maiúsculas de minúsculas e que não diferencia a cultura.
Para comparar duas horas, devemos comparar suas partes de hora; se forem iguais, suas partes de minuto e, se forem iguais, suas partes de segundo.
Os operadores and
e or
são chamados de operadores lógicos condicionais.
expressão-OR-lógica:
logical-and-expression
logical-and-expressionor
logical-or-expression
expressão-AND-lógica:
expressão-is
is-expressionand
logical-and-expression
O operador or
retorna true
quando pelo menos um de seus operandos é true
. O operando direito será avaliado se e somente se o operando esquerdo não for true
.
O operador and
retorna false
quando pelo menos um de seus operandos é false
. O operando direito será avaliado se e somente se o operando esquerdo não for false
.
As tabelas da verdade para os operadores or
e and
são mostradas abaixo, com o resultado da avaliação da expressão de operando esquerdo no eixo vertical e o resultado da avaliação da expressão do operando direito no eixo horizontal.
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 |
Os seguintes preceitos são válidos ao avaliar uma expressão que contém operadores lógicos condicionais:
Erros gerados ao avaliar as expressões x
ou y
são propagados.
Os operadores lógicos condicionais são definidos sobre os tipos logical
e null
. Se os valores de operando não forem desses tipos, um erro com o código de motivo "Expression.Error"
será gerado.
O resultado é um valor lógico.
Na expressão x
ou y
, a expressão y
será avaliada se e somente se x
não for avaliada como true
.
Na expressão x
e y
, a expressão y
será avaliada se e somente se x
não for avaliada como false
.
As duas últimas propriedades dão aos operadores lógicos condicionais a respectiva qualificação "condicional". Essas propriedades também são conhecidas como "curto-circuito". Essas propriedades são úteis para escrever predicados compactos protegidos. Por exemplo, as seguintes expressões são equivalentes:
d <> 0 and n/d > 1 if d <> 0 then n/d > 1 else false
Os operadores +
, -
, *
e /
são os operadores aritméticos.
expressão-de-adição:
multiplicative-expression
additive-expression+
multiplicative-expression
additive-expression-
multiplicative-expression
expressão-multiplicadora:
expressão-de-metadados
multiplicative-expression*
metadata-expression
multiplicative-expression/
metadata-expression
Os números em M são armazenados usando uma variedade de representações para manter o máximo possível de informações sobre números provenientes de uma variedade de fontes. Os números são convertidos apenas de uma representação para outra, conforme requerido pelos operadores aplicados a eles. Duas precisões são compatíveis com o M:
Precision | Semântica |
---|---|
Precision.Decimal |
Representação decimal de 128 bits com um intervalo de ±1,0 x 10-28 a ±7,9 x 1.028 e 28-29 dígitos significativos. |
Precision.Double |
Representação científica usando mantissa e expoente; está em conformidade com o padrão aritmético IEEE 754 de precisão dupla binário de 64 bits IEEE 754-2008. |
As operações aritméticas são executadas escolhendo uma precisão, convertendo ambos os operandos para essa precisão (se necessário), executando a operação propriamente dita e, finalmente, retornando um número na precisão escolhida.
Os operadores aritméticos internos (+
, -
, *
e /
) usam precisão dupla. As funções de biblioteca padrão (Value.Add
, Value.Subtract
, Value.Multiply
e Value.Divide
) podem ser usadas para solicitar essas operações usando um modelo de precisão específico.
Nenhum estouro numérico é possível: #infinity
ou -#infinity
representam valores de magnitudes grandes demais para serem representados.
Nenhum fluxo negativo numérico é possível: 0
e -0
representam valores de magnitudes pequenas demais para serem representados.
O valor especial do IEEE 754 #nan
(NaN – não é um número) é usado para cobrir casos que não são matematicamente válidos, como uma divisão de zero por zero.
A conversão de precisão decimal para dupla é executada por meio do arredondamento de números decimais para o valor duplo equivalente mais próximo.
A conversão da precisão de dupla para decimal é executada por meio do arredondamento de números duplos para o valor decimal equivalente mais próximo e, se necessário, estourando para valores #infinity
ou -#infinity
.
A interpretação do operador de adição (x + y
) depende do tipo de valor das expressões x e y avaliadas, da seguinte maneira:
x | a | Resultado | Interpretação |
---|---|---|---|
type number |
type number |
type number |
Soma numérica |
type number |
null |
null |
|
null |
type number |
null |
|
type duration |
type duration |
type duration |
Soma numérica de magnitudes |
type duration |
null |
null |
|
null |
type duration |
null |
|
type datetime |
type duration |
type datetime |
Deslocamento de data/hora por duração |
type duration |
type datetime |
type datetime |
|
type datetime |
null |
null |
|
null |
type datetime |
null |
Na tabela, type
datetime representa qualquer um entre type date
, type datetime
, type datetimezone
ou type time
. Ao adicionar uma duração e um valor de algum tipo de datetime, o valor resultante é desse mesmo tipo.
Para outras combinações de valores além daquelas listadas na tabela, um erro com o código de motivo "Expression.Error"
é gerado. Cada uma das combinações é abordada nas seções a seguir.
Os erros gerados ao avaliar qualquer um dos dois operandos são propagados.
A soma de dois números é computada usando o operador de adição, produzindo um número.
Por exemplo:
1 + 1 // 2
#nan + #infinity // #nan
O operador de adição +
usado em números usa precisão dupla. A função de biblioteca padrão Value.Add
pode ser usada para especificar a precisão decimal. Os seguintes preceitos são válidos ao computar uma soma de números:
A soma em precisão dupla é computada de acordo com as regras de aritmética de IEEE 754 de precisão dupla binária de 64 bits, IEEE 754-2008. A tabela a seguir lista os resultados de todas as combinações possíveis de valores finitos diferentes de zero, zeros, infinitos e NaNs. Na tabela, x
e y
são valores finitos diferentes de zero e z
é o resultado de x + y
. Se x
e y
tiverem a mesma magnitude, mas sinais opostos, z
será zero positivo. Se x + y
for grande demais para ser representado no tipo de destino, z
será um infinito com o mesmo sinal que x + y
.
+ | a | +0 | -0 | +∞ | -∞ | NaN |
---|---|---|---|---|---|---|
x | z | x | x | +∞ | -∞ | NaN |
+0 | a | +0 | +0 | +∞ | -∞ | NaN |
-0 | a | +0 | -0 | +∞ | -∞ | NaN |
+∞ | +∞ | +∞ | +∞ | +∞ | NaN | NaN |
-∞ | -∞ | -∞ | -∞ | NaN | -∞ | NaN |
NaN | NaN | NaN | NaN | NaN | NaN | NaN |
A soma em precisão decimal é computada sem perda de precisão. A escala do resultado é maior que as escalas dos dois operandos.
A soma de duas durações é a duração que representa a soma do número de tiques de 100 nanossegundos representada pelas durações. Por exemplo:
#duration(2,1,0,15.1) + #duration(0,1,30,45.3)
// #duration(2, 2, 31, 0.4)
Um datetimex
e uma duração y
podem ser adicionados usando x + y
para computar um novo datetime cuja distância de x
em uma linha do tempo linear é exatamente a magnitude de y
. Aqui, datetime representa qualquer uma das opções Date
, DateTime
, DateTimeZone
e Time
; assim, um resultado não nulo será do mesmo tipo. A diferença de datetime por duração pode ser calculado da seguinte maneira:
Se o valor de dias desde o início da época de datetime for especificado, crie um datetime com os seguintes elementos de informação:
Calcule um novo equivalente de dias desde o início da época, a fim de dividir a magnitude de y pelo número de tiques de 100 nanossegundos em um período de 24 horas, truncando a parte decimal do resultado e adicionando esse valor aos dias desde o início da época de x.
Calcule uma nova contagem de tiques desde a meia-noite equivalente à adição da magnitude de y aos tiques desde a meia-noite de x, módulo o número de tiques de 100 nanossegundos em um período de 24 horas. Se x não especificar um valor para tiques desde a meia-noite, um valor de 0 será assumido.
Copie o valor da diferença em minutos em relação ao UTC, inalterado, de x.
Se o valor de dias desde o início da época de datetime não for especificado, crie um datetime com os seguintes elementos de informação especificados:
Calcule uma nova contagem de tiques desde a meia-noite equivalente à adição da magnitude de y aos tiques desde a meia-noite de x, módulo o número de tiques de 100 nanossegundos em um período de 24 horas. Se x não especificar um valor para tiques desde a meia-noite, um valor de 0 será assumido.
Copie os valores de dias desde o início da época e a diferença em minutos em relação ao UTC, inalterados, de x.
Os exemplos a seguir mostram o cálculo da soma temporal absoluta quando o datetime especifica os dias desde o início da época:
#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
O exemplo a seguir mostra o cálculo da diferença de datetime por duração para uma determinada hora:
#time(8,0,0) + #duration(30,5,0,0)
//#time(13, 0, 0)
//13:00:00
A interpretação do operador de subtração (x - y
) depende do tipo de valor das expressões x
e y
avaliadas, da seguinte maneira:
x | Y | Resultado | Interpretação |
---|---|---|---|
type number |
type number |
type number |
Diferença numérica |
type number |
null |
null |
|
null |
type number |
null |
|
type duration |
type duration |
type duration |
Diferença numérica de magnitudes |
type duration |
null |
null |
|
null |
type duration |
null |
|
type datetime |
type datetime |
type duration |
Duração entre datetimes |
type datetime |
type duration |
type datetime |
Deslocamento de Datetime por duração negada |
type datetime |
null |
null |
|
null |
type datetime |
null |
Na tabela, type
datetime representa qualquer um entre type date
, type datetime
, type datetimezone
ou type time
. Ao subtrair uma duração de um valor de algum tipo de datetime, o valor resultante é desse mesmo tipo.
Para outras combinações de valores além daquelas listadas na tabela, um erro com o código de motivo "Expression.Error"
é gerado. Cada uma das combinações é abordada nas seções a seguir.
Os erros gerados ao avaliar qualquer um dos dois operandos são propagados.
A diferença entre dois números é computada usando o operador de subtração, produzindo um número. Por exemplo:
1 - 1 // 0
#nan - #infinity // #nan
O operador de subtração -
usado em números usa precisão dupla. A função de biblioteca padrão Value.Subtract
pode ser usada para especificar a precisão decimal. Os seguintes preceitos são válidos ao computar uma diferença de números:
A diferença em precisão dupla é computada de acordo com as regras de aritmética de IEEE 754 de precisão dupla binária de 64 bits, IEEE 754-2008. A tabela a seguir lista os resultados de todas as combinações possíveis de valores finitos diferentes de zero, zeros, infinitos e NaNs. Na tabela, x
e y
são valores finitos diferentes de zero e z
é o resultado de x - y
. Se x
e y
forem iguais, z
será zero positivo. Se x - y
for grande demais para ser representado no tipo de destino, z
será um infinito com o mesmo sinal que x - y
.
- | a | +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 |
A diferença em precisão decimal é computada sem perda de precisão. A escala do resultado é maior que as escalas dos dois operandos.
A diferença entre duas durações é a duração que representa a diferença entre o número de tiques de 100 nanossegundos representada pelas durações. Por exemplo:
#duration(1,2,30,0) - #duration(0,0,0,30.45)
// #duration(1, 2, 29, 29.55)
Um datetimex
e uma duração y
podem ser subtraídos usando x - y
para computar um novo datetime. Aqui, datetime representa qualquer um entre date
, datetime
, datetimezone
ou time
. O datetime resultante tem uma distância de x
em uma linha do tempo linear, que é exatamente a magnitude de y
, na direção oposta ao sinal de y
. A subtração de durações positivas gera resultados que são regressivos no tempo em relação a x
, enquanto a subtração de valores negativos gera resultados que são progressivos no tempo.
#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
Dois datetimest
e u
podem ser subtraídos usando t - u
para computar a duração entre eles. Aqui, datetime representa qualquer um entre date
, datetime
, datetimezone
ou time
. A duração produzida subtraindo u
de t
precisa resultar t
quando adicionada a u
.
#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
A subtração t - u
quando u > t
resulta em uma duração negativa:
#time(01,30,00) - #time(08,00,00)
// #duration(0, -6, -30, 0)
Os seguintes preceitos são válidos ao subtrair dois datetimes usando t - u
:
A interpretação do operador de multiplicação (x * y
) depende do tipo de valor das expressões x e y avaliadas, da seguinte maneira:
X | Y | Resultado | Interpretação |
---|---|---|---|
type number |
type number |
type number |
Produto numérico |
type number |
null |
null |
|
null |
type number |
null |
|
type duration |
type number |
type duration |
Múltiplo da duração |
type number |
type duration |
type duration |
Múltiplo da duração |
type duration |
null |
null |
|
null |
type duration |
null |
Para outras combinações de valores além daquelas listadas na tabela, um erro com o código de motivo "Expression.Error"
é gerado. Cada uma das combinações é abordada nas seções a seguir.
Os erros gerados ao avaliar qualquer um dos dois operandos são propagados.
O produto de dois números é computado usando o operador de multiplicação, produzindo um número. Por exemplo:
2 * 4 // 8
6 * null // null
#nan * #infinity // #nan
O operador de multiplicação *
usado em números usa precisão dupla. A função de biblioteca padrão Value.Multiply
pode ser usada para especificar a precisão decimal. Os seguintes preceitos são válidos ao computar um produto de números:
O produto em precisão dupla é computado de acordo com as regras de aritmética de IEEE 754 de precisão dupla binária de 64 bits, IEEE 754-2008. A tabela a seguir lista os resultados de todas as combinações possíveis de valores finitos diferentes de zero, zeros, infinitos e NaNs. Na tabela, x
e y
são valores positivos finitos. z
é o resultado de x * y
. Se o resultado é grande demais para o tipo de destino, z
é infinito. Se o resultado é pequeno demais para o tipo de destino, z
é 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 |
O produto em precisão decimal é computado sem perda de precisão. A escala do resultado é maior que as escalas dos dois operandos.
O produto de uma duração e um número é a duração que representa o número de tiques de 100 nanossegundos representado pela multiplicação do operando de duração pelo operando de número. Por exemplo:
#duration(2,1,0,15.1) * 2
// #duration(4, 2, 0, 30.2)
A interpretação do operador de divisão (x / y
) depende do tipo de valor das expressões x
e y
avaliadas, da seguinte maneira:
X | Y | Resultado | Interpretação |
---|---|---|---|
type number |
type number |
type number |
Quociente numérico |
type number |
null |
null |
|
null |
type number |
null |
|
type duration |
type number |
type duration |
Fração de uma duração |
type duration |
type duration |
type number |
Quociente numérico de durações |
type duration |
null |
null |
|
null |
type duration |
null |
Para outras combinações de valores além daquelas listadas na tabela, um erro com o código de motivo "Expression.Error"
é gerado. Cada uma das combinações é abordada nas seções a seguir.
Os erros gerados ao avaliar qualquer um dos dois operandos são propagados.
O quociente de dois números é computado usando o operador de divisão, produzindo um número. Por exemplo:
8 / 2 // 4
8 / 0 // #infinity
0 / 0 // #nan
0 / null // null
#nan / #infinity // #nan
O operador de divisão /
usado em números usa precisão dupla. A função de biblioteca padrão Value.Divide
pode ser usada para especificar a precisão decimal. Os seguintes preceitos são válidos ao calcular um quociente de números:
O quociente em precisão dupla é computado de acordo com as regras de aritmética de IEEE 754 de precisão dupla binária de 64 bits, IEEE 754-2008. A tabela a seguir lista os resultados de todas as combinações possíveis de valores finitos diferentes de zero, zeros, infinitos e NaNs. Na tabela, x
e y
são valores positivos finitos. z
é o resultado de x / y
. Se o resultado é grande demais para o tipo de destino, z
é infinito. Se o resultado é pequeno demais para o tipo de destino, z
é 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 |
A soma em precisão decimal é computada sem perda de precisão. A escala do resultado é maior que as escalas dos dois operandos.
O quociente de duas durações é o número que representa o quociente do número de tiques de 100 nanossegundos representada pelas durações. Por exemplo:
#duration(2,0,0,0) / #duration(0,1,30,0)
// 32
O quociente de uma duração x
e um número y
é a duração que representa o quociente do número de tiques de 100 nanossegundos representados pela duração x
e o número y
. Por exemplo:
#duration(2,0,0,0) / 32
// #duration(0,1,30,0)
O operador de combinação (x & y
) é definido para os seguintes tipos de valores:
X | Y | Resultado | Interpretação |
---|---|---|---|
type text |
type text |
type text |
Concatenação |
type text |
null |
null |
|
null |
type text |
null |
|
type date |
type time |
type datetime |
Mesclar |
type date |
null |
null |
|
null |
type time |
null |
|
type list |
type list |
type list |
Concatenação |
type record |
type record |
type record |
Mesclar |
type table |
type table |
type table |
Concatenação |
Dois textos, duas listas ou dois valores de tabela podem ser concatenados usando x & y
.
Este exemplo ilustra a concatenação de valores de texto:
"AB" & "CDE" // "ABCDE"
Este exemplo ilustra a concatenação de listas:
{1, 2} & {3} // {1, 2, 3}
Os seguintes preceitos são válidos ao concatenar dois valores usando x & y
:
Erros gerados ao avaliar as expressões x
ou y
são propagados.
Nenhum erro será propagado se um item de x
ou de y
contiver um erro.
O resultado da concatenação de dois valores de texto é um valor de texto que contém o valor de x seguido imediatamente por y. Se um dos operandos for nulo e o outro for um valor de texto, o resultado será nulo.
O resultado da concatenação de duas listas é uma lista que contém todos os itens de x
seguidos por todos os itens de y
.
O resultado da concatenação de duas tabelas é uma tabela contendo a união das colunas das tabelas dos dois operandos. A ordenação de colunas de x
é preservada, seguida pelas colunas que aparecem apenas em y
, preservando a ordenação relativa delas. Para colunas que aparecem apenas em um dos operandos, null
é usado para preencher valores de célula para o outro operando.
Dois registros podem ser mesclados usando x & y
, produzindo um registro que inclui campos de x
e y
.
Os exemplos a seguir ilustram a mesclagem de registros:
[ x = 1 ] & [ y = 2 ] // [ x = 1, y = 2 ]
[ x = 1, y = 2 ] & [ x = 3, z = 4 ] // [ x = 3, y = 2, z = 4 ]
Os seguintes preceitos são válidos ao mesclar dois registros usando x + y
:
Erros gerados ao avaliar as expressões x
ou y
são propagados.
Se um campo aparecer tanto em x
quanto em y
, o valor de y
será usado.
A ordem dos campos no registro resultante é a de x
, seguida pelos campos em y
que não fazem parte de x
, na mesma ordem em que aparecem em y
.
A mesclagem de registros não causa a avaliação dos valores.
Nenhum erro é gerado devido a um campo conter um erro.
O resultado é um registro.
Uma data x
pode ser mesclada com uma hora y
usando x & y
, produzindo um datetime que combina as partes de x
e y
.
O exemplo a seguir ilustra a mesclagem de uma data e uma hora:
#date(2013,02,26) & #time(09,17,00)
// #datetime(2013,02,26,09,17,00)
Os seguintes preceitos são válidos ao mesclar dois registros usando x + y
:
Erros gerados ao avaliar as expressões x
ou y
são propagados.
O resultado é um datetime.
Os operadores +
, -
e not
são operadores unários.
expressão-unária:
expressão-de-tipo
+
expressão unária
-
expressão unária
not
expressão unária
O operador de adição de unário (+x
) é definido para os seguintes tipos de valores:
X | Resultado | Interpretação |
---|---|---|
type number |
type number |
Adição de unário |
type duration |
type duration |
Adição de unário |
null |
nulo |
Para outros valores, um erro com o código de motivo "Expression.Error"
é gerado.
O operador de adição de unário permite que um sinal de +
seja aplicado a um valor numérico, datetime ou nulo. O resultado é esse mesmo valor. Por exemplo:
+ - 1 // -1
+ + 1 // 1
+ #nan // #nan
+ #duration(0,1,30,0) // #duration(0,1,30,0)
Os seguintes preceitos são válidos ao avaliar o operador de adição de unário +x
:
Os erros gerados ao avaliar x
são propagados.
Se o resultado da avaliação de x
não for um valor numérico, um erro com o código de motivo "Expression.Error"
será gerado.
O operador de subtração de unário (-x
) é definido para os seguintes tipos de valores:
X | Resultado | Interpretação |
---|---|---|
type number |
type number |
Negação |
type duration |
type duration |
Negação |
null |
null |
Para outros valores, um erro com o código de motivo "Expression.Error"
é gerado.
O operador de subtração de unário é usado para alterar o sinal de um número ou duração. Por exemplo:
- (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)
Os seguintes preceitos são válidos ao avaliar o operador de subtração unário -x
:
Os erros gerados ao avaliar x
são propagados.
Se a expressão for um número, o resultado será o valor numérico da expressão x
com seu sinal alterado. Se o valor for um NaN, o resultado também será um NaN.
O operador de negação lógica (not
) é definido para os seguintes tipos de valores:
X | Resultado | Interpretação |
---|---|---|
type logical |
type logical |
Negação |
null |
null |
Esse operador computa a operação not
lógica em um determinado valor lógico. Por exemplo:
not true // false
not false // true
not (true and true) // false
Os seguintes preceitos são válidos ao avaliar o operador lógico de negação not x
:
Os erros gerados ao avaliar x
são propagados.
O valor produzido da avaliação da expressão x precisa ser um valor lógico, caso contrário, um erro com o código de motivo "Expression.Error"
precisará ser gerado. Se o valor for true
, o resultado será false
. Se o operando for false
, o resultado será true
.
O resultado é um valor lógico.
Os operadores is
e as
são conhecidos como operadores de tipo.
O operador de compatibilidade de tipo x is y
é definido para os seguintes tipos de valores:
X | Y | Resultado |
---|---|---|
type any |
tipo-primitivo-que-permite-valor-nulo | type logical |
A expressão x is y
retornará true
se o tipo atribuído de x
for compatível com y
e retornará false
se o tipo atribuído de x
for incompatível com y
. y
precisa ser um tipo-primitivo-que-permite-valor-nulo.
expressão-is:
expressão-as
is-expressionis
nullable-primitive-type
tipo-primitivo-que-permite-valor-nulo:
nullable
opcional tipo-primitivo
A compatibilidade de tipo, conforme compatível com o operador is
, é um subconjunto de compatibilidade de tipo geral e é definida usando as seguintes regras:
Se x
for nulo, ele será compatível se y
for do tipo any
, do tipo null
ou de um tipo anulável.
Se x
for não nulo, ele será compatível se o tipo primitivo de x
for o mesmo que y
.
Os seguintes preceitos são válidos ao avaliar a expressão x is y
:
x
é propagado.O operador de asserção de tipo x as y
é definido para os seguintes tipos de valores:
X | Y | Resultado |
---|---|---|
type any |
tipo-primitivo-que-permite-valor-nulo | type any |
A expressão x as y
declara que o valor x
é compatível com y
, conforme o operador is
. Se não for compatível, um erro será gerado. y
precisa ser um tipo-primitivo-que-permite-valor-nulo.
expressão-as:
expressão de igualdade
as-expressionas
nullable-primitive-type
A expressão x as y
é avaliada desta maneira:
Uma verificação de compatibilidade de tipo x is y
é executada e a asserção retorna x
inalterado se o teste é executado com sucesso.
Se a verificação de compatibilidade falhar, um erro com o código de motivo "Expression.Error"
será gerado.
Exemplos:
1 as number // 1
"A" as number // error
null as nullable number // null
Os seguintes preceitos são válidos ao avaliar a expressão x as y
:
x
é propagado.O operador de união ??
retornará o resultado do operando esquerdo dele caso ele não seja nulo; do contrário, ele retornará o resultado do operando direito. O operando direito será avaliado se e somente se o operando esquerdo for nulo.
Treinamento
Módulo
Executar operações básicas em números em C# - Training
Aprenda quais são os operadores e as técnicas usadas para executar operações matemáticas básicas em dados numéricos.
Documentação
Valores da linguagem M - PowerQuery M
Descreve o uso de valores na linguagem de fórmula M do Power Query
Funções da linguagem M - PowerQuery M
Descreve o uso de funções na linguagem de fórmula M do Power Query
Tipos da linguagem M - PowerQuery M
Descreve o uso de tipos na linguagem de fórmula M do Power Query