Cómo reemplazar una clave hash con otra clave

Tengo una condición en la que tengo un hash

  hash = {"_id"=>"4de7140772f8be03da000018", .....}

y quiero este hash como

  hash = {"id"=>"4de7140772f8be03da000018", ......}

PD : No sé cuáles son las claves en el hash, son aleatorias, lo que viene con un prefijo "_" para cada clave y no quiero subrayados

hash[:new_key] = hash.delete :old_key

rails Hash tiene un método estándar para ello:

hash.transform_keys{ |key| key.to_s.upcase }

http://api.rubyonrails.org/classes/Hash.html#method-i-transform_keys

UPD: método ruby ​​2.5

Si todas las teclas son cadenas y todas tienen el prefijo de subrayado, entonces puede parchear el hash en su lugar con esto:

h.keys.each { |k| h[k[1, k.length - 1]] = h[k]; h.delete(k) }

El k[1, k.length - 1]bit agarra todo kexcepto el primer personaje. Si quieres una copia, entonces:

new_h = Hash[h.map { |k, v| [k[1, k.length - 1], v] }]

O

new_h = h.inject({ }) { |x, (k,v)| x[k[1, k.length - 1]] = v; x }

También puede usar subsi no le gusta la k[]notación para extraer una subcadena:

h.keys.each { |k| h[k.sub(/\A_/, '')] = h[k]; h.delete(k) }
Hash[h.map { |k, v| [k.sub(/\A_/, ''), v] }]
h.inject({ }) { |x, (k,v)| x[k.sub(/\A_/, '')] = v; x }

Y, si solo algunas de las teclas tienen el prefijo de subrayado:

h.keys.each do |k|
  if(k[0,1] == '_')
    h[k[1, k.length - 1]] = h[k]
    h.delete(k)
  end
end

Se pueden hacer modificaciones similares a todas las otras variantes anteriores, pero estas dos:

Hash[h.map { |k, v| [k.sub(/\A_/, ''), v] }]
h.inject({ }) { |x, (k,v)| x[k.sub(/\A_/, '')] = v; x }

debería estar bien con las teclas que no tienen prefijos de subrayado sin modificaciones adicionales.

tu puedes hacer

hash.inject({}){|option, (k,v) | option["id"] = v if k == "_id"; option}

¡Esto debería funcionar para su caso!

Si queremos cambiar el nombre de una clave específica en hash, entonces podemos hacerlo de la siguiente manera:
supongamos que mi hash es my_hash = {'test' => 'ruby hash demo'}
Ahora quiero reemplazar 'prueba' por 'mensaje', entonces:
my_hash['message'] = my_hash.delete('test')

h.inject({}) { |m, (k,v)| m[k.sub(/^_/,'')] = v; m }

hash.each {|k,v| hash.delete(k) && hash[k[1..-1]]=v if k[0,1] == '_'}

Fui exagerado y se me ocurrió lo siguiente. Mi motivación detrás de esto fue agregar claves de hash para evitar conflictos de alcance al fusionar / aplanar hashes.

Ejemplos

Extender clase de hash

Agrega el método rekey a las instancias de Hash.

# Adds additional methods to Hash
class ::Hash
  # Changes the keys on a hash
  # Takes a block that passes the current key
  # Whatever the block returns becomes the new key
  # If a hash is returned for the key it will merge the current hash 
  # with the returned hash from the block. This allows for nested rekeying.
  def rekey
    self.each_with_object({}) do |(key, value), previous|
      new_key = yield(key, value)
      if new_key.is_a?(Hash)
        previous.merge!(new_key)
      else
        previous[new_key] = value
      end
    end
  end
end

Ejemplo de anteponer

my_feelings_about_icecreams = {
  vanilla: 'Delicious',
  chocolate: 'Too Chocolatey',
  strawberry: 'It Is Alright...'
}

my_feelings_about_icecreams.rekey { |key| "#{key}_icecream".to_sym }
# => {:vanilla_icecream=>"Delicious", :chocolate_icecream=>"Too Chocolatey", :strawberry_icecream=>"It Is Alright..."}

Ejemplo de recorte

{ _id: 1, ___something_: 'what?!' }.rekey do |key|
  trimmed = key.to_s.tr('_', '')
  trimmed.to_sym
end
# => {:id=>1, :something=>"what?!"}

Acoplar y anexar un "alcance"

Si devuelve un hash para volver a escribir, combinará el hash que le permite aplanar colecciones. Esto nos permite agregar alcance a nuestras claves al aplanar un hash para evitar sobrescribir una clave al fusionar.

people = {
  bob: {
    name: 'Bob',
    toys: [
      { what: 'car', color: 'red' },
      { what: 'ball', color: 'blue' }
    ]
  },
  tom: {
    name: 'Tom',
    toys: [
      { what: 'house', color: 'blue; da ba dee da ba die' },
      { what: 'nerf gun', color: 'metallic' }
    ]
  }
}

people.rekey do |person, person_info|
  person_info.rekey do |key|
    "#{person}_#{key}".to_sym
  end
end

# =>
# {
#   :bob_name=>"Bob",
#   :bob_toys=>[
#     {:what=>"car", :color=>"red"},
#     {:what=>"ball", :color=>"blue"}
#   ],
#   :tom_name=>"Tom",
#   :tom_toys=>[
#     {:what=>"house", :color=>"blue; da ba dee da ba die"},
#     {:what=>"nerf gun", :color=>"metallic"}
#   ]
# }

Las respuestas anteriores son lo suficientemente buenas, pero podrían actualizar los datos originales. En caso de que no desee que se vean afectados los datos originales, puede probar mi código.

 newhash=hash.reject{|k| k=='_id'}.merge({id:hash['_id']})

Primero ignorará la clave '_id' y luego se fusionará con la actualizada.