As stated in the dart article:
The ".." syntax invokes a method (or setter or getter) but discards the result, and returns the original receiver instead.
So I assumed that this would work:
myList..clear().addAll(otherList);
which gave me the error that I can't call .addAll
on null
.
So apparently .
precedes ..
so that .addAll
has been invoked on the result of .clear()
.
I figure now that I have two possibilities to write this:
myList..clear()..addAll(otherList);
(myList..clear()).addAll(otherList);
(If I wanted to get the result of .addAll()
.Is this correct? If yes, why the decision to give .
precedence? It seems very counterintuitive. Is it to avoid syntax like this: myList(..clear().useResultOfClear()).addAll(otherList);
?
The cascade notation (. .) in Dart allows you to make a sequence of operations on the same object (including function calls and field access). This notation helps keep Dart code compact and removes the need to create temporary variables to store data.
Cascade notation is syntactic sugar in Dart that allows you to make a sequence of operations on the same object. You can use the "double dot" to call functions on objects and access properties. This "operator" is simply used to make your code cleaner and concise.
As pointed in the official Dart language article Method Cascades in Dart:
The ".." syntax invokes a method (or setter or getter) but discards the result, and returns the original receiver instead.
In brief, method cascades provide a syntactic sugar for situations where the receiver of a method invocation might otherwise have to be repeated.
Below are example based/copied from the previously cited article. For further information, go read it.
add()
exampleIn the scenario where one want to add multiple elements to a list, the legacy-way is to do multiple assignements :
myList.add("item1"); myList.add("item2"); // add again and again… myList.add("itemN");
While you can't do something like myList.add("item1").add("item1")….add("itemN");
as the add()
does not method return the myList
object but a void
, you can use the cascading operator instead as it discards the result, and returns the original receiver myList
:
myList..add("item1")..add("item2")…..add("itemN");
myList.add("item1").add("item2")….add("itemN");
So Instead of writing:
var address = getAddress(); address.setStreet(“Elm”, “13a”); address.city = “Carthage”; address.state = “Eurasia” address.zip(66666, extended: 6666);
One may write
getAddress() ..setStreet(“Elm”, “13a”) ..city = “Carthage” ..state = “Eurasia” ..zip(66666, extended: 6666);
You can read the article from Gilad Bracha : Method Cascades in Dart. At its ends, you will see many examples.
See also this answer of Lasse Nielsen about operator precedence :
It helps to think of ".." as not really an operator, but more like a scoping construct (like parentheses). It creates a new scope from the ".." to either the next "..", or the first other scope delimiter (";", ")", "}" or similar).
Basically, a..b().c()
is the same as (t){t.b().c(); return t;}(a)
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With