Null-aware operator with Maps - dart

Question

I had the same problem with lists, now it is Map.
What I would like to do
The following syntax is not Dart, as in it does not compile:
map?[key] ?? otherValue
If my map was not a Map but a List, it would look like Günter pointed out here:
list?.elementAt(index) ?? otherValue
What I am searching for
I understand that map?[key] is not valid syntax and therefore I am searching for something like elementAt, which works for lists, for maps.
map?.valueFor(key) ?? otherValue
valueOf
That does obviously not yet exist. The problem has solutions and valueOf might be a good one as well.

Answer 1

This works:
(map ?? const {})[key] ?? otherValue;
Because the key will fallback to accessing an empty Map, which will always return null.

Answer 2

I use this function for null-safe nested map access:
// Returns value of map[p1][p2]...[pn]
// where path = [p1, p2, ..., pn]
//
// example: mapGet(map, ["foo", 9, 'c'])
dynamic mapGet(Map map, List path) {
assert(path.length > 0);
var m = map ?? const {};
for (int i = 0; i < path.length - 1; i++) {
m = m[path[i]] ?? const {};
}
return m[path.last];
}

Answer 3

Something like this might work as an extension function:
extension MapExtensions<T, K> on Map<T, K> {
K getOrNull(T key) {
if (this == null || !this.containsKey(key)) {
return null;
} else {
return this[key];
}
}
K getOrElse(T key, K fallback) {
return this.getOrNull(key) ?? fallback;
}
}
Note: I haven't tested this, but should work.

Answer 4

Yet another syntax I used a few times:
map?.containsKey(key) ?? false ? map[key] : otherValue
Although functionally equivalent to the one proposed by #Günter Zöchbauer it is a bit more cumbersome.
Anyway, since it might look clearer in a few circumstances, it is worth to mention.

Answer 5

Or
map != null ? map[key]: otherValue;
which checks to see if the map is null before attempting to access the variable, which is the same as Günter's answer but checks first.

Answer 6

Based on Arturs answer, I think we should improve it and discuss alternative implementations.
Extension on non-null Map<K,V>
In extensions on non-nullable types this is never null, so we should not check against it. (see bottom for more information)
I use K for the key type and V for the value type
make all parameters and return values nullable.
extension MapExt<K, V> on Map<K, V> {
V? getOrNull(K? key) {
if (!containsKey(key) || key == null) {
return null;
} else {
return this[key];
}
}
V? getOrElse(K? key, V? fallback) {
return getOrNull(key) ?? fallback;
}
}
Null-safe usage would then look like this:
myMap?.getOrNull(someKey)
Note that it is required to put a ? here because the extensions is implemented on non-null maps, which is consistent with the rest of the nullsafe-apis.
(Not really an ) alternative: implement extension on nullable Map<K,V>?
It is possible to implement the extension on nullable maps (i.e. Map<K,V>?) which then would require to check this for null:
extension MapExt<K, V> on Map<K, V>? {
V? getOrNull(K? key) {
if (this == null || !this!.containsKey(key) || key == null) {
return null;
} else {
return this![key];
}
}
V? getOrElse(K? key, V? fallback) {
return getOrNull(key) ?? fallback;
}
}
This implementation allows accessing the extension methods on a potential null map directly without ?:
Map<int,int>? = ...
myMap.getOrNull(someKey); // no compiler error
I think this is not consistent with the rest of the null-safe operators. I would suggest not using it, but preferring the first variant, which reveals that the map might be null.

Answer 7

I have written my own version based on the answers above. It is used mostly for the JSON object handling.
dynamic mapOrListGet(dynamic map, List path) {
assert(path.length > 0);
assert(map is List || map is Map);
var m = map ?? const {};
var firstEl = path.removeAt(0);
var result = (m is List)
? (firstEl < m.length ? m.elementAt(firstEl) : null)
: m[firstEl];
if (path.length == 0 || result == null) {
return result;
} else {
return mapOrListGet(result, path);
}
}
And here is how it works.