Le comte, la taille, la longueur...trop de choix en Ruby?

Je n'arrive pas à trouver une réponse définitive à ce sujet et je veux m'assurer de comprendre ce à le "n-ième niveau" 🙂

 
a = { "un" => "Bonjour", "b" => "Monde" } 
un.décompte # 2 
un.taille # 2 
un.longueur # 2 

a = [ 10, 20 ] 
un.décompte # 2 
un.taille # 2 
un.longueur # 2

Afin de l'utiliser? Si je veux savoir si l'un a plus d'un élément, alors il ne semble pas à la matière, mais je veux m'assurer de comprendre la vraie différence. Cela s'applique à des tableaux trop. J'obtiens les mêmes résultats.

Aussi, je me rends compte que le comte/taille/longueur, ont des sens différents avec ActiveRecord. Je suis surtout intéressé à la pure Ruby (1.92) pour l'instant, mais si quelqu'un veut le carillon sur la différence AR fait que ce serait aussi bien appréciés.

Merci!

  • Le phénomène que vous avez rencontré est parfois appelé TMTOWTDI: Il n'y a Plus d'Une Façon De le Faire. Ce slogan vient de la communauté Perl, Perl et est l'un de l'influence sur Ruby.
  • ce sont généralement des alias pour les uns les autres, ils font la même chose. Il y a une méthode que vous devez garder à l'esprit: Array#nitems , qui retourne le nombre de non-NÉANT les éléments dans un tableau. Mais ce n'est pas disponible en Ruby 1.9 plus
InformationsquelleAutor cbmeeks | 2010-12-29
  1. 192

    Pour les tableaux et les tables de hachage taille est un alias pour length. Ils sont synonymes et de faire exactement la même chose.

    count est plus polyvalent - il peut prendre un élément ou d'un prédicat et de ne compter que ceux de ces éléments qui correspondent.

    > [1,2,3].count{|x| x > 2 }
=> 1

    Dans le cas où vous ne pas fournir un paramètre pour le comte, il a fondamentalement le même effet que l'appel de la longueur. Il peut y avoir une différence de performance si.

    Nous pouvons voir à partir de la le code source pour le Tableau qu'ils ne sont presque exactement la même chose. Voici le code en C pour la mise en œuvre de array.length:

    static VALUE
rb_ary_length(VALUE ary)
{
    long len = RARRAY_LEN(ary);
    return LONG2NUM(len);
}

    Et voici la partie pertinente de la mise en œuvre de array.count:

    static VALUE
rb_ary_count(int argc, VALUE *argv, VALUE ary)
{
    long n = 0;

    if (argc == 0) {
        VALUE *p, *pend;

        if (!rb_block_given_p())
            return LONG2NUM(RARRAY_LEN(ary));

        // etc..
    }
}

    Le code pour array.count fait quelques contrôles supplémentaires, mais à la fin des appels exactement le même code: LONG2NUM(RARRAY_LEN(ary)).

    Les hachages (le code source) d'autre part ne semblent pas mettre en place leur propre version optimisée de count de sorte que la mise en œuvre de Enumerable (le code source) est utilisé, ce qui itère sur tous les éléments et les compte un par un.

    En général, je conseille d'utiliser length (ou son alias size) plutôt que de count si vous voulez savoir combien il y a d'éléments tout à fait.

    Concernant ActiveRecord, d'autre part, il y sont des différences importantes. découvrez ce post:

    • +1 Yay pour aller à la source et de répondre à ma rêverie 🙂
    • Merci pour ce très instructif réponse!
    InformationsquelleAutor Mark Byers
  2. 10

    Il y a une différence cruciale pour les applications qui font usage de connexions de base de données.

    Lorsque vous êtes en utilisant de nombreuses Orm (ActiveRecord, DataMapper, etc.) la perception générale est que .la taille va générer une requête qui tous les articles de la base de données ('select * from matable') et de vous donner le nombre de postes, alors que .le comte va générer un seul query ('select count(*) from matable"), ce qui est considérablement plus rapide.

    Parce que ces Formulaires sont si répandues que j'suivant le principe de moindre surprise. En général, si j'ai quelque chose dans la mémoire déjà, puis je utiliser .taille, et si mon code va générer une requête à une base de données (ou de service externe via une API) que j'utilise .le comte.

    • Quelque chose à considérer, c'est counter_cache. Si vous avez une table, foo, et il has_many bar, vous aurez une colonne dans foo nommé bars_count est mise à jour à tout moment d'un bar est créé ou détruit. À l'aide de foo.bars.size est ce que vérifie que la colonne (sans l'interrogation de tout bars). foo.bars.count la requête réelle, ce qui irait à l'encontre de l'objet de la cache.
    InformationsquelleAutor stef
  3. 7

    Dans la plupart des cas (par exemple, Tableau ou Chaîne) size est un alias pour length.

    count vient normalement à partir de Énumérable et peut prendre un prédicat facultatif bloc. Ainsi enumerable.count {cond} est [à peu près] (enumerable.select {cond}).length - il peut bien sûr contourner la structure intermédiaire qu'il a juste besoin de le comte de correspondance des prédicats.

    Note: je ne suis pas sûr si count forces une évaluation de l'énumération si le bloc n'est pas spécifié ou si elle les courts-circuits à la length si possible.

    Edit (et merci à Marc de réponse!): count sans bloc (au moins pour les Tableaux) ne pas la force d'une évaluation. Je suppose que sans mise comportement il est "ouvert" pour les autres implémentations, si forcer une évaluation sans un prédicat même jamais fait vraiment de sens de toute façon.

    InformationsquelleAutor
  4. 5

    J'ai trouvé une bonne answare à http://blog.hasmanythrough.com/2008/2/27/count-length-size

    Dans ActiveRecord, il existe plusieurs façons de savoir combien d'enregistrements
    sont dans une association, et il ya quelques différences subtiles dans la façon dont
    ils travaillent.

    post.commentaires.comte - Déterminer le nombre d'éléments avec un SQL
    Le COMTE de la requête. Vous pouvez également spécifier des conditions de compter uniquement un sous-ensemble de
    les éléments qui lui sont associés (par exemple :conditions => {:author_name =>
    "josh"}). Si vous configurez un compteur de cache sur l'association, #le comte
    sera de retour que la valeur mise en cache au lieu d'exécuter une nouvelle requête.

    post.commentaires.durée - Ce, toujours en charge le contenu de la
    association en mémoire, puis renvoie le nombre d'éléments chargés.
    Notez que cela ne peut pas forcer une mise à jour si l'association avait été
    précédemment chargé et ensuite de nouveaux commentaires ont été créés grâce à un autre
    (comme par exemple le Commentaire.créer(...) à la place de la poste.commentaires.créer(...)).

    post.commentaires.taille - Cela fonctionne comme une combinaison des deux précédentes
    des options. Si la collection a déjà été chargé, il sera de retour à son
    longueur semblable à l'appel d' #longueur. Si elle n'a pas encore été chargé, il est
    comme l'appel de #comte.

    J'ai également une expérience personnelle:

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

    Nous avons plusieurs façons de savoir combien d'éléments dans un tableau comme .length, .count et .size. Cependant, Il est préférable d'utiliser array.size plutôt que array.count. Parce que .size est de mieux en matière de performance.

    InformationsquelleAutor Venkat M
  6. 1

    L'ajout de plus pour Marquer Byers réponse. En Ruby, la méthode array.size est un alias pour Tableau#longueur méthode. Il n'y a pas de différence technique dans l'utilisation de ces deux méthodes. Peut-être que vous ne verrez pas de différence dans les performances. Cependant, la array.count aussi fait le même travail mais avec des fonctionnalités supplémentaires Tableau#comte

    Il peut être utilisé pour obtenir le nombre total des éléments basée sur une condition. Nombre peut être appelé en trois façons:

    Tableau#comte # Renvoie le nombre d'éléments dans le Tableau

    Tableau#comte n # Renvoie le nombre d'éléments ayant valeur de n dans la gamme

    Tableau#count{|i| i.même?} Retourne le comte basée sur la condition appelée sur chaque élément de la matrice de

    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

    Ici toutes les trois méthodes de faire le même travail. Cependant c'est là où le count devient intéressant.

    Disons, je veux savoir combien d'éléments du tableau le tableau contient la valeur 2

    array.count 2    # => 3

    Le tableau a un total de trois éléments dont la valeur est 2.

    Maintenant, je veux trouver tous les éléments du tableau de plus de 4

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

    Le tableau a un total de 6 éléments qui sont > de 4.

    J'espère qu'il donne des informations sur count méthode.

    InformationsquelleAutor Prabhakar