Riferimenti per simboli e operatori (F#)

Questo argomento include una tabella di simboli e operatori usati nel linguaggio F#.

Tabella di simboli e operatori

Nella tabella seguente sono descritti i simboli usati nel linguaggio F#, vengono forniti collegamenti ad argomenti che contengono altre informazioni e una breve descrizione di alcuni degli usi del simbolo. I simboli sono elencati in base all'ordinamento del set di caratteri ASCII.

Simbolo o operatore	Collegamenti	Descrizione
!	Celle di riferimento (F#) Espressioni di calcolo (F#)	Dereferenzia una cella di riferimento. Dopo una parola chiave indica una versione modificata del comportamento della parola chiave, controllato da un flusso di lavoro.
!=	Non applicabile.	Non usato in F#. Usare <> per le operazioni di disuguaglianza.
"	Valori letterali (F#) Stringhe (F#)	Delimita una stringa di testo.
"""	Stringhe (F#)	Delimita una stringa di testo letterale. È diverso da @"..." in quanto si può indicare un carattere di virgolette usando una virgoletta singola nella stringa.
#	Direttive per il compilatore (F#) Tipi flessibili (F#)	Prefisso di una direttiva del preprocessore o del compilatore, ad esempio #light. Se usato con un tipo, indica un tipo flessibile, che fa riferimento a un tipo o a uno dei relativi tipi derivati.
$	Non sono disponibili altre informazioni.	Usato internamente per determinati nomi di variabile e funzione generati dal compilatore.
%	Operatori aritmetici (F#) Citazioni di codice (F#)	Calcola il modulo integer. Usato per lo splicing delle espressioni in citazioni di codice tipizzato.
%%	Citazioni di codice (F#)	Usato per lo splicing delle espressioni in citazioni di codice non tipizzato.
%?	Operatori nullable (F#)	Calcola il modulo di integer, quando la parte destra è un tipo nullable.
&	Espressioni match (F#)	Calcola l'indirizzo di un valore modificabile, da usare quando si interagisce con altri linguaggi. Usato nei modelli AND.
&&	Operatori booleani (F#)	Calcola l'operazione AND booleana.
&&&	Operatori bit per bit (F#)	Calcola l'operazione AND bit per bit.
'	Valori letterali (F#) Generalizzazione automatica (F#)	Delimita un valore letterale a carattere singolo. Indica un parametro di tipo generico.
``...``	Non sono disponibili altre informazioni.	Delimita un identificatore che altrimenti non sarebbe un identificatore valido, ad esempio una parola chiave del linguaggio.
( )	Tipo di unità (F#)	Rappresenta il singolo valore del tipo di unità.
(...)	Tuple (F#) Overload degli operatori (F#)	Indica l'ordine in cui le espressioni vengono valutate. Delimita una tupla. Usato nelle definizioni degli operatori.
(*...*)		Delimita un commento che potrebbe estendersi su più righe.
(|...|)	Modelli attivi (F#)	Delimita un criterio attivo. Chiamato anche banana clip.
*	Operatori aritmetici (F#) Tuple (F#) Unità di misura (F#)	Quando viene usato come operatore binario, moltiplica i lati sinistro e destro. Nei tipi, indica l'associazione in una tupla. Usato in unità di tipi di misura.
*?	Operatori nullable (F#)	Moltiplica il lato sinistro e destro, quando il lato destro è un tipo nullable.
**	Operatori aritmetici (F#)	Calcola l'operazione di elevamento a potenza (x * * y indica x alla potenza di y).
+	Operatori aritmetici (F#)	Quando usato come operatore binario, aggiunge i lati sinistro e destro. Quando usato come operatore unario, indica una quantità positiva (formalmente, produce lo stesso valore con segno non modificato.)
+?	Operatori nullable (F#)	Addiziona il lato sinistro e destro, quando il lato destro è un tipo nullable.
,	Tuple (F#)	Separa gli elementi di una tupla o parametri di tipo.
-	Operatori aritmetici (F#)	Quando usato come operatore binario, sottrae il lato destro dal lato sinistro. Quando usato come operatore unario, esegue un'operazione di negazione.
-	Operatori nullable (F#)	Sottrae il lato destro dal lato sinistro, quando la parte destra è un tipo nullable.
->	Funzioni (F#) Espressioni match (F#)	Nei tipi di funzione, delimita argomenti e valori restituiti. Produce un'espressione (nelle espressioni di sequenza); equivalente alla parola chiave yield. Usato nelle espressioni match
.	Membri (F#) Tipi primitivi (F#)	Accede a un membro e separa i singoli nomi in un nome completo. Consente di specificare un separatore decimale nei numeri a virgola mobile.
..	Cicli: espressioni for...in (F#)	Specifica un intervallo.
.. ..	Cicli: espressioni for...in (F#)	Specifica un intervallo con un incremento.
.[...]	Matrici (F#)	Accede a un elemento di matrice.
/	Operatori aritmetici (F#) Unità di misura (F#)	Divide il lato sinistro (numeratore) per il lato destro (denominatore). Usato in unità di tipi di misura.
/?	Operatori nullable (F#)	Divide il lato sinistro dal lato destro, quando il lato destro è un tipo nullable.
//		Indica l'inizio di un commento a riga singola.
///	Documentazione XML (F#)	Indica un commento XML.
:	Funzioni (F#)	In un'annotazione di tipo, separa un nome di parametro o membro dal relativo tipo.
::	Elenchi (F#) Espressioni match (F#)	Crea un elenco. L'elemento sul lato sinistro viene aggiunto all'elenco sul lato destro. Usato nella corrispondenza tra modelli per separare le parti di un elenco.
:=	Celle di riferimento (F#)	Assegna un valore a una cella di riferimento.
:>	Cast e conversioni (F#)	Converte un tipo in un tipo di livello superiore nella gerarchia.
:?	Espressioni match (F#)	Restituisce true se il valore corrisponde al tipo specificato. In caso contrario, restituisce false (operatore di prova di tipo).
:?>	Cast e conversioni (F#)	Converte un tipo in un tipo di livello inferiore nella gerarchia.
;	Sintassi dettagliata (F#) Elenchi (F#) Record (F#)	Separa le espressioni (usate soprattutto nella sintassi dettagliata). Separa gli elementi di un elenco. Separa i campi di un record.
<	Operatori aritmetici (F#)	Calcola l'operazione "minore di".
<?	Operatori nullable (F#)	Calcola l'operazione "minore di", quando la parte destra è un tipo nullable.
<<	Funzioni (F#)	Compone due funzioni in ordine inverso. La seconda viene eseguita per prima (operatore di composizione inverso).
<<<	Operatori bit per bit (F#)	Sposta a sinistra i bit nella quantità sul lato sinistro indicata dal numero di bit specificato sul lato destro.
<-	Valori (F#)	Assegna un valore a una variabile.
<...>	Generalizzazione automatica (F#)	Delimita i parametri di tipo.
<>	Operatori aritmetici (F#)	Restituisce true se il lato sinistro non è uguale a quello destro; in caso contrario, restituisce false.
<>?	Operatori nullable (F#)	Calcola l'operazione "diverso da" quando la parte destra è un tipo nullable.
<=	Operatori aritmetici (F#)	Restituisce true se il lato sinistro è minore o diverso da quello destro; in caso contrario, restituisce false.
<=?	Operatori nullable (F#)	Calcola l'operazione "minore o uguale a" quando la parte destra è un tipo nullable.
<|	Funzioni (F#)	Passa il risultato dell'espressione sul lato destro alla funzione sul lato sinistro (operatore pipe inverso).
<||	Funzione Operators.( <|| )<'T1,'T2,'U> (F#)	Passa la tupla di due argomenti sul lato destro alla funzione sul lato sinistro.
<|||	Funzione Operators.( <||| )<'T1,'T2,'T3,'U> (F#)	Passa la tupla di tre argomenti sul lato destro alla funzione sul lato sinistro.
<@...@>	Citazioni di codice (F#)	Delimita una citazione di codice tipizzato.
<@@...@@>	Citazioni di codice (F#)	Delimita una citazione di codice non tipizzato.
=	Operatori aritmetici (F#)	Restituisce true se il lato sinistro è uguale a quello destro; in caso contrario, restituisce false.
=?	Operatori nullable (F#)	Calcola l'operazione "uguale a" quando la parte destra è un tipo nullable.
==	Non applicabile.	Non usato in F#. Usa = per le operazioni di uguaglianza.
>	Operatori aritmetici (F#)	Restituisce true se il lato sinistro non è maggiore di quello destro; in caso contrario, restituisce false.
>?	Operatori nullable (F#)	Calcola l'operazione "maggiore di", quando la parte destra è un tipo nullable.
>>	Funzioni (F#)	Compone due funzioni (operatore di composizione diretto).
>>>	Operatori bit per bit (F#)	Sposta a destra i bit nella quantità sul lato sinistro indicata dal numero di posizioni specificato sul lato destro.
>=	Operatori aritmetici (F#)	Restituisce true se il lato destro è maggiore o uguale a quello destro; in caso contrario, restituisce false.
>=?	Operatori nullable (F#)	Calcola l'operazione "maggiore o uguale a" quando la parte destra è un tipo nullable.
?	Parametri e argomenti (F#)	Specifica un argomento facoltativo. Usato come operatore per le chiamate di metodo e proprietà dinamiche. È necessario fornire un'implementazione personalizzata.
? ... <- ...	Non sono disponibili altre informazioni.	Usato come operatore per l'impostazione delle proprietà dinamiche. È necessario fornire un'implementazione personalizzata.
?>=, ?>, ?<=, ?<, ?=, ?<>, ?+, ?-, ?*, ?/	Operatori nullable (F#)	Equivalente per i corrispondenti operatori senza il prefisso ?, per cui un tipo nullable è a sinistra.
>=?, >?, <=?, <?, =?, <>?, +?, -?, *?, /?	Operatori nullable (F#)	Equivalente per i corrispondenti operatori senza il suffisso ?, per cui un tipo nullable è a destra.
?>=?, ?>?, ?<=?, ?<?, ?=?, ?<>?, ?+?, ?-?, ?*?, ?/?	Operatori nullable (F#)	Equivalente per i corrispondenti operatori non racchiusi da punti interrogativi, dove entrambi i lati sono tipi nullable.
@	Elenchi (F#) Stringhe (F#)	Concatena due elenchi. Quando si trova prima di una stringa letterale, indica che la stringa deve essere interpretata alla lettera, senza interpretazione dei caratteri di escape.
[...]	Elenchi (F#)	Delimita gli elementi di un elenco.
[|...|]	Matrici (F#)	Delimita gli elementi di una matrice.
[<...>]	Attributi (F#)	Delimita un attributo.
\	Stringhe (F#)	Effettua l'escape del carattere successivo. Usato nei valori letterali di stringa e carattere.
^	Parametri di tipo risolti staticamente (F#) Stringhe (F#)	Specifica i parametri di tipo che devono essere risolti in fase di compilazione, non in fase di esecuzione. Concatena le stringhe.
^^^	Operatori bit per bit (F#)	Calcola l'operazione di OR esclusivo bit per bit.
_	Espressioni match (F#) Generics (F#)	Indica un modello di carattere jolly. Specifica un parametro generico anonimo.
`	Generalizzazione automatica (F#)	Usato internamente per indicare un parametro di tipo generico.
{...}	Sequenze (F#) Record (F#)	Delimita le espressioni di sequenza e le espressioni di calcolo. Usato nelle definizioni dei record.
|	Espressioni match (F#)	Delimita singoli case di corrispondenza, singoli case di unione discriminata e valori di enumerazione.
||	Operatori booleani (F#)	Calcola l'operazione OR booleana.
|||	Operatori bit per bit (F#)	Calcola l'operazione OR bit per bit.
|>	Funzioni (F#)	Passa il risultato del lato sinistro alla funzione sul lato destro (operatore pipe diretto).
||>	Funzione Operators.( ||> )<'T1,'T2,'U> (F#)	Passa la tupla di due argomenti sul lato sinistro alla funzione sul lato destro.
|||>	Funzione Operators.( |||> )<'T1,'T2,'T3,'U> (F#)	Passa la tupla di tre argomenti sul lato sinistro alla funzione sul lato destro.
~~	Overload degli operatori (F#)	Usato per dichiarare un overload per l'operatore di negazione unario.
~~~	Operatori bit per bit (F#)	Calcola l'operazione NOT bit per bit.
~-	Overload degli operatori (F#)	Usato per dichiarare un overload per l'operatore meno unario.
~+	Overload degli operatori (F#)	Usato per dichiarare un overload per l'operatore più unario.

Precedenza tra gli operatori

Nella tabella seguente viene illustrato l'ordine di precedenza degli operatori e altre parole chiave di espressioni nel linguaggio F#, in ordine dalla precedenza più bassa alla precedenza più elevata. È anche elencata l'associatività, se applicabile.

Operatore	Associazione
as	A destra
when	A destra
| (pipe)	A sinistra
;	A destra
let	Non associativo
function, fun, match, try	Non associativo
if	Non associativo
->	A destra
:=	A destra
,	Non associativo
or, ||	A sinistra
&, &&	A sinistra
<op, >op, =, |op, &op	A sinistra
&&&, |||, ^^^, ~~~, <<<, >>>	A sinistra
^op	A destra
::	A destra
:?>, :?	Non associativo
-op, +op, (binario)	A sinistra
*op, /op, %op	A sinistra
**op	A destra
f x (applicazione di funzione)	A sinistra
| (criteri di ricerca)	A destra
operatori prefisso (+op, -op, %, %%, &, &&, !op, ~op)	A sinistra
.	A sinistra
f(x)	A sinistra
f<types>	A sinistra

F# supporta l'overload degli operatori personalizzati. Ciò significa che è possibile definire operatori personalizzati. Nella tabella precedente, op può essere qualsiasi sequenza valida (eventualmente vuota) di caratteri dell'operatore, incorporata o definita dall'utente. In questo modo, è possibile usare questa tabella per determinare la sequenza di caratteri da usare in modo che un operatore personalizzato raggiunga il livello di priorità desiderato. I caratteri . iniziali vengono ignorati quando il compilatore determina la precedenza.

Vedere anche

Riferimenti

Overload degli operatori (F#)

Altre risorse

Riferimenti per il linguaggio F#