dojo
Configuration de Dojo avec dojoConfig

Remarques

Charger DojoConfig

Dans l'exemple ci-dessous, nous créons un objet javascript global, dojoConfig qui contiendra toutes les valeurs de configuration.

Remarque: dojoConfig est défini dans un bloc de script avant le chargement de dojo.js. Ceci est d'une importance primordiale - si elle est inversée, les propriétés de configuration seront ignorées.

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

Configuration du chargeur

Dojo a reçu un nouveau chargeur dans Dojo 1.7 pour prendre en charge le nouveau format de module AMD du kit d'outils. Ce nouveau chargeur a ajouté quelques nouvelles options de configuration essentielles à la définition de packages, de cartes et autres. Pour plus de détails sur le chargeur, voir le didacticiel Advanced AMD Usage. Les paramètres de configuration importants du chargeur incluent:

baseUrl: URL de base ajoutée à un identificateur de module lors de sa conversion en un chemin ou une URL.

baseUrl: "/js"

packages: tableau d'objets fournissant le nom et l'emplacement du package:

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

map: Permet de mapper des chemins dans des identificateurs de module vers différents chemins:

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

chemins: une carte des fragments d'ID de module pour les chemins de fichiers:

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: Définit si le core Dojo doit être chargé de manière asynchrone. Les valeurs peuvent être true, false ou legacyAsync, ce qui place le chargeur en permanence dans le mode interdomaine hérité.

async: true

parseOnLoad: Si true, analyse la page avec dojo / parser lorsque le DOM et toutes les dépendances initiales (y compris celles du tableau dojoConfig.deps) ont été chargées.

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: Un tableau de chemins de ressources à charger immédiatement une fois que Dojo a été chargé:

deps: ["dojo/parser"]

callback: le callback à exécuter une fois les deps récupérés:

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

waitSeconds: temps d'attente avant de signaler le délai de chargement d'un module; la valeur par défaut est 0 (attendez toujours):

waitSeconds: 5

cacheBust: Si true, ajoute l'heure à une chaîne de requête à chaque URL du module pour éviter la mise en cache du module:

cacheBust: true

Maintenant, créons une démo simple qui utilise les paramètres de base. Un scénario très courant consiste à utiliser Dojo Toolkit de CDN avec des modules locaux.

Disons que nous utilisons Google CDN avec des modules dans l'espace /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>

En utilisant la configuration des paquets, nous avons fait toutes les références à demo/* le point à notre locale /documentation/tutorials/1.10/dojo_config/demo/ répertoire, tout en permettant des références à dojo , dijit et dojox à venir de Google CDN. Si le paquet de démonstration n'avait pas été défini, la demande de demo/AuthoredDialog serait passée à //ajax.googleapis.com/ajax/libs/dojo/1.10.4/dojo/demo/AuthoredDialog.js . Nous avons également utilisé des alias, en les associant avec dojo/domReady .