D Language => Invoer en modules

Syntaxis

module mijn.pakket;
import my.package;
import my.package: function;
import fancyName = mijnpakket;
import my.package: fancyFunctionName = function;

Opmerkingen

Modules bieden automatisch een naamruimte voor hun inhoud. Modules lijken oppervlakkig op klassen, maar verschillen daarin:

Er is slechts één exemplaar van elke module en deze wordt statisch toegewezen.
Er is geen virtuele tabel.
Modules erven niet, ze hebben geen supermodules, enz.
Slechts één module per bestand.
Module symbolen kunnen worden geïmporteerd.
Modules worden altijd gecompileerd op wereldwijde schaal en worden niet beïnvloed door omringende attributen of andere modificaties.
Modules kunnen worden gegroepeerd in hiërarchieën die pakketten worden genoemd.

Modules bieden verschillende garanties:

De volgorde waarin modules worden geïmporteerd, heeft geen invloed op de semantiek.
De semantiek van een module wordt niet beïnvloed door wat deze importeert.
Als een module C modules A en B importeert, zullen wijzigingen in B niet stilzwijgend code in C wijzigen die afhankelijk is van A.

Wereldwijde invoer

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

Meerdere invoer kan worden opgegeven op dezelfde regel, gescheiden door een comma of in een nieuwe regel.

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

Selectieve invoer

Selectieve import kan helpen de naamruimte op te schonen en de compilatie nog sneller te maken, omdat de compiler alleen de specifieke, geselecteerde functies hoeft te parseren.

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

Lokale invoer

U kunt ook symbolen in elk bereik importeren, de import wordt alleen opgezocht als het bereik nodig is (dat wil zeggen gecompileerd) en de geïmporteerde namen worden alleen in het geïmporteerde bereik weergegeven. Meestal zijn de mogelijkheden voor lokale import functies, structuren en klassen.

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

Publieke invoer

Modules kunnen worden blootgesteld aan andere modules met public imports .

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

Hernoemde invoer

Er kan een lokale naam voor een import worden gegeven, waarmee alle verwijzingen naar de symbolen van de module moeten worden gekwalificeerd met:

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

Hernoemde importen zijn handig bij het omgaan met zeer lange importnamen.

Hernoemde en selectieve invoer

Selectieve invoer kan ook worden hernoemd.

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

Module verklaring

Modules hebben een één-op-één correspondentie met bronbestanden. De modulenaam is standaard de bestandsnaam met het pad en de extensie verwijderd, en kan expliciet worden ingesteld met de moduleaangifte. De ModuleDeclaration stelt de naam van de module in en tot welk pakket deze behoort. Indien afwezig, wordt de modulenaam beschouwd als dezelfde naam (ontdaan van pad en extensie) van de bronbestandsnaam.

module my.fancy.module;

Modified text is an extract of the original Stack Overflow Documentation

Licentie onder CC BY-SA 3.0

Niet aangesloten bij Stack Overflow

D Language
Invoer en modules

Zoeken…