activerecord length - ¿Contar, tamaño, longitud...demasiadas opciones en Ruby?





vs size (6)


Encontré un buen answare en http://blog.hasmanythrough.com/2008/2/27/count-length-size

En ActiveRecord, hay varias maneras de averiguar cuántos registros hay en una asociación, y existen algunas diferencias sutiles en la forma en que funcionan.

post.comments.count: determina la cantidad de elementos con una consulta SQL COUNT. También puede especificar condiciones para contar solo un subconjunto de los elementos asociados (por ejemplo: conditions => {: author_name => "josh"}). Si configura un contador de caché en la asociación, #count devolverá ese valor almacenado en caché en lugar de ejecutar una nueva consulta.

post.comments.length: siempre carga los contenidos de la asociación en la memoria y luego devuelve la cantidad de elementos cargados. Tenga en cuenta que esto no obligará a una actualización si la asociación se ha cargado previamente y luego se crearon nuevos comentarios de otra manera (por ejemplo, Comment.create (...) en lugar de post.comments.create (...)).

post.comments.size - Esto funciona como una combinación de las dos opciones anteriores. Si la colección ya se ha cargado, devolverá su longitud igual que al invocar #length. Si aún no se ha cargado, es como llamar a #count.

También tengo una experiencia personal:

<%= h(params.size.to_s) %> # works_like_that !
<%= h(params.count.to_s) %> # does_not_work_like_that !

Parece que no puedo encontrar una respuesta definitiva al respecto y quiero asegurarme de que entiendo esto al "n'º nivel" :-)

    a = { "a" => "Hello", "b" => "World" }
    a.count  # 2
    a.size   # 2
    a.length # 2

    a = [ 10, 20 ]
    a.count  # 2
    a.size   # 2
    a.length # 2

Entonces, ¿qué usar? Si quiero saber si a tiene más de un elemento, parece que no importa, pero quiero asegurarme de que entiendo la diferencia real. Esto se aplica a las matrices también. Obtuve los mismos resultados.

Además, me doy cuenta de que count / size / length tiene diferentes significados con ActiveRecord. En este momento estoy más interesado en el Ruby puro (1.92), pero si alguien quiere hablar sobre la diferencia que hace AR, también sería apreciado.

¡Gracias!




Tenemos varias formas de averiguar cuántos elementos en una matriz como .length , .size y .size . Sin embargo, es mejor usar array.size lugar de array.count . Porque. .size es mejor en rendimiento.




Agregando más a la respuesta de Mark Byers. En Ruby, el método array.size es un alias del método Array#length . No hay diferencia técnica al usar cualquiera de estos dos métodos. Posiblemente tampoco verá ninguna diferencia en el rendimiento. Sin embargo, array.count también hace el mismo trabajo pero con algunas funcionalidades adicionales count

Se puede usar para obtener un total de elementos no basados ​​en alguna condición. Se puede llamar al conde de tres maneras:

Array # count # Devuelve el número de elementos en Array

Array # count n # Devuelve el número de elementos que tienen el valor n en Array

Array # count {| i | i.even?} Devuelve el recuento según la condición invocada en cada matriz de elementos

array = [1,2,3,4,5,6,7,4,3,2,4,5,6,7,1,2,4]

array.size     # => 17
array.length   # => 17
array.count    # => 17

Aquí los tres métodos hacen el mismo trabajo. Sin embargo, aquí es donde el count pone interesante.

Digamos, quiero encontrar cuántos elementos de matriz contiene la matriz con valor 2

array.count 2    # => 3

La matriz tiene un total de tres elementos con valor como 2.

Ahora, quiero encontrar todos los elementos de la matriz mayores que 4

array.count{|i| i > 4}   # =>6

La matriz tiene un total de 6 elementos que son> de 4.

Espero que brinde información sobre el método de count .




En la mayoría de los casos (por ejemplo, Array o String ) el size es un alias de length .

count normalmente viene de Enumerable y puede tomar un bloque de predicados opcional. Por lo tanto, enumerable.count {cond} es [roughly] (enumerable.select {cond}).length - por supuesto puede eludir la estructura intermedia ya que solo necesita el recuento de predicados coincidentes.

Nota: No estoy seguro si el count fuerza una evaluación de la enumeración si el bloque no está especificado o si cortocircuita la length si es posible.

Editar (¡y gracias a la respuesta de Mark!): count sin bloque (al menos para Arrays) no obliga a una evaluación. Supongo que sin un comportamiento formal está "abierto" para otras implementaciones, si forzar una evaluación sin un predicado alguna vez tiene sentido de todos modos.




Existe una diferencia crucial para las aplicaciones que hacen uso de las conexiones de bases de datos.

Cuando está utilizando muchos ORM (ActiveRecord, DataMapper, etc.), el entendimiento general es que .size generará una consulta que solicita todos los elementos de la base de datos ('select * from mytable') y luego le dará el número de elementos resultante, mientras que .count generará una sola consulta ('select count (*) from mytable') que es considerablemente más rápido.

Debido a que estos ORM son tan frecuentes, sigo el principio de menos asombro. En general, si ya tengo algo en la memoria, uso .size, y si mi código generará una solicitud a una base de datos (o servicio externo a través de una API), uso .count.




Con el advenimiento de los argumentos de palabras clave en Ruby 2.0 ahora puede hacer

def login_success(msg:"Default", gotourl:"http://example.com")
  puts msg
  redirect_to gotourl
end

En Ruby 2.1 puede omitir los valores predeterminados,

def login_success(msg:, gotourl:)
  puts msg
  redirect_to gotourl
end

Cuando se llama, dejando fuera un parámetro que no tiene valor predeterminado, se generará un ArgumentError





ruby activerecord size content-length