Quand dois-je utiliser require () et quand utiliser define ()?

Je joue avec requirejs depuis quelques jours. J'essaie de comprendre les différences entre définir et exiger.

Définir semble permettre la séparation des modules et permettre le respect de l'ordre des dépendances. Mais il télécharge tous les fichiers dont il a besoin pour commencer. Alors que ne nécessitent que les charges dont vous avez besoin quand vous en avez besoin.

Ces deux éléments peuvent-ils être utilisés ensemble et à quelles fins chacun d'eux devrait-il être utilisé?

Lorsque definevous enregistrez un module dans require.js sur lequel vous pouvez ensuite compter dans d'autres définitions de module ou exiger des instructions. Avec requirevous, "juste" chargez / utilisez un module ou un fichier javascript qui peut être chargé par require.js. Pour des exemples, regardez la documentation

Ma règle d'or:

• Définir: si vous souhaitez déclarer un module, d'autres parties de votre application dépendront.

• Obligatoire: si vous souhaitez simplement charger et utiliser des éléments.

À partir du code source require.js (ligne 1902):

/**
 * 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.
 */

La define()fonction accepte deux paramètres facultatifs (une chaîne qui représente un ID de module et un tableau de modules requis) et un paramètre requis (une méthode d'usine).

Le retour de la méthode d'usine DOIT retourner l'implémentation de votre module (de la même manière que le modèle de module ).

La require()fonction n'a pas à retourner l'implémentation d'un nouveau module.

À l'aide de define()vous, vous demandez quelque chose comme "exécutez la fonction que je transmets en tant que paramètre et attribuez ce qui retourne à l'ID que je transmets mais, avant, vérifiez que ces dépendances sont chargées" .

En utilisant require()vous dites quelque chose comme "la fonction que je passe a les dépendances suivantes, vérifiez que ces dépendances sont chargées avant de l'exécuter" .

La require()fonction est l'endroit où vous utilisez vos modules définis, afin d'être sûr que les modules sont définis, mais vous n'y définissez pas de nouveaux modules.

méthode "define" pour faciliter la définition du module et méthode "require" pour gérer le chargement des dépendances

define est utilisé pour définir des modules nommés ou non nommés en fonction de la proposition en utilisant la signature suivante:

define(
module_id /*optional*/, 
[dependencies] /*optional*/, 
definition function /*function for instantiating the module or object*/
);

exiger d'autre part est généralement utilisé pour charger du code dans un fichier JavaScript de niveau supérieur ou dans un module si vous souhaitez récupérer dynamiquement les dépendances

Reportez-vous à https://addyosmani.com/writing-modular-js/ pour plus d'informations.

Règles générales:

1. Vous utilisez définir lorsque vous souhaitez définir un module qui sera réutilisé

2. Vous utilisez require pour charger simplement une dépendance

   //sample1.js file : module definition 
   define(function() {
         var sample1 = {};
         //do your stuff
        return sample1;
    });
   
   //sample2.js file : module definition and also has a dependency on jQuery and sample1.js
   define(['jquery', 'sample1'], function($,sample1) {
       var sample2 = {
           getSample1:sample1.getSomeData();
       };
       var selectSomeElement = $('#someElementId');
       //do your stuff....
       return sample2;
   });
   
   //calling in any file (mainly in entry file)
   require(['sample2'], function(sample2) {
       // sample1 will be loaded also
   });
   

J'espère que cela vous aidera.

require () et define () tous deux utilisés pour charger les dépendances. Il existe une différence majeure entre ces deux méthodes.

Ses gars très simples

Require (): la méthode est utilisée pour exécuter des fonctionnalités immédiates. define (): La méthode est utilisée pour définir les modules à utiliser dans plusieurs emplacements (réutilisation).