Singleton Design Pattern
The Singleton design pattern ensures that a class has only one instance
and provides a global point of access to it. This pattern is useful when you want to limit the number of instances of a class to one.
Typescript Implementation
Here’s an example of the Singleton design pattern implemented in TypeScript:
class Singleton {
// Holds the single instance of the class
private static instance: Singleton;
// Private constructor ensures the class can't be instantiated from outside
private constructor() {
// Initialize any properties here
}
// Static method to provide access to the single instance
public static getInstance(): Singleton {
if (!Singleton.instance) {
Singleton.instance = new Singleton();
}
return Singleton.instance;
}
// Example method for demonstration
public showMessage(): void {
console.log("Hello from the Singleton instance!");
}
}
// Usage
const singleton1 = Singleton.getInstance();
const singleton2 = Singleton.getInstance();
// Output: Hello from the Singleton instance!
singleton1.showMessage();
// Output: true (Both are the same instance)
console.log(singleton1 === singleton2);
Golang Implementation
Here’s an example of the Singleton design pattern implemented in Golang:
package main
import "fmt"
type Singleton struct {
}
var instance *Singleton
func GetInstance() *Singleton {
if instance == nil {
instance = &Singleton{}
}
return instance
}
func (s *Singleton) ShowMessage() {
fmt.Println("Hello from the Singleton instance!")
}
func main() {
singleton1 := GetInstance()
singleton2 := GetInstance()
singleton1.ShowMessage()
fmt.Println(singleton1 == singleton2)
}
Python Implementation
Here’s an example of the Singleton design pattern implemented in Python:
class Singleton:
_instance = None
def __new__(cls):
if cls._instance is None:
cls._instance = super(Singleton, cls).__new__(cls)
return cls._instance
def show_message(self):
print("Hello from the Singleton instance!")
# Usage
singleton1 = Singleton()
singleton2 = Singleton()
singleton1.show_message()
print(singleton1 is singleton2)
Applications of the Singleton Pattern
The Singleton design pattern is commonly used in scenarios where you need to ensure that a class has only one instance, such as:
- Database connections
- Configuration settings
- Logger instances
- Caching mechanisms
- Thread pools
- Print spoolers
- Event managers