F#-språkreferens

  • Artikel

Det här avsnittet är en referens för F#, ett programmeringsspråk med flera paradigm som riktar sig till .NET. F# stöder funktionella, objektorienterade och imperativa programmeringsmodeller.

Organisera F#-kod

I följande tabell visas referensartiklar som rör organisering av din F#-kod.

Rubrik Beskrivning
Namnrymder Läs mer om stöd för namnområden i F#. Med ett namnområde kan du ordna kod i områden med relaterade funktioner genom att göra det möjligt att koppla ett namn till en gruppering av programelement.
Moduler Lär dig mer om moduler. En F#-modul är som ett namnområde och kan även innehålla värden och funktioner. Genom att gruppera kod i moduler kan du hålla ihop relaterad kod och undvika namnkonflikter i ditt program.
open Deklarationer Lär dig mer om hur open fungerar. En open deklaration anger en modul, ett namnområde eller en typ vars element du kan referera till utan att använda ett fullständigt kvalificerat namn.
Signaturer Lär dig mer om signaturer och signaturfiler. En signaturfil innehåller information om offentliga signaturer för en uppsättning F#-programelement, till exempel typer, namnrymder och moduler. Den kan användas för att ange tillgängligheten för dessa programelement.
Access Control Läs mer om åtkomstkontroll i F#. Åtkomstkontroll innebär att deklarera vilka klienter som kan använda vissa programelement, till exempel typer, metoder, funktioner och så vidare.
XML-dokumentation Lär dig mer om stöd för att generera dokumentationsfiler från XML-dokumentkommentarer, även kallade trippelsnedstreckskommentar. Du kan skapa dokumentation från kodkommentaren i F# som på andra .NET-språk.

Literaler och strängar

I följande tabell visas referensartiklar som beskriver literaler och strängar i F#.

Rubrik Beskrivning
Literaler Lär dig mer om syntaxen för literalvärden i F# och hur du anger typinformation för F#-literaler.
Strängar Läs mer om strängar i F#. Typen string representerar oföränderlig text som en sekvens med Unicode-tecken. string är ett alias för System.String i .NET.
Interpolerade strängar Lär dig mer om interpolerade strängar, en särskild form av sträng som gör att du kan bädda in F#-uttryck direkt i dem.

Värden och funktioner

I följande tabell visas referensartiklar som beskriver språkbegrepp relaterade till värden, let-bindningar och funktioner.

Rubrik Beskrivning
Värden Lär dig mer om värden, som är oföränderliga kvantiteter som har en viss typ; värden kan vara heltal eller flyttalsnummer, tecken eller text, listor, sekvenser, matriser, tupplar, diskriminerade unioner, poster, klasstyper eller funktionsvärden.
Funktioner Funktioner är den grundläggande enheten för programkörning i alla programmeringsspråk. En F#-funktion har ett namn, kan ha parametrar och ta argument och har en brödtext. F# stöder också funktionella programmeringskonstruktioner som att behandla funktioner som värden, använda icke namngivna funktioner i uttryck, sammansättning av funktioner för att bilda nya funktioner, curried-funktioner och den implicita definitionen av funktioner genom partiell tillämpning av funktionsargument.
Funktionsuttryck Lär dig hur du använder nyckelordet F# "kul" för att definiera ett lambda-uttryck, som är en anonym funktion.

Loopar och villkor

I följande tabell visas artiklar som beskriver F#-loopar och villkor.

Rubrik Beskrivning
Villkorsstyrda uttryck: if...then...else Lär dig mer om if...then...else uttrycket, som kör olika grenar av kod och även utvärderar till ett annat värde beroende på det booleska uttrycket.
Loopar: for...in Uttryck Lär dig mer om for...in uttrycket, en loopkonstruktion som används för att iterera över matchningar av ett mönster i en uppräkningsbar samling, till exempel ett intervalluttryck, sekvens, lista, matris eller annan konstruktion som stöder uppräkning.
Loopar: for...to Uttryck Lär dig mer om uttrycket for...to , som används för att iterera i en loop över ett värdeintervall för en loopvariabel.
Loopar: while...do Uttryck Lär dig mer om uttrycket while...do , som används för att utföra iterativ körning (loopning) medan ett angivet testvillkor är sant.

Mönstermatchning

I följande tabell visas referensartiklar som beskriver språkbegrepp.

Rubrik Beskrivning
Mönstermatchning Lär dig mer om mönster, som är regler för att transformera indata och som används i hela F#. Du kan jämföra data med ett mönster, dela upp data i ingående delar eller extrahera information från data på olika sätt.
Matcha uttryck Lär dig mer om uttrycket match , som ger förgreningskontroll som baseras på jämförelsen av ett uttryck med en uppsättning mönster.
Aktiva mönster Läs mer om aktiva mönster. Med aktiva mönster kan du definiera namngivna partitioner som delar upp indata. Du kan använda aktiva mönster för att dela upp data på ett anpassat sätt för varje partition.

Undantagshantering

I följande tabell visas referensartiklar som beskriver språkbegrepp relaterade till undantagshantering.

Rubrik Beskrivning
Undantagshantering Innehåller information om stöd för undantagshantering i F#.
Uttrycket try...with Lär dig mer om hur du använder uttrycket try...with för undantagshantering.
Uttrycket try...finally Lär dig mer om hur F# try...finally -uttrycket gör att du kan köra rensningskod även om ett kodblock utlöser ett undantag.
Nyckelordet use Lär dig mer om nyckelorden use och using, som kan styra initieringen och lanseringen av resurser.
Påståenden Lär dig mer om uttrycket assert , som är en felsökningsfunktion som du kan använda för att testa ett uttryck. Vid fel i felsökningsläge genererar en kontroll en dialogruta för systemfel.

Typer och typinferens

I följande tabell visas referensartiklar som beskriver hur typer och typinferens fungerar i F#.

Rubrik Beskrivning
Typer Lär dig mer om de typer som används i F# och hur F#-typer namnges och beskrivs.
Grundläggande typer Lär dig mer om de grundläggande typer som används i F#. Den innehåller också motsvarande .NET-typer och lägsta och högsta värden för varje typ.
Enhetstyp Lär dig mer om unit typen, som är en typ som anger avsaknaden av ett specifikt värde. unit Typen har bara ett enda värde, som fungerar som platshållare när inget annat värde finns eller behövs.
Skriv förkortningar Läs mer om typförkortningar, som är alternativa namn för typer.
Typinferens Lär dig mer om hur F#-kompilatorn härleder typerna av värden, variabler, parametrar och returvärden.
Omvandling och konvertering Läs mer om stöd för typkonverteringar i F#.
Generika Läs mer om generiska konstruktioner i F#.
Automatisk generalisering Lär dig mer om hur F# automatiskt generaliserar argument och typer av funktioner så att de fungerar med flera typer när det är möjligt.
Restriktioner Lär dig mer om begränsningar som gäller för generiska typparametrar för att ange kraven för ett typargument i en generisk typ eller funktion.
Flexibla typer Lär dig mer om flexibla typer. En flexibel typanteckning är en indikation på att en parameter, variabel eller ett värde har en typ som är kompatibel med angiven typ, där kompatibilitet bestäms av position i en objektorienterad hierarki med klasser eller gränssnitt.
Måttenheter Lär dig mer om måttenheter. Flyttalsvärden i F# kan ha associerade måttenheter, som vanligtvis används för att ange längd, volym, massa och så vidare.
Byrefs Lär dig mer om byref- och byref-liknande typer i F#, som används för lågnivåprogrammering.

Tupplar, listor, samlingar, alternativ

I följande tabell visas referensartiklar som beskriver typer som stöds av F#.

Rubrik Beskrivning
Tupplar Lär dig mer om tupplar, som är grupperingar av namnlösa men ordnade värden av möjligen olika typer.
Samlingar En översikt över F#-funktionssamlingstyperna, inklusive typer för matriser, listor, sekvenser (seq), kartor och uppsättningar.
Listor Läs mer om listor. En lista i F# är en ordnad, oföränderlig serie element av samma typ.
Alternativ Läs mer om alternativtypen. Ett alternativ i F# används när ett värde kanske eller kanske inte finns. Ett alternativ har en underliggande typ och kan antingen innehålla ett värde av den typen eller så har det kanske inget värde.
Matriser Lär dig mer om matriser. Matriser är fasta, nollbaserade, föränderliga sekvenser av på varandra följande dataelement, alla av samma typ.
Sekvenser Lär dig mer om sekvenser. En sekvens är en logisk serie med element av samma typ. Enskilda sekvenselement beräknas bara om det behövs, så representationen kan vara mindre än ett antal literalelement indikerar.
Sekvensuttryck Lär dig mer om sekvensuttryck, som gör att du kan generera sekvenser av data på begäran.
Referensceller Lär dig mer om referensceller, som är lagringsplatser som gör att du kan skapa föränderliga variabler med referenssemantik.

Arkivhandlingar och diskriminerade fackföreningar

I följande tabell visas referensartiklar som beskriver post- och definitioner av unionstyper som stöds av F#.

Rubrik Beskrivning
Poster Läs mer om poster. Poster representerar enkla aggregeringar av namngivna värden, om du vill med medlemmar.
Anonyma poster Lär dig hur du skapar och använder anonyma poster, en språkfunktion som hjälper dig att manipulera data.
Diskriminerade fackföreningar Lär dig mer om diskriminerade fackföreningar, som ger stöd för värden som kan vara ett av en mängd olika namngivna fall, var och en med möjligen olika värden och typer.
Strukturer Lär dig mer om strukturer, som är kompakta objekttyper som kan vara mer effektiva än en klass för typer som har en liten mängd data och enkelt beteende.
Uppräkningar Uppräkningar är typer som har en definierad uppsättning namngivna värden. Du kan använda dem i stället för literaler för att göra koden mer läsbar och underhållsbar.

Objektprogrammering

I följande tabell visas referensartiklar som beskriver F#-objektprogrammering.

Rubrik Beskrivning
Klasser Lär dig mer om klasser, som är typer som representerar objekt som kan ha egenskaper, metoder och händelser.
Gränssnitt Lär dig mer om gränssnitt, som anger uppsättningar med relaterade medlemmar som andra klasser implementerar.
Abstrakta klasser Lär dig mer om abstrakta klasser, som är klasser som lämnar vissa eller alla medlemmar oimplementerade, så att implementeringar kan tillhandahållas av härledda klasser.
Typtillägg Lär dig mer om typtillägg, där du kan lägga till nya medlemmar i en tidigare definierad objekttyp.
Delegeringar Lär dig mer om ombud, som representerar ett funktionsanrop som ett objekt.
Arv Lär dig mer om arv, som används för att modellera "is-a"-relationen, eller undertyperingen, i objektorienterad programmering.
Medlemmar Lär dig mer om medlemmar i F#-objekttyper.
Parametrar och argument Lär dig mer om språkstöd för att definiera parametrar och skicka argument till funktioner, metoder och egenskaper. Den innehåller information om hur du skickar med referens.
Överlagring av operatorer Lär dig mer om att överbelasta aritmetiska operatorer i en klass eller posttyp och på global nivå.
Objektuttryck Lär dig mer om objektuttryck, som är uttryck som skapar nya instanser av en dynamiskt skapad, anonym objekttyp som baseras på en befintlig bastyp, ett gränssnitt eller en uppsättning gränssnitt.

Async, Tasks och Lazy

I följande tabell visas avsnitt som beskriver Asynkrona F#-uttryck, uppgiftsuttryck och uppskjutna uttryck.

Rubrik Beskrivning
Asynkrona uttryck Lär dig mer om asynkrona uttryck, som gör att du kan skriva asynkron kod på ett sätt som ligger mycket nära det sätt som du skulle skriva synkron kod naturligt.
Uppgiftsuttryck Lär dig mer om uppgiftsuttryck, som är ett alternativt sätt att skriva asynkron kod som används när du samverkar med .NET-kod som använder eller producerar .NET-uppgifter.
Lazy-uttryck Lär dig mer om lata uttryck, som är beräkningar som inte utvärderas omedelbart, utan i stället utvärderas när resultatet faktiskt behövs.

Beräkningsuttryck och frågor

I följande tabell visas avsnitt som beskriver F#-beräkningsuttryck och frågor.

Rubrik Beskrivning
Beräkningsuttryck Lär dig mer om beräkningsuttryck i F#, som ger en praktisk syntax för att skriva beräkningar som kan sekvenseras och kombineras med hjälp av kontrollflödeskonstruktioner och bindningar. De kan användas för att hantera data, kontroll och biverkningar i funktionella program.
Frågeuttryck Lär dig mer om frågeuttryck, en språkfunktion som implementerar LINQ för F# och gör att du kan skriva frågor mot en datakälla eller uppräkningsbar samling.

Attribut, reflektion, citat och oformaterad textformatering

I följande tabell visas artiklar som beskriver F#-reflekterande funktioner, inklusive attribut, citattecken och nameofoformaterad textformatering.

Rubrik Beskrivning
Attribut Lär dig hur F#-attribut gör att metadata kan tillämpas på en programmeringskonstruktion.
nameof Lär dig mer om operatorn nameof , en metaprogramfunktion som gör att du kan skapa namnet på valfri symbol i källkoden.
Information om uppringare Lär dig mer om hur du använder argumentattribut för anropare för att hämta information från en metod.
Källrads-, fil- och sökvägsidentifierare Lär dig mer om identifierarna , __SOURCE_DIRECTORY__och __SOURCE_FILE__, som är inbyggda värden som gör att du kan komma åt källradens __LINE__nummer, katalog och filnamn i koden.
Kodcitat Lär dig mer om kodcitat, en språkfunktion som gör att du kan generera och arbeta med F#-koduttryck programmatiskt.
Formatering av oformaterad text Lär dig hur du använder sprintf och annan formatering av oformaterad text i F#-program och skript.

Typprovidrar

I följande tabell visas artiklar som beskriver F#-typprovidrar.

Rubrik Beskrivning
Typprovidrar Lär dig mer om typprovidrar och hitta länkar till genomgångar om hur du använder de inbyggda typprovidrar för att få åtkomst till databaser och webbtjänster.
Skapa en typprovider Lär dig hur du skapar egna F#-typprovidrar genom att undersöka flera enkla typprovidrar som illustrerar de grundläggande begreppen.

API-referens för F# Core Library

F# Core Library (FSharp.Core) API-referens är referensen för alla F# Core Library-namnrymder, moduler, typer och funktioner.

Referenstabeller

I följande tabell visas referensartiklar som innehåller tabeller med nyckelord, symboler och literaler som används som token i F#.

Rubrik Beskrivning
Nyckelordsreferens Innehåller länkar till information om alla nyckelord för F#-språk.
Symbol- och operatorreferens Innehåller en tabell med symboler och operatorer som används i F#.

Konstruktioner som stöds av kompilatorn

I följande tabell visas avsnitt som beskriver särskilda konstruktioner som stöds av kompilatorn.

Avsnitt Beskrivning
Kompilatoralternativ Beskriver kommandoradsalternativen för F#-kompilatorn.
Kompilatordirektiv Beskriver processordirektiv och kompilatordirektiv som stöds av F#-kompilatorn.