dojo
Dojo configureren met dojoConfig

Opmerkingen

DojoConfig laden

In het onderstaande voorbeeld maken we een globaal javascript-object dojoConfig dat alle configuratiewaarden zal bevatten.

Opmerking: dojoConfig wordt gedefinieerd in een scriptblok voordat dojo.js wordt geladen. Dit is van het allergrootste belang - indien teruggedraaid, worden de configuratie-eigenschappen genegeerd.

<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>

Lader configuratie

Dojo ontving een nieuwe lader in Dojo 1.7 voor het nieuwe AMD-moduleformaat van de toolkit. Deze nieuwe lader heeft een paar nieuwe configuratie-opties toegevoegd die cruciaal zijn voor het definiëren van pakketten, kaarten en meer. Raadpleeg de zelfstudie Geavanceerd AMD-gebruik voor meer informatie over de lader. Belangrijke configuratieparameters van de lader zijn onder meer:

baseUrl: de basis-URL voorafgegaan aan een module-ID bij het converteren naar een pad of URL.

baseUrl: "/js"

pakketten: een reeks objecten die de pakketnaam en -locatie bieden:

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

map: hiermee kunt u paden in module-ID's toewijzen aan verschillende paden:

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

paden: een kaart van module-ID-fragmenten naar bestandspaden:

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: bepaalt of de Dojo-kern asynchroon moet worden geladen. Waarden kunnen true, false of legacyAsync zijn, waardoor de lader permanent in de oude domeinoverschrijdende modus wordt geplaatst.

async: true

parseOnLoad: Indien true, parseert de pagina met dojo / parser wanneer de DOM en alle initiële afhankelijkheden (inclusief die in de dojoConfig.deps array) zijn geladen.

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: Een reeks resourcepaden die onmiddellijk moeten worden geladen nadat Dojo is geladen:

deps: ["dojo/parser"]

callback: de callback die moet worden uitgevoerd nadat deps zijn opgehaald:

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

waitSeconds: hoeveelheid tijd om te wachten voordat de time-out van de belasting voor een module wordt aangegeven; standaard ingesteld op 0 (wacht altijd):

waitSeconds: 5

cacheBust: Indien waar, voegt de tijd als een querystring toe aan elke module-URL om modulecaching te voorkomen:

cacheBust: true

Laten we nu een eenvoudige demo maken waarin de basisparameters worden gebruikt. Een veel voorkomend scenario is het gebruik van Dojo Toolkit van CDN met lokale modules.

Stel dat we Google CDN gebruiken met modules in de ruimte /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>

Door de pakketconfiguratie te gebruiken, hebben we alle verwijzingen naar demo/* naar onze lokale /documentation/tutorials/1.10/dojo_config/demo/ directory gemaakt, terwijl we alle verwijzingen naar dojo , dijit en dojox van Google CDN hebben toegestaan. Als het demo/AuthoredDialog niet was gedefinieerd, zou het verzoek om demo/AuthoredDialog zijn gegaan naar //ajax.googleapis.com/ajax/libs/dojo/1.10.4/dojo/demo/AuthoredDialog.js . We hebben ook alias gebruikt, door ready te associëren met dojo/domReady .