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.");