ruby on rails - sort_by - Ruby(Rails)#inject en hashes-¿buen estilo?

ruby sort_by

Question

Dentro del código de Rails, las personas tienden a usar el método de Inumerable # Inject para crear hash, como este:

somme_enum.inject({}) do |hash, element|
  hash[element.foo] = element.bar
  hash
 end

Si bien esto parece haberse convertido en una expresión común, ¿alguien ve una ventaja sobre la versión "ingenua", que sería como:

hash = {}
some_enum.each { |element| hash[element.foo] = element.bar }

La única ventaja que veo para la primera versión es que lo haces en un bloque cerrado y no (explícitamente) inicializas el hash. De lo contrario, abusa de un método de forma inesperada, es más difícil de entender y más difícil de leer. Entonces ¿por qué es tan popular?

Answer 1

Acabo de encontrar en Ruby inject con una sugerencia de hash inicial para usar each_with_object lugar de each_with_object :

hash = some_enum.each_with_object({}) do |element, h|
  h[element.foo] = element.bar
end

Me parece natural.

Otra forma, usando el tap :

hash = {}.tap do |h|
  some_enum.each do |element|
    h[element.foo] = element.bar
  end
end

Answer 2

Como señala Aleksey, Hash # update () es más lento que Hash # store (), pero eso me hizo pensar en la eficiencia general de #inject () frente a un # sencillo bucle. Así que hice una evaluación comparativa de algunas cosas:

(NOTA: actualizado el 19 de septiembre de 2012 para incluir #each_with_object)

(NOTA: actualizado el 31 de marzo de 2014 para incluir #by_initialization, gracias a la sugerencia de https://.com/users/244969/pablo )

los exámenes

require ''benchmark''
module HashInject
  extend self

  PAIRS = 1000.times.map {|i| [sprintf("s%05d",i).to_sym, i]}

  def inject_store
    PAIRS.inject({}) {|hash, sym, val| hash[sym] = val ; hash }
  end

  def inject_update
    PAIRS.inject({}) {|hash, sym, val| hash.update(val => hash) }
  end

  def each_store
    hash = {}
    PAIRS.each {|sym, val| hash[sym] = val }
    hash
  end

  def each_update
    hash = {}
    PAIRS.each {|sym, val| hash.update(val => hash) }
    hash
  end

  def each_with_object_store
    PAIRS.each_with_object({}) {|pair, hash| hash[pair[0]] = pair[1]}
  end

  def each_with_object_update
    PAIRS.each_with_object({}) {|pair, hash| hash.update(pair[0] => pair[1])}
  end

  def by_initialization
    Hash[PAIRS]
  end

  def tap_store
    {}.tap {|hash| PAIRS.each {|sym, val| hash[sym] = val}}
  end

  def tap_update
    {}.tap {|hash| PAIRS.each {|sym, val| hash.update(sym => val)}}
  end

  N = 10000

  Benchmark.bmbm do |x|
    x.report("inject_store") { N.times { inject_store }}
    x.report("inject_update") { N.times { inject_update }}
    x.report("each_store") { N.times {each_store }}
    x.report("each_update") { N.times {each_update }}
    x.report("each_with_object_store") { N.times {each_with_object_store }}
    x.report("each_with_object_update") { N.times {each_with_object_update }}
    x.report("by_initialization") { N.times {by_initialization}}
    x.report("tap_store") { N.times {tap_store }}
    x.report("tap_update") { N.times {tap_update }}
  end

end

Los resultados

Rehearsal -----------------------------------------------------------
inject_store             10.510000   0.120000  10.630000 ( 10.659169)
inject_update             8.490000   0.190000   8.680000 (  8.696176)
each_store                4.290000   0.110000   4.400000 (  4.414936)
each_update              12.800000   0.340000  13.140000 ( 13.188187)
each_with_object_store    5.250000   0.110000   5.360000 (  5.369417)
each_with_object_update  13.770000   0.340000  14.110000 ( 14.166009)
by_initialization         3.040000   0.110000   3.150000 (  3.166201)
tap_store                 4.470000   0.110000   4.580000 (  4.594880)
tap_update               12.750000   0.340000  13.090000 ( 13.114379)
------------------------------------------------- total: 77.140000sec

                              user     system      total        real
inject_store             10.540000   0.110000  10.650000 ( 10.674739)
inject_update             8.620000   0.190000   8.810000 (  8.826045)
each_store                4.610000   0.110000   4.720000 (  4.732155)
each_update              12.630000   0.330000  12.960000 ( 13.016104)
each_with_object_store    5.220000   0.110000   5.330000 (  5.338678)
each_with_object_update  13.730000   0.340000  14.070000 ( 14.102297)
by_initialization         3.010000   0.100000   3.110000 (  3.123804)
tap_store                 4.430000   0.110000   4.540000 (  4.552919)
tap_update               12.850000   0.330000  13.180000 ( 13.217637)
=> true

conclusión

Enumerable # cada uno es más rápido que Enumerable # inject, y Hash # store es más rápido que Hash # update. Pero el más rápido de todos es pasar una matriz en el momento de la inicialización:

Hash[PAIRS]

Si está agregando elementos después de que se ha creado el hash, la versión ganadora es exactamente lo que el OP sugería:

hash = {}
PAIRS.each {|sym, val| hash[sym] = val }
hash

Pero en ese caso, si eres un purista que quiere una sola forma léxica, puedes usar #tap y #each y obtener la misma velocidad:

{}.tap {|hash| PAIRS.each {|sym, val| hash[sym] = val}}

Para aquellos que no están familiarizados con el tap, crea un enlace del receptor (el nuevo hash) dentro del cuerpo, y finalmente devuelve el receptor (el mismo hash). Si conoces a Lisp, piensa que es la versión de Ruby del enlace LET.

-Uf-. Gracias por su atención.

posdata

Como la gente ha preguntado, este es el entorno de prueba:

# Ruby version    ruby 2.0.0p247 (2013-06-27) [x86_64-darwin12.4.0]
# OS              Mac OS X 10.9.2
# Processor/RAM   2.6GHz Intel Core i7 / 8GB 1067 MHz DDR3

Answer 3

Creo que tiene que ver con personas que no entienden completamente cuándo usar reducir. Estoy de acuerdo contigo, cada una es la forma en que debería ser

Answer 4

La belleza está en el ojo del espectador. Aquellos con algún fondo de programación funcional probablemente preferirán el método basado en inject (como yo), porque tiene la misma semántica que la función de orden superior , que es una forma común de calcular un único resultado de múltiples entradas. Si entiende la inject , debe comprender que la función se está utilizando como se pretendía.

Como una razón por la cual este enfoque parece mejor (a mis ojos), considere el alcance léxico de la variable hash . En el método basado en inject , hash solo existe dentro del cuerpo del bloque. En el método basado en each , la variable hash dentro del bloque necesita estar de acuerdo con algún contexto de ejecución definido fuera del bloque. ¿Quieres definir otro hash en la misma función? Usando el método de inject , es posible cortar y pegar el código basado en la inject y usarlo directamente, y es casi seguro que no introduzca errores (ignorando si uno debería usar C & P durante la edición, la gente sí). Utilizando each método, necesita C & P el código y cambiar el nombre de la variable hash al nombre que quiera usar; el paso adicional significa que es más propenso a error.

Answer 5

Si devuelve un hash, usar fusionar puede mantenerlo más limpio para que no tenga que devolver el hash después.

some_enum.inject({}){|h,e| h.merge(e.foo => e.bar) }

Si su enumeración es un hash, puede obtener la clave y valorarla bien con (k, v).

some_hash.inject({}){|h,(k,v)| h.merge(k => do_something(v)) }

Answer 6

inject (aka reduce ) tiene un lugar largo y respetado en los lenguajes de programación funcionales. Si estás listo para dar el paso y quieres entender mucha de la inspiración de Matz para Ruby, deberías leer la Estructura e Interpretación de los Programas de Computadora , disponible en línea en http://mitpress.mit.edu/sicp/ .

Algunos programadores encuentran estilísticamente más limpio tener todo en un paquete léxico. En su ejemplo de hash, al usar Inject significa que no tiene que crear un hash vacío en una declaración separada. Además, la instrucción de inyección devuelve el resultado directamente; no tiene que recordar que está en la variable hash. Para dejarlo realmente claro, considera:

[1, 2, 3, 5, 8].inject(:+)

vs

total = 0
[1, 2, 3, 5, 8].each {|x| total += x}

La primera versión devuelve la suma. La segunda versión almacena la suma en total , y como programador, debe recordar usar total lugar del valor devuelto por la declaración .each .

Una pequeña adición (y puramente idónea, no sobre inyección): su ejemplo podría estar mejor escrito:

some_enum.inject({}) {|hash, element| hash.update(element.foo => element.bar) }

... ya que hash.update() devuelve el hash en sí mismo, no necesita la declaración adicional de hash al final.

actualizar

@Aleksey me ha avergonzado de hacer una evaluación comparativa de las diversas combinaciones. Ver mi respuesta de evaluación comparativa en otro lugar aquí. Forma corta:

hash = {}
some_enum.each {|x| hash[x.foo] = x.bar}
hash 

es el más rápido, pero puede ser refundido un poco más elegantemente, y es tan rápido como:

{}.tap {|hash| some_enum.each {|x| hash[x.foo] = x.bar}}