D语言

import std.stdio;       // 以使用writefln()
alias char[] string;    // 以兼容旧的编译器；新的编译器中已隐含定义
int main(string[] args)
{
    foreach(i, a; args)
        writefln("args[%d] = '%s'", i, a);
    return 0;
}

import std.stdio;       // 以使用writefln()
alias char[] string;    // 以兼容旧的编译器；新的编译器中已隐含定义

int main(string[] args)
{
    // 声明以字符串键和字符串数组作为数据的关联数组
    string[] [string] container;

    // 将人们加入到容器中，并让他们携带一些项目
    container["Anya"] ~= "scarf";
    container["Dimitri"] ~= "tickets";
    container["Anya"] ~= "puppy";

    // 迭代容器中所有的人
    //Iterate over all the persons in the container
    foreach (string person, string[] items; container)
        display_item_count(person, items);
    return 0;//完成
}

void display_item_count(string person, string[] items)
{
    writefln(person, " is carrying ", items.length, " items.");
}

#!/usr/bin/dmd -run
/* 支持sh风格的script语法！*/
/* D语言的Hello World
 * 进行编译：
 *   dmd hello.d
 * 或进行优化：
 *   dmd -O -inline -release hello.d
 * 或产生文档：
 *   dmd hello.d -D
 */

import std.stdio;       // 参照常用的I/O例行工作。
alias char[] string;    // 以兼容旧的编译器；新的编译器中已隐含定义

int main(string[] args)
{
    // 'writefln' (写入-格式化-行，Write-Formatted-Line)即型态安全的「printf」
    writefln("Hello World, "             // 自动链接的字符串文本
             "Reloaded");

    // 字符串即字符的动态数组「char[]」，别名为「string」
    // 自动的型态推断，以及内置的foreach
    foreach(argc, argv; args)
    {
        auto cl = new CmdLin(argc, argv);                       // 支持OOP
	writefln(cl.argnum, cl.suffix, " arg: %s", cl.argv);    // 用户定义的类别属性。

	delete cl; 	              // 垃圾回收或显示的内存管理——由你自己选择
    }

    // 嵌套结构、类别和函数
    struct specs
    {
        // 所有的变量会在运行时期自动初始化为0
        int count, allocated;
 	// 不过你可选择避开数组的初始化
        int[10000] bigarray = void;
    }

    specs argspecs(string[] args)
    // 可选用的（内置）函数契约。
    in
    {
        assert(args.length > 0);                   // 内置assert
    }
    out(result)
    {
        assert(result.count == CmdLin.total);
        assert(result.allocated > 0);
    }
    body
    {
        specs* s = new specs;
        // 不需要「->」
        s.count = args.length;  // 「length」属性是元素的数量。
        s.allocated = typeof(args).sizeof; // 原生型态内置的属性
 	foreach(arg; args)
 	    s.allocated += arg.length * typeof(arg[0]).sizeof;
 	return *s;
    }

    // 内置字符串和普通的字符串操作，例如「~」是链接。
    string argcmsg = "argc = %d";
    string allocmsg = "allocated = %d";
    writefln(argcmsg ~ ", " ~ allocmsg,
	    argspecs(args).count,argspecs(args).allocated);
    return 0;
}
 
/**
 * 保存单独命令行参数
 */
class CmdLin
{
    private
    {
        int _argc;
        string _argv;
        static uint _totalc;
    }
 
    public:
        /**
         * 对象的建构子。
         * 参数：
         *   argc = 参数的串行计数。
         *   argv = 参数内文。
         */
        this(int argc, string argv)
        {
            _argc = argc + 1;
            _argv = argv;
            _totalc++;
        }

        ~this() // 对象的解构子
        {
            // 本例中不做任何事。
        }

        int argnum() // 属性，可返回参数数目
        {
            return _argc;
        }

        string argv() // 属性，可返回参数内文
        {
            return _argv;
        }

        wstring suffix() // 属性，可返回序数后缀
        {
            wstring suffix; // 内置Unicode字符串（UTF-8，UTF-16，UTF-32）
            switch(_argc)
            {
                case 1:
                    suffix = "st";
                    break;
                case 2:
                    suffix = "nd";
                    break;
                case 3:
                    suffix = "rd";
                    break;
                default:  // 'default' is mandatory with "-w" compile switch.
                    suffix = "th";
            }
            return suffix;
        }

        /**
          * 静态属性，如同在C++ 或Java中，
          * 适用于类别对象，而不是实体。
          * 返回：己加入的命令行参数总数。
          */
        static typeof(_totalc) total()
        {
            return _totalc;
        }

        // 类别不变量，任何方法在运行之后，这些必须为真。
        invariant ()
        {
            assert(_argc > 0);
            assert(_totalc >= _argc);
        }
}

/*
 * D语言里的模板比C++ 的要更加强大。
 * 在此可以看到使用static if（D的编译时期条件建构）简单的建构出阶乘模板。
 */
template Factorial(ulong n)
{
    static if( n <= 1 )
        const Factorial = 1;
    else
        const Factorial = n * Factorial!(n-1);
}

/*
 * 这里有一个正规的函数，可完成同样的计算。
 * 注意它们有多么的相似。
 */
ulong factorial(ulong n)
{
    if( n <= 1 )
        return 1;
    else
        return n * factorial(n-1);
}

/*
 * 终于，我们可以计算我们的阶乘。注意，我们不需要去
 * 明确的指定我们的常数的型态：编译器有足够的智能为
 * 我们填充空白，因为它早已知道赋值中右手边的型态。
 */
const fact_7 = Factorial!(7);

/*
 * 这是编译时期函数评估的范例：普通函数可用于常数、
 * 编译时期表达式，假若它们满足一定的条件。
 */
const fact_9 = factorial(9);

/*在此我们可以看到多么强大的D我们使用 
 * std.metastrings.Format模板完成型态安全的printf 
 * 数据格式化，并使用message pragma显示计算结果。
 */
import std.metastrings;
pragma(msg, Format!("7! = %s", fact_7));
pragma(msg, Format!("9! = %s", fact_9));

/*
 * 完成任务后，我们可以强制停止编译。这样的程序需是
 * 从未实际编译成可运行档！
 */
static assert(false, "My work here is done.");