Freigeben über


F#-Typen

In diesem Thema werden die in F# verwendeten Typen beschrieben, und es wird erläutert, wie F#-Typen benannt und beschrieben werden.

Übersicht über F#-Typen

Einige Typen gelten als primitive Typen, z. B. der boolesche Typ bool sowie ganzzahlige Typen und Gleitkommatypen verschiedener Größe, darunter Typen für Bytes und Zeichen. Diese Typen werden in Primitive Typen (F#) beschrieben.

Andere in F# integrierte Typen sind Tupel, Listen, Arrays, Sequenzen, Datensätze und Unterscheidungs-Unions. Wenn Sie über Erfahrung mit anderen .NET-Sprachen verfügen und F# erlernen, sollten Sie die Themen für jeden dieser Typen lesen. Der Abschnitt Verwandte Themen dieses Themas enthält Links zu weiteren Informationen über diese Typen. Die F#-spezifischen Typen unterstützen die üblichen Programmierungsstile von funktionalen Programmiersprachen. Vielen dieser Typen sind Module in der F#-Bibliothek zugeordnet, die allgemeine Operationen mit diesen Typen unterstützt.

Der Typ einer Funktion enthält Informationen über die Parametertypen und den Rückgabetyp.

.NET Framework ist die Quelle von Objekttypen, Schnittstellentypen, Delegattypen und anderen Typen. Sie können genau wie in jeder anderen .NET-Sprache eigene Objekttypen definieren.

In F#-Code können auch Aliase definiert werden. Dies sind benannte Typabkürzungen, die als alternative Namen für Typen verwendet werden. Sie können Typabkürzungen verwenden, wenn sich der Typ möglicherweise in der Zukunft ändert und Sie Code nicht ändern möchten, der von dem Typ abhängt. Oder Sie können eine Typabkürzung als Anzeigenamen für einen Typ verwenden, um die Lesbarkeit und Verständlichkeit von Code zu erhöhen.

Syntax für Typen

In F#-Code müssen Sie oft die Namen von Typen schreiben. Jeder Typ verfügt über eine syntaktische Form, und Sie verwenden diese syntaktischen Formen in Typanmerkungen, abstrakten Methodendeklarationen, Delegatdeklarationen, Signaturen und anderen Konstrukten. Wenn Sie im Interpreter ein neues Programmkonstrukt deklarieren, gibt der Interpreter immer den Namen des Konstrukts und die Syntax für dessen Typ aus. Die Syntax kann einfach ein Bezeichner für einen benutzerdefinierten Typ oder ein integrierter Bezeichner, z. B. für int oder string sein, jedoch ist die Syntax für komplexere Typen komplexer.

In der folgenden Tabelle werden Aspekte der Typsyntax für F#-Typen dargestellt.

Typ

Typsyntax

Beispiele

Primitiver Typ

type-name

int

float

string

Aggregierter Typ (Klasse, Struktur, Union, Datensatz, Enumeration usw.)

type-name

System.DateTime

Color

Typabkürzung

type-abbreviation-name

bigint

Vollqualifizierter Typ

namespaces.type-name

oder

modules.type-name

oder

namespaces.modules.type-name

System.IO.StreamWriter

-Array

type-name[] oder

type-name-Array

int[]

array<int>

int array

Zweidimensionales Array

type-name[,]

int[,]

float[,]

Dreidimensionales Array

type-name[,,]

float[,,]

Tupel

type-name1 * type-name2 ...

Beispielsweise ist (1,'b',3) vom Typ int * char * int.

Typ, generischer

type-parameter generic-type-name

oder

generic-type-name<type-parameter-list>

'a list

list<'a>

Dictionary<'key, 'value>

Konstruierter Typ (ein generischer Typ, für den ein bestimmtes Typargument bereitgestellt wurde)

type-argument generic-type-name

oder

generic-type-name<type-argument-list>

int option

string list

int ref

option<int>

list<string>

ref<int>

Dictionary<int, string>

Funktionstyp, der über einen einzelnen Parameter verfügt

parameter-type1 -> return-type

Eine Funktion, die ein int akzeptiert und einen string zurückgibt, besitzt den Typ int -> string.

Funktionstyp, der über mehrere Parameter verfügt

parameter-type1 -> parameter-type2 -> ... -> return-type

Eine Funktion, die ein int und ein float akzeptiert und einen string vom Typ int -> float -> string zurückgibt.

Funktion höherer Ordnung als Parameter

(function-type)

List.map ist vom Typ ('a -> 'b) -> 'a list -> 'b list.

Delegat

Delegat von function-type

delegate of unit -> int

Flexibler Typ

#type-name

#System.Windows.Forms.Control

#seq<int>

Verwandte Themen

Thema

Beschreibung

Primitive Typen (F#)

Beschreibt integrierte einfache Typen z. B. ganzzahlige Typen, den Boolean-Typ und Zeichentypen.

Unit-Typ (F#)

Beschreibt den unit-Typ, ein Typ, der über einen einzelnen Wert verfügt und mit () angegeben wird. Entspricht void in C# und Nothing in Visual Basic.

Tupel (F#)

Beschreibt den Tupeltyp, ein Typ, der aus zugeordneten Werten eines beliebigen Typs besteht, die als Paare, Tripel, Quadrupel usw. angeordnet sind.

Optionen (F#)

Beschreibt den Optionstyp, ein Typ, der entweder über einen Wert verfügt oder leer ist.

Listen (F#)

Beschreibt Listen. Dies sind geordnete, unveränderliche Reihen von Elementen, die vom gleichen Typ sind.

Arrays (F#)

Beschreibt Arrays. Dies sind geordnete Mengen von änderbaren Elementen des gleichen Typs, die einen zusammenhängenden Speicherblock belegen und eine feste Größe aufweisen.

Sequenzen (F#)

Beschreibt den Sequenztyp. Dieser stellt eine logische Reihe von Werten dar. Einzelne Werte werden nur bei Bedarf berechnet.

Datensätze (F#)

Beschreibt den Datensatztyp, ein kleines Aggregat benannter Werte.

Unterscheidungs-Union (F#)

Beschreibt den Unterscheidungs-Union-Typ, ein Typ, dessen Werte einen beliebigen Typ aus einem Satz möglicher Typen aufweisen können.

Funktionen (F#)

Beschreibt Funktionswerte.

Klassen (F#)

Beschreibt den Klassentyp, ein Objekttyp, der einem .NET-Verweistyp entspricht. Klassentypen können Member, Eigenschaften, implementierte Schnittstellen und einen Basistyp enthalten.

Strukturen (F#)

Beschreibt den struct-Typ, ein Objekttyp, der einem .NET-Werttyp entspricht. Der struct-Typ stellt normalerweise ein kleines Aggregat von Daten dar.

Schnittstellen (F#)

Beschreibt Schnittstellentypen. Diese Typen stellen einen Satz von Membern dar, die bestimmte Funktionen bereitstellen, jedoch keine Daten enthalten. Ein Schnittstellentyp ist nur von Nutzen, wenn er von einem Objekttyp implementiert wird.

Delegaten (F#)

Beschreibt den Delegattyp. Dieser stellt eine Funktion als Objekt dar.

Enumerationen (F#)

Beschreibt Enumerationstypen. Deren Werte gehören einem Satz benannter Werte an.

Attribute (F#)

Beschreibt Attribute. Diese werden verwendet, um Metadaten für einen anderen Typ anzugeben.

Ausnahmetypen (F#)

Beschreibt Ausnahmen. Diese geben Fehlerinformationen an.