Dojo exigent() et DMLA (1.7)

Question

Je vais avoir un heckuva temps de la transition de Dojo et de la nouvelle AMD structure, et je suis vraiment en espérant que quelqu'un peut jeter quelque lumière sur l'ensemble du concept. J'ai été sur Google pour la dernière quelques semaines à essayer de trouver des informations sur de ne pas l'usage, mais la structure et le modèle de conception tendances dans l'utilisation de ce.

Je trouve étrange que pour un nombre relativement complexe javascript de l'application, comme pour une page principale, où Dijits de la nécessité de créer et de style, des éléments du DOM, etc, que j'ai besoin de besoin, et donc d'utiliser, une TONNE de différents modules qui étaient disponibles dans le dojo de l'espace de noms avant que le système AMD (ou, au moins, n'est pas attribuée à 23 vars).

Exemple:

require(['dijit/form/ValidationTextBox', 'dijit/form/SimpleTextarea', 'dijit/form/CheckBox', 'dijit/Dialog', 'dijit/form/Form'])
require(['dojo/ready', 'dojo/parser', 'dojo/dom-style', 'dijit/registry', 'dojo/dom', 'dojo/_base/connect', 'dojo/dom-construct'], 
function(ready, parser, style, registry, dom, event, construct){
    //...etc
}

C'est seulement d'un ensemble de modules pour l'une des pages que je suis en train de travailler sur. Il y a certainement mieux, de non-rupture-de-future-communiqués de moyen d'accéder à ces méthodes, etc. Je veux dire, dois-je vraiment à l'importation d'un tout nouveau module d'utiliser byId()? Et encore un autre pour connecter les événements? En plus de cela, tout le désordre créé par avoir à attribuer un nom de variable dans les fonctions de la liste d'arguments à s'accrocher à juste semble un backstep.

J'ai pensé que vous seriez peut - require() le module uniquement lorsque cela est nécessaire, comme l' query module, mais si j'ai besoin d'elle plus d'une fois, alors les chances sont la variable, il vous est assigné est hors de portée, et j'avais besoin de le mettre dans un domReady! ou ready appel. reaalllly....??!

C'est pourquoi je ne peux que supposer que c'est mon manque de compréhension pour le dojo.

J'ai vraiment cherché et cherché et acheté des livres (quoique, un pré-AMD), mais cette bibliothèque est vraiment de me donner une course pour mon argent. J'apprécie la lumière quelqu'un peut jeter sur cette.

Edit par Exemple

require(['dijit/form/ValidationTextBox'])
require(['dojo/ready', 'dojo/parser', 'dojo/dom-style', 'dijit/registry', 'dojo/dom', 'dojo/_base/connect', 'dojo/dom-construct'], function(ready, parser, style, registry, dom, event, construct){
    /* perform some tasks */
    var _name = new dijit.form.ValidationTextBox({
        propercase : true,
        tooltipPosition : ['above', 'after']
    }, 'name')

    /*
    Let's say I want to use the query module in some places, i.e. here.
    */
    require(['dojo/query', 'dojo/dom-attr'], function(query, attr){
        query('#list li').forEach(function(li){
            // do something with these
        })
    })
}

Grâce à ce format, qui est utilisé avec de nombreux exemples à la fois le dojo toolkit gens ainsi que des sites de tiers, il serait, à mon humble avis, absolument ridicule pour charger tous les modules requis que le premier function(ready, parser, style, registy... serait de plus en plus longue, et de créer des problèmes avec les conflits de noms, etc.

De tir et require()ing tous les modules que j'aurais besoin au cours de la vie de l'script semble tout simplement ridicule à moi. Cela étant dit, je dois regarder à certains de le "gestionnaire de paquets" scripts. Mais pour cet exemple, si je voulais utiliser le module d'interrogation de sélectionner les lieux, j'faut le charger avec le reste dans la principale require() déclaration. Je comprends pourquoi dans une certaine mesure, mais ce qui est si mal avec des génériques de dot-syntaxe des espaces de noms? dojo.quel que soit? bibliothèque dijit.findIt()? Pourquoi charger le module, la référence à un nom unique, passe par la fermeture, bla bla?

Je souhaite que cela était plus facile de se poser la question, mais j'espère qu'un sens.

Ras-le-bol

Appelez-moi un newb, mais c'est vraiment.. vraiment.. me rend fou. Je ne suis pas un noob quand il s'agit de Javascript (apparemment non), mais wow. Je ne peux pas comprendre cette sortie!

Voici ce que je suis la collecte. Dans adder.js:

define('adder', function(require, exports){
    exports.addTen = function(x){
        return x + 10
    }
})

Dans certains page maître ou quoi que ce soit:

require(['./js/cg/adder.js'])

...ce qui ne veut pas suivre la nlfa require(['cg/adder']) format mais peu importe. Pas important maintenant.

Ensuite, l'utilisation de l' adder doit être:

console.log(adder.addTen(100)) // 110

Le plus proche que j'ai eu était console.log(adder) de retour 3. Yep. 3. Dans le cas contraire, adder is not defined.

Pourquoi est-ce si difficile? Je suis avec mon noob de la carte sur ce point, la cause je n'ai vraiment aucune idée de pourquoi ce n'est pas à venir ensemble.

Merci les gars.

Answer 1

La dépendance format de tableau:

define(["a", "b", "c"], function (a, b, c) {
});

peut en effet être ennuyeux et sujette à erreur. Correspondant de la matrice des entrées de paramètres de la fonction est une vraie douleur.

Je préfère l' require format ("Simplifié CommonJS Wrapper"):

define(function (require) {
    var a = require("a");
    var b = require("b");
    var c = require("c");
});

Cela permet de maintenir des lignes courtes et vous permet de réorganiser/supprimer/ajouter des lignes sans avoir à vous rappeler de changer les choses dans les deux endroits.

Ce dernier format ne fonctionnera pas sur PS3 et plus mobile Opera navigateurs, mais j'espère que vous n'avez pas de soins.

---

Quant à savoir pourquoi au lieu de le faire manuellement namespacing objets, @peller la réponse donne un bon aperçu de pourquoi la modularité est une bonne chose, et ma réponse à une question similaire, parle de pourquoi AMD et systèmes de modules comme un moyen de parvenir à la modularité sont une bonne chose.

La seule chose que je voudrais ajouter à @peller la réponse est de s'étendre sur les "attention de dépendances en fait en fait beaucoup mieux le code." Si votre module nécessite beaucoup trop d'autres modules, c'est mauvais signe! Nous avons un lâche règle dans notre 72K LOC JavaScript base de code d'un module doit être d'environ 100 lignes de long et exige entre zéro et quatre dépendances. Il nous a bien servi.

Answer 2

requirejs.org donne un assez bon aperçu de ce qu'AMD est et pourquoi vous voulez l'utiliser. Oui, Dojo est en mouvement vers de plus petits modules qui vous ferait référence individuellement. Le résultat est que vous charge de moins de code, et vos références sont explicites. Attention aux dépendances en fait en fait beaucoup mieux le code, je pense. AMD permet des optimisations, et une fois la migration terminée, vous n'aurez pas à charger le tout dans globals plus. Pas plus de collisions! Le require() bloc encapsule le code qui utilise différents modules. domReady! concerne le chargement du DOM et n'a rien à voir avec les variables dans la portée.

De toute façon, c'est en s'écartant de la Q&A de format de. Vous voudrez peut-être poser des questions spécifiques.