Uniq par attribut d'objet en Ruby

Question

Quel est le moyen le plus élégant de sélectionner dans un tableau des objets uniques par rapport à un ou plusieurs attributs?

Ces objets étant stockés dans ActiveRecord, vous pouvez également utiliser les méthodes de AR.

Answer 1

Utilisez Array # uniq avec un bloc:

@photos = @photos.uniq { |p| p.album_id }

Answer 2

Ajoutez la méthode uniq_by à Array dans votre projet. Cela fonctionne par analogie avec sort_by . Donc, uniq_by est destiné à uniq comme sort_by est destiné à tri . Utilisation:

uniq_array = my_array.uniq_by {|obj| obj.id}

La mise en œuvre:

class Array
  def uniq_by(&blk)
    transforms = []
    self.select do |el|
      should_keep = !transforms.include?(t=blk[el])
      transforms << t
      should_keep
    end
  end
end

Notez que cela retourne un nouveau tableau plutôt que de modifier votre tableau actuel. Nous n'avons pas encore écrit de méthode uniq_by! , mais elle devrait être assez simple si vous le souhaitez.

EDIT: Tribalvibes indique que cette implémentation est O (n ^ 2). Mieux serait quelque chose comme (non testé) ...

class Array
  def uniq_by(&blk)
    transforms = {}
    select do |el|
      t = blk[el]
      should_keep = !transforms[t]
      transforms[t] = true
      should_keep
    end
  end
end

Answer 3

Faites-le au niveau de la base de données:

YourModel.find(:all, :group => "status")

Answer 4

Vous pouvez utiliser cette astuce pour sélectionner unique par plusieurs attributs des éléments du tableau:

@photos = @photos.uniq { |p| [p.album_id, p.author_id] }

Answer 5

Au départ, j'avais suggéré d'utiliser la méthode select sur Array. À savoir:

[1, 2, 3, 4, 5, 6, 7] .select {| e | e% 2 == 0} nous renvoie [2,4,6] .

Mais si vous voulez le premier objet de ce type, utilisez detect .

[1, 2, 3, 4, 5, 6, 7] .detect {| e | e & 3> nous donne 4 .

Je ne sais pas trop ce que vous allez faire ici.

Answer 6

J'aime l’utilisation par Jmah d’un hachage pour imposer l’unicité. Voici quelques autres moyens de peau ce chat:

objs.inject({}) {|h,e| h[e.attr]=e; h}.values

C'est une belle doublure, mais je suppose que cela pourrait être un peu plus rapide:

h = {}
objs.each {|e| h[e.attr]=e}
h.values

Answer 7

Si je comprends bien votre question, je me suis attaqué à ce problème en utilisant une approche de quasi-piratage consistant à comparer les objets Marshaled afin de déterminer si les attributs varient. L'injection à la fin du code suivant serait un exemple:

class Foo
  attr_accessor :foo, :bar, :baz

  def initialize(foo,bar,baz)
    @foo = foo
    @bar = bar
    @baz = baz
  end
end

objs = [Foo.new(1,2,3),Foo.new(1,2,3),Foo.new(2,3,4)]

# find objects that are uniq with respect to attributes
objs.inject([]) do |uniqs,obj|
  if uniqs.all? { |e| Marshal.dump(e) != Marshal.dump(obj) }
    uniqs << obj
  end
  uniqs
end

Answer 8

La façon la plus élégante que j’ai trouvée est de faire appel à Tableau # uniq avec un bloc

enumerable_collection.uniq(&:property)

… ça se lit mieux aussi!

Answer 9

Vous pouvez utiliser un hachage, qui ne contient qu'une valeur pour chaque clé:

Hash[*recs.map{|ar| [ar[attr],ar]}.flatten].values

Answer 10

Rails a également une méthode #uniq_by - voir Tableau paramétré # uniq (c'est-à-dire, uniq_by)

Answer 11

J'aime les réponses de Jmah et Head. Mais préservent-ils l'ordre des tableaux? Cela pourrait arriver dans les versions ultérieures de ruby, car certaines exigences relatives à la préservation de l'ordre d'insertion dans le hachage ont été écrites, mais voici une solution similaire, que j'aime bien, qui préserve l'ordre, quel que soit.

h = Set.new
objs.select{|el| h.add?(el.attr)}

Answer 12

Implémentation ActiveSupport:

def uniq_by
  hash, array = {}, []
  each { |i| hash[yield(i)] ||= (array << i) }
  array
end

Answer 13

Maintenant, si vous pouvez trier les valeurs d'attribut, cela peut être fait:

class A
  attr_accessor :val
  def initialize(v); self.val = v; end
end

objs = [1,2,6,3,7,7,8,2,8].map{|i| A.new(i)}

objs.sort_by{|a| a.val}.inject([]) do |uniqs, a|
  uniqs << a if uniqs.empty? || a.val != uniqs.last.val
  uniqs
end

C'est pour un attribut unique unique, mais la même chose peut être faite avec un tri lexicographique ...