JS++ | Static Members and "Application-Global" Data

Table of Contents#

1. Classes and Instances Refresher
2. What Are Static Members?
3. Defining Static Members
4. Accessing Static Members
5. When to Use Static Members: Common Patterns
6. Static Members as Application-Global Data
7. Best Practices and Pitfalls
8. Advanced: Static Constructors
9. Conclusion
10. References

1. Classes and Instances Refresher#

Before diving into static members, recall that:

• Classes are blueprints for creating objects (instances)
• Each instance maintains its own copy of instance fields
• Methods operate on the state of their specific instance

class User {
    string name;
    int age;
 
    void greet() {
        Console.log("Hello, I'm " + this.name);
    }
}
 
User alice = new User("Alice", 30);
alice.greet(); // Operates on alice's state

2. What Are Static Members?#

Static members belong to the class itself, not individual instances. They have two key characteristics:

1. Single copy: Only one copy exists regardless of instance count
2. Lifetime: Persists for the application's duration

Use cases include:

• Constants (e.g., app version)
• Utility functions (e.g., math operations)
• Shared data (e.g., configuration)
• Singleton implementations

3. Defining Static Members#

Static Fields#

Add static modifier before the field declaration:

class AppConfig {
    // Constants
    static const string VERSION = "1.0.0";
 
    // Shared state
    static string environment = "production";
}

Static Methods#

Add static modifier before method declaration. Note they can't access this:

class MathUtils {
    static double square(double x) {
        return x * x;
    }
 
    static double hypotenuse(double a, double b) {
        return sqrt(square(a) + square(b));
    }
}

4. Accessing Static Members#

Access directly via the class name:

// Accessing static fields
Console.log(AppConfig.VERSION); // "1.0.0"
AppConfig.environment = "staging";
 
// Calling static methods
double result = MathUtils.hypotenuse(3, 4); // 5

Important: Instance syntax is invalid:

MathUtils m = new MathUtils();
m.square(2); // Error! Static member accessed via instance

5. When to Use Static Members: Common Patterns#

Pattern 1: Constants#

class Physics {
    static const double LIGHT_SPEED = 299792458;
}

Pattern 2: Utility Classes#

class StringUtils {
    static bool isBlank(string str) {
        return str.trim().length == 0;
    }
 
    static string reverse(string str) {
        // Implementation...
    }
}

Pattern 3: Shared Counter#

class Car {
    static int totalCars = 0;
    int id;
 
    Car() {
        this.id = ++totalCars;
    }
}

Pattern 4: Factories#

class LoggerFactory {
    static Logger getLogger(string name) {
        // Return configured logger instance
    }
}

6. Static Members as Application-Global Data#

The "Safe Globals" Approach#

Instead of polluting global namespace:

// ❌ Avoid: True global variable
string appName = "MyApp";

Use static members for controlled access:

class GlobalSettings {
    static string appName = "MyApp";
    static bool debugMode = false;
}
 
// Access anywhere safely
if (GlobalSettings.debugMode) {
    Console.log("[DEBUG] Operation started");
}

Singleton Implementation#

Singleton using a static field and private constructor:

class Database {
    private static Database instance;
    
    private Database() {
        // Initialization logic
    }
    
    static Database getInstance() {
        if (instance === null) {
            instance = new Database();
        }
        return instance;
    }
    
    void query(string sql) { /* ... */ }
}
 
// Usage
Database.getInstance().query("SELECT ...");

7. Best Practices and Pitfalls#

✅ Do:#

1. Immutable data: Prefer static const for constants
2. Stateless utilities: Use for pure functions without side effects
3. Lazy initialization: Delay expensive initialization until needed
4. Thread-safety: Note JS++ compiles to JavaScript (single-threaded)

❌ Avoid:#

1. Mutable global state: Leads to spaghetti code

   // Problematic mutable global
   static User currentUser; // Avoid in most cases

2. Instance-specific logic: Static methods shouldn't depend on instance state
3. Overuse: Only use when truly need class-wide behavior

⚠️ Memory Considerations#

Unlike instance members, static fields:

• Live in memory for the application lifecycle
• Can't be garbage-collected automatically
• Use sparingly for large datasets

8. Advanced: Static Constructors#

Initialize complex static data with static construct blocks (called automatically once):

class ThemeManager {
    static map<string, Color> themes;
    
    static construct {
        themes = {
            "light": new Color(255, 255, 255),
            "dark": new Color(0, 0, 0)
        };
        Console.log("Themes loaded");
    }
}

Key behaviors:

• Executed when class is first referenced
• Runs before any static members are accessed
• Only invoked once

9. Conclusion#

Static members in JS++ provide a robust mechanism for:

• Creating shared class-specific data and utilities
• Implementing safe application-global patterns
• Reducing memory overhead compared to per-instance storage

While powerful, exercise discipline:

• Prefer stateless utilities over mutable shared state
• Use const where possible for immutable data
• Reserve for truly class-wide concerns

When applied judiciously, static members help create more efficient, maintainable JS++ applications while avoiding the pitfalls of traditional global variables.

10. References#

1. JS++ Documentation: Classes
2. JS++ Language Specification (Section 8.7: Static Members)
3. Effective JS++: Modern Patterns by A. Developer
4. MDN Web Docs: Static Methods (JS++ parallels JavaScript)
5. Design Patterns: Elements of Reusable Object-Oriented Software by Gamma et al. (Singleton Pattern)