dojo
Configurando Dojo con dojoConfig

Observaciones

Cargar DojoConfig

En el siguiente ejemplo, estamos creando un objeto javascript global dojoConfig que contendrá todos los valores de configuración.

Nota: dojoConfig se define en un bloque de script antes de que se cargue dojo.js. Esto es de suma importancia: si se revierte, las propiedades de configuración se ignorarán.

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

Configuración del cargador

Dojo recibió un nuevo cargador en Dojo 1.7 para adaptarse al nuevo formato del módulo AMD del kit de herramientas. Este nuevo cargador agregó algunas nuevas opciones de configuración que son cruciales para definir paquetes, mapas y más. Para obtener más información sobre el cargador, consulte el tutorial de uso avanzado de AMD. Los parámetros importantes de configuración del cargador incluyen:

baseUrl: la URL base precedida de un identificador de módulo al convertirla en una ruta o URL.

baseUrl: "/js"

paquetes: una matriz de objetos que proporcionan el nombre y la ubicación del paquete:

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

mapa: le permite asignar rutas en identificadores de módulo a diferentes rutas:

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

rutas: un mapa de fragmentos de ID de módulo a rutas de archivo:

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" }
    ]
};

asíncrono: define si el núcleo de Dojo debe cargarse de forma asíncrona. Los valores pueden ser true, false o legacyAsync, lo que coloca al cargador de forma permanente en el modo de dominio cruzado heredado.

async: true

parseOnLoad: si es verdadero, analiza la página con dojo / parser cuando el DOM y todas las dependencias iniciales (incluidas las de la matriz dojoConfig.deps) se han cargado.

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 matriz de rutas de recursos que deben cargarse inmediatamente una vez que Dojo se haya cargado:

deps: ["dojo/parser"]

devolución de llamada: la devolución de llamada para ejecutar una vez que se han recuperado los deps:

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

waitSeconds: Cantidad de tiempo de espera antes de indicar el tiempo de espera de carga para un módulo; el valor predeterminado es 0 (esperar siempre):

waitSeconds: 5

cacheBust: Si es verdadero, agrega el tiempo como una cadena de consulta a cada URL del módulo para evitar el almacenamiento en caché del módulo:

cacheBust: true

Ahora vamos a crear una demostración simple que ponga los parámetros básicos a utilizar. Un escenario muy común es el uso de Dojo Toolkit desde CDN con módulos locales.

Digamos que usamos Google CDN con módulos en el espacio /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>

Mediante el uso de la configuración de paquetes, hemos hecho todas las referencias a demo/* punto en nuestro local de /documentation/tutorials/1.10/dojo_config/demo/ directorio, al tiempo que permite cualquier referencia al dojo , dijit , y dojox que venir de Google CDN. Si el paquete de demostración no se hubiera definido, la solicitud de demo/AuthoredDialog habría ido a //ajax.googleapis.com/ajax/libs/dojo/1.10.4/dojo/demo/AuthoredDialog.js . También usamos alias, asociando ready con dojo/domReady .