D Language => Importaciones y módulos.

Sintaxis

módulo my.package;
importar mi.paquete;
importar my.package: function;
import fancyName = mypackage;
importar my.package: fancyFunctionName = function;

Observaciones

Los módulos proporcionan automáticamente un ámbito de espacio de nombres para sus contenidos. Los módulos se asemejan superficialmente a las clases, pero difieren en eso:

Solo hay una instancia de cada módulo, y se asigna de forma estática.
No hay mesa virtual.
Los módulos no se heredan, no tienen super módulos, etc.
Sólo un módulo por archivo.
Los símbolos del módulo pueden ser importados.
Los módulos siempre se compilan a nivel global y no se ven afectados por los atributos circundantes u otros modificadores.
Los módulos se pueden agrupar en jerarquías llamadas paquetes.

Los módulos ofrecen varias garantías:

El orden en que se importan los módulos no afecta a la semántica.
La semántica de un módulo no se ve afectada por lo que lo importa.
Si un módulo C importa los módulos A y B, cualquier modificación a B no cambiará de manera silenciosa el código en C que depende de A.

Importaciones globales

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

Las importaciones múltiples se pueden especificar en la misma línea, separadas por una comma o en una nueva línea.

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

Importaciones selectivas

Las importaciones selectivas pueden ayudar a limpiar el espacio de nombres y acelerar el tiempo de compilación aún más, porque el compilador solo necesita analizar las funciones específicas seleccionadas.

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

Importaciones locales

También puede importar símbolos en cualquier ámbito, la importación solo se buscará cuando el ámbito sea necesario (es decir, compilado) y los nombres importados solo se expondrán en el ámbito importado. Más comúnmente, el alcance de las importaciones locales son funciones, estructuras y clases.

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

Importaciones publicas

Los módulos pueden ser expuestos a otros módulos con public imports .

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

Importaciones renombradas

Se puede dar un nombre local para una importación, a través del cual todas las referencias a los símbolos del módulo se deben calificar 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
}

Las importaciones renombradas son útiles cuando se trata de nombres de importación muy largos.

Importaciones renombradas y selectivas.

Las importaciones selectivas también pueden ser renombradas.

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

Declaración del módulo

Los módulos tienen una correspondencia de uno a uno con los archivos de origen. El nombre del módulo es, de forma predeterminada, el nombre del archivo con la ruta y la extensión eliminadas, y se puede establecer explícitamente con la declaración del módulo. La ModuleDeclaration establece el nombre del módulo y el paquete al que pertenece. Si está ausente, el nombre del módulo se toma como el mismo nombre (eliminado de la ruta y la extensión) del nombre del archivo fuente.

module my.fancy.module;

Modified text is an extract of the original Stack Overflow Documentation

Licenciado bajo CC BY-SA 3.0

No afiliado a Stack Overflow

D Language
Importaciones y módulos.

Buscar..