Comportamento degli operatoriOperator behavior

Questa sezione definisce il comportamento dei diversi operatori M.This section defines the behavior of the various M operators.

Precedenza tra gli operatoriOperator precedence

Quando un'espressione contiene più operatori, la precedenza degli operatori controlla l'ordine in cui vengono valutati i singoli operatori.When an expression contains multiple operators, the precedence of the operators controls the order in which the individual operators are evaluated. Ad esempio, l'espressione x + y * z viene valutata come x + (y * z) perché l'operatore * ha la precedenza rispetto all'operatore + binario.For example, the expression x + y * z is evaluated as x + (y * z) because the * operator has higher precedence than the binary + operator. La precedenza di un operatore viene stabilita dalla definizione della produzione grammaticale associata.The precedence of an operator is established by the definition of its associated grammar production. Un'additive-expression, ad esempio, è costituita da una sequenza di multiplicative-expression separate dagli operatori + o -, assegnando in questo modo una precedenza inferiore agli operatori + e - rispetto agli operatori * e /.For example, an additive-expression consists of a sequence of multiplicative-expression's separated by + or - operators, thus giving the + and - operators lower precedence than the * and / operators.

La produzione di parenthesized-expression può essere usata per modificare l'ordine di precedenza predefinito.The parenthesized-expression production can be used to change the default precedence ordering.

parenthesized-expression:parenthesized-expression:
      ( expression )      ( expression )

ad esempio:For example:

1 + 2 * 3       // 7 
(1 + 2) * 3     // 9

La tabella seguente riepiloga gli operatori M, elencando le categorie di operatori in ordine di precedenza, dalla più alta alla più bassa.The following table summarizes the M operators, listing the operator categories in order of precedence from highest to lowest. Gli operatori nella stessa categoria hanno la stessa precedenza.Operators in the same category have equal precedence.

CategoriaCategory EspressioneExpression DescrizioneDescription
PrimariaPrimary ii
@i@i
Espressione identificatoreIdentifier expression
(x)(x) Espressione racchiusa tra parentesiParenthesized expression
x[i]x[i] LookupLookup
x{y}x{y} Accesso agli elementiItem access
x(...)x(...) Chiamata di funzioneFunction invocation
{x, y, ...}{x, y, ...} Inizializzazione dell'elencoList initialization
[ i = x, ... ][ i = x, ... ] Inizializzazione del recordRecord initialization
...... Non implementatoNot implemented
UnariaUnary +x+x IdentitàIdentity
-x-x NegazioneNegation
not xnot x Negazione logicaLogical negation
MetadatiMetadata x meta yx meta y Associare i metadatiAssociate metadata
MoltiplicazioneMultiplicative x \* yx \* y MoltiplicazioneMultiplication
x / yx / y DivisioneDivision
AdditiveAdditive x + yx + y AddizioneAddition
x - yx - y SottrazioneSubtraction
RelazionaleRelational x < yx < y Minore diLess than
x > yx > y Maggiore diGreater than
x <= yx <= y Minore o uguale aLess than or equal
x >= yx >= y Maggiore o uguale aGreater than or equal
UguaglianzaEquality x = yx = y Uguale aEqual
x <> yx <> y Diverso daNot equal
Asserzione di tipoType assertion x as yx as y Errore o tipo primitivo nullable compatibileIs compatible nullable-primitive type or error
Conformità del tipoType conformance x is yx is y Testa se è un tipo primitivo nullable compatibileTest if compatible nullable-primitive type
AND logicoLogical AND x and yx and y Congiunzione di corto circuitoShort-circuiting conjunction
OR logicoLogical OR x or yx or y Disgiunzione di cortocircuitoShort-circuiting disjunction

Operatori e metadatiOperators and metadata

A ogni valore è associato un valore di record che può includere informazioni aggiuntive sul valore.Every value has an associated record value that can carry additional information about the value. Questo record è detto record di metadati per un valore.This record is referred to as the metadata record for a value. Un record di metadati può essere associato a qualsiasi tipo di valore, anche null.A metadata record can be associated with any kind of value, even null. Il risultato di tale associazione è un nuovo valore con i metadati specificati.The result of such an association is a new value with the given metadata.

Un record di metadati è un normale record e può contenere qualsiasi campo e valore possa essere contenuto in un normale record e contenga a sua volta un record di metadati.A metadata record is just a regular record and can contain any fields and values that a regular record can, and itself has a metadata record. L'associazione di un record di metadati a un valore è "non invasiva".Associating a metadata record with a value is "non-intrusive". Non comporta la modifica del comportamento del valore nelle valutazioni, a eccezione di quelle che ispezionano in modo esplicito i record di metadati.It does not change the value's behavior in evaluations except for those that explicitly inspect metadata records.

Ogni valore ha un record di metadati predefinito, anche se non ne è stato specificato uno.Every value has a default metadata record, even if one has not been specified. Il record di metadati predefinito è vuoto.The default metadata record is empty. Gli esempi seguenti illustrano l'accesso al record di metadati di un valore di testo tramite la funzione della libreria standard Value.Metadata:The following examples show accessing the metadata record of a text value using the Value.Metadata standard library function:

Value.Metadata( "Mozart" )   // []

I record di metadati in genere non vengono conservati quando un valore viene usato con un operatore o una funzione che costruisce un nuovo valore.Metadata records are generally not preserved when a value is used with an operator or function that constructs a new value. Ad esempio, se due valori di testo vengono concatenati tramite l'operatore &, i metadati del valore di testo risultante sono un record vuoto [].For example, if two text values are concatenated using the & operator, the metadata of the resulting text value is the empty record []. Le espressioni seguenti sono equivalenti:The following expressions are equivalent:

"Amadeus " & ("Mozart" meta [ Rating = 5 ])  
"Amadeus " & "Mozart"

È possibile usare le funzioni della libreria standard Value.RemoveMetadata e Value.ReplaceMetadata per rimuovere tutti i metadati da un valore e sostituire i metadati di un valore (invece di unire i metadati nei metadati eventualmente esistenti).The standard library functions Value.RemoveMetadata and Value.ReplaceMetadata can be used to remove all metadata from a value and to replace a value's metadata (rather than merge metadata into possibly existing metadata).

Il solo operatore che restituisce risultati contenenti metadati è l'operatore meta.The only operator that returns results that carry metadata is the meta operator.

Operatori ricorsivi a livello strutturaleStructurally recursive operators

I valori possono essere ciclici,Values can be cyclic. ad esempio:For example:

let l = {0, @l} in l
// {0, {0, {0, ... }}}
[A={B}, B={A}]
// [A = {{ ... }}, B = {{ ... }}]

M gestisce i valori ciclici mantenendo la costruzione di record, elenchi e tabelle lazy.M handles cyclic values by keeping construction of records, lists, and tables lazy. Un tentativo di costruire un valore ciclico che non trae vantaggio dai valori strutturati lazy inseriti genera un errore:An attempt to construct a cyclic value that does not benefit from interjected lazy structured values yields an error:

[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"), 
// ]

Alcuni operatori in M sono definiti dalla ricorsione strutturale.Some operators in M are defined by structural recursion. Ad esempio, l'uguaglianza di record ed elenchi è definita dall'uguaglianza congiunta dei campi di record e degli elenchi di elementi corrispondenti, rispettivamente.For instance, equality of records and lists is defined by the conjoined equality of corresponding record fields and item lists, respectively.

Per i valori non ciclici, l'applicazione di una ricorsione strutturale genera un'espansione finita del valore: i valori annidati condivisi verranno attraversati ripetutamente, ma il processo di ricorsione termina sempre.For non-cyclic values, applying structural recursion yields a finite expansion of the value: shared nested values will be traversed repeatedly, but the process of recursion always terminates.

Un valore ciclico ha un'espansione infinita quando si applica una ricorsione strutturale.A cyclic value has an infinite expansion when applying structural recursion. La semantica di M non prevede la presenza di tali espansioni infinite. Il tentativo di confrontare valori ciclici per verificarne l'uguaglianza, ad esempio, in genere esaurirà le risorse e verrà terminato con un'eccezione.The semantics of M makes no special accommodations for such infinite expansions—an attempt to compare cyclic values for equality, for instance, will typically run out of resources and terminate exceptionally.

Operatori di selezione e proiezioneSelection and Projection Operators

Gli operatori di selezione e proiezione consentono di estrarre i dati dai valori di elenco e di record.The selection and projection operators allow data to be extracted from list and record values.

Accesso agli elementiItem Access

Un valore può essere selezionato da un elenco o da una tabella a seconda della posizione in base zero all'interno di tale elenco o tabella usando un'espressione item-access-expression.A value may be selected from a list or table based on its zero-based position within that list or table using an item-access-expression.

item-access-expression:
      item-selection
      optional-item-selection
item-selection:
      primary-expression
{ item-selector }
item-access-expression:
      item-selection
      optional-item-selection
item-selection:
      primary-expression
{ item-selector }

optional-item-selection:
      primary-expression
{ item-selector } ?
optional-item-selection:
      primary-expression
{ item-selector } ?

item-selector:
      expression
item-selector:
      expression

L'espressione item-access-expression x{y} restituisce:The item-access-expression x{y} returns:

  • Per un elenco x e un numero y, l'elemento dell'elenco x nella posizione y.For a list x and a number y, the item of list x at position y. Si presuppone che il primo elemento di un elenco abbia un indice ordinale pari a zero.The first item of a list is considered to have an ordinal index of zero. Se la posizione richiesta non esiste nell'elenco, viene generato un errore.If the requested position does not exist in the list, an error is raised.

  • Per una tabella x e un numero y, la riga della tabella x nella posizione y.For a table x and a number y, the row of table x at position y. Si presuppone che la prima riga di una tabella abbia un indice ordinale pari a zero.The first row of a table is considered to have an ordinal index of zero. Se la posizione richiesta non esiste nella tabella, viene generato un errore.If the requested position does not exist in the table, an error is raised.

  • Per una tabella x e un record y, la riga della tabella x che corrisponde ai valori di campo del record y per i campi con nomi di campo che corrispondono ai relativi nomi delle colonne della tabella.For a table x and a record y, the row of table x that matches the field values of record y for fields with field names that match corresponding table-column names. Se nella tabella non è presente alcuna riga univoca corrispondente, viene generato un errore.If there is no unique matching row in the table, an error is raised.

ad esempio:For example:

{"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

item-access-expression supporta anche la forma x{y}?, che restituisce null quando la posizione (o la corrispondenza) y non esiste nell'elenco o nella tabella x.The item-access-expression also supports the form x{y}?, which returns null when position (or match) y does not exist in list or table x. Se sono presenti più corrispondenze per y, viene comunque generato un errore.If there are multiple matches for y, an error is still raised.

ad esempio:For example:

{"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

L'accesso agli elementi non forza la valutazione di elementi dell'elenco o della tabella diversi da quello a cui si accede,Item access does not force the evaluation of list or table items other than the one being accessed. ad esempio:For example:

{ error "a", 1, error "c"}{1}  // 1 
{ error "a", error "b"}{1}     // error "b"

Quando viene valutato l'operatore di accesso all'elemento x{y}, tenere presente quanto segue:The following holds when the item access operator x{y} is evaluated:

  • Gli errori generati durante la valutazione delle espressioni x o y vengono propagati.Errors raised during the evaluation of expressions x or y are propagated.

  • L'espressione x produce un elenco o un valore di tabella.The expression x produces a list or a table value.

  • L'espressione y produce un valore numerico o, se x produce un valore di tabella, un valore di record.The expression y produces a number value or, if x produces a table value, a record value.

  • Se y produce un valore numerico e il valore di y è negativo, viene generato un errore con il codice motivo "Expression.Error".If y produces a number value and the value of y is negative, an error with reason code "Expression.Error" is raised.

  • Se y produce un valore numerico e il valore di y è maggiore o uguale al conteggio di x, viene generato un errore con il codice motivo "Expression.Error" a meno che non venga usata la forma dell'operatore facoltativo x{y}?, nel qual caso viene restituito il valore null.If y produces a number value and the value of y is greater than or equal to the count of x, an error with reason code "Expression.Error" is raised unless the optional operator form x{y}? is used, in which case the value null is returned.

  • Se x produce un valore di tabella e y produce un valore di record e non sono presenti corrispondenze per y in x, viene generato un errore con il codice motivo "Expression.Error" a meno che non venga usata la forma dell'operatore facoltativo x{y}?, nel qual caso viene restituito il valore null.If x produces a table value and y produces a record value and there are no matches for y in x, an error with reason code "Expression.Error" is raised unless the optional operator form x{y}? is used, in which case the value null is returned.

  • Se x produce un valore di tabella e y produce un valore di record e sono presenti più corrispondenze per y in x, viene generato un errore con il codice motivo "Expression.Error".If x produces a table value and y produces a record value and there are multiple matches for y in x, an error with reason code "Expression.Error" is raised.

Nessun elemento in x diverso da quello nella posizione y viene valutato durante il processo di selezione dell'elemento.No items in x other than that at position y is evaluated during the process of item selection. Per gli elenchi o le tabelle di flusso, gli elementi o le righe che lo precedono nella posizione y vengono ignorati e possono quindi venire valutati, a seconda dell'origine dell'elenco o della tabella.(For streaming lists or tables, the items or rows preceding that at position y are skipped over, which may cause their evaluation, depending on the source of the list or table.)

Accesso ai campiField Access

field-access-expression viene usata per selezionare un valore da un record o per proiettare un record o una tabella in una con meno campi o colonne, rispettivamente.The field-access-expression is used to select a value from a record or to project a record or table to one with fewer fields or columns, respectively.

field-access-expression:
      field-selection
      implicit-target-field-selection
      projection
      implicit-target-projection
field-selection:
      primary-expression field-selector
field-selector:
      required-field-selector
      optional-field-selector
required-field-selector:
field-access-expression:
      field-selection
      implicit-target-field-selection
      projection
      implicit-target-projection
field-selection:
      primary-expression field-selector
field-selector:
      required-field-selector
      optional-field-selector
required-field-selector:

      [ field-name ]      [ field-name ]
optional-field-selector:optional-field-selector:
      [ field-name ] ?      [ field-name ] ?
field-name:
      generalized-identifier
      quoted-identifier
implicit-target-field-selection:
      field-selector
projection:
      primary-expression required-projection
      primary-expression optional-projection
required-projection:
field-name:
      generalized-identifier
      quoted-identifier
implicit-target-field-selection:
      field-selector
projection:
      primary-expression required-projection
      primary-expression optional-projection
required-projection:

      [ required-selector-list ]      [ required-selector-list ]
optional-projection:optional-projection:
      [ required-selector-list ] ?      [ required-selector-list ] ?
required-selector-list:
      required-field-selector
      required-selector-list
, required-field-selector
implicit-target-projection:
      required-projection
      optional-projection
required-selector-list:
      required-field-selector
      required-selector-list
, required-field-selector
implicit-target-projection:
      required-projection
      optional-projection

La forma più semplice di accesso a un campo è la selezione del campo obbligatoria,The simplest form of field access is required field selection. che usa l'operatore x[y] per cercare un campo in un record in base al nome del campo.It uses the operator x[y] to look up a field in a record by field name. Se il campo y non esiste in x, viene generato un errore.If the field y does not exist in x, an error is raised. La forma x[y]? viene usata per eseguire la selezione del campo facoltativa e restituisce null se il campo richiesto non esiste nel record.The form x[y]? is used to perform optional field selection, and returns null if the requested field does not exist in the record.

ad esempio:For example:

[A=1,B=2][B]       // 2 
[A=1,B=2][C]       // error 
[A=1,B=2][C]?      // null

L'accesso collettivo di più campi è supportato dagli operatori per la proiezione del record obbligatoria e la proiezione del record facoltativa.Collective access of multiple fields is supported by the operators for required record projection and optional record projection. L'operatore x[[y1],[y2],...] proietta il record in un nuovo record con meno campi (selezionati da y1, y2, ...).The operator x[[y1],[y2],...] projects the record to a new record with fewer fields (selected by y1, y2, ...). Se un campo selezionato non esiste, viene generato un errore.If a selected field does not exist, an error is raised. L'operatore x[[y1],[y2],...] proietta il record in un nuovo record con i campi selezionati da y1, y2, .... Se un campo non è presente, viene usato null,The operator x[[y1],[y2],...] projects the record to a new record with the fields selected by y1, y2, ...; if a field is missing, null is used instead. ad esempio:For example:

[A=1,B=2][[B]]           // [B=2] 
[A=1,B=2][[C]]           // error 
[A=1,B=2][[B],[C]]?      // [B=2,C=null]

Le forme [y] e [y]? sono supportate come riferimento di sintassi abbreviata all'identificatore _ (carattere di sottolineatura).The forms [y] and [y]? are supported as a shorthand reference to the identifier _ (underscore). Le due espressioni seguenti sono equivalenti:The following two expressions are equivalent:

[A]                 
_[A]

L'esempio seguente illustra la forma abbreviata di accesso ai campi:The following example illustrates the shorthand form of field access:

let _ = [A=1,B=2] in [A] //1

Anche le forme [[y1],[y2],...] e [[y1],[y2],...]? sono supportate come sintassi abbreviata e anche le due espressioni seguenti sono equivalenti:The form [[y1],[y2],...] and [[y1],[y2],...]? are also supported as a shorthand and the following two expressions are likewise equivalent:

[[A],[B]]                 
_[[A],[B]]

La forma abbreviata è particolarmente utile in combinazione con la sintassi abbreviata each, che consente di introdurre una funzione di un singolo parametro denominato _. Per informazioni dettagliate, vedere Dichiarazioni semplificate.The shorthand form is particularly useful in combination with the each shorthand, a way to introduce a function of a single parameter named _ (for details, see Simplified declarations. Insieme, le due sintassi abbreviate semplificano le espressioni funzionali comuni di ordine superiore:Together, the two shorthands simplify common higher-order functional expressions:

List.Select( {[a=1, b=1], [a=2, b=4]}, each [a] = [b]) 
// {[a=1, b=1]}

L'espressione sopra indicata è equivalente alla sintassi estesa seguente più difficile da interpretare:The above expression is equivalent to the following more cryptic looking longhand:

List.Select( {[a=1, b=1], [a=2, b=4]}, (_) => _[a] = _[b]) 
// {[a=1, b=1]}

L'accesso ai campi non forza la valutazione di campi diversi da quelli a cui si accede,Field access does not force the evaluation of fields other than the one(s) being accessed. ad esempio:For example:

[A=error "a", B=1, C=error "c"][B]  // 1 
[A=error "a", B=error "b"][B]       // error "b"

Quando viene valutato l'operatore di accesso a un campo x[y], x[y]?, x[[y]] o x[[y]]?, tenere presente quanto segue:The following holds when a field access operator x[y], x[y]?, x[[y]], or x[[y]]? is evaluated:

  • Gli errori generati durante la valutazione dell'espressione x vengono propagati.Errors raised during the evaluation of expression x are propagated.

  • Gli errori generati durante la valutazione del campo y sono associati in modo permanente al campo y, quindi propagati.Errors raised when evaluating field y are permanently associated with field y, then propagated. Eventuali accessi futuri al campo y genereranno un errore identico.Any future access to field y will raise the identical error.

  • L'espressione x produce un valore di record o tabella oppure viene generato un errore.The expression x produces a record or table value, or an error is raised.

  • Se l'identificatore y denomina un campo che non esiste in x, viene generato un errore con il codice motivo "Expression.Error" a meno che non venga usata la forma dell'operatore facoltativo ...?, nel qual caso viene restituito il valore null.If the identifier y names a field that does not exist in x, an error with reason code "Expression.Error" is raised unless the optional operator form ...? is used, in which case the value null is returned.

Nessun campo di x diverso da quello denominato da y viene valutato durante il processo di accesso al campo.No fields of x other than that named by y is evaluated during the process of field access.

Operatore di metadatiMetadata operator

Il record di metadati per un valore viene modificato usando l'operatore meta (x meta y).The metadata record for a value is amended using the meta operator (x meta y).

metadata-expression:
      unary-expression
      unary-expression
meta unary-expression
metadata-expression:
      unary-expression
      unary-expression
meta unary-expression

L'esempio seguente costruisce un valore di testo con un record di metadati usando l'operatore meta e quindi accede al record di metadati del valore risultante usando Value.Metadata:The following example constructs a text value with a metadata record using the meta operator and then accesses the metadata record of the resulting value using Value.Metadata:

Value.Metadata( "Mozart" meta [ Rating = 5 ] ) 
// [Rating = 5 ]
Value.Metadata( "Mozart" meta [ Rating = 5 ] )[Rating] 
// 5

Quando si applicano i metadati che combinano l'operatore x meta y, tenere presente quanto segue:The following holds when applying the metadata combining operator x meta y:

  • Gli errori generati durante la valutazione delle espressioni x o y vengono propagati.Errors raised when evaluating the x or y expressions are propagated.

  • L'espressione y deve essere un record, altrimenti viene generato un errore con il codice motivo "Expression.Error".The y expression must be a record, or an error with reason code "Expression.Error" is raised.

  • Il record di metadati risultante è il record di metadati di x unito con y.The resulting metadata record is x's metadata record merged with y. Per la semantica del merge di record, vedere Unione di record.(For the semantics of record merge, see Record merge.)

  • Il valore risultante è il valore dell'espressione x, senza i metadati, a cui è collegato il record di metadati appena calcolato.The resulting value is the value from the x expression, without its metadata, with the newly computed metadata record attached.

È possibile usare le funzioni della libreria standard Value.RemoveMetadata e Value.ReplaceMetadata per rimuovere tutti i metadati da un valore e sostituire i metadati di un valore (invece di unire i metadati nei metadati eventualmente esistenti).The standard library functions Value.RemoveMetadata and Value.ReplaceMetadata can be used to remove all metadata from a value and to replace a value's metadata (rather than merge metadata into possibly existing metadata). Le espressioni seguenti sono equivalenti:The following expressions are equivalent:

x meta y  
Value.ReplaceMetadata(x, Value.Metadata(x) & y) 
Value.RemoveMetadata(x) meta (Value.Metadata(x) & y)

Operatori di uguaglianzaEquality operators

L'operatore di uguaglianza = viene usato per determinare se due valori sono uguali.The equality operator = is used to determine if two values are the equal. L'operatore di disuguaglianza <> viene usato per determinare se due valori non sono uguali.The inequality operator <> is used to determine if two values are not equal.

equality-expression:
      relational-expression
      relational-expression
= equality-expression
      relational-expression
<> equality-expression
equality-expression:
      relational-expression
      relational-expression
= equality-expression
      relational-expression
<> equality-expression

ad esempio:For example:

1 = 1            // true 
1 = 2            // false 
1 <> 1           // false 
1 <> 2           // true 
null = true      // false 
null = null      // true

I metadati non fanno parte del confronto di uguaglianza o disuguaglianza,Metadata is not part of equality or inequality comparison. ad esempio:For example:

(1 meta [ a = 1 ]) = (1 meta [ a = 2 ]) // true 
(1 meta [ a = 1 ]) = 1                  // true

Quando si applicano gli operatori di uguaglianza x = y e x <> y, tenere presente quanto segue:The following holds when applying the equality operators x = y and x <> y:

  • Gli errori generati durante la valutazione delle espressioni x o y vengono propagati.Errors raised when evaluating the x or y expressions are propagated.

  • L'operatore = ha come risultato true se i valori sono uguali; in caso contrario, false.The = operator has a result of true if the values are equal, and false otherwise.

  • L'operatore <> ha come risultato false se i valori sono uguali; in caso contrario, true.The <> operator has a result of false if the values are equal, and true otherwise.

  • I record di metadati non sono inclusi nel confronto.Metadata records are not included in the comparison.

  • Se i valori prodotti dalla valutazione delle espressioni x e y non sono dello stesso tipo, i valori non sono uguali.If values produced by evaluating the x and y expressions are not the same kind of value, then the values are not equal.

  • Se i valori prodotti dalla valutazione delle espressioni x e y sono dello stesso tipo, esistono regole specifiche per determinare se sono uguali, come definito di seguito.If the values produced by evaluating the x and y expression are the same kind of value, then there are specific rules for determining if they are equal, as defined below.

  • La condizione seguente è sempre vera:The following is always true:

    (x = y) = not (x <> y)

Gli operatori di uguaglianza sono definiti per i tipi seguenti:The equality operators are defined for the following types:

  • Il valore null è uguale solo a se stesso.The null value is only equal to itself.
    null = null    // true 
    null = true    // false 
    null = false   // false
  • I valori logici true e false sono uguali a se stessi,The logical values true and false are only equal to themselves. ad esempio:For example:
    true = true      // true 
    false = false    // true 
    true = false     // false 
    true = 1         // false
  • I numeri vengono confrontati con la precisione specificata:Numbers are compared using the specified precision:

    • Se uno dei due numeri è #nan, i numeri non sono uguali.If either number is #nan, then the numbers are not the same.

    • Quando nessuno dei due numeri è #nan, i numeri vengono confrontati usando un confronto bit per bit del valore numerico.When neither number is #nan, then the numbers are compared using a bit-wise comparison of the numeric value.

    • #nan è l'unico valore non uguale a se stesso.#nan is the only value that is not equal to itself.

      ad esempio:For example:

        1 = 1,              // true 
        1.0 = 1             // true 
        2 = 1               // false 
        #nan = #nan         // false 
        #nan <> #nan        // true
  • Due durate sono uguali se rappresentano lo stesso numero di cicli da 100 nanosecondi.Two durations are equal if they represent the same number of 100-nanosecond ticks.

  • Due ore sono uguali se gli ordini di grandezza delle parti (ora, minuto, secondo) sono uguali.Two times are equal if the magnitudes of their parts (hour, minute, second) are equal.

  • Due date sono uguali se gli ordini di grandezza delle parti (anno, mese, giorno) sono uguali.Two dates are equal if the magnitudes of their parts (year, month, day) are equal.

  • Due valori di data/ora sono uguali se gli ordini di grandezza delle parti (anno, mese, giorno, ora, minuto, secondo) sono uguali.Two datetimes are equal if the magnitudes of their parts (year, month, day, hour, minute, second) are equal.

  • Due fusi orari sono uguali se i valori di data/ora UTC corrispondenti sono uguali.Two datetimezones are equal if the corresponding UTC datetimes are equal. Per ottenere la data/ora UTC corrispondente, l'offset di ore/minuti viene sottratto dal componente data/ora del fuso orario.To arrive at the corresponding UTC datetime, the hours/minutes offset is subtracted from the datetime component of the datetimezone.

  • Due valori di testo sono uguali se, usando un confronto ordinale, con distinzione tra maiuscole e minuscole e senza distinzione di impostazioni cultura, hanno la stessa lunghezza e caratteri uguali nelle posizioni corrispondenti.Two text values are equal if using an ordinal, case-sensitive, culture-insensitive comparison they have the same length and equal characters at corresponding positions.

  • Due valori di elenco sono uguali se si verificano tutte le condizioni seguenti:Two list values are equal if all of the following are true:

    • Entrambi gli elenchi contengono lo stesso numero di elementi.Both lists contain the same number of items.

    • I valori di ogni elemento corrispondente a livello di posizione negli elenchi sono uguali.The values of each positionally corresponding item in the lists are equal. Ciò significa che non solo gli elenchi devono contenere elementi uguali, ma gli elementi devono anche essere nello stesso ordine.This means that not only do the lists need to contain equal items, the items need to be in the same order.

      ad esempio:For example:

        {1, 2} = {1, 2}     // true 
        {2, 1} = {1, 2}     // false 
        {1, 2, 3} = {1, 2}  // false
  • Due record sono uguali se si verificano tutte le condizioni seguenti:Two records are equal if all of the following are true:

    • Il numero di campi è lo stesso.The number of fields is the same.

    • Ogni nome di campo di un record è presente anche nell'altro record.Each field name of one record is also present in the other record.

    • Il valore di ogni campo di un record è uguale al campo con lo stesso nome nell'altro record.The value of each field of one record is equal to the like-named field in the other record.

      ad esempio:For example:

        [ 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
  • Due tabelle sono uguali se si verificano tutte le condizioni seguenti:Two tables are equal if all of the following are true:

    • Il numero di colonne è lo stesso.The number of columns is the same.

    • Ogni nome di colonna in una tabella è presente anche nell'altra tabella.Each column name in one table is also present in the other table.

    • Il numero di righe è lo stesso.The number of rows is the same.

    • Ogni riga ha valori uguali nelle celle corrispondenti.Each row has equal values in corresponding cells.

      ad esempio:For example:

        #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
  • Un valore di funzione è uguale a se stesso, ma può essere uguale o meno a un altro valore di funzione.A function value is equal to itself, but may or may not be equal to another function value. Se due valori di funzione sono considerati uguali, si comporteranno in modo identico quando vengono richiamati.If two function values are considered equal, then they will behave identically when invoked.

    Due valori di funzione specificati avranno sempre la stessa relazione di uguaglianza.Two given function values will always have the same equality relationship.

  • Un valore di tipo è uguale a se stesso, ma può essere uguale o meno a un altro valore di tipo.A type value is equal to itself, but may or may not be equal to another type value. Se due valori di tipo sono considerati uguali, si comporteranno in modo identico quando ne viene verificata la conformità tramite query.If two type values are considered equal, then they will behave identically when queried for conformance.

    Due valori di tipo specificati avranno sempre la stessa relazione di uguaglianza.Two given type values will always have the same equality relationship.

Operatori relazionaliRelational operators

Gli operatori <, >, <= e >= sono detti operatori relazionali.The <, >, <=, and >= operators are called the relational operators.

relational-expression:
      additive-expression
      additive-expression
< relational-expression
      additive-expression
> relational-expression
      additive-expression
<= _relational-expression
relational-expression:
      additive-expression
      additive-expression
< relational-expression
      additive-expression
> relational-expression
      additive-expression
<= _relational-expression

      additive-expression >= relational-expression      additive-expression >= relational-expression

Questi operatori vengono usati per determinare la relazione di ordinamento relativa tra due valori, come illustrato nella tabella seguente:These operators are used to determine the relative ordering relationship between two values, as shown in the following table:

OperazioneOperation RisultatoResult
x < y true se x è minore di y; in caso contrario, falsetrue if x is less than y, false otherwise
x > y true se x è maggiore di y; in caso contrario, falsetrue if x is greater than y, false otherwise
x <= y true se x è minore o uguale a y; in caso contrario, falsetrue if x is less than or equal to y, false otherwise
x >= y true se x è maggiore o uguale a y; in caso contrario, falsetrue if x is greater than or equal to y, false otherwise

ad esempio:For example:

0 <= 1            // true 
null < 1          // null 
null <= null      // null 
"ab" < "abc"      // true 
#nan >= #nan      // false  
#nan <= #nan      // false

Quando si valuta un'espressione contenente gli operatori relazionali, tenere presente quanto segue:The following holds when evaluating an expression containing the relational operators:

  • Gli errori generati durante la valutazione delle espressioni dell'operando x o y vengono propagati.Errors raised when evaluating the x or y operand expressions are propagated.

  • I valori prodotti dalla valutazione di entrambe le espressioni x e y devono essere un valore di numero, data, data/ora, fuso orario, durata, logico, Null o ora.The values produced by evaluating both the x and y expressions must be a number, date, datetime, datetimezone, duration, logical, null or time value. In caso contrario, viene generato un errore con il codice motivo "Expression.Error".Otherwise, an error with reason code "Expression.Error" is raised.

  • Se uno o entrambi gli operandi sono null, il risultato è il valore null.If either or both operands are null, the result is the null value.

  • Se entrambi gli operandi sono logici, il valore true viene considerato maggiore di false.If both operands are logical, the value true is considered to be greater than false.

  • Se entrambi gli operandi sono durate, i valori vengono confrontati in base al numero totale di cicli da 100 nanosecondi rappresentato.If both operands are durations, then the values are compared according to the total number of 100-nanosecond ticks they represent.

  • Due ore vengono confrontate confrontando le parti delle ore e, se uguali, le parti dei minuti e, se uguali, le parti dei secondi.Two times are compared by comparing their hour parts and, if equal, their minute parts and, if equal, their second parts.

  • Due date vengono confrontate confrontando le parti degli anni e, se uguali, le parti dei mesi e, se uguali, le parti dei giorni.Two dates are compared by comparing their year parts and, if equal, their month parts and, if equal, their day parts.

  • Due valori di data/ora vengono confrontati confrontando le parti degli anni e, se uguali, le parti dei mesi e, se uguali, le parti dei giorni e, se uguali, le parti delle ore e, se uguali, le parti dei minuti e, se uguali, le parti dei secondi.Two datetimes are compared by comparing their year parts and, if equal, their month parts and, if equal, their day parts and, if equal, their hour parts and, if equal, their minute parts and, if equal, their second parts.

  • Due fusi orari vengono confrontati normalizzandoli in UTC sottraendo l'offset di ora/minuto e confrontando quindi i componenti di data/ora.Two datetimezones are compared by normalizing them to UTC by subtracting their hour/minute offset and then comparing their datetime components.

  • Due numeri x e y vengono confrontati in base alle regole dello standard IEEE 754:Two numbers x and y are compared according to the rules of the IEEE 754 standard:

    • Se uno degli operandi è #nan, il risultato è false per tutti gli operatori relazionali.If either operand is #nan, the result is false for all relational operators.

    • Quando nessuno degli operandi è #nan , gli operatori confrontano i valori dei due operandi virgola mobile rispetto all'ordine in -∞ < -max < ... < -min < -0.0 = +0.0 < +min < ... < +max < +∞ cui min e Max sono i valori finiti positivi più piccoli e più grandi che possono essere rappresentati.When neither operand is #nan, the operators compare the values of the two floatingpoint operands with respect to the ordering -∞ < -max < ... < -min < -0.0 = +0.0 < +min < ... < +max < +∞ where min and max are the smallest and largest positive finite values that can be represented. I nomi M per -∞ e +∞ sono -#infinity e #infinity.The M names for -∞ and +∞ are -#infinity and #infinity.

      Gli effetti più importanti di questo ordinamento sono:Notable effects of this ordering are:

      • Gli zeri negativi e positivi sono considerati uguali.Negative and positive zeros are considered equal.

      • Un valore -#infinity è considerato minore di tutti gli altri valori numerici, ma uguale a un altro -#infinity.A -#infinity value is considered less than all other number values, but equal to another -#infinity.

      • Un valore #infinity è considerato maggiore di tutti gli altri valori numerici, ma uguale a un altro #infinity.A #infinity value is considered greater than all other number values, but equal to another #infinity.

Operatori logici condizionaliConditional logical operators

Gli operatori and e or sono detti operatori logici condizionali.The and and or operators are called the conditional logical operators.

logical-or-expression:
      logical-and-expression
      logical-and-expression
or logical-or-expression
logical-and-expression:
      is-expression
      is-expression
and logical-and-expression
logical-or-expression:
      logical-and-expression
      logical-and-expression
or logical-or-expression
logical-and-expression:
      is-expression
      is-expression
and logical-and-expression

L'operatore or restituisce true quando almeno uno degli operandi è true.The or operator returns true when at least one of its operands is true. L'operando di destra viene valutato solo se l'operando di sinistra non è true.The right operand is evaluated if and only if the left operand is not true.

L'operatore and restituisce false quando almeno uno degli operandi è false.The and operator returns false when at least one of its operands is false. L'operando di destra viene valutato solo se l'operando di sinistra non è false.The right operand is evaluated if and only if the left operand is not false.

Le tabelle di veridicità per gli operatori or e and sono illustrate di seguito, con il risultato della valutazione dell'espressione dell'operando di sinistra sull'asse verticale e il risultato della valutazione dell'espressione dell'operando di destra sull'asse orizzontale.Truth tables for the or and and operators are shown below, with the result of evaluating the left operand expression on the vertical axis and the result of evaluating the right operand expression on the horizontal axis.

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

Quando si valuta un'espressione contenente gli operatori logici condizionali, tenere presente quanto segue:The following holds when evaluating an expression containing conditional logical operators:

  • Gli errori generati durante la valutazione delle espressioni x o y vengono propagati.Errors raised when evaluating the x or y expressions are propagated.

  • Gli operatori logici condizionali vengono definiti sui tipi logical e null.The conditional logical operators are defined over the types logical and null. Se i valori degli operandi non sono di tali tipi, viene generato un errore con il codice motivo "Expression.Error".If the operand values are not of those types, an error with reason code "Expression.Error" is raised.

  • Il risultato è un valore logico.The result is a logical value.

  • Nell'espressione x o y l'espressione y verrà valutata solo se x non restituisce true.In the expression x or y, the expression y will be evaluated if and only if x does not evaluate to true.

  • Nell'espressione x e y l'espressione y verrà valutata solo se x non restituisce false.In the expression x and y, the expression y will be evaluated if and only if x does not evaluate to false.

Le ultime due proprietà assegnano agli operatori logici condizionali la qualifica di "condizionale". Le proprietà vengono definite anche di "corto circuito".The last two properties give the conditional logical operators their "conditional" qualification; properties also referred to as "short-circuiting". Queste proprietà sono utili per scrivere predicati controllati compatti.These properties are useful to write compact guarded predicates. Le espressioni seguenti, ad esempio, sono equivalenti:For example, the following expressions are equivalent:

d <> 0 and n/d > 1 if d <> 0 then n/d > 1 else false

Operatori aritmeticiArithmetic Operators

Gli operatori +, -, * e / sono gli operatori aritmetici.The +, -, * and / operators are the arithmetic operators.

additive-expression:
      multiplicative-expression
      additive-expression
+ multiplicative-expression
      additive-expression
- multiplicative-expression
multiplicative-expression:
      metadata- expression
      multiplicative-expression
* metadata-expression
      multiplicative-expression
/ metadata-expression
additive-expression:
      multiplicative-expression
      additive-expression
+ multiplicative-expression
      additive-expression
- multiplicative-expression
multiplicative-expression:
      metadata- expression
      multiplicative-expression
* metadata-expression
      multiplicative-expression
/ metadata-expression

PrecisionPrecision

I numeri in M vengono archiviati usando diverse rappresentazioni per conservare il maggior numero possibile di informazioni sui numeri provenienti da svariate origini.Numbers in M are stored using a variety of representations to retain as much information as possible about numbers coming from a variety of sources. I numeri vengono solo convertiti da una rappresentazione a un'altra in base alle esigenze tramite gli operatori applicati.Numbers are only converted from one representation to another as needed by operators applied to them. Sono supportate due precisioni in M:Two precisions are supported in M:

PrecisionPrecision SemanticaSemantics
Precision.Decimal Rappresentazione decimale a 128 bit con un intervallo compreso tra ±1,0 x 10-28 e ±7,9 x 1028 e 28-29 cifre significative.128-bit decimal representation with a range of ±1.0 x 10-28 to ±7.9 x 1028 and 28-29 significant digits.
Precision.Double Rappresentazione scientifica con mantissa ed esponente, conforme allo standard aritmetico IEEE 754 a precisione doppia a 64 bit IEEE 754-2008.Scientific representation using mantissa and exponent; conforms to the 64-bit binary double-precision IEEE 754 arithmetic standard IEEE 754-2008.

Le operazioni aritmetiche vengono eseguite scegliendo una precisione, convertendo entrambi gli operandi in tale precisione (se necessario), quindi eseguendo l'operazione effettiva e infine restituendo un numero nella precisione scelta.Arithmetic operations are performed by choosing a precision, converting both operands to that precision (if necessary), then performing the actual operation, and finally returning a number in the chosen precision.

Gli operatori aritmetici predefiniti (+, -, *, /) usano la precisione doppia.The built-in arithmetic operators (+, -, *, /) use Double Precision. È possibile usare le funzioni della libreria standard (Value.Add, Value.Subtract, Value.Multiply, Value.Divide) per richiedere queste operazioni usando un modello di precisione specifico.Standard library functions (Value.Add, Value.Subtract, Value.Multiply, Value.Divide) can be used to request these operations using a specific precision model.

  • Nessun overflow numerico è possibile: #infinity o -#infinity rappresentano valori di ordini di grandezza troppo elevati per essere rappresentati.No numeric overflow is possible: #infinity or -#infinity represent values of magnitudes too large to be represented.

  • Nessun underflow numerico è possibile: 0 e -0 rappresentano valori di ordini di grandezza troppo piccoli per essere rappresentati.No numeric underflow is possible: 0 and -0 represent values of magnitudes too small to be represented.

  • Il valore speciale IEEE 754 #nan (non un numero) viene usato per i casi aritmeticamente non validi, ad esempio una divisione di zero per zero.The IEEE 754 special value #nan (NaN—Not a Number) is used to cover arithmetically invalid cases, such as a division of zero by zero.

  • La conversione da precisione decimale a doppia viene eseguita arrotondando i numeri decimali al valore doppio equivalente più vicino.Conversion from Decimal to Double precision is performed by rounding decimal numbers to the nearest equivalent double value.

  • La conversione da precisione doppia a decimale viene eseguita arrotondando i numeri doppi al valore decimale equivalente più vicino e, se necessario, tramite overflow ai valori #infinity o -#infinity.Conversion from Double to Decimal precision is performed by rounding double numbers to the nearest equivalent decimal value and, if necessary, overflowing to #infinity or -#infinity values.

Operatore di addizioneAddition operator

L'interpretazione dell'operatore di addizione (x + y) dipende dal tipo di valore delle espressioni x e y valutate, come indicato di seguito:The interpretation of the addition operator (x + y) is dependent on the kind of value of the evaluated expressions x and y, as follows:

xx yy RisultatoResult InterpretazioneInterpretation
type number type number type number Somma numericaNumeric sum
type number null null
null type number null
type duration type duration type duration Somma numerica degli ordini di grandezzaNumeric sum of magnitudes
type duration null null
null type duration null
type datetimetype datetime type duration type datetimetype datetime Offset di datetime in base alla durataDatetime offset by duration
type duration type datetimetype datetime type datetimetype datetime
type datetimetype datetime null null
null type datetimetype datetime null

Nella tabella type datetime sta per type date, type datetime, type datetimezone o type time.In the table, type datetime stands for any of type date, type datetime, type datetimezone, or type time. Quando si aggiungono una durata e un valore di un tipo datetime, il valore risultante è dello stesso tipo.When adding a duration and a value of some type datetime, the resulting value is of that same type.

Per combinazioni di valori diverse da quelle elencate nella tabella, viene generato un errore con il codice motivo "Expression.Error".For other combinations of values than those listed in the table, an error with reason code "Expression.Error" is raised. Ogni combinazione viene trattata nelle sezioni seguenti.Each combination is covered in the following sections.

Gli errori generati durante la valutazione di uno degli operandi vengono propagati.Errors raised when evaluating either operand are propagated.

Somma numericaNumeric sum

La somma di due numeri viene calcolata usando l'operatore di addizione, che produce un numero.The sum of two numbers is computed using the addition operator, producing a number.

ad esempio:For example:

1 + 1             // 2 
#nan + #infinity  // #nan

L'operatore di addizione + sui numeri usa la precisione doppia. La funzione della libreria standard Value.Add può essere usata per specificare la precisione decimale.The addition operator + over numbers uses Double Precision; the standard library function Value.Add can be used to specify Decimal Precision. Quando si calcola una somma di numeri, tenere presente quanto segue:The following holds when computing a sum of numbers:

  • La somma a precisione doppia viene calcolata in base alle regole aritmetiche IEEE 754 a precisione doppia binarie a 64 bit IEEE 754-2008.The sum in Double Precision is computed according to the rules of 64-bit binary doubleprecision IEEE 754 arithmetic IEEE 754-2008. La tabella seguente elenca i risultati di tutte le possibili combinazioni di valori finiti diversi da zero, zeri, infiniti e non numeri.The following table lists the results of all possible combinations of nonzero finite values, zeros, infinities, and NaN's. Nella tabella x e y sono valori finiti diversi da zero e z è il risultato di x + y.In the table, x and y are nonzero finite values, and z is the result of x + y. Se x e y hanno lo stesso ordine di grandezza ma segni opposti, z è zero positivo.If x and y have the same magnitude but opposite signs, z is positive zero. Se x + y è troppo grande per essere rappresentato nel tipo di destinazione, z è un valore infinito con lo stesso segno di x + y.If x + y is too large to be represented in the destination type, z is an infinity with the same sign as x + y.

    + yy +0+0 -0-0 +∞+∞ -∞-∞ NaNNaN
    xx zz xx xx +∞+∞ -∞-∞ NaNNaN
    +0+0 yy +0+0 +0+0 +∞+∞ -∞-∞ NaNNaN
    -0-0 yy +0+0 -0-0 +∞+∞ -∞-∞ NaNNaN
    +∞+∞ +∞+∞ +∞+∞ +∞+∞ +∞+∞ NaNNaN NaNNaN
    -∞-∞ -∞-∞ -∞-∞ -∞-∞ NaNNaN -∞-∞ NaNNaN
    NaNNaN NaNNaN NaNNaN NaNNaN NaNNaN NaNNaN NaNNaN
  • La somma a precisione decimale viene calcolata senza perdere la precisione.The sum in Decimal Precision is computed without losing precision. La scala del risultato è la più grande tra le scale dei due operandi.The scale of the result is the larger of the scales of the two operands.

Somma delle durateSum of durations

La somma di due durate è la durata che rappresenta la somma del numero di cicli da 100 nanosecondi rappresentati dalle durate,The sum of two durations is the duration representing the sum of the number of 100nanosecond ticks represented by the durations. ad esempio:For example:

#duration(2,1,0,15.1) + #duration(0,1,30,45.3) 
// #duration(2, 2, 31, 0.4)

Offset di datetime in base alla durataDatetime offset by duration

Un valore datetime x e una durata y possono essere sommati usando x + y per calcolare un nuovo valore datetime la cui distanza da x su una sequenza temporale lineare è esattamente l'ordine di grandezza di y.A datetime x and a duration y may be added using x + y to compute a new datetime whose distance from x on a linear timeline is exactly the magnitude of y. In questo caso datetime sta per Date, DateTime, DateTimeZone o Time e un risultato non Null sarà dello stesso tipo.Here, datetime stands for any of Date, DateTime, DateTimeZone, or Time and a non-null result will be of the same type. L'offset di datetime in base alla durata può essere calcolato come segue:The datetime offset by duration may be computed as follows:

  • Se vengono specificati i giorni di datetime a partire dal valore di periodo, costruire un nuovo valore datetime con le informazioni seguenti:If the datetime's days since epoch value is specified, construct a new datetime with the following information elements:

    • Calcolare un nuovo valore "giorni dal periodo" equivalente alla divisione della grandezza di y per il numero di cicli da 100 nanosecondi in un periodo di 24 ore, troncando la parte decimale del risultato e aggiungendo questo valore ai giorni di x dal periodo.Calculate a new days since epoch equivalent to dividing the magnitude of y by the number of 100-nanosecond ticks in a 24-hour period, truncating the decimal portion of the result, and adding this value to the x's days since epoch.

    • Calcolare un nuovo valore "cicli da mezzanotte" equivalente all'aggiunta della grandezza di y ai cicli di x da mezzanotte, eseguendo il modulo del numero di cicli da 100 nanosecondi in un periodo di 24 ore.Calculate a new ticks since midnight equivalent to adding the magnitude of y to the x's ticks since midnight, modulo the number of 100-nanosecond ticks in a 24-hour period. Se x non specifica un valore per i cicli dalla mezzanotte, si presume un valore pari a 0.If x does not specify a value for ticks since midnight, a value of 0 is assumed.

    • Copiare il valore di x per l'offset dei minuti dall'ora UTC non modificata.Copy x's value for minutes offset from UTC unchanged.

  • Se non vengono specificati i giorni di datetime a partire dal valore di periodo, costruire un nuovo valore datetime con le informazioni seguenti specificate:If the datetime's days since epoch value is unspecified, construct a new datetime with the following information elements specified:

    • Calcolare un nuovo valore "cicli da mezzanotte" equivalente all'aggiunta della grandezza di y ai cicli di x da mezzanotte, eseguendo il modulo del numero di cicli da 100 nanosecondi in un periodo di 24 ore.Calculate a new ticks since midnight equivalent to adding the magnitude of y to the x's ticks since midnight, modulo the number of 100-nanosecond ticks in a 24-hour period. Se x non specifica un valore per i cicli dalla mezzanotte, si presume un valore pari a 0.If x does not specify a value for ticks since midnight, a value of 0 is assumed.

    • Copiare i valori di x per i giorni dal periodo e l'offset dei minuti dall'ora UTC non modificata.Copy x's values for days since epoch and minutes offset from UTC unchanged.

Gli esempi seguenti illustrano il calcolo della somma temporale assoluta quando datetime specifica i giorni dal periodo:The following examples show calculating the absolute temporal sum when the datetime specifies the days since epoch:

#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

L'esempio seguente illustra il calcolo dell'offset di datetime in base alla durata per un determinato periodo di tempo:The following example shows calculating the datetime offset by duration for a given time:

#time(8,0,0) + #duration(30,5,0,0) 
   //#time(13, 0, 0) 
   //13:00:00

Operatore di sottrazioneSubtraction operator

L'interpretazione dell'operatore di sottrazione (x - y) dipende dal tipo del valore delle espressioni x e y valutate, come indicato di seguito:The interpretation of the subtraction operator (x - y) is dependent on the kind of the value of the evaluated expressions x and y, as follows:

xx YY RisultatoResult InterpretazioneInterpretation
type number type number type number Differenza numericaNumeric difference
type number null null
null type number null
type duration type duration type duration Differenza numerica degli ordini di grandezzeNumeric difference of magnitudes
type duration null null
null type duration null
type datetimetype datetime type datetimetype datetime type duration Durata tra valori datetimeDuration between datetimes
type datetimetype datetime type duration type datetimetype datetime Offset di datetime in base alla durata negataDatetime offset by negated duration
type datetimetype datetime null null
null type datetimetype datetime null

Nella tabella type datetime sta per type date, type datetime, type datetimezone o type time.In the table, type datetime stands for any of type date, type datetime, type datetimezone, or type time. Quando si sottrae una durata da un valore di un tipo datetime, il valore risultante è dello stesso tipo.When subtracting a duration from a value of some type datetime, the resulting value is of that same type.

Per combinazioni di valori diverse da quelle elencate nella tabella, viene generato un errore con il codice motivo "Expression.Error".For other combinations of values than those listed in the table, an error with reason code "Expression.Error" is raised. Ogni combinazione viene trattata nelle sezioni seguenti.Each combination is covered in the following sections.

Gli errori generati durante la valutazione di uno degli operandi vengono propagati.Errors raised when evaluating either operand are propagated.

Differenza numericaNumeric difference

La differenza tra due numeri viene calcolata usando l'operatore di sottrazione, che produce un numero.The difference between two numbers is computed using the subtraction operator, producing a number. ad esempio:For example:

1 - 1                // 0 
#nan - #infinity     // #nan

L'operatore di sottrazione - sui numeri usa la precisione doppia. La funzione della libreria standard Value.Subtract può essere usata per specificare la precisione decimale.The subtraction operator - over numbers uses Double Precision; the standard library function Value.Subtract can be used to specify Decimal Precision. Quando si calcola una differenza tra numeri, tenere presente quanto segue:The following holds when computing a difference of numbers:

  • La differenza a precisione doppia viene calcolata in base alle regole aritmetiche IEEE 754 a precisione doppia binarie a 64 bit IEEE 754-2008.The difference in Double Precision is computed according to the rules of 64-bit binary double-precision IEEE 754 arithmetic IEEE 754-2008. La tabella seguente elenca i risultati di tutte le possibili combinazioni di valori finiti diversi da zero, zeri, infiniti e non numeri.The following table lists the results of all possible combinations of nonzero finite values, zeros, infinities, and NaN's. Nella tabella x e y sono valori finiti diversi da zero e z è il risultato di x - y.In the table, x and y are nonzero finite values, and z is the result of x - y. Se x e y sono uguali, z è zero positivo.If x and y are equal, z is positive zero. Se x - y è troppo grande per essere rappresentato nel tipo di destinazione, z è un valore infinito con lo stesso segno di x - y.If x - y is too large to be represented in the destination type, z is an infinity with the same sign as x - y.

    - yy +0+0 -0-0 +∞+∞ -∞-∞ NaNNaN
    xx zz xx xx -∞-∞ +∞+∞ NaNNaN
    +0+0 -y-y +0+0 +0+0 -∞-∞ +∞+∞ NaNNaN
    -0-0 -y-y -0-0 +0+0 -∞-∞ +∞+∞ NaNNaN
    +∞+∞ +∞+∞ +∞+∞ +∞+∞ NaNNaN +∞+∞ NaNNaN
    -∞-∞ -∞-∞ -∞-∞ -∞-∞ -∞-∞ NaNNaN NaNNaN
    NaNNaN NaNNaN NaNNaN NaNNaN NaNNaN NaNNaN NaNNaN
  • La differenza a precisione decimale viene calcolata senza perdere la precisione.The difference in Decimal Precision is computed without losing precision. La scala del risultato è la più grande tra le scale dei due operandi.The scale of the result is the larger of the scales of the two operands.

Differenza tra le durateDifference of durations

La differenza di due durate è la durata che rappresenta la differenza tra il numero di cicli da 100 nanosecondi rappresentati da ogni durata,The difference of two durations is the duration representing the difference between the number of 100-nanosecond ticks represented by each duration. ad esempio:For example:

#duration(1,2,30,0) - #duration(0,0,0,30.45) 
// #duration(1, 2, 29, 29.55)

Offset di datetime in base alla durata negataDatetime offset by negated duration

Un valore datetime x e una durata y possono essere sottratti usando x - y per calcolare un nuovo valore datetime.A datetime x and a duration y may be subtracted using x - y to compute a new datetime. In questo caso datetime sta per date, datetime, datetimezone o time.Here, datetime stands for any of date, datetime, datetimezone, or time. Il valore datetime risultante ha una distanza da x su una sequenza temporale lineare che corrisponde esattamente alla grandezza di y, nella direzione opposta al segno di y.The resulting datetime has a distance from x on a linear timeline that is exactly the magnitude of y, in the direction opposite the sign of y. La sottrazione di durate positive produce risultati che tornano indietro nel tempo relativamente a x, mentre la sottrazione di valori negativi produce risultati che vanno avanti nel tempo.Subtracting positive durations yields results that are backwards in time relative to x, while subtracting negative values yields results that are forwards in time.

#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

Durata tra due valori datetimeDuration between two datetimes

È possibile sottrarre due valori datetime t e u usando t - u per calcolare la durata tra di essi.Two datetimes t and u may be subtracted using t - u to compute the duration between them. In questo caso datetime sta per date, datetime, datetimezone o time.Here, datetime stands for any of date, datetime, datetimezone, or time. La durata ottenuta sottraendo u da t deve restituire t se aggiunta a u.The duration produced by subtracting u from t must yield t when added to 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

La sottrazione t - u quando u > t restituisce una durata negativa:Subtracting t - u when u > t results in a negative duration:

#time(01,30,00) - #time(08,00,00) 
// #duration(0, -6, -30, 0)

Quando si sottraggono due valori datetime usando t - u, tenere presente quanto segue:The following holds when subtracting two datetimes using t - u:

  • u + (t - u) = tu + (t - u) = t

Operatore di moltiplicazioneMultiplication operator

L'interpretazione dell'operatore di moltiplicazione (x * y) dipende dal tipo di valore delle espressioni x e y valutate, come indicato di seguito:The interpretation of the multiplication operator (x * y) is dependent on the kind of value of the evaluated expressions x and y, as follows:

XX YY RisultatoResult InterpretazioneInterpretation
type number type number type number Prodotto numericoNumeric product
type number null null
null type number null
type duration type number type duration Multiplo della durataMultiple of duration
type number type duration type duration Multiplo della durataMultiple of duration
type duration null null
null type duration null

Per combinazioni di valori diverse da quelle elencate nella tabella, viene generato un errore con il codice motivo "Expression.Error".For other combinations of values than those listed in the table, an error with reason code "Expression.Error" is raised. Ogni combinazione viene trattata nelle sezioni seguenti.Each combination is covered in the following sections.

Gli errori generati durante la valutazione di uno degli operandi vengono propagati.Errors raised when evaluating either operand are propagated.

Prodotto numericoNumeric product

Il prodotto di due numeri viene calcolato usando l'operatore di moltiplicazione, che produce un numero.The product of two numbers is computed using the multiplication operator, producing a number. ad esempio:For example:

2 * 4                // 8 
6 * null             // null 
#nan * #infinity     // #nan

L'operatore di moltiplicazione * sui numeri usa la precisione doppia. La funzione della libreria standard Value.Multiply può essere usata per specificare la precisione decimale.The multiplication operator * over numbers uses Double Precision; the standard library function Value.Multiply can be used to specify Decimal Precision. Quando si calcola un prodotto di numeri, tenere presente quanto segue:The following holds when computing a product of numbers:

  • Il prodotto a precisione doppia viene calcolato in base alle regole aritmetiche IEEE 754 a precisione doppia binarie a 64 bit IEEE 754-2008.The product in Double Precision is computed according to the rules of 64-bit binary double-precision IEEE 754 arithmetic IEEE 754-2008. La tabella seguente elenca i risultati di tutte le possibili combinazioni di valori finiti diversi da zero, zeri, infiniti e non numeri.The following table lists the results of all possible combinations of nonzero finite values, zeros, infinities, and NaN's. Nella tabella x e y sono valori finiti positivi.In the table, x and y are positive finite values. z è il risultato di x * y.z is the result of x * y. Se il risultato è troppo grande per il tipo di destinazione, z è infinito.If the result is too large for the destination type, z is infinity. Se il risultato è troppo piccolo per il tipo di destinazione, z è pari a zero.If the result is too small for the destination type, z is zero.

    * +y+y -y-y +0+0 -0-0 +∞+∞ -∞-∞ NaNNaN
    +x+x +z+z -Z-z +0+0 -0-0 +∞+∞ -∞-∞ NaNNaN
    -x-x -Z-z +z+z -0-0 +0+0 -∞-∞ +∞+∞ NaNNaN
    +0+0 +0+0 -0-0 +0+0 -0-0 NaNNaN NaNNaN NaNNaN
    -0-0 -0-0 +0+0 -0-0 +0+0 NaNNaN NaNNaN NaNNaN
    +∞+∞ +∞+∞ -∞-∞ NaNNaN NaNNaN +∞+∞ -∞-∞ NaNNaN
    -∞-∞ -∞-∞ +∞+∞ NaNNaN NaNNaN -∞-∞ +∞+∞ NaNNaN
    NaNNaN NaNNaN NaNNaN NaNNaN NaNNaN NaNNaN NaNNaN NaNNaN
  • Il prodotto a precisione decimale viene calcolato senza perdere la precisione.The product in Decimal Precision is computed without losing precision. La scala del risultato è la più grande tra le scale dei due operandi.The scale of the result is the larger of the scales of the two operands.

Multipli di durateMultiples of durations

Il prodotto di una durata e di un numero è uguale alla durata che rappresenta il numero di cicli da 100 nanosecondi rappresentati dall'operando della durata moltiplicato per l'operando del numero,The product of a duration and a number is the duration representing the number of 100nanosecond ticks represented by the duration operand times the number operand. ad esempio:For example:

#duration(2,1,0,15.1) * 2 
// #duration(4, 2, 0, 30.2)

Operatore di divisioneDivision operator

L'interpretazione dell'operatore di divisione (x / y) dipende dal tipo di valore delle espressioni x e y valutate, come indicato di seguito:The interpretation of the division operator (x / y) is dependent on the kind of value of the evaluated expressions x and y, as follows:

XX YY RisultatoResult InterpretazioneInterpretation
type number type number type number Quoziente numericoNumeric quotient
type number null null
null type number null
type duration type number type duration Frazione di durataFraction of duration
type duration type duration type duration Quoziente numerico delle durateNumeric quotient of durations
type duration null null
null type duration null

Per combinazioni di valori diverse da quelle elencate nella tabella, viene generato un errore con il codice motivo "Expression.Error".For other combinations of values than those listed in the table, an error with reason code "Expression.Error" is raised. Ogni combinazione viene trattata nelle sezioni seguenti.Each combination is covered in the following sections.

Gli errori generati durante la valutazione di uno degli operandi vengono propagati.Errors raised when evaluating either operand are propagated.

Quoziente numericoNumeric quotient

Il quoziente di due numeri viene calcolato usando l'operatore di divisione, che produce un numero,The quotient of two numbers is computed using the division operator, producing a number. ad esempio:For example:

8 / 2               // 4 
8 / 0               // #infinity 
0 / 0               // #nan 
0 / null            // null 
#nan / #infinity    // #nan

L'operatore di divisione / sui numeri usa la precisione doppia. La funzione della libreria standard Value.Divide può essere usata per specificare la precisione decimale.The division operator / over numbers uses Double Precision; the standard library function Value.Divide can be used to specify Decimal Precision. Quando si calcola un quoziente di numeri, tenere presente quanto segue:The following holds when computing a quotient of numbers:

  • Il quoziente a precisione doppia viene calcolato in base alle regole aritmetiche IEEE 754 a precisione doppia binarie a 64 bit IEEE 754-2008.The quotient in Double Precision is computed according to the rules of 64-bit binary double-precision IEEE 754 arithmetic IEEE 754-2008. La tabella seguente elenca i risultati di tutte le possibili combinazioni di valori finiti diversi da zero, zeri, infiniti e non numeri.The following table lists the results of all possible combinations of nonzero finite values, zeros, infinities, and NaN's. Nella tabella x e y sono valori finiti positivi.In the table, x and y are positive finite values. z è il risultato di x / y.z is the result of x / y. Se il risultato è troppo grande per il tipo di destinazione, z è infinito.If the result is too large for the destination type, z is infinity. Se il risultato è troppo piccolo per il tipo di destinazione, z è pari a zero.If the result is too small for the destination type, z is zero.

    / +y+y -y-y +0+0 -0-0 +∞+∞ -∞-∞ NaNNaN
    +x+x +z+z -Z-z +∞+∞ -∞-∞ +0+0 -0-0 NaNNaN
    -x-x -Z-z +z+z -∞-∞ +∞+∞ -0-0 +0+0 NaNNaN
    +0+0 +0+0 -0-0 NaNNaN NaNNaN +0+0 -0-0 NaNNaN
    -0-0 -0-0 +0+0 NaNNaN NaNNaN -0-0 +0+0 NaNNaN
    +∞+∞ +∞+∞ -∞-∞ +∞+∞ -∞-∞ NaNNaN NaNNaN NaNNaN
    -∞-∞ -∞-∞ +∞+∞ -∞-∞ +∞+∞ NaNNaN NaNNaN NaNNaN
    NaNNaN NaNNaN NaNNaN NaNNaN NaNNaN NaNNaN NaNNaN NaNNaN
  • La somma a precisione decimale viene calcolata senza perdere la precisione.The sum in Decimal Precision is computed without losing precision. La scala del risultato è la più grande tra le scale dei due operandi.The scale of the result is the larger of the scales of the two operands.

Quoziente di durateQuotient of durations

Il quoziente di due durate è il numero che rappresenta il quoziente del numero di cicli da 100 nanosecondi rappresentati dalle durate,The quotient of two durations is the number representing the quotient of the number of 100nanosecond ticks represented by the durations. ad esempio:For example:

#duration(2,0,0,0) / #duration(0,1,30,0) 
// 32

Durate ridimensionateScaled durations

Il quoziente di una durata x e di un numero y è uguale alla durata che rappresenta il quoziente del numero di cicli da 100 nanosecondi rappresentati dalla durata x e dal numero y,The quotient of a duration x and a number y is the duration representing the quotient of the number of 100-nanosecond ticks represented by the duration x and the number y. ad esempio:For example:

#duration(2,0,0,0) / 32 
// #duration(0,1,30,0)

Combinazione di struttureStructure Combination

L'operatore di combinazione (x & y) viene definito nei tipi di valori seguenti:The combination operator (x & y) is defined over the following kinds of values:

XX YY RisultatoResult InterpretazioneInterpretation
type text type text type text ConcatenazioneConcatenation
type text null null
null type text null
type date type time type datetime UnioneMerge
type date null null
null type time null
type list type list type list ConcatenazioneConcatenation
type record type record type record UnioneMerge
type table type table type table ConcatenazioneConcatenation

ConcatenazioneConcatenation

Due valori di testo, due valori di elenco o due valori di tabelle possono essere concatenati usando x & y.Two text, two list, or two table values can be concatenated using x & y.

L'esempio seguente illustra la concatenazione di valori di testo:The following example illustrates concatenating text values:

"AB" & "CDE"     // "ABCDE"

L'esempio seguente illustra la concatenazione di elenchi:The following example illustrates concatenating lists:

{1, 2} & {3}     // {1, 2, 3}

Quando si concatenano due valori usando x & y, tenere presente quanto segue:The following holds when concatenating two values using x & y:

  • Gli errori generati durante la valutazione delle espressioni x o y vengono propagati.Errors raised when evaluating the x or y expressions are propagated.

  • Se un elemento di x o y contiene un errore, non viene propagato alcun errore.No error is propagated if an item of either x or y contains an error.

  • Il risultato della concatenazione di due valori di testo è un valore di testo che contiene il valore di x seguito immediatamente da y.The result of concatenating two text values is a text value that contains the value of x immediately followed by y. Se uno degli operandi è Null e l'altro è un valore di testo, il risultato è Null.If either of the operands is null and the other is a text value, the result is null.

  • Il risultato della concatenazione di due elenchi è un elenco che contiene tutti gli elementi di x seguiti da tutti gli elementi di y.The result of concatenating two lists is a list that contains all the items of x followed by all the items of y.

  • Il risultato della concatenazione di due tabelle è una tabella che contiene l'unione delle colonne delle due tabelle dell'operando.The result of concatenating two tables is a table that has the union of the two operand table's columns. L'ordinamento delle colonne di x viene mantenuto, seguito dalle colonne visualizzate solo in y, che mantengono il proprio ordinamento relativo.The column ordering of x is preserved, followed by the columns only appearing in y, preserving their relative ordering. Per le colonne visualizzate solo in uno degli operandi, viene usato null per inserire i valori delle celle per l'altro operando.For columns appearing only in one of the operands, null is used to fill in cell values for the other operand.

UnioneMerge

Unione di recordRecord merge

È possibile unire due record usando x & y, che produce un record che include i campi sia di x che di y.Two records can be merged using x & y, producing a record that includes fields from both x and y.

Gli esempi seguenti illustrano l'unione di record:The following examples illustrate merging records:

[ x = 1 ] & [ y = 2 ]                // [ x = 1, y = 2 ] 
[ x = 1, y = 2 ] & [ x = 3, z = 4 ]  // [ x = 3, y = 2, z = 4 ]

Quando si uniscono due record usando x + y, tenere presente quanto segue:The following holds when merging two records using x + y:

  • Gli errori generati durante la valutazione delle espressioni x o y vengono propagati.Errors raised when evaluating the x or y expressions are propagated.

  • Se un campo viene visualizzato sia in x che in y, viene usato il valore di y.If a field appears in both x and y, the value from y is used.

  • L'ordine dei campi nel record risultante è quello di x, seguiti dai campi di y che non fanno parte di x, nello stesso ordine in cui vengono visualizzati in y.The order of the fields in the resulting record is that of x, followed by fields in y that are not part of x, in the same order that they appear in y.

  • L'unione di record non comporta la valutazione dei valori.Merging records does not cause evaluation of the values.

  • Non vengono generati errori perché un campo contiene un errore.No error is raised because a field contains an error.

  • Il risultato è un record.The result is a record.

Unione di data e oraDate-time merge

Una data x può essere unita a un'ora y usando x & y, che produce un valore datetime che combina le parti sia di x che di y.A date x can be merged with a time y using x & y, producing a datetime that combines the parts from both x and y.

L'esempio seguente illustra l'unione di una data e di un'ora:The following example illustrates merging a date and a time:

#date(2013,02,26) & #time(09,17,00) 
// #datetime(2013,02,26,09,17,00)

Quando si uniscono due record usando x + y, tenere presente quanto segue:The following holds when merging two records using x + y:

  • Gli errori generati durante la valutazione delle espressioni x o y vengono propagati.Errors raised when evaluating the x or y expressions are propagated.

  • Il risultato è un valore datetime.The result is a datetime.

Operatori unariUnary operators

Gli operatori +, - e not sono operatori unari.The +, -, and not operators are unary operators.

unary-expression:
      type-expression
unary-expression:
      type-expression

      + unary expression      + unary expression
      - unary expression      - unary expression
      not unary expression      not unary expression

Operatore unario piùUnary plus operator

L'operatore unario più (+x) viene definito per i tipi di valori seguenti:The unary plus operator (+x) is defined for the following kinds of values:

XX RisultatoResult InterpretazioneInterpretation
type number type number Più unarioUnary plus
type duration type duration Più unarioUnary plus
null `null`null

Per gli altri valori, viene generato un errore con il codice motivo "Expression.Error".For other values, an error with reason code "Expression.Error" is raised.

L'operatore unario più consente di applicare un segno + a un numero, a un valore datetime o a un valore Null.The unary plus operator allows a + sign to be applied to a number, datetime, or null value. Il risultato è quello stesso valore,The result is that same value. ad esempio:For example:

+ - 1                 // -1 
+ + 1                 // 1 
+ #nan                // #nan 
+ #duration(0,1,30,0) // #duration(0,1,30,0)

Quando si valuta l'operatore unario più +x, tenere presente quanto segue:The following holds when evaluating the unary plus operator +x:

  • Gli errori generati durante la valutazione di x vengono propagati.Errors raised when evaluating x are propagated.

  • Se il risultato della valutazione di x non è un valore numerico, viene generato un errore con il codice motivo "Expression.Error".If the result of evaluating x is not a number value, then an error with reason code "Expression.Error" is raised.

Operatore unario menoUnary minus operator

L'operatore unario meno (-x) viene definito per i tipi di valori seguenti:The unary minus operator (-x) is defined for the following kinds of values:

XX RisultatoResult InterpretazioneInterpretation
type number type number NegazioneNegation
type duration type duration NegazioneNegation
null null

Per gli altri valori, viene generato un errore con il codice motivo "Expression.Error".For other values, an error with reason code "Expression.Error" is raised.

L'operatore unario meno viene usato per cambiare il segno di un numero o di una durata,The unary minus operator is used to change the sign of a number or duration. ad esempio:For example:

- (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)

Quando si valuta l'operatore unario meno -x, tenere presente quanto segue:The following holds when evaluating the unary minus operator -x:

  • Gli errori generati durante la valutazione di x vengono propagati.Errors raised when evaluating x are propagated.

  • Se l'espressione è un numero, il risultato è il valore numerico dell'espressione x con il segno cambiato.If the expression is a number, then the result is the number value from expression x with its sign changed. Se il valore non è un numero, neanche il risultato è un numero.If the value is NaN, then the result is also NaN.

Operatore di negazione logicaLogical negation operator

L'operatore di negazione logica (not) viene definito per i tipi di valori seguenti:The logical negation operator (not) is defined for the following kinds of values:

XX RisultatoResult InterpretazioneInterpretation
type logical type logical NegazioneNegation
null null

Questo operatore calcola l'operazione not logica su un valore logico specificato,This operator computes the logical not operation on a given logical value. ad esempio:For example:

not true             // false 
not false            // true 
not (true and true)  // false

Quando si valuta l'operatore di negazione logica not x, tenere presente quanto segue:The following holds when evaluating the logical negation operator not x:

  • Gli errori generati durante la valutazione di x vengono propagati.Errors raised when evaluating x are propagated.

  • Il valore prodotto dalla valutazione dell'espressione x deve essere un valore logico oppure deve essere generato un errore con il codice motivo "Expression.Error".The value produced from evaluating expression x must be a logical value, or an error with reason code "Expression.Error" must be raised. Se il valore è true, il risultato è false.If the value is true, the result is false. Se l'operando è false, il risultato è true.If the operand is false, the result is true.

Il risultato è un valore logico.The result is a logical value.

Operatori di tipoType operators

Gli operatori is e as sono noti come operatori di tipo.The operators is and as are known as the type operators.

Operatore di compatibilità del tipoType compatibility operator

L'operatore di compatibilità del tipo x is y è definito per i tipi di valori seguenti:The type compatibility operator x is y is defined for the following types of values:

XX YY RisultatoResult
type any nullable-primitive-typenullable-primitive-type type logical

L'espressione x is y restituisce true se il tipo ascritto di x è compatibile con y e restituisce false se il tipo ascritto di x non è compatibile con y.The expression x is y returns true if the ascribed type of x is compatible with y, and returns false if the ascribed type of x is incompatible with y. y deve essere un tipo nullable-primitivetype.y must be a nullable-primitivetype.

is-expression:
      as-expression
      is-expression
is nullable-primitive-type
nullable-primitive-type:
is-expression:
      as-expression
      is-expression
is nullable-primitive-type
nullable-primitive-type:

      nullableopt primitive-type      nullableopt primitive-type

La compatibilità del tipo, supportata dall'operatore is, è un subset della compatibilità del tipo generale e viene definita usando le regole seguenti:Type compatibility, as supported by the is operator, is a subset of general type compatibility and is defined using the following rules:

  • Se x è Null, è compatibile se y è un tipo nullable o il tipo any.If x is null then it is compatible iff y is a nullable type or the type any.

  • Se x è diverso da Null, è compatibile se il tipo primitivo di x è lo stesso di y.If x is non-null then if it is a compatible if the the primitive type of x is the same as y.

Quando si valuta l'espressione x is y, tenere presente quanto segue:The following holds when evaluating the expression x is y:

  • Un errore generato durante la valutazione dell'espressione x viene propagato.An error raised when evaluating expression x is propagated.

Operatore di asserzione del tipoType assertion operator

L'operatore di asserzione del tipo x as y è definito per i tipi di valori seguenti:The type assertion operator x as y is defined for the following types of values:

XX YY RisultatoResult
type any nullable-primitive-typenullable-primitive-type type any

L'espressione x as y asserisce che il valore x è compatibile con y in base all'operatore is.The expression x as y asserts that the value x is compatible with y as per the is operator. Se non è compatibile, viene generato un errore.If it is not compatible, an error is raised. y deve essere un tipo nullable-primitive-type.y must be a nullable-primitive-type.

as-expression:
      equality-expression
      as-expression
as nullable-primitive-type
as-expression:
      equality-expression
      as-expression
as nullable-primitive-type

L'espressione x as y viene valutata nel modo seguente:The expression x as y is evaluated as follows:

  • Viene eseguita una verifica della compatibilità del tipo x is y e l'asserzione restituisce x non modificato se il test ha esito positivo.A type compatibility check x is y is performed and the assertion returns x unchanged if that test succeeds.

  • Se la verifica della compatibilità ha esito negativo, viene generato un errore con il codice motivo "Expression.Error".If the compatibility check fails, an error with reason code "Expression.Error" is raised.

Esempi:Examples:

1 as number               // 1 
"A" as number             // error 
null as nullable number   // null

Quando si valuta l'espressione x as y, tenere presente quanto segue:The following holds when evaluating the expression x as y:

  • Un errore generato durante la valutazione dell'espressione x viene propagato.An error raised when evaluating expression x is propagated.