D Language => Importe und Module

Syntax

Modul my.package;
importiere mein.Paket;
importiere mein.Paket: Funktion;
import fancyName = meinPaket;
importiere mein.Paket: fancyFunctionName = Funktion;

Bemerkungen

Module stellen automatisch einen Namespace-Bereich für ihren Inhalt bereit. Die Module ähneln oberflächlich den Klassen, unterscheiden sich jedoch darin:

Es gibt nur eine Instanz jedes Moduls, und es ist statisch zugewiesen.
Es gibt keine virtuelle Tabelle.
Module erben nicht, sie haben keine Supermodule usw.
Nur ein Modul pro Datei.
Modulsymbole können importiert werden.
Module werden immer im globalen Bereich kompiliert und sind nicht von umgebenden Attributen oder anderen Modifizierern beeinflusst.
Module können in Hierarchien, sogenannten Paketen, zusammengefasst werden.

Module bieten mehrere Garantien:

Die Reihenfolge, in der Module importiert werden, hat keinen Einfluss auf die Semantik.
Die Semantik eines Moduls wird davon nicht beeinflusst, was es importiert.
Wenn ein Modul C die Module A und B importiert, wird bei Änderungen an B der Code in C, der von A abhängig ist, nicht automatisch geändert.

Weltweite Importe

import std.stdio;
void main()
{
    writeln("Hello World!");
}

Mehrere Importe können entweder in derselben Zeile, durch comma oder in einer neuen Zeile angegeben werden.

import std.stdio, std.math;
import std.datetime;
void main()
{
    writeln("2^4: ", pow(2, 4));
    writeln("Current time: ", Clock.currTime());
}

Selektive Importe

Durch das selektive Importieren können Sie den Namespace bereinigen und die Kompilierzeit noch beschleunigen, da der Compiler nur die bestimmten ausgewählten Funktionen analysieren muss.

import std.stdio: writeln;
void main()
{
    writeln("Hello world");
}

Lokale Importe

Sie können auch Symbole in einem beliebigen Bereich importieren. Der Import wird nur dann gesucht, wenn der Bereich benötigt (dh kompiliert) wird. Die importierten Namen werden nur im importierten Bereich angezeigt. Für den lokalen Import sind am häufigsten Funktionen, Strukturen und Klassen vorgesehen.

void main()
{
    import std.stdio: writeln;
    writeln("Hello world");
}
// writeln isn't defined here

Öffentliche Importe

Module können mit public imports anderen Modulen public imports .

public import std.math;
// only exports the symbol 'pow'
public import std.math : pow;

Umbenannte Importe

Es kann ein lokaler Name für einen Import angegeben werden, über den alle Verweise auf die Symbole des Moduls qualifiziert werden müssen

import io = std.stdio; 
void main()
{
    io.writeln("Hello world");
    std.stdio.writeln("hello!"); // error, std is undefined
    writeln("hello!");           // error, writeln is undefined
}

Umbenannte Importe sind praktisch, wenn sehr lange Importnamen verwendet werden.

Umbenannte und selektive Importe

Selektive Importe können auch umbenannt werden.

void main()
{
    import std.stdio : fooln = writeln;
    fooln("Hello world");
}

Moduldeklaration

Module haben eine Eins-zu-Eins-Entsprechung mit Quelldateien. Der Modulname ist standardmäßig der Dateiname mit entferntem Pfad und Erweiterung und kann mit der Moduldeklaration explizit festgelegt werden. Die ModuleDeclaration legt den Namen des Moduls fest und zu welchem Paket es gehört. Wenn dies nicht der Fall ist, wird angenommen, dass der Name des Moduls dem Namen der Quelldatei entspricht (ohne Pfad und Erweiterung).

module my.fancy.module;

Modified text is an extract of the original Stack Overflow Documentation

Lizenziert unter CC BY-SA 3.0

Nicht angeschlossen an Stack Overflow

D Language
Importe und Module

Suche…