O-I/hash_except.md

## hash_except.md

      
    Raw
  

              hash_except.md
            
          
    Note: As of Ruby 3.0.0, Hash#except is now part of the language. However, Ruby does not implement Hash#except!.
Sometimes I want to remove a specific key-value pair from a Ruby hash and get the resulting hash back. If you're using Rails or ActiveSupport you can accomplish this using Hash#except:
hash = { a: 1, b: 2, c: 3 }
hash.except(:a)     # => { b: 2, c: 3 }

# note, the original hash is not modified
hash                # => { a: 1, b: 2, c: 3 }

# it also works with multiple key-value pairs
hash.except(:a, :c) # => { b: 2 }

# and returns the original hash if the key doesn't exist
hash.except(:q)    # => { a: 1, b: 2, c: 3 }

# there's also Hash#except!
hash.except!(:b)   # => { a: 1, c: 3 }

# this method does modify the original hash
hash               # => { a: 1, c: 3 }

# and also returns the original hash if the key doesn't exist
hash.except!(:b)   # => { a: 1, c: 3 }
Great. But what if we want to do this with plain old Ruby?
hash = { a: 1, b: 2, c: 3, d: 4 }

# the destructive case with removing exactly one key-value pair is easy
hash.tap { |h| h.delete(:a) }                         # => { b: 2, c: 3, d: 4 }
hash                                                  # => { b: 2, c: 3, d: 4 }

# the non-destructive case with one key-value pair isn't much harder
hash.dup.tap { |h| h.delete(:c) }                     # => { b: 2, d: 4 }
hash                                                  # => { b: 2, c: 3, d: 4 }

# but when we want to remove several key-value pairs, it gets a little messy
hash.dup.tap { |h| [:b, :c].map { |k| h.delete(k) } } # => { d: 4 }
hash                                                  # => { b: 2, c: 3, d: 4 }

# using reject makes it more palatable
hash.reject { |k, _| [:b, :c].include? k }            # => { d: 4 }
hash                                                  # => { b: 2, c: 3, d: 4 }

# and, of course, we can also use reject!
hash.reject! { |k, _| [:b, :c].include? k }           # => { d: 4 }
hash                                                  # => { d: 4 }

# not so fast...reject! doesn't behave the way we want when the keys aren't there :-(
hash.reject! { |k, _| [:b, :c].include? k }           # => nil
hash                                                  # => { d: 4 }

# so maybe tap-map-delete is the best we can do here
hash.tap { |h| [:b, :c].map { |k| h.delete(k) } }     # => { d: 4 }
hash                                                  # => { d: 4 }
How would you choose to do it?