F#-Sprachreferenz
Dieser Abschnitt bietet eine Referenz zur Programmiersprache F#, eine Programmiersprache für die .NET-Plattform mit mehreren Paradigmen. F# unterstützt funktionale, objektorientierte und imperative Programmiermodelle.
F#-Token
Die folgende Tabelle enthält Referenzthemen mit Tabellen, in denen Schlüsselwörter, Symbole und Literale angegeben werden, die in F# als Token verwendet werden.
Titel |
Beschreibung |
|---|---|
Enthält Links zu Informationen über alle F#-Schlüsselwörter. |
|
Enthält eine Tabelle mit Symbolen und Operatoren, die in F# verwendet werden. |
|
Beschreibt die Syntax für literale Werte in F# und erläutert, wie Typinformationen für F#-Literale angegeben werden. |
F#-Sprachkonzepte
In der folgenden Tabelle werden verfügbare Referenzthemen aufgeführt, in denen Sprachkonzepte beschrieben werden.
Titel |
Beschreibung |
|---|---|
Funktionen sind in jeder Programmiersprache die grundlegende Einheit der Programmausführung. Wie Funktionen anderer Sprachen weist eine F#-Funktion einen Namen auf, sie kann über Parameter verfügen und Argumente akzeptieren, und sie verfügt über einen Funktionsrumpf. F# unterstützt auch Konstrukte der funktionalen Programmierung. Hierzu zählen beispielsweise das Behandeln von Funktionen als Werte, das Verwenden unbenannter Funktionen in Ausdrücken, das Zusammensetzen von Funktionen zum Bilden neuer Funktionen, Curry-Funktionen sowie die implizite Definition von Funktionen durch die partielle Anwendung von Funktionsargumenten. |
|
Beschreibt die in F# verwendeten Typen und erläutert, wie F#-Typen benannt und beschrieben werden. |
|
Beschreibt, wie der F#-Compiler die Typen von Werten, Variablen, Parametern und Rückgabewerten ableitet. |
|
Beschreibt generische Konstrukte in F#. |
|
Beschreibt Vererbung, die in der objektorientierten Programmierung verwendet wird, um die Ist-Beziehung bzw. die Definition von Untertypen zu modellieren. |
|
Beschreibt Member von F#-Objekttypen. |
|
Beschreibt die Sprachunterstützung für das Definieren von Parametern und das Übergeben von Argumenten an Funktionen, Methoden und Eigenschaften. Enthält auch Informationen zum Übergeben von Elementen als Verweis. |
|
Beschreibt, wie arithmetische Operatoren in einem Klassen- oder Datensatztyp sowie auf globaler Ebene überladen werden. |
|
Beschreibt die Unterstützung für Typkonvertierungen in F#. |
|
Beschreibt die Zugriffssteuerung in F#. Durch Zugriffssteuerung wird deklariert, welche Clients bestimmte Programmelemente, z. B. Typen, Methoden, Funktionen usw., verwenden können. |
|
Beschreibt Muster. Diese sind Regeln zum Transformieren von Eingabedaten, die in F# stets verwendet werden, um Vergleichsdaten mit einem Muster zu extrahieren, Daten in einzelne Bestandteile zu zerlegen oder auf unterschiedliche Weise Informationen aus Daten zu extrahieren. |
|
Beschreibt aktive Muster. Mit aktiven Mustern können Sie benannte Partitionen für die Unterteilung von Eingabedateien definieren. Mit aktiven Mustern können Sie Daten für jede Partition benutzerdefiniert zerlegen. |
|
Beschreibt den assert-Ausdruck, eine Debugfunktion, mit der Sie einen Ausdruck testen können. Nach einem Fehler im Debugmodus generiert eine Assertion ein Systemfehlerdialogfeld. |
|
Enthält Informationen über die Unterstützung der Ausnahmebehandlung in F#. |
|
Beschreibt Attribute. Diese ermöglichen das Anwenden von Metadaten auf ein Programmierkonstrukt. |
|
Beschreibt die Schlüsselwörter use und using, mit denen die Initialisierung und Freigabe von Ressourcen gesteuert werden kann. |
|
Beschreibt die Namespaceunterstützung in F#. Mit einem Namespace können Sie Code nach Funktionsbereichen organisieren, indem Sie an eine Gruppierung von Programmelementen einen Namen anfügen. |
|
Beschreibt Module. Ein F#-Modul ist eine Gruppe von F#-Code, z. B. Werte, Typen und Funktionswerte, in einem F#-Programm. Durch das Gruppieren von Code in Modulen kann zugehöriger Code zusammengehalten werden, und Namenskonflikte im Programm lassen sich leichter vermeiden. |
|
Beschreibt die Funktionsweise von open. Eine Importdeklaration gibt ein Modul oder einen Namespace an, auf dessen Elemente Sie verweisen können, ohne einen vollqualifizierten Namen zu verwenden. |
|
Beschreibt Signaturen und Signaturdateien. Eine Signaturdatei enthält Informationen zu den öffentlichen Signaturen eines Satzes von F#-Programmelementen, z. B. Typen, Namespaces und Module. Mit ihr kann der Zugriff auf diese Programmelemente angegeben werden. |
|
Beschreibt die Unterstützung für das Generieren von Dokumentationsdateien für XML-Dokumentkommentare (Kommentare mit drei Schrägstrichen). Sie können in F# genau wie in anderen .NET-Sprachen Dokumentation aus Codekommentaren erzeugen. |
|
Beschreibt die Syntax für F#-Konstrukte, wenn einfache Syntax nicht aktiviert ist. Ausführliche Syntax wird durch das Fehlen der #light "off"-Direktive am oberen Rand der Codedatei gekennzeichnet. |
F#-Typen
In der folgenden Tabelle werden verfügbare Referenzthemen aufgeführt, in denen von F# unterstützte Typen beschrieben werden.
Titel |
Beschreibung |
|---|---|
Beschreibt Werte, d. h. unveränderliche Größen, die einen bestimmten Typ aufweisen. Werte können ganze Zahlen oder Gleitkommazahlen, Zeichen oder Text, Listen, Sequenzen, Arrays, Tupel, Unterscheidungs-Unions, Datensätze, Klassentypen oder Funktionswerte sein. |
|
Beschreibt die grundlegenden primitiven Typen, die in F# verwendet werden. Außerdem werden die entsprechenden .NET-Typen sowie der Mindest- und Höchstwert für jeden Typ angegeben. |
|
Beschreibt den unit-Typ. Dieser Wert gibt das Fehlen eines bestimmten Werts an. Der unit-Typ verfügt über einen einzigen Wert, der als Platzhalter fungiert, wenn kein anderer Wert vorhanden ist oder benötigt wird. |
|
Beschreibt Zeichenfolgen in F#. Der string stellt unveränderlichen Text als eine Reihe von Unicode-Zeichen dar. Der string-Typ ist ein Alias für String in .NET Framework. |
|
Beschreibt Tupel. Dies sind Gruppierungen von unbenannten, jedoch geordneten Werten möglicherweise unterschiedlicher Typen. |
|
Beschreibt Listen. In F# ist eine Liste eine geordnete, unveränderliche Reihe von Elementen, die alle den gleichen Typ aufweisen. |
|
Beschreibt den Optionstyp. In F# wird eine Option verwendet, wenn ein Wert möglicherweise nicht vorhanden ist. Eine Option verfügt über einen zugrunde liegenden Typ, und sie enthält möglicherweise einen Wert dieses Typs. Sie kann auch über keinen Wert verfügen. |
|
Beschreibt Sequenzen. Eine Sequenz ist eine logische Reihe von Elementen eines einzigen Typs. Einzelne Sequenzelemente werden nur bei Bedarf berechnet, daher ist die Darstellung möglicherweise kleiner als die Anzahl der Literalelemente. |
|
Beschreibt Arrays. Arrays sind nullbasierte, änderbare Sequenzen fester Größe von aufeinander folgenden Datenelementen, die alle den gleichen Typ aufweisen. |
|
Beschreibt Datensätze. Datensätze stellen einfache Aggregate benannter Werte, optional mit Membern, dar. |
|
Beschreibt Unterscheidungs-Unions. Diese bieten Unterstützung für Werte, bei denen es sich um einen Fall aus einer Reihe verschiedener benannter Fälle handeln kann, mit jeweils potenziell unterschiedlichen Werten und Typen. |
|
Beschreibt Enumerationen, d. h. Typen, die über einen definierten Satz benannter Werte verfügen. Sie können sie anstelle von Literalen verwenden, um die Verwaltung von Code zu erleichtern und die Lesbarkeit von Code zu erhöhen. |
|
Beschreibt Referenzzellen. Dies sind Speicherorte, die es Ihnen ermöglichen, änderbare Variablen mit Verweissemantik zu erstellen. |
|
Beschreibt Typabkürzungen, d. h. alternative Namen für Typen. |
|
Beschreibt Klassen. Dies sind Typen, die Objekte darstellen, die über Eigenschaften, Methoden und Ereignisse verfügen können. |
|
Beschreibt Strukturen. Dies sind kompakte Objekttypen, die für Typen, die eine geringe Datenmenge und einfaches Verhalten aufweisen, effizienter als eine Klasse sein können. |
|
Beschreibt Schnittstellen. Diese geben Sätze von verwandten Membern an, die von anderen Klassen implementiert werden. |
|
Beschreibt abstrakte Klassen. In diesen Klassen bleiben einige oder alle Member unimplementiert, damit Implementierungen von abgeleiteten Klassen bereitgestellt werden können. |
|
Beschreibt Typerweiterungen. Mit diesen können Sie einem zuvor definierten Objekttyp neue Member hinzufügen. |
|
Beschreibt flexible Typen. Eine flexible Typanmerkung gibt an, dass der Typ eines Parameters, einer Variablen oder eines Werts mit dem angegebenen Typ kompatibel ist, wobei die Kompatibilität nach der Position in einer objektorientierten Hierarchie von Klassen oder Schnittstellen bestimmt wird. |
|
Beschreibt Delegaten. Diese stellen einen Funktionsaufruf als Objekt dar. |
|
Beschreibt Maßeinheiten. In F# können Gleitkommawerten Maßeinheiten zugeordnet werden. Mit diesen werden i. d. R. Länge, Volumen, Masse usw. angegeben. |
F#-Ausdrücke
In der folgenden Tabelle werden Themen aufgeführt, in denen F#-Ausdrücke beschrieben werden.
Titel |
Beschreibung |
|---|---|
Beschreibt den if...then...else-Ausdruck, der unterschiedliche Codeverzweigungen ausführt und je nach dem angegebenen booleschen Ausdruck einen anderen Wert ergibt. |
|
Beschreibt den match-Ausdruck, der Verzweigungssteuerung bereitstellt, die auf dem Vergleich eines Ausdrucks mit einem Satz von Mustern basiert. |
|
Beschreibt den for...to-Ausdruck, der verwendet wird, um einen Bereich von Werten einer Schleifenvariablen in einer Schleife zu durchlaufen. |
|
Beschreibt den for...in-Ausdruck. Dies ist ein Schleifenkonstrukt, mit dem die Übereinstimmungen eines Musters in einer aufzählbaren Auflistung z. B. ein Bereichsausdruck, eine Sequenz, ein Liste, ein Array oder ein anderes Konstrukt, das Enumeration unterstützt, durchlaufen werden. |
|
Beschreibt den while...do-Ausdruck, mit dem eine iterative Ausführung (in einer Schleife) erfolgt, solange eine angegebene Testbedingung true ist. |
|
Beschreibt Objektausdrücke. Mit diesen werden neue Instanzen eines dynamisch erstellten, anonymen Objekttyps erstellt, der auf einem vorhandenen Basistyp, einer vorhandenen Schnittstelle oder einem vorhandenen Satz von Schnittstellen basiert. |
|
Beschreibt verzögerte Berechnungen. Diese werden nicht sofort ausgewertet, sondern erst, wenn das Ergebnis tatsächlich benötigt wird. |
|
Beschreibt Berechnungsausdrücke in F#, die eine zweckmäßige Syntax zum Schreiben von Berechnungen bereitstellen, die sequenziert und anhand von Ablaufsteuerungskonstrukten und Bindungen verbunden werden können. Sie können verwendet werden, um eine zweckmäßige Syntax für Monaden bereitzustellen, eine funktionale Programmierfunktion, die verwendet werden kann, um Daten-, Steuerelement- und Nebeneffekte in funktionalen Programmen zu verwalten. Der Berechnungsausdruck "asynchroner Workflow" unterstützt asynchrone und parallele Berechnungen. Weitere Informationen finden Sie unter Asynchrone Workflows (F#). |
|
Beschreibt asynchrone Workflows, eine Sprachfunktion, mit der Sie asynchronen Code auf eine Weise schreiben können, die dem Schreiben natürlichen synchronen Codes ähnlich ist. |
|
Beschreibt Codezitate. Diese Sprachfunktion ermöglicht es Ihnen, programmgesteuert F#-Codeausdrücke zu generieren und mit diesen zu arbeiten. |
Vom Compiler unterstützte Konstrukte
In der folgenden Tabelle werden Themen aufgeführt, in denen spezielle vom Compiler unterstützte Konstrukte beschrieben werden.
Thema |
Beschreibung |
|---|---|
Beschreibt Prozessordirektiven und Compilerdirektiven. |
|
Beschreibt die Bezeichner __LINE__, __SOURCE_DIRECTORY__ und __SOURCE_FILE__. Dies sind integrierte Werte, die es Ihnen ermöglichen, im Code auf die Zeilennummer, das Verzeichnis und den Dateinamen des Quellcodes zuzugreifen. |