D Language => Importations et modules

Syntaxe

module mon.package;
importer mon.package;
import my.package: function;
import fancyName = mypackage;
import my.package: fancyFunctionName = function;

Remarques

Les modules fournissent automatiquement une étendue d'espace de noms pour leur contenu. Les modules ressemblent superficiellement aux classes, mais diffèrent par le fait que:

Il n'y a qu'une seule instance de chaque module, et celle-ci est allouée de manière statique.
Il n'y a pas de table virtuelle.
Les modules n'héritent pas, ils n'ont pas de super modules, etc.
Un seul module par fichier.
Les symboles de module peuvent être importés.
Les modules sont toujours compilés au niveau global et ne sont pas affectés par les attributs environnants ou d'autres modificateurs.
Les modules peuvent être regroupés dans des hiérarchies appelées packages.

Les modules offrent plusieurs garanties:

L'ordre dans lequel les modules sont importés n'affecte pas la sémantique.
La sémantique d'un module n'est pas affectée par ce qui l'importe.
Si un module C importe les modules A et B, toute modification apportée à B ne modifiera pas silencieusement le code en C qui dépend de A.

Importations mondiales

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

Plusieurs importations peuvent être spécifiées dans la même ligne, séparées par une comma ou dans une nouvelle ligne.

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

Importations sélectives

Les importations sélectives peuvent aider à nettoyer l'espace de nommage et à accélérer la compilation, car le compilateur n'a qu'à analyser les fonctions spécifiques sélectionnées.

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

Importations locales

Vous pouvez également importer des symboles dans n'importe quelle portée, l'importation ne sera recherchée que lorsque la portée est requise (c.-à-d. Compilée) et les noms importés ne seront exposés que dans la portée importée. Le plus souvent, les possibilités d'importation locale sont les fonctions, les structures et les classes.

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

Importations publiques

Les modules peuvent être exposés à d'autres modules avec public imports .

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

Importations renommées

Un nom local pour une importation peut être donné, par lequel toutes les références aux symboles du module doivent être qualifiées avec:

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

Les importations renommées sont pratiques lorsque vous utilisez des noms d'importation très longs.

Importations renommées et sélectives

Les importations sélectives peuvent également être renommées.

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

Déclaration de module

Les modules ont une correspondance univoque avec les fichiers sources. Le nom du module est, par défaut, le nom du fichier avec le chemin d'accès et l'extension supprimés, et peut être défini explicitement avec la déclaration du module. Le ModuleDeclaration définit le nom du module et le package ModuleDeclaration il appartient. S'il est absent, le nom du module correspond au même nom (sans chemin ni extension) du nom du fichier source.

module my.fancy.module;

Modified text is an extract of the original Stack Overflow Documentation

Sous licence CC BY-SA 3.0

Non affilié à Stack Overflow

D Language
Importations et modules

Recherche…