ReviseAlgo Logo

OOP in JavaScript

Static Methods & Properties

Master static class properties and methods in JavaScript. Learn to declare static properties, define factory methods, and understand how static keys bind to constructor functions.

Last Updated: July 15, 2026 • 10 min read

1. Introduction

In Object-Oriented Programming, some methods and properties belong to the class itself, rather than to class instances. JavaScript handles this using the static keyword, allowing you to declare static methods and properties on the class constructor.

2. Why It Matters

Static members are useful for implementing utility helpers, configuration settings, or factory patterns (methods that instantiate class instances). They group related functions under the class namespace without requiring you to instantiate an object first.

3. Real-World Analogy

Think of a Bicycle Factory:

  • Instance Method (Riding the bike): Ringing the bell or pedaling. These actions can only be performed on a specific bicycle instance.
  • Static Property (Factory blueprints): The total number of bicycles manufactured (factory counter), or the default color blueprint settings. These metrics belong to the factory namespace (the class), not to any individual bicycle. You don't ask a bicycle: "How many of you exist globally?"; you query the factory registry directly.

4. Static Members Syntax

Static methods and properties are declared using the static modifier prefix inside the class body:

5. Architectural Binding

Under the hood, static members are attached directly to the class constructor function, not the prototype:
• Instance Members: Attached to MathUtils.prototype.
• Static Members: Attached to the MathUtils function object itself.

6. Practical Example

This script demonstrates implementing the Factory Pattern using static class methods to instantiate objects from raw JSON payloads:

7. Common Mistakes

  • Trying to access static properties using this inside instance methods: Inside an instance method, the this context points to the object instance, not the class constructor. To access static properties, reference the class name directly: ClassName.staticProp.

8. Quick Quiz

Q1: Where are static methods attached under the hood?

A) Stored on each object instance

B) Attached directly to the class constructor function object itself

Answer: B — Static methods are attached directly to the constructor function object, rather than its prototype.

9. Scenario-Based Challenge

The Instance Counter Tracker:

You want to track how many user account instances are active. Every time a new User is instantiated, increment a counter. Design this class using a private static property #count and a public static getter method getActiveUsers().

10. Debugging Exercise

Explain why this static helper call crashes, and how to fix it:

class Helper {
  static formatText(txt) {
    return txt.trim();
  }
}

const h = new Helper();
// Bug: trying to call static method on the instance!
h.formatText(' hello '); // crashes with TypeError: h.formatText is not a function! Why?
View Solution

Diagnosis: Static methods are attached directly to the constructor function object, not the prototype, meaning they cannot be called on class instances.

Fix: Call the static method directly on the class constructor:

Helper.formatText(' hello '); // Works!

11. Interview Questions

🟢 Q1: Explain where static properties and methods are stored under the hood, and how this affects inheritance.

Answer: Static properties and methods are attached directly to the constructor function object, rather than its prototype.
• Inheritance: In JavaScript classes, static properties are inherited by child classes. The prototype link of the child class constructor points to the parent class constructor (Object.getPrototypeOf(Child) === Parent). This allows static members to be inherited by child classes (e.g. ChildClass.staticMethod() works), which is a key difference between JS prototypes and traditional class languages.

12. Production Considerations

  • • Avoid Instance Dependencies: Static methods should be side-effect free and should not depend on instance state. If a method needs to access instance properties (like this.username), declare it as a standard instance method instead of a static method.