Design Patterns Questions

Limited flexibility in handling object variations and customizations.

Slower performance because of the overhead of managing shared objects.

Increased memory consumption due to object duplication.

Reduced code readability due to the separation of intrinsic and extrinsic state.

To create objects without specifying their concrete classes.

To manage and transition between different states of an object.

To define a family of algorithms and encapsulate each one.

To provide a way to access elements of an aggregate object sequentially.

Open/Closed Principle

Liskov Substitution Principle

Dependency Inversion Principle

Single Responsibility Principle

The object that controls access to the real object.

The interface shared by the proxy and the real object.

The client that interacts with the proxy or the real object.

The object being accessed through the proxy.

By directly copying object properties.

By implementing the Cloneable interface.

By using the spread operator.

By using the Object.assign() method.

It relies on the client code to manage synchronization and prevent issues.

It creates a copy of the collection to ensure data integrity during iteration.

It generally does not handle this directly; safeguards like concurrent modification exceptions might be needed.

It automatically prevents any modifications to the collection while iteration is in progress.

It creates objects without exposing the instantiation logic to the client.

It represents the collection of objects being iterated over.

It implements the Iterator interface and provides the concrete implementation for iterating over a specific aggregate object.

It defines the interface for accessing and traversing elements.

It violates the Open/Closed Principle by requiring modification for new states.

It increases code complexity, especially for simple state machines.

It is inefficient for handling a large number of states.

It cannot be used with other design patterns.

To provide a way to access shared objects in a synchronized manner.

To encapsulate algorithms in objects, allowing for easy swapping and extension.

To define a family of algorithms, encapsulate each one, and make them interchangeable.

To minimize memory usage by sharing common data among multiple objects.

Creating objects that are only instantiated when actually needed.

Representing a complex object hierarchy in a simplified manner.

Defining a one-to-many dependency between objects.

Iterating over a collection of objects without exposing its structure.