IIFEs Explained: How JavaScript Functions Can Run Automatically?

Have you ever seen code like this and wondered what it does?

(function() {
  // Some magic happens here
})();

This pattern, called an Immediately Invoked Function Expression (IIFE) (pronounced “iffy”), is a fundamental JavaScript concept with practical uses in modern development.

Function Declarations vs Expressions

JavaScript offers two ways to create functions:

// 1. Function Declaration (hoisted)
function loginUser() {
  console.log("User logged in");
}

// 2. Function Expression (not hoisted)
const authUser = function() {
  console.log("Authenticating...");
};

IIFEs use function expressions wrapped in parentheses:

(function() {
  console.log("Running immediately!");
})();

Why Use IIFEs? A Practical Example

Imagine building an authentication system:

// Without IIFE - variables are global
const API_KEY = "secret123";
let authToken = "";

function generateToken() {
  authToken = Math.random().toString(36).substr(2);
}

This pollutes the global scope. Here’s the IIFE solution:

const authModule = (function() {
  const API_KEY = "secret123";
  let authToken = "";

  function generateToken() {
    authToken = Math.random().toString(36).substr(2);
    return authToken;
  }

  return {
    getToken: generateToken
  };
})();

// Usage:
const token = authModule.getToken();

Key Benefits of IIFEs

• Private Scope: Variables don’t leak to global scope
• No Naming Collisions: Avoids conflicts in large apps
• Controlled Access: Only expose what’s needed
• Immediate Execution: Runs as soon as defined

Modern JavaScript Alternatives

While still useful, many IIFE use cases can now be handled with:

// ES6 Modules
export const API_KEY = "secret123";

// Block Scope (let/const)
{
  const privateVar = "hidden";
}

When to Use IIFEs Today

Conclusion

IIFEs remain valuable for:

1. Creating private scopes in script-based applications
2. Building modular patterns before ES6 modules
3. Isolating code execution contexts

While modern JavaScript provides alternatives like modules and block scoping, understanding IIFEs helps you work with legacy code and appreciate JavaScript’s evolution.