Understanding Custom Type Assignment by Value in TypeScript

Learn how to effectively assign custom types by value in TypeScript using the spread operator to avoid reference issues.
---

Visit these links for original content and any more details, such as alternate solutions, latest updates/developments on topic, comments, revision history etc. For example, the original title of the Question was: Typescript - Custom type assignment by value

If anything seems off to you, please feel free to write me at vlogize [AT] gmail [DOT] com.
---
Understanding Custom Type Assignment by Value in TypeScript

When working with custom types in TypeScript (or JavaScript), you might encounter a common issue: assignments are made by reference rather than by value. This can lead to unintended changes in your variables when you expect them to remain independent. Let's dive into this problem and explore how to handle it using practical solutions.

The Problem Statement

In TypeScript, when you assign one variable of a custom type to another, both variables reference the same underlying object in memory rather than creating a new instance. This behavior is particularly crucial when you want to reset or modify one variable without affecting another. Consider the following example:

[[See Video to Reveal this Text or Code Snippet]]

As illustrated, changing v1 also alters v2 due to both variables referencing the same object. You might wonder: Is there a way to create a true copy of the object, allowing changes in one without impacting the other?

The Solution: Using the Spread Operator

For scenarios like this, the spread operator offers a neat and concise solution to create a shallow copy of an object. This way, you can assign a new independent copy of the desired object rather than just another reference. Here is how you can do it:

[[See Video to Reveal this Text or Code Snippet]]

Important Notes on the Spread Operator

While the spread operator effectively creates a new instance for the top-level properties, it's important to note that it performs a shallow copy. This means:

Nested objects and arrays within the object will still be referenced rather than copied.

Changes to nested structures in one variable will still reflect in the other.

For instance, consider this more complex example:

[[See Video to Reveal this Text or Code Snippet]]

In this instance, modifying v2.c.d also changes v1.c.d because both v1.c and v2.c refer to the same nested object.

Conclusion

To effectively work with custom types in TypeScript while avoiding reference-related issues, utilizing the spread operator is a powerful technique. It allows you to create shallow copies of your objects, enabling modifications to one instance without impacting others. However, be cautious when dealing with nested objects, as they require more thoughtful handling.

By understanding and leveraging these features in TypeScript, you can improve your code's reliability and maintainability, ensuring that your variables behave as expected.