dojo
Configurazione di Dojo con dojoConfig

Osservazioni

Carica DojoConfig

Nell'esempio seguente, stiamo creando un oggetto javascript globale dojoConfig che conterrà tutti i valori di configurazione.

Nota: dojoConfig è definito in un blocco di script prima che venga caricato dojo.js. Ciò è di fondamentale importanza: se invertite, le proprietà di configurazione verranno ignorate.

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

Configurazione del caricatore

Dojo ha ricevuto un nuovo caricatore in Dojo 1.7 per adattarsi al nuovo formato del modulo AMD del toolkit. Questo nuovo caricatore ha aggiunto alcune nuove opzioni di configurazione che sono fondamentali per la definizione di pacchetti, mappe e altro. Per i dettagli sul caricatore, vedere il tutorial sull'uso di AMD avanzato. I parametri di configurazione del caricatore importanti includono:

baseUrl: l'URL di base anteposto a un identificatore di modulo durante la conversione in un percorso o URL.

baseUrl: "/js"

pacchetti: una serie di oggetti che forniscono il nome e l'ubicazione del pacchetto:

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

map: ti consente di mappare i percorsi negli identificatori dei moduli in diversi percorsi:

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

percorsi: una mappa dei frammenti di identificazione dei moduli in percorsi di file:

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: definisce se il core Dojo deve essere caricato in modo asincrono. I valori possono essere true, false o legacyAsync, che mette il caricatore permanentemente in modalità cross-domain legacy.

async: true

parseOnLoad: se true, analizza la pagina con dojo / parser quando il DOM e tutte le dipendenze iniziali (comprese quelle nell'array dojoConfig.deps) sono state caricate.

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: una serie di percorsi di risorse che dovrebbero essere caricati immediatamente dopo il caricamento di Dojo:

deps: ["dojo/parser"]

callback: il callback da eseguire una volta che i deps sono stati recuperati:

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

waitSeconds: tempo di attesa prima di segnalare il timeout del carico per un modulo; il valore predefinito è 0 (attendere per sempre):

waitSeconds: 5

cacheBust: se true, aggiunge l'ora come una stringa di query a ciascun URL del modulo per evitare la memorizzazione nella cache del modulo:

cacheBust: true

Ora creiamo una semplice demo che mette i parametri di base da usare. Uno scenario molto comune è l'utilizzo di Dojo Toolkit da CDN con moduli locali.

Supponiamo di utilizzare Google CDN con i moduli nello spazio /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>

Usando la configurazione dei pacchetti, abbiamo fatto tutti i riferimenti a demo/* puntare alla nostra directory /documentation/tutorials/1.10/dojo_config/demo/ , consentendo nel contempo qualsiasi riferimento a dojo , dijit e dojox provenienti da Google CDN. Se il pacchetto demo non fosse stato definito, la richiesta di demo/AuthoredDialog sarebbe andata a //ajax.googleapis.com/ajax/libs/dojo/1.10.4/dojo/demo/AuthoredDialog.js . Abbiamo anche usato l'alias, associando ready con dojo/domReady .