dojo
Dojo mit dojoConfig konfigurieren

Bemerkungen

Laden Sie DojoConfig

Im folgenden Beispiel erstellen wir ein globales Javascript-Objekt dojoConfig das alle Konfigurationswerte enthält.

Hinweis: dojoConfig wird in einem Skriptblock definiert, bevor dojo.js geladen wird. Dies ist von größter Bedeutung - bei einer Umkehrung werden die Konfigurationseigenschaften ignoriert.

<script>
    dojoConfig= {
        has: {
            "dojo-firebug": true
        },
        parseOnLoad: false,
        foo: "bar",
        async: true
    };
</script>
<script src="//ajax.googleapis.com/ajax/libs/dojo/1.10.4/dojo/dojo.js"></script>

<script>
// Require the registry, parser, Dialog, and wait for domReady
require(["dijit/registry", "dojo/parser", "dojo/json", "dojo/_base/config", "dijit/Dialog", "dojo/domReady!"]
, function(registry, parser, JSON, config) {
    // Explicitly parse the page
    parser.parse();
    // Find the dialog
    var dialog = registry.byId("dialog");
    // Set the content equal to what dojo.config is
    dialog.set("content", "<pre>" + JSON.stringify(config, null, "\t") + "```");
    // Show the dialog
    dialog.show();
});
</script>

<!-- and later in the page -->
<div id="dialog" data-dojo-type="dijit/Dialog" data-dojo-props="title: 'dojoConfig / dojo/_base/config'"></div>

Loader-Konfiguration

Dojo hat in Dojo 1.7 einen neuen Loader für das neue AMD-Modulformat des Toolkits erhalten. Dieser neue Loader fügte einige neue Konfigurationsoptionen hinzu, die für die Definition von Paketen, Karten und mehr wichtig sind. Weitere Informationen zum Loader finden Sie im Lernprogramm Fortgeschrittene AMD-Nutzung. Wichtige Konfigurationsparameter des Laders sind:

baseUrl: Die Basis-URL, die bei der Konvertierung in einen Pfad oder eine URL einem Modulbezeichner vorangestellt wird.

baseUrl: "/js"

Pakete: Ein Array von Objekten, die den Paketnamen und den Ort angeben:

packages: [{
    name: "myapp",
    location: "/js/myapp"
}]

map: Ermöglicht das Zuordnen von Pfaden in Modulkennungen zu verschiedenen Pfaden:

map: {
    dijit16: {
        dojo: "dojo16"
    }
}

Pfade: Eine Zuordnung von Modul-ID-Fragmenten zu Dateipfaden:

var dojoConfig = {
    packages: [
        "package1",
        "package2"
    ],
    paths: {
        package1: "../lib/package1",
        package2: "/js/package2"
    }
};

    // ...is equivalent to:
var dojoConfig = {
    packages: [
        { name: "package1", location: "../lib/package1" },
        { name: "package2", location: "/js/package2" }
    ]
};

async: Definiert, ob Dojo-Core asynchron geladen werden soll. Die Werte können true, false oder legacyAsync sein. Dadurch wird der Loader dauerhaft im domänenübergreifenden Modus versetzt.

async: true

parseOnLoad: Wenn "true", wird die Seite mit Dojo / Parser analysiert, wenn das DOM und alle anfänglichen Abhängigkeiten (einschließlich derjenigen im Array dojoConfig.deps) geladen wurden.

parseOnLoad: true

It is recommended that parseOnLoad be left at false (it defaults to false, so you can simply omit this property), and that developers explicitly require dojo/parser and call parser.parse().

deps: Ein Array von Ressourcenpfaden, das sofort geladen werden sollte, sobald Dojo geladen hat:

deps: ["dojo/parser"]

callback: Der Callback, der ausgeführt wird, sobald deps abgerufen wurden:

callback: function(parser) {
    // Use the resources provided here
}

waitSeconds: Wartezeit bis zum Laden des Timeout für ein Modul; Standardwert 0 (für immer warten):

waitSeconds: 5

cacheBust: Wenn "true", wird die Zeit als Abfragenzeichenfolge an die URL jedes Moduls angehängt, um das Zwischenspeichern des Moduls zu vermeiden:

cacheBust: true

Lassen Sie uns nun eine einfache Demo erstellen, in der die grundlegenden Parameter verwendet werden. Ein sehr häufiges Szenario ist die Verwendung von Dojo Toolkit von CDN mit lokalen Modulen.

Nehmen wir an, wir verwenden Google CDN mit Modulen im Bereich /documentation/tutorials/1.10/dojo_config/demo :

<!-- Configure Dojo first -->
<script>
    dojoConfig = {
        has: {
            "dojo-firebug": true,
            "dojo-debug-messages": true
        },
        // Don't attempt to parse the page for widgets
        parseOnLoad: false,
        packages: [
            // Any references to a "demo" resource should load modules locally, *not* from CDN
            {
                name: "demo",
                location: "/documentation/tutorials/1.10/dojo_config/demo"
            }
        ],
        // Timeout after 10 seconds
        waitSeconds: 10,
        map: {
            // Instead of having to type "dojo/domReady!", we just want "ready!" instead
            "*": {
                ready: "dojo/domReady"
            }
        },
        // Get "fresh" resources
        cacheBust: true
    };
</script>

<!-- Load Dojo, Dijit, and DojoX resources from Google CDN -->
<script src="//ajax.googleapis.com/ajax/libs/dojo/1.10.4/dojo/dojo.js"></script>

<!-- Load a "demo" module -->

<script>
    require(["demo/AuthoredDialog", "dojo/parser", "ready!"], function(AuthoredDialog, parser) {
        // Parse the page
        parser.parse();

        // Do something with demo/AuthoredDialog...
    });
</script>

Durch die Verwendung der /documentation/tutorials/1.10/dojo_config/demo/ wir alle Verweise auf demo/* auf unser lokales Verzeichnis /documentation/tutorials/1.10/dojo_config/demo/ , während alle Verweise auf dojo , dijit und dojox von Google CDN stammen. Wenn das //ajax.googleapis.com/ajax/libs/dojo/1.10.4/dojo/demo/AuthoredDialog.js nicht definiert worden wäre, wäre die Anforderung für ein demo/AuthoredDialog //ajax.googleapis.com/ajax/libs/dojo/1.10.4/dojo/demo/AuthoredDialog.js an //ajax.googleapis.com/ajax/libs/dojo/1.10.4/dojo/demo/AuthoredDialog.js gegangen. Wir verwendeten auch einen Alias, indem wir ready mit dojo/domReady .