Скачать или смотреть Understanding Why Dart Appears to Use Pass by Reference

Explore the nuances of Dart's parameter passing and why it behaves like `pass by reference` in certain scenarios while maintaining its `pass by value` foundation.
---
This video is based on the question https://stackoverflow.com/q/64080400/ asked by the user 'anas salhi' ( https://stackoverflow.com/u/6538884/ ) and on the answer https://stackoverflow.com/a/64080736/ provided by the user 'julemand101' ( https://stackoverflow.com/u/1953515/ ) at 'Stack Overflow' website. Thanks to these great users and Stackexchange community for their contributions.

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: Why Dart is acting as pass by reference?

Also, Content (except music) licensed under CC BY-SA https://meta.stackexchange.com/help/l...
The original Question post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license, and the original Answer post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license.

If anything seems off to you, please feel free to write me at vlogize [AT] gmail [DOT] com.
---
Understanding Why Dart Appears to Use Pass by Reference

When learning Dart, many developers encounter a common confusion regarding how variations in variable passing occur, especially in relation to pass by value and pass by reference. Specifically, you might wonder why certain behaviors in Dart make it feel like the language is using pass by reference. In this post, we will clarify these concepts and break down a practical example to illuminate this confusion.

The Core of the Confusion

Consider the following code snippet that demonstrates the behavior in question:

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

When you run this code, it produces the output:

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

What's Happening Here?

At a glance, it seems like modifying a property of an object inside a method has impacted the reference of that object outside the method. Let's break it down step-by-step to better understand this behavior.

Explaining Pass by Value vs. Pass by Reference

Fundamentals of Variables in Dart

First, it's important to know that in Dart, variables are essentially references to objects. Here's how it operates:

Pass by Value: When you pass a variable to a method, you are passing a copy of the reference (not the actual object). This means the method receives a reference to the same object in memory but cannot change the reference itself to point somewhere else.

Pass by Reference: To many, this implies that the method can change the actual object that the reference points to and see those changes outside the method. However, Dart's behavior is a twist on this expectation.

The Nature of Modifiable and Immutable Objects

In Dart, certain types of objects (like String, int, and double) are immutable. This restriction means that when passed to a method, you can't change their internal state, leading to a pure pass by value behavior. But when you’re working with mutable objects, like lists or instances of custom classes, you can modify their internal state even though the reference is passed by value.

Example of Immutability:

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

In this case, even if you try to change a to point to a new instance, the original reference in main remains unaffected. This illustrates Dart's consistency in pass by value even with the appearance of pass by reference for mutable object manipulations.

Understanding the Example's Output

Now, returning to our original example:

When you call b.add(a), you are passing a reference to the object a, which lets the add method access and manipulate its state.

The line a.y = 20; changes the state of the object itself, so when you print a.y afterwards, it reflects this change as 20.

Thus, Dart’s behavior may resemble pass by reference due to the mutability of objects, but the fundamental passing of the reference itself is still a case of pass by value.

Conclusion

Understanding how Dart handles variable passing is crucial to mastering the language. While Dart strictly adheres to pass by value, mutable objects can produce results that mimic pass by reference behavior. By grasping these concepts, you will become more adept at managing object states effectively in your Dart applications.

If you have any further questions or need clarification on this topic, feel free to ask in the comments below!