D Language => Importazioni e moduli

Sintassi

modulo my.package;
import my.package;
import my.package: function;
import fancyName = mypackage;
import my.package: fancyFunctionName = function;

Osservazioni

I moduli forniscono automaticamente un ambito namespace per i loro contenuti. I moduli assomigliano superficialmente alle classi, ma differiscono in questo:

C'è solo un'istanza di ciascun modulo ed è allocata staticamente.
Non c'è tavolo virtuale.
I moduli non ereditano, non hanno moduli super, ecc.
Solo un modulo per file.
I simboli del modulo possono essere importati.
I moduli vengono sempre compilati nell'ambito globale e non sono interessati dagli attributi circostanti o da altri modificatori.
I moduli possono essere raggruppati in gerarchie denominate pacchetti.

I moduli offrono diverse garanzie:

L'ordine in cui i moduli vengono importati non influisce sulla semantica.
La semantica di un modulo non è influenzata da ciò che importa.
Se un modulo C importa i moduli A e B, qualsiasi modifica a B non modificherà automaticamente il codice in C che dipende da A.

Importazioni globali

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

È possibile specificare più importazioni nella stessa riga, separate da una comma o in una nuova riga.

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

Importazioni selettive

Le importazioni selettive possono aiutare a ripulire lo spazio dei nomi e accelerare ulteriormente la compilazione, poiché il compilatore deve solo analizzare le funzioni specifiche selezionate.

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

Importazioni locali

È inoltre possibile importare simboli in qualsiasi ambito, l'importazione verrà esaminata solo quando l'ambito è necessario (ovvero compilato) ei nomi importati verranno esposti solo nell'ambito importato. Più comunemente l'ambito per le importazioni locali sono funzioni, strutture e classi.

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

Importazioni pubbliche

I moduli possono essere esposti ad altri moduli con public imports .

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

Importazioni rinominate

Si può dare un nome locale per un'importazione, attraverso il quale tutti i riferimenti ai simboli del modulo devono essere qualificati con:

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

Le importazioni rinominate sono utili quando si gestiscono nomi di importazione molto lunghi.

Importazioni rinominate e selettive

Le importazioni selettive possono anche essere rinominate.

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

Dichiarazione del modulo

I moduli hanno una corrispondenza uno-a-uno con i file sorgente. Il nome del modulo è, per impostazione predefinita, il nome del file con il percorso e l'estensione eliminati e può essere impostato in modo esplicito con la dichiarazione del modulo. La ModuleDeclaration imposta il nome del modulo e il pacchetto a cui appartiene. Se assente, il nome del modulo assume lo stesso nome (spogliato del percorso e dell'estensione) del nome del file sorgente.

module my.fancy.module;

Modified text is an extract of the original Stack Overflow Documentation

Autorizzato sotto CC BY-SA 3.0

Non affiliato con Stack Overflow

D Language
Importazioni e moduli

Ricerca…