Module scope in Javascript - Time & Space Complexity

Time Complexity: Module scope

O(1)

Understanding Time Complexity

When we use modules in JavaScript, we want to know how the program's speed changes as the code grows.

We ask: How does the time to run code inside a module change with more code or imports?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

// module.js
export function greet(name) {
  return `Hello, ${name}!`;
}

// main.js
import { greet } from './module.js';
console.log(greet('Alice'));
    

This code defines a simple function in a module and uses it in another file.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Calling the greet function once.
• How many times: Exactly one time in this example.

How Execution Grows With Input

Since the function runs once, the time remains constant as code size grows.

Input Size (n)	Approx. Operations
10	1 operation
100	1 operation
1000	1 operation

Pattern observation: The time is constant regardless of input size.

Final Time Complexity

Time Complexity: O(1)

This means the execution time is constant for this operation inside the module.

Common Mistake

[X] Wrong: "Importing a module makes the program slower as the module size grows."

[OK] Correct: Importing just brings code in once; running functions inside the module costs time only when called.

Interview Connect

Understanding module scope time helps you explain how code organization affects performance in real projects.

Self-Check

"What if the greet function called another function inside the module multiple times? How would the time complexity change?"