web-dev-qa-db-fra.com

Explication de la définition de la bibliothèque RequireJS

J'ai commencé à lire plusieurs tutoriels sur RequireJS. Dans aucun d'entre eux, le mot clé "define" n'a été expliqué de manière satisfaisante pour moi. Quelqu'un pourrait-il m'aider avec les tâches suivantes: 

define(
  ["Models/Person", "Utils/random", "jquery"], 
  function (Person, randomUtility, $) {..}
)

Qu'est-ce que "définir"? Est-ce que définir une fonction avec un tableau et une fonction anonyme à l'intérieur de celui-ci? Ou s'agit-il d'autre chose? Quelqu'un peut-il me donner plus d'informations sur ce type de définitions?

Ajout: Merci nnnnnn et pradeek pour vos réponses. Ici en Europe, il était 2h30 du soir lorsque je posais la question. Peut-être que je n'ai donc pas reconnu qu'il s'agissait d'un simple appel de fonction.

javascriptrequirejs
47
Wolfgang Adamec

define n'est pas spécifique à RequireJS, il fait partie de la spécification AMD . Burke notera que RequireJS n’implémente pas exactement la façon dont AMD le spécifie, car AMD n’a pas vraiment pris en compte les navigateurs.

define n'a pas de fonction anonyme. define est une méthode mise à la disposition des fichiers JavaScript basés sur AMD pour le chargement de leurs données. Des bibliothèques telles que RequireJS le mettent à votre disposition. L'implémentation spécifique n'a probablement pas de valeur pour vous. Je vais donc passer en revue celui que vous avez fourni car il s’agit du moyen le plus courant de déclarer un module.

define([array], object);

Array est une liste de modules dont dépend ce module. Il existe une relation 1 à 1 entre les modules et les fichiers. Vous ne pouvez pas avoir plusieurs modules dans un fichier ni plusieurs fichiers pour un module.

L'objet est le module que vous définissez. Cela peut être n'importe quoi, une structure ou une fonction qui retourne une structure. Lisez la documentation sur RequireJS pour plus de détails.

Si objet est une fonction, les arguments transmis à la fonction sont les modules répertoriés comme dépendances dans le premier argument de définition. Il est également important de noter que lorsque vous passez une fonction en tant que object, celle-ci ne sera exécutée qu'une fois. Les méthodes ou les propriétés créées sur cette instanciation peuvent être consultées à tout moment, mais ensuite par d’autres modules répertoriant ce module en tant que dépendance.

Bonne chance, je vous recommande de jouer avec cela et de lire la documentation lorsque les choses ne vous disent rien. Les documents RequireJS sont parfaits pour un démarrage rapide du fonctionnement des modules AMD.

60
Drew

J'ai trouvé define défini au bas de require.js (je me demandais aussi quel genre de chose ce mot define était, et voici la réponseIcherchais):

/**
 * The function that handles definitions of modules. Differs from
 * require() in that a string for the module should be the first argument,
 * and the function to execute after dependencies are loaded should
 * return a value to define the module corresponding to the first argument's
 * name.
 */
define = function (name, deps, callback) {
    var node, context;

    //Allow for anonymous modules
    if (typeof name !== 'string') {
        //Adjust args appropriately
        callback = deps;
        deps = name;
        name = null;
    }

    //This module may not have dependencies
    if (!isArray(deps)) {
        callback = deps;
        deps = null;
    }

    //If no name, and callback is a function, then figure out if it a
    //CommonJS thing with dependencies.
    if (!deps && isFunction(callback)) {
        deps = [];
        //Remove comments from the callback string,
        //look for require calls, and pull them into the dependencies,
        //but only if there are function args.
        if (callback.length) {
            callback
                .toString()
                .replace(commentRegExp, '')
                .replace(cjsRequireRegExp, function (match, dep) {
                    deps.Push(dep);
                });

            //May be a CommonJS thing even without require calls, but still
            //could use exports, and module. Avoid doing exports and module
            //work though if it just needs require.
            //REQUIRES the function to expect the CommonJS variables in the
            //order listed below.
            deps = (callback.length === 1 ? ['require'] : ['require', 'exports', 'module']).concat(deps);
        }
    }

    //If in IE 6-8 and hit an anonymous define() call, do the interactive
    //work.
    if (useInteractive) {
        node = currentlyAddingScript || getInteractiveScript();
        if (node) {
            if (!name) {
                name = node.getAttribute('data-requiremodule');
            }
            context = contexts[node.getAttribute('data-requirecontext')];
        }
    }

    //Always save off evaluating the def call until the script onload handler.
    //This allows multiple modules to be in a file without prematurely
    //tracing dependencies, and allows for anonymous module support,
    //where the module name is not known until the script onload event
    //occurs. If no context, use the global queue, and get it processed
    //in the onscript load callback.
    (context ? context.defQueue : globalDefQueue).Push([name, deps, callback]);
};
5
BlueMonkMN

J'ai trouvé cette page Pourquoi la DMLA? très utile. Pour résumer à partir de cette page, la spécification AMD est utile pour résoudre le problème "écrire un groupe de balises de script avec des dépendances implicites que vous devez commander manuellement". Il est utile de charger les dépendances avant d'exécuter les fonctions requises, comme import dans d'autres langages de programmation tels que python. AMD empêche également le problème de la pollution globale des espaces de noms. Vérifiez la section "It is an improvement over the web's current "globals and script tags" because".

1
vine'th

Je pense que la spécification de l’API RequireJs le résume assez bien:

Si le module a des dépendances, le premier argument doit être un tableau de noms de dépendances et le second argument doit être une fonction de définition. La fonction sera appelée pour définir le module une fois toutes les dépendances chargées. La fonction doit renvoyer un objet qui définit le module.

Ils énumèrent des exemples de toutes les formes syntaxiques de définitions.

0
undefined behaviour