Riferimenti per simboli e operatori (F#)

In questo argomento è inclusa una tabella di simboli e operatori utilizzati nel linguaggio F#.

Tabella di simboli e operatori

Nella tabella seguente vengono descritti i simboli utilizzati nel linguaggio F#, vengono forniti collegamenti ad argomenti in cui sono disponibili ulteriori informazioni e viene fornita una breve descrizione di alcuni modi in cui è possibile utilizzare il simbolo.I simboli sono ordinati 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 utilizzato in F#.Utilizzare <> per operazioni di disuguaglianza.
"	Valori letterali (F#) Stringhe (F#)	Delimita una stringa di testo.
"""	Stringhe (F#)	Delimita una stringa di testo parola per parola.Differisce da @"..." in quanto è possibile indicare il carattere virgoletta utilizzando una virgoletta singola nella stringa.
#	Direttive per il compilatore (F#) Tipi flessibili (F#)	Antepone un prefisso a una direttiva del preprocessore o del compilatore, ad esempio #light. In caso di utilizzo con un tipo, indica un tipo flessibile, che si riferisce a un tipo o a uno dei suoi tipi derivati.
$	Non sono disponibili ulteriori informazioni.	Utilizzato internamente per determinati nomi di variabili e funzioni generati dal compilatore.
%	Operatori aritmetici (F#) Citazioni di codice (F#)	Calcola il modulo Integer.Utilizzato per unire citazioni.
%?	Operatori nullable (F#)	Calcola il modulo integer, quando a destra c'è un tipo che ammette valori null.
&	Espressioni match (F#)	Calcola l'indirizzo di un valore modificabile, da utilizzare quando si interagisce con altri linguaggi. Utilizzato 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 un solo carattere. Indica un parametro di tipo generico.
``...``	Non sono disponibili ulteriori informazioni.	Delimita un identificatore che in caso contrario 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 con cui vengono valutate le espressioni. Delimita una tupla. Utilizzato nelle definizioni degli operatori.
(*...*)		Delimita un commento che potrebbe estendersi su più righe.
(|...|)	Modelli attivi (F#)	Delimita un modello attivo.Detto anche banana clip.
*	Operatori aritmetici (F#) Tuple (F#) Unità di misura (F#)	In caso di utilizzo come operatore binario, moltiplica il lato sinistro per quello destro. Nei tipi, indica l'associazione in una tupla. Utilizzato nei tipi di unità di misura.
*?	Operatori nullable (F#)	Moltiplica i lati sinistro e destro, quando la parte destra è un tipo che ammette valori null.
**	Operatori aritmetici (F#)	Calcola l'operazione di elevamento a potenza (x ** y indica x alla potenza di y).
+	Operatori aritmetici (F#)	In caso di utilizzo come operatore binario, somma il lato sinistro con quello destro. In caso di utilizzo come un operatore unario, indica una quantità positiva.Formalmente, produce lo stesso valore con il segno non modificato.
+?	Operatori nullable (F#)	Aggiunge i lati sinistro e destro, quando la destra c'è un tipo che ammette valori null.
,	Tuple (F#)	Separa gli elementi di una tupla o i parametri del tipo.
-	Operatori aritmetici (F#)	In caso di utilizzo come operatore binario, sottrae il lato destro da quello sinistro. In caso di utilizzo come un operatore unario, esegue un'operazione di negazione.
-	Operatori nullable (F#)	Sottrae la destra a sinistra, quando a destra c'è un tipo che ammette valori null.
->	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. Utilizzato nelle espressioni di ricerca.
.	Membri (F#) Tipi primitivi (F#)	Accede a un membro e separa i singoli nomi in un nome completo. Specifica un separatore decimale nei numeri a virgola mobile.
..	Cicli: espressioni for...in (F#)	Specifica un intervallo.
.. ..	Cicli: espressioni for...in (F#)	Specifica un intervallo insieme a un incremento.
.[...]	Matrici (F#)	Accede a un elemento della matrice.
/	Operatori aritmetici (F#) Unità di misura (F#)	Divide il lato sinistro (numeratore) per il lato destro (denominatore). Utilizzato nei tipi di unità di misura.
/?	Operatori nullable (F#)	Divide la parte sinistra a destra, quando la destra c'è un tipo che ammette valori null.
//		Indica l'inizio di un commento su una sola riga.
///	Documentazione XML (F#)	Indica un commento XML.
:	Funzioni (F#)	In un'annotazione del tipo, separa il nome di un parametro o di un membro dal relativo tipo.
::	Elenchi (F#) Espressioni match (F#)	Crea un elenco.L'elemento a sinistra viene aggiunto all'elenco a destra. Utilizzato nella corrispondenza dei 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 altro tipo più in alto nella gerarchia.
:?	Espressioni match (F#)	Restituisce true se il valore corrisponde al tipo specificato; in caso contrario, restituisce false (operatore di test del tipo).
:?>	Cast e conversioni (F#)	Converte un tipo in un altro tipo più in basso nella gerarchia.
;	Sintassi dettagliata (F#) Elenchi (F#) Record (F#)	Separa le espressioni (utilizzato 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 il minore di un'operazione, quando a destra c'è un tipo che ammette valori null.
<<	Funzioni (F#)	Compone due funzioni in ordine inverso. La seconda viene eseguita per prima (operatore di composizione inverso).
<<<	Operatori bit per bit (F#)	Sposta verso sinistra i bit della quantità sul lato sinistro, del numero di bit specificato sul lato destro.
<-	Valori (F#)	Consente di assegnare un valore a una variabile.
<...>	Generalizzazione automatica (F#)	Delimita i parametri di tipo.
<>	Operatori aritmetici (F#)	Restituisce true se il lato sinistro è diverso da quello destro; in caso contrario, restituisce false.
<>?	Operatori nullable (F#)	Calcola l'operazione "non uguale" quando a destra c'è un tipo che ammette valori null.
<=	Operatori aritmetici (F#)	Restituisce true se il lato sinistro è minore o uguale a quello destro; in caso contrario, restituisce false.
<=?	Operatori nullable (F#)	Calcola "minore o uguale a" l'operazione quando a destra c'è un tipo che ammette valori null.
<|	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 da destra alla funzione a sinistra.
<|||	Funzione Operators.( <||| )<'T1,'T2,'T3,'U> (F#)	Passa la tupla di tre argomenti da destra alla funzione a sinistra.
<@...@>	Citazioni di codice (F#)	Delimita una quotation di codice tipizzato.
<@@...@@>	Citazioni di codice (F#)	Delimita una quotation 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" quando a destra c'è un tipo che ammette valori null.
==	Non applicabile.	Non utilizzato in F#.Utilizzare = per operazioni di uguaglianza.
>	Operatori aritmetici (F#)	Restituisce true se il lato sinistro è maggiore di quello destro; in caso contrario, restituisce false.
>?	Operatori nullable (F#)	Calcola il "più grande di" l'operazione quando a destra c'è un tipo che ammette valori null.
>>	Funzioni (F#)	Compone due funzioni (operatore di composizione diretto).
>>>	Operatori bit per bit (F#)	Sposta verso destra i bit della quantità sul lato sinistro, del numero di posizioni specificato sul lato destro.
>=	Operatori aritmetici (F#)	Restituisce true se il lato destro è maggiore o uguale a quello sinistro; in caso contrario, restituisce false.
>=?	Operatori nullable (F#)	Calcola "maggiore o uguale a" quando a destra c'è un tipo che ammette valori null.
?	Parametri e argomenti (F#)	Specifica un argomento facoltativo. Utilizzato come operatore per le chiamate di metodi dinamici e proprietà.È necessario fornire un'implementazione personalizzata.
? ... <- ...	Non sono disponibili ulteriori informazioni.	Utilizzato come operatore per l'impostazione delle proprietà dinamiche.È necessario fornire un'implementazione personalizzata.
?>=, ?>, ?<=, ?<, ?=, ?<>, ?+, ?-, ?*, ?/	Operatori nullable (F#)	Equivalente agli operatori corrispondenti senza?prefisso, in cui un tipo nullable è a sinistra.
>=?, >?, <=?, <?, =?, <>?, +?, -?, *?, /?	Operatori nullable (F#)	Equivalente agli operatori corrispondenti senza?suffisso, in cui un tipo nullable viene visualizzato a destra.
?>=?, ?>?, ?<=?, ?<?, ?=?, ?<>?, ?+?, ?-?, ?*?, ?/?	Operatori nullable (F#)	Equivalente agli operatori corrispondenti senza i punti interrogativi circostanti, in cui i lati sono tipi nullable.
@	Elenchi (F#) Stringhe (F#)	Concatena due elenchi. Quando viene posizionato prima di un valore letterale stringa, 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#)	Utilizza caratteri di escape per il carattere successivo. Utilizzato nei valori letterali stringa e carattere.
^	Parametri di tipo risolti staticamente (F#) Stringhe (F#)	Specifica i parametri del 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 OR esclusiva bit per bit.
_	Espressioni match (F#) Generics (F#)	Indica un modello carattere jolly. Specifica un parametro generico anonimo.
`	Generalizzazione automatica (F#)	Utilizzato internamente per indicare un parametro di tipo generico.
{...}	Sequenze (F#) Record (F#)	Delimita le espressioni di sequenza e le espressioni di calcolo. Utilizzato 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 dell'espressione sul lato sinistro alla funzione sul lato destro (operatore pipe diretto).
||>	Funzione Operators.( ||> )<'T1,'T2,'U> (F#)	Passa la tupla di due argomenti a sinistra della funzione a destra.
|||>	Funzione Operators.( |||> )<'T1,'T2,'T3,'U> (F#)	Passa la tupla di tre argomenti a sinistra della funzione a destra.
~~	Overload degli operatori (F#)	Utilizzato 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#)	Utilizzato per dichiarare un overload per l'operatore meno (-) unario.
~+	Overload degli operatori (F#)	Utilizzato per dichiarare un overload per l'operatore più (+) unario.

Precedenza tra gli operatori

Nella tabella seguente è illustrato l'ordine di precedenza di operatori e altre parole chiave delle espressioni nel linguaggio F#. Gli elementi sono elencati in ordine crescente di precedenza.Viene indicato anche il tipo di associazione, se applicabile.

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

F# supporta l'overload degli operatori personalizzato.È pertanto possibile definire operatori personalizzati.Nella tabella precedente op può corrispondere a qualsiasi sequenza valida (eventualmente anche vuota) di caratteri di operatore, di tipo incorporato o definito dall'utente.È pertanto possibile utilizzare questa tabella per determinare la sequenza di caratteri da utilizzare per un operatore personalizzato in modo da ottenere il livello di precedenza desiderato.I caratteri . iniziali vengono ignorati nel caso in cui il compilatore determini la precedenza.

Vedere anche

Riferimenti

Overload degli operatori (F#)

Altre risorse

Riferimenti per il linguaggio F#