proposal: maps: add function to check existence of a key #67377
Comments
|
I have also written plenty of examples like this. I've also fielded questions from folks new to Go about what it means when they encountered it for the first time in existing code, since it's not very easy to search for what this weird bunch of punctuation means. I like the idea of giving this common operation a name, even if it's not saving that many lines of code. (I tend to care much more about code being easy to understand for unfamiliar readers than about number of lines of code, in any event.) If I might join the bikeshedding discussion: since buzzies = slices.DeleteFunc(buzzies, func (buzz Buzz) bool {
return maps.HasKey(fizzies, buzz.ID)
})To me that makes the meaning pretty clear without having to consult the documentation, and isn't onerously long. Although I would be considerably more skeptical about it, if we do decide to also have a function for testing whether any of the elements have a matching value, analogous to |
|
More often than buzzies = slices.DeleteFunc(buzzies, func (buzz Buzz) bool {
return maps.HasKeyFunc(fizzies, func(key string) {
return strings.EqualFold(buzz.ID, key)
})
}) |
If you need to do that often, you probably are doing something very wrong. To perform case-insensitive search (or any similar operation that needs to modify key before comparison) you need to lookup all map keys. That defeats one purpose of the map, which is quick key lookup. If you need to do this kind of search, better way is to append records in e.g. upper case and then transform input value to upper case. |
|
One use-case I encountered is with switch statements. Example switch {
case _, ok := myMap["k1"]; ok: //this code is invalid
//...
case _, ok := myMap["k2"]; ok:
//...
}the if _, ok := myMap["k1"]; ok {
//...
}
if _, ok := myMap["k2"]; ok {
//...
}with HasKey it can look like this: switch {
case maps.HasKey(myMap, "k1"):
//...
case maps.HasKey(myMap, "k2"):
//...
}In fact, I already implemented a similar function for my personal use. |
|
@mrg0lden You can try nstd.HasEntry. |
Proposal Details
A lot of code uses pattern like this:
just to check if key exists in a map.
And, with
*Funcfunctions fromstrings,slices, etc packages it makes code look unnecessary ugly.For example, to filter out elements of a slice that exist in a map you need to do this:
Instead of, let's say, this:
That might be subjective, but one-line return statement looks less clunky.
I deliberately used this example because simple one, with
var buzzies []stringmight raise unnecessary questions like "why not add something likeHasKeyFunc(map[K]V) func(K) bool" which will make this example look like this:Which looks pretty, but doesn't make other cases any more readable than first example.
Bike-shedding section
I don't care about naming, but already implied
maps.Containsbecause it's common across std.One might argue that semantics of e.g.
slices.Containsdiffer frommaps.Containsbecauseslices.Containsuses slice values instead of indices.But there is an opposite argument of
delete(map, key)that follows this pattern for maps whileslices.Deleteuses indices instead of values.The text was updated successfully, but these errors were encountered: