Singleton Design Pattern: The Key to Efficient and Maintainable Code

A Singleton is a design pattern that ensures a class has only one instance (object) throughout the entire application and provides a global point to access it.

Let's us an analogy to understand!

Imagine if every department in a university (Computer Science, Engineering, Business) created their own separate Student Records Office. Each office:

• Has its own staff
• Maintains its own copy of student records
• Takes up its own building space
• Could have different, conflicting versions of the same student's data

Problems:

• Wastes resources (multiple buildings, staff)
• Data inconsistency (one office shows different grades than another)
• Higher maintenance costs
• Confusion about which office is authoritative

With Singleton:

There's ONE Student Records Office for the entire university:

• Single location everyone knows about
• One authoritative source of student data
• Shared staff and resources
• Consistent information

Benefits:

• Resource efficiency (one building, one staff)
• Data consistency (one source of truth)
• Clear authority (everyone knows where to go)
• Easier maintenance

Without Singleton: creates new instance every time service is initialised.

module.exports = function(app) {
 function postService(){
 	//some logic
 }
 postService.prototype.resolver = function (){
 // some more logic 
 }
  return new PostService(app); 
};

Bad design

Without Singleton, here we can create any number of instances

const postService1 = new PostService(app);
const postService2 = new PostService(app); 
const postService3 = new PostService(app); 

Without Singleton, you can create multiple copies of the same piece of code and no one knows what each one is doing. Which is waste of resources.

Without the Singleton pattern:

• Multiple instances of the same class can be created, leading to wasted resources.
• Data inconsistency can occur if different instances manage their own state.
• Maintenance becomes harder as there's no single source of truth.

Implementing Singleton:

Return existing instance if it exists, Only create new instance if one doesn't exist.

There is only 1 way to work with this piece of code.

function PostService(app) {
  if (PostService.instance) {
    return PostService.instance;
  }

  PostService.instance = this;
  this.db = app.get("user");
  this.Post = this.db.model("Post");
}

PostService.prototype.resolver = function (){
}

PostService.prototype.getInstance = function(app) {
  if (!PostService.instance) {
    PostService.instance = new PostService(app);
  }
  return PostService.instance;
};

Always returns same instance

module.exports = function(app) {
  return PostService.getInstance(app); 
};

When you use the PostService, you always get the same instance, no matter how many times you call getInstance:

With Singleton

1. First time: creates connection
2. Reuses existing connection, if called getInstance.
3. Reuses same connection again and again

const postService1 =PostService.getInstance(app);
const postService2 =PostService.getInstance(app);
const postService3 =PostService.getInstance(app);

console.log(postService1 === postService2); true - same instance!

Think of your phone's Settings app.

There's only ONE Settings app on your phone, and it's the same Settings every time you open it. It wouldn't make sense to have multiple, different versions of Settings on the same phone.

That's what a Singleton is - it ensures you're always working with the exact same instance, like how:

• Opening Settings always shows the same settings data
• Changes made in Settings are reflected everywhere
• You can't accidentally create a second Settings app

In code:

function PhoneSettings() {
    // Return existing Settings if it exists
    if (PhoneSettings.instance) {
        return PhoneSettings.instance;
    }

    // First time? Create the one and only Settings
    this.brightness = 50;
    this.volume = 70;
    PhoneSettings.instance = this;
}

// Try to access Settings from different places
const settings1 = new PhoneSettings();
settings1.brightness = 75;

const settings2 = new PhoneSettings();
console.log(settings2.brightness); // 75 - Same settings!

Just like how your phone maintains one source of truth for settings, a Singleton maintains one source of truth for your application's critical components.

Key Benefits of Singleton

1. Resource Efficiency:
2. Only one instance of the class is created and reused, saving memory and resources.
3. Data Consistency:
4. Since there's only one instance, all parts of the application work with the same data, avoiding inconsistencies.
5. Global Access:
6. The Singleton provides a single, well-known point of access for the instance.
7. Easier Maintenance:
8. With only one instance to manage, debugging and maintaining the code becomes simpler.

#designPattern #programming #softwareDevelopment #coding