Détecter si appelé via require ou directement par ligne de commande

Comment puis - je détecter si mon fichier Node.JS a été appelé en utilisant SH: node path-to-fileou JS: require('path-to-file')?

Ceci est l'équivalent Node.JS de ma question précédente en Perl: Comment puis-je exécuter mon script Perl uniquement s'il n'a pas été chargé avec require?

if (require.main === module) {
    console.log('called directly');
} else {
    console.log('required as a module');
}

Voir la documentation à ce sujet ici: https://nodejs.org/docs/latest/api/modules.html#modules_accessing_the_main_module

Il existe une autre méthode, légèrement plus courte (non décrite dans les documents mentionnés).

var runningAsScript = !module.parent;

J'ai décrit plus en détail comment tout cela fonctionne sous le capot dans cet article de blog .

J'étais un peu confus par la terminologie utilisée dans les explications. J'ai donc dû faire quelques tests rapides.

J'ai trouvé que ceux-ci produisent les mêmes résultats:

var isCLI = !module.parent;
var isCLI = require.main === module;

Et pour les autres confus (et pour répondre directement à la question):

var isCLI = require.main === module;
var wasRequired = !isCLI;

Tout comme en Python, je me retrouve toujours à essayer de me rappeler comment écrire ce putain d'extrait de code. J'ai donc décidé de créer un module simple pour cela. Cela m'a pris un peu de temps à développer, car l'accès aux informations du module de l'appelant n'est pas simple, mais c'était amusant de voir comment cela pourrait être fait.

L'idée est donc d'appeler un module et de lui demander si le module appelant est le principal. Nous devons comprendre le module de la fonction appelant. Ma première approche a été une variation de la réponse acceptée:

module.exports = function () {
    return require.main === module.parent;
};

Mais cela n'est pas garanti de fonctionner. module.parentpointe vers le module qui nous a chargés en mémoire, pas celui qui nous appelle. Si c'est le module appelant qui a chargé ce module d'assistance en mémoire, c'est bien. Mais si ce n'était pas le cas, nous sommes impuissants. Nous devons donc essayer autre chose. Ma solution était de générer une trace de pile et d'obtenir le nom du module de l'appelant à partir de là:

module.exports = function () {
    // generate a stack trace
    const stack = (new Error()).stack;
    // the third line refers to our caller
    const stackLine = stack.split("\n")[2];
    // extract the module name from that line
    const callerModuleName = /\((.*):\d+:\d+\)$/.exec(stackLine)[1];

    return require.main.filename === callerModuleName;
};

Maintenant, nous pouvons faire:

if (require("./is-main-module")()) {  // notice the `()` at the end
    // do something
} else {
    // do something else
}

Ou plus lisible:

const isMainModule = require("./is-main-module");

if (isMainModule()) {
    // do something
} else {
    // do something else
}

Inoubliable :-)

Essayez ceci si vous utilisez des modules ES6:

if (process.mainModule.filename === __filename) {
  console.log('running as main module')
}