Static Properties & Methods

Static members belong to the class itself, not to any individual object created from it. They're shared across everything.

What Is a Static Member?

Normally, methods and properties on a class belong to each instance (each object you create with new). A static method or property belongs to the class itself. You call it directly on the class name, not on an instance.

Static Methods

A static method is a function on the class that you call on the class name itself — not on an object made from the class.

class MathHelper {
  static square(n) {
    return n * n;
  }

  static cube(n) {
    return n * n * n;
  }

  static add(a, b) {
    return a + b;
  }
}

// Called on the CLASS — not on an instance
MathHelper.square(4); // 16
MathHelper.cube(3);   // 27
MathHelper.add(2, 3); // 5

// ❌ Cannot call on an instance
const m = new MathHelper();
m.square(4); // TypeError: m.square is not a function

• static keyword before the method name makes it static
• You call it on the class: MathHelper.square(4)
• You cannot call it on an object: new MathHelper().square(4) throws an error
• Static methods are great for utility functions that relate to the class but don't need object data

Static Properties (Fields)

Static properties store values that belong to the class, not to any instance. All instances share the same static property.

class Counter {
  static count = 0; // shared across ALL Counter objects

  constructor(name) {
    this.name = name;
    Counter.count++; // increment the class-level counter each time
  }
}

const a = new Counter("Alice");
const b = new Counter("Bob");
const c = new Counter("Carol");

Counter.count; // 3 — the class knows how many instances were made
a.count;       // undefined — instances don't have access to static properties

• static count = 0 — a property that lives on the class itself
• Counter.count++ — we access it via the class name, not this
• All three instances update the same count — it's shared
• Individual instances (a, b, c) cannot read static properties directly

Static vs Instance — Side by Side

Real-World Use Cases

1. Factory Methods — Creating Objects in Different Ways

A factory method is a static method that creates and returns an instance. It's handy when you want different ways to build an object.

class User {
  constructor(name, role) {
    this.name = name;
    this.role = role;
  }

  static createAdmin(name) {
    return new User(name, "admin"); // creates a User with role already set
  }

  static createGuest() {
    return new User("Guest", "guest");
  }
}

const admin = User.createAdmin("Alice");
const guest = User.createGuest();

admin.name; // "Alice"
admin.role; // "admin"
guest.role; // "guest"

2. Constants on a Class

Static properties are great for constants that are naturally related to the class.

class Direction {
  static UP    = "up";
  static DOWN  = "down";
  static LEFT  = "left";
  static RIGHT = "right";
}

Direction.UP;    // "up"
Direction.RIGHT; // "right"

// Use them instead of raw strings — avoids typos
function move(dir) {
  if (dir === Direction.UP) { /* move up */ }
}

3. Validation Helper

class Email {
  constructor(address) {
    if (!Email.isValid(address)) {
      throw new Error("Invalid email address");
    }
    this.address = address;
  }

  static isValid(address) {
    return address.includes("@") && address.includes(".");
  }
}

Email.isValid("hello@example.com"); // true  — check without creating an object
Email.isValid("notanemail");         // false

const e = new Email("hello@example.com"); // works
const bad = new Email("notanemail");       // throws Error

Static Members and Inheritance

Child classes inherit static methods from parent classes — you can call the parent's static method on the child class too.

class Animal {
  static kingdom = "Animalia";

  static describe() {
    return `Kingdom: ${this.kingdom}`;
    // here 'this' is the class itself, not an instance
  }
}

class Dog extends Animal {
  static species = "Canis lupus familiaris";
}

Animal.describe();  // "Kingdom: Animalia"
Dog.describe();     // "Kingdom: Animalia" ← inherited!
Dog.kingdom;        // "Animalia"         ← static property inherited too
Dog.species;        // "Canis lupus familiaris" ← Dog's own static

You Already Know Static Members

JavaScript's built-in classes use static methods everywhere. You've likely already used them:

// Math class — all static methods
Math.round(4.7);  // 5
Math.max(1, 2, 3); // 3
Math.PI;          // 3.14159… (static property)

// Array — static methods
Array.isArray([1, 2]);    // true
Array.from("hello");      // ["h","e","l","l","o"]
Array.of(1, 2, 3);        // [1, 2, 3]

// Object — static methods
Object.keys({ a: 1 });    // ["a"]
Object.freeze({ a: 1 });  // frozen object

// Number — static methods and properties
Number.isInteger(4);      // true
Number.isNaN(NaN);         // true
Number.MAX_SAFE_INTEGER;    // 9007199254740991

// Promise — static methods
Promise.resolve(42);
Promise.all([p1, p2]);

All of these — Math.round, Array.isArray, Object.keys — are static methods. You call them on the class name, not on an instance.

Common Mistakes

class Foo {
  static total = 0;

  constructor() {
    this.total++;  // ❌ creates instance.total = NaN, doesn't change Foo.total
    Foo.total++;   // ✅ correct — updates the class-level property
  }
}

Best Practices

• Use static methods for utility/helper functions that are logically grouped with the class but don't need to read or write instance data.
• Use static properties for constants, configuration, and counters that belong to the concept of the class, not any one object.
• Factory methods (User.createAdmin()) are a great use for static — they make your API cleaner and more readable.
• Always access static members via the class name (ClassName.prop), not via this in an instance method — it's clearer and avoids bugs.

Performance Notes

Static methods are slightly cheaper than instance methods because they're looked up directly on the class, not through the prototype chain. In practice this difference is tiny — the main benefit of static is code organisation, not speed.

Browser Compatibility

Static methods have been supported since ES6 (2015) in all browsers. Static fields (static prop = value inside the class body) are ES2022 and supported in all modern browsers since 2022. For older environments, declare static properties after the class: MyClass.prop = value;.

Interview Questions

Summary

• The static keyword makes a method or property belong to the class itself, not to instances.
• Static methods are called on the class: ClassName.method().
• Static properties store shared data or constants at the class level.
• Inside a static method, this refers to the class, not an instance.
• Child classes inherit static members from parent classes.
• You already use static members every day: Math.round, Array.isArray, Object.keys.

Related Topics

• Classes: The Basics
• Inheritance & The super Keyword
• Getters, Setters & Private Fields

MDN reference: developer.mozilla.org → JavaScript → Classes → static