update - validar hash ruby




La mejor manera de convertir cadenas a símbolos en hash (20)

¿Cuál es la forma (más rápida / limpia / directa) de convertir todas las claves en un hash de cadenas a símbolos en Ruby?

Esto sería útil al analizar YAML.

my_hash = YAML.load_file('yml')

Me gustaría poder usar:

my_hash[:key] 

Más bien que:

my_hash['key']

La matriz que queremos cambiar.

cadenas = ["HTML", "CSS", "JavaScript", "Python", "Ruby"]

Cree una nueva variable como una matriz vacía para que podamos ".push" los símbolos en.

símbolos = []

Aquí es donde definimos un método con un bloque.

cuerdas. cada {| x | symbols.push (x.intern)}

Fin del código.

Así que esta es probablemente la forma más sencilla de convertir cadenas a símbolos en su (s) matriz (s) en Ruby. Haga una matriz de cadenas, luego cree una nueva variable y establezca la variable en una matriz vacía. Luego seleccione cada elemento en la primera matriz que creó con el método ".each". Luego use un código de bloque para ".push" todos los elementos en su nueva matriz y use ".intern o .to_sym" para convertir todos los elementos en símbolos.

Los símbolos son más rápidos porque ahorran más memoria en su código y solo puede usarlos una vez. Los símbolos son más comúnmente utilizados para las claves en hash lo que es genial. No soy el mejor programador de Ruby, pero esta forma de código me ayudó mucho. Si alguien sabe una manera mejor, por favor, comparta y puede usar este método para el hash también.



Aún más terso:

Hash[my_hash.map{|(k,v)| [k.to_sym,v]}]

Aquí hay un método mejor, si estás usando Rails:

params symbolize_keys

El fin.

Si no lo está, simplemente copie su código (también está en el enlace):

myhash.keys.each do |key|
  myhash[(key.to_sym rescue key) || key] = myhash.delete(key)
end

En caso de que la razón por la que necesite hacer esto sea porque sus datos provinieron originalmente de JSON, podría omitir cualquiera de estos análisis simplemente pasando la opción :symbolize_names al ingerir JSON.

No requiere rieles y funciona con Ruby> 1.9

JSON.parse(my_json, :symbolize_names => true)

En ruby, considero que esta es la forma más sencilla y fácil de entender para convertir claves de cadena en hashes a símbolos:

my_hash.keys.each { |key| my_hash[key.to_sym] = my_hash.delete(key)}

Para cada clave en el hash, llamamos delete en ella, que lo elimina del hash (también delete devuelve el valor asociado con la clave que se eliminó) e inmediatamente establecemos este valor igual a la clave simbolizada.


Esto es para las personas que usan mruby y no tienen definido ningún método symbolize_keys :

class Hash
  def symbolize_keys!
    self.keys.each do |k|
      if self[k].is_a? Hash
        self[k].symbolize_keys!
      end
      if k.is_a? String
        raise RuntimeError, "Symbolizing key '#{k}' means overwrite some data (key :#{k} exists)" if self[k.to_sym]
        self[k.to_sym] = self[k]
        self.delete(k)
      end
    end
    return self
  end
end

El método:

  • simboliza solo las teclas que son String
  • Si simbolizar una cadena significa perder algunas informaciones (sobrescribir parte del hash) RuntimeError un RuntimeError
  • simbolizan también hashes contenidas recursivamente
  • devolver el hash simbolizado
  • trabaja en su lugar!

Esto no es exactamente de una sola línea, pero convierte todas las claves de cadena en símbolos, también las anidadas:

def recursive_symbolize_keys(my_hash)
  case my_hash
  when Hash
    Hash[
      my_hash.map do |key, value|
        [ key.respond_to?(:to_sym) ? key.to_sym : key, recursive_symbolize_keys(value) ]
      end
    ]
  when Enumerable
    my_hash.map { |value| recursive_symbolize_keys(value) }
  else
    my_hash
  end
end

Para el caso específico de YAML en Ruby, si las teclas comienzan con ' : ', se internarán automáticamente como símbolos.

require 'yaml'
require 'pp'
yaml_str = "
connections:
  - host: host1.example.com
    port: 10000
  - host: host2.example.com
    port: 20000
"
yaml_sym = "
:connections:
  - :host: host1.example.com
    :port: 10000
  - :host: host2.example.com
    :port: 20000
"
pp yaml_str = YAML.load(yaml_str)
puts yaml_str.keys.first.class
pp yaml_sym = YAML.load(yaml_sym)
puts yaml_sym.keys.first.class

Salida:

#  /opt/ruby-1.8.6-p287/bin/ruby ~/test.rb
{"connections"=>
  [{"port"=>10000, "host"=>"host1.example.com"},
   {"port"=>20000, "host"=>"host2.example.com"}]}
String
{:connections=>
  [{:port=>10000, :host=>"host1.example.com"},
   {:port=>20000, :host=>"host2.example.com"}]}
Symbol

Podrías ser perezoso, y envolverlo en un lambda :

my_hash = YAML.load_file('yml')
my_lamb = lambda { |key| my_hash[key.to_s] }

my_lamb[:a] == my_hash['a'] #=> true

Pero esto solo funcionaría para leer el hash, no escribir.

Para hacer eso, puedes usar Hash#merge

my_hash = Hash.new { |h,k| h[k] = h[k.to_s] }.merge(YAML.load_file('yml'))

El bloque de inicio convertirá las claves una vez a petición, aunque si actualiza el valor de la versión de cadena de la clave después de acceder a la versión de símbolo, la versión de símbolo no se actualizará.

irb> x = { 'a' => 1, 'b' => 2 }
#=> {"a"=>1, "b"=>2}
irb> y = Hash.new { |h,k| h[k] = h[k.to_s] }.merge(x)
#=> {"a"=>1, "b"=>2}
irb> y[:a]  # the key :a doesn't exist for y, so the init block is called
#=> 1
irb> y
#=> {"a"=>1, :a=>1, "b"=>2}
irb> y[:a]  # the key :a now exists for y, so the init block is isn't called
#=> 1
irb> y['a'] = 3
#=> 3
irb> y
#=> {"a"=>3, :a=>1, "b"=>2}

También puede hacer que el bloque de inicio no actualice el hash, lo que lo protegería de ese tipo de error, pero aún sería vulnerable a lo contrario: actualizar la versión del símbolo no actualizaría la versión de la cadena:

irb> q = { 'c' => 4, 'd' => 5 }
#=> {"c"=>4, "d"=>5}
irb> r = Hash.new { |h,k| h[k.to_s] }.merge(q)
#=> {"c"=>4, "d"=>5}
irb> r[:c] # init block is called
#=> 4
irb> r
#=> {"c"=>4, "d"=>5}
irb> r[:c] # init block is called again, since this key still isn't in r
#=> 4
irb> r[:c] = 7
#=> 7
irb> r
#=> {:c=>7, "c"=>4, "d"=>5}

Por lo tanto, hay que tener cuidado con estos cambios entre las dos formas clave. Quédate con uno.


Realmente me gusta la gema Mash .

puede hacer mash['key'] , o mash[:key] , o mash.key


Si desea una solución de vainilla rubí y, como yo, no tengo acceso a ActiveSupport aquí encontrará una solución de simbolización profunda (muy similar a las anteriores)

    def deep_convert(element)
      return element.collect { |e| deep_convert(e) } if element.is_a?(Array)
      return element.inject({}) { |sh,(k,v)| sh[k.to_sym] = deep_convert(v); sh } if element.is_a?(Hash)
      element
    end

Si está utilizando json y desea utilizarlo como un hash, en Ruby Core puede hacerlo:

json_obj = JSON.parse(json_str, symbolize_names: true)

simbolizar nombres: si se establece en verdadero, devuelve símbolos para los nombres (claves) en un objeto JSON. De lo contrario se devuelven cadenas. Las cadenas son las predeterminadas.

Doc: Json # parse symbolize_names


Si quieres una sola línea,

my_hash = my_hash.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}

Copiará el hash en uno nuevo con las teclas simbolizadas.


Symbolize_keys recursivamente para cualquier hash:

class Hash
  def symbolize_keys
    self.is_a?(Hash) ? Hash[ self.map { |k,v| [k.respond_to?(:to_sym) ? k.to_sym : k, v.is_a?(Hash) ? v.symbolize_keys : v] } ] : self
  end
end

Tantas respuestas aquí, pero la función de un solo método es hash.symbolize_keys


un fwiw más corto de una sola línea:

my_hash.inject({}){|h,(k,v)| h.merge({ k.to_sym => v}) }

symbolize_keys

hash = { 'name' => 'Rob', 'age' => '28' }
hash.symbolize_keys
# => { name: "Rob", age: "28" }

params.symbolize_keys también funcionará. Este método convierte las claves hash en símbolos y devuelve un nuevo hash.


ruby-1.9.2-p180 :001 > h = {'aaa' => 1, 'bbb' => 2}
 => {"aaa"=>1, "bbb"=>2} 
ruby-1.9.2-p180 :002 > Hash[h.map{|a| [a.first.to_sym, a.last]}]
 => {:aaa=>1, :bbb=>2}




hashmap