`if name == 'main'` equivalent in javascript es6 modules

Question

Is it possible to check if JavaScript file is being run directly or if it was required as part of an es6 module import.

for example a main script is included.

// main.js
import './other';

if (mainTest){
  console.log('This should run');
}

which imports a dependency.

// other.js
if (mainTest){
  console.log('This should never run');
}

including <script src=main.js></script> should result in the console message from main.js but not other.js.

I found the answer to this question with regards to node, but I am interested specifically for es6 imports

The specification is a work in progress. So we don't know yet what the final code to retrieve this information looks like. — Walle Cyril, Apr 05 '16 at 17:22
See also [Detect whether ES Module is run from command line in Node](https://stackoverflow.com/q/57838022/1048572) — Bergi, Jul 04 '20 at 17:16

Junaga · Answer 1 · 2022-01-21T20:33:07.367

An alternative for ES6 modules is now supported in Node. Using the new import.meta builtin. (Don't forget to set "type": "module" in package.json.)

Example

// main.js
import "./lib.js"
import { fileURLToPath } from "url";

if (process.argv[1] === fileURLToPath(import.meta.url)) {
  console.log("I print to stdout!");
}

// lib.js
import { fileURLToPath } from "url";

if (process.argv[1] === fileURLToPath(import.meta.url)) {
  console.log("I don't run, because I'm an imported module.");
}

$ node main.js output:

I print to stdout!

Utility function

I like to just import { isMain } from "./lib/utils.js" and pass import.meta.url to isMain().

import { argv } from "process"
import { fileURLToPath } from "url"
/**
 * Check if a module is the main module launched with the node process.
 * Meaning the module is NOT imported by another module,
 * but was directly invoked by `node`, like this: `$ node main.js`
 *
 * @example
 * ```js
 * // main.js
 * import lib from "./lib.js"
 * import { isMain } from "./utils.js"
 *
 * if (isMain(import.meta.url)) {
 *   console.log("I print to stdout")
 * }
 *
 * // lib.js
 * import { isMain } from "./utils"
 *
 * if (isMain(import.meta.url)) {
 *   console.log("I don't run, because I'm an imported module")
 * }
 * ```
 *
 * @param {string} moduleUrl needs to be `import.meta.url`
 * @returns {boolean} true if the module is the main module
 */
export function isMain(moduleUrl) {
  const modulePath = fileURLToPath(moduleUrl)
  const [_binPath, mainScriptPath] = argv
  return modulePath === mainScriptPath
}

score 8 · Answer 2 · answered Jan 19 '16 at 15:42

8

module.parent will help you:

if(module.parent) {
    console.log('required module')
} else {
    console.log('main')
}

answered Jan 19 '16 at 15:42

just-boris

9,468
5
48
84

That seems to be node-specific as well. – Bergi Jan 19 '16 at 16:16
Yes, ES6 modules don't add anything here. Also, I guess it can be emulated somehow with Webpack for browsers. – just-boris Jan 19 '16 at 16:34
I'm looking for something that works in browsers. currently I use rollup as my bundling mechanism – Peter Saxton Jan 20 '16 at 07:58
2

NOTE: module.parent is [deprecated](https://nodejs.org/api/deprecations.html#DEP0144) now – Luke Taylor May 13 '21 at 20:09

score 3 · Answer 3 · answered Jan 20 '21 at 17:55

3

module.parent was deprecated in Node.js v14.6.0, however we can use require.main.

function main() {
    console.log("You're running the main file!");
}

if (require.main === module) {
    main();
}

A related answer can be found here.

answered Jan 20 '21 at 17:55

Ed The ''Pro''

875
10
22

5

It only works with commonjs and not es6 modules. – ofarukcaki Dec 21 '21 at 17:58

score 0 · Answer 4 · answered Jan 17 '16 at 19:38

0

The solution I see there is just to define the variable in the script you're importing. I.e. you define mainTest in main.js, and then use your existing if block.

answered Jan 17 '16 at 19:38

nicael

18,550
13
57
90

score 0 · Answer 5 · answered Jan 15 '22 at 16:14

If you are running in Node.js with type module, and don't name your files the same, and don't want to import a library, and want 1 line of code, this'll work:

if(process.argv[1].split('/')[process.argv[1].split('/').length - 1] === import.meta.url.split('/')[import.meta.url.split('/').length - 1]) {
  console.log("called from commandline")
} else {
  console.log("imported")
}

score 0 · Answer 6 · answered Mar 23 '22 at 08:23

0

The following simple code is available.

import { fileURLToPath } from "url";
const __filename = fileURLToPath(import.meta.url);

if (__filename === process.argv[1]) {
  console.log("main");
} else {
  console.log("not main");
}

answered Mar 23 '22 at 08:23

nemo

11

score -1 · Answer 7 · answered Jun 29 '23 at 16:22

Here is a function which works for both CommonJS and ES6. Read the code comments for example usage. This is written in TypeScript but can be easily converted to any flavor of plain JS.

// const { fileURLToPath } = require('url');
import { fileURLToPath } from "url";

/** 
 * Determines whether a module is the entry point for the running node process.
 * This works for both CommonJS and ES6 environments.
 * 
 * ### CommonJS
 * ```js
 * if (moduleIsEntry(module)) {
 *     console.log('WOO HOO!!!');
 * }
 * ``` 
 * 
 * ### ES6
 * ```js
 * if (moduleIsEntry(import.meta.url)) {
 *     console.log('WOO HOO!!!');
 * }
 * ```
 */
const moduleIsEntry = (moduleOrImportMetaUrl: NodeModule | string) => {
    if (typeof moduleOrImportMetaUrl === 'string') {
        return process.argv[1] === fileURLToPath(moduleOrImportMetaUrl);
    }

    if (typeof require !== 'undefined' && 'exports' in moduleOrImportMetaUrl) {
        return require.main === moduleOrImportMetaUrl;
    }

    return false;
}

`if name == 'main'` equivalent in javascript es6 modules

7 Answers7

Example

Utility function

Linked

Related

`if __name__ == '__main__'` equivalent in javascript es6 modules

7 Answers7

Example

Utility function

Linked

Related

`if name == 'main'` equivalent in javascript es6 modules