Aritmetiska operatorer

Det här avsnittet beskriver aritmetiska operatorer som är tillgängliga i F#.

Sammanfattning av binära aritmetiska operatorer

Aritmetiska operationer i F# kan utföras i två lägen: Omarkerad och Kontrollerad. Som standard använder aritmetiska åtgärder omarkerat beteende, vilket prioriterar prestanda men tillåter spill/underflöde. Kontrollerade operatörer prioriterar säkerheten genom att utlösa undantag i sådana fall.

Okontrollerade aritmetiska operatorer

I följande tabell sammanfattas de binära aritmetiska operatorer som är tillgängliga för omarkerad aritmetik med oinslagna heltals- och flyttalstyper.

Binär operator	Anteckningar
+ (tillägg, plus)	Okontrollerat. Möjligt spillvillkor när tal läggs ihop och summan överskrider det högsta absoluta värde som stöds av typen.
- (subtraktion, minus)	Okontrollerat. Möjliga underflödesvillkor när osignerade typer subtraheras, eller när flyttalsvärdena är för små för att representeras av typen.
* (multiplikation, gånger)	Okontrollerat. Möjligt spillvillkor när tal multipliceras och produkten överskrider det högsta absoluta värde som stöds av typen.
/ (division, dividerat med)	Division med noll orsakar en DivideByZeroException för integraltyper. För flyttalstyper ger division med noll de särskilda flyttalsvärdena infinity eller -infinity. Det finns också ett möjligt underflödesvillkor när ett flyttalsnummer är för litet för att representeras av typen .
% (rest, rem)	Returnerar resten av en divisionsåtgärd. Resultatets tecken är samma som tecknet för den första operanden.
** (exponentiering, upphöjt till)	Möjligt spillvillkor när resultatet överskrider det maximala absoluta värdet för typen. Exponentiationsoperatorn fungerar endast med flyttalstyper.

Det okontrollerade beteendet utlöser inte undantag när översvämning eller underflöde inträffar, vilket gör det mindre säkert vid aritmetiska operationer med stora värden eller värden vid gränsfall.

Kontrollerade aritmetiska operatorer

I följande tabell sammanfattas tillgängliga binära aritmetiska operatorer för kontrollerad aritmetik med oboxade integraltyper. Kontrollerade operatorer ser till att beräkningar verifieras för överflöde eller underflöde, vilket ger säkrare aritmetik för kritiska tillämpningar.

Binär operator	Anteckningar
+ (tillägg, plus)	Genererar en OverflowException om resultatet överskrider det maximala värdet eller går under det minsta värde som stöds av typen. Både Overflow och Underflow är möjliga.
- (subtraktion, minus)	Genererar en OverflowException om resultatet överskrider det maximala värdet eller går under det minsta värde som stöds av typen. Både Overflow och Underflow är möjliga.
* (multiplikation, gånger)	Genererar en OverflowException om produkten överskrider det maximala värdet eller går under det minsta värde som stöds av typen. Både Overflow och Underflow är möjliga.

De kontrollerade operatorerna är användbara för att säkerställa att aritmetiska överflöden fångas upp och hanteras tydligt.

Här är ett exempel:

open Microsoft.FSharp.Core.Operators.Checked

let safeAddition () =
    try
        let result = 2147483647 + 1 // Attempt to add integers at their maximum boundary
        printfn "Result: %d" result
    with
    | :? System.OverflowException as ex ->
        printfn "Overflow occurred: %s" ex.Message

safeAddition()

// Output:
// Overflow occurred: Arithmetic operation resulted in an overflow.

Välja mellan markerade och avmarkerade operatorer

Kontrollerade operatorer: Perfekt för scenarier där överflödesfel måste identifieras och hanteras tydligt.

Omarkerade operatorer: Som standard använder F# omarkerad aritmetik av prestandaskäl. Dessa åtgärder kan ge felaktiga resultat när spill eller underflöde uppstår. Använd med försiktighet.

Sammanfattning av unära aritmetiska operatorer

I följande tabell sammanfattas de oarliga aritmetiska operatorer som är tillgängliga för integral- och flyttalstyper.

Unär operator	Anteckningar
+ (positivt)	Kan tillämpas på alla aritmetiska uttryck. Ändrar inte värdets tecken.
- (negation, negativ)	Kan tillämpas på alla aritmetiska uttryck. Ändrar värdets tecken.

Beteendet vid överskridande eller underskridande för integraltyper är att cirkulera. Detta orsakar ett felaktigt resultat. Heltalsspill är ett potentiellt allvarligt problem som kan bidra till säkerhetsproblem när programvara inte skrivs för att ta hänsyn till det. Om det här är ett problem för ditt program bör du överväga att använda de kontrollerade operatorerna i Microsoft.FSharp.Core.Operators.Checked.

Sammanfattning av binära jämförelseoperatorer

I följande tabell visas de binära jämförelseoperatorer som är tillgängliga för integral- och flyttalstyper. Dessa operatorer returnerar värden av typen bool.

Flyttalsnummer bör aldrig jämföras direkt för likhet, eftersom IEEE-flyttalsrepresentationen inte stöder en exakt likhetsåtgärd. Två tal som du enkelt kan verifiera vara lika genom att inspektera koden kan faktiskt ha olika bitrepresentationer.

Operatör	Anteckningar
= (likhet, lika med)	Det här är inte en tilldelningsoperator. Det används endast för jämförelse. Det här är en generisk operator.
> (större än)	Det här är en allmän operator.
< (mindre än)	Det här är en allmän operator.
>= (större än eller lika med)	Detta är en allmän operator.
<= (mindre än eller lika med)	Det här är en allmän operator.
<> (inte lika med)	Det här är en allmän operator.

Överlagrade och generiska operatorer

Alla operatorer som beskrivs i det här avsnittet definieras i Microsoft.FSharp.Core.Operators namnrymd. Vissa av operatorerna definieras med statiskt lösta typparametrar. Det innebär att det finns enskilda definitioner för varje specifik typ som fungerar med operatorn. Alla unära och binära aritmetiska och bitvisa operatorer finns i den här kategorin. Jämförelseoperatorerna är generiska och fungerar därför med alla typer, inte bara primitiva aritmetiska typer. Diskriminerade unions- och posttyper har egna anpassade implementeringar som genereras av F#-kompilatorn. Klasstyper använder metoden Equals.

De generiska operatorerna är anpassningsbara. För att anpassa jämförelsefunktionerna, åsidosätt Equals för att ge en egen anpassad likhetsjämförelse och implementera sedan IComparable. System.IComparable-gränssnittet har en enda metod, CompareTo-metoden.

Operatorer och typinferens

Användningen av en operator i ett uttryck begränsar typinferens för operatorn. Dessutom förhindrar användningen av operatorer automatisk generalisering, eftersom användningen av operatorer innebär en aritmetiktyp. I avsaknad av annan information härleder F#-kompilatorn int som typ av aritmetiska uttryck. Du kan åsidosätta det här beteendet genom att ange en annan typ. Argumenttyperna och returtypen för function1 i följande kod härleds därför till int, men typerna för function2 härleds till float.

// x, y and return value inferred to be int
// function1: int -> int -> int
let function1 x y = x + y

// x, y and return value inferred to be float
// function2: float -> float -> float
let function2 (x: float) y = x + y

Se även

• Symbol- och operatorreferens
• Operatoröverlagring
• Bitwise-operatorer
• booleska operatorer