在 Ruby 中，array.select { |x| array.count(x) > 1 } 的意思是什么？

Question

What does array.count(x) mean in the following:

arr1 = [1, 1, 3, 2, 6, 7, 9 ,6, 5, 1, 8, 9, 3]

def dups (array)
  duplicates = array.select { |x| array.count(x) > 1} #the (x) 
  duplicates.uniq
end

p dups(arr1) => [1,3,6,9]

The result is what I want, but I'm having a hard time understanding when I say what the block of code is doing. I've been playing around with the code and removing (x) to see that I then just get all the unique numbers in the array once, but I can't get through the array.count(x) > 1 part.

Answer 1

select is a filtering method. It passes each element to the block, and the block determines whether that element should be included in the output by returning true or false .

The block in your code does so by counting how often that element occurs in the array. If it occurs more than once, the block returns true , and select includes the corresponding element in the output.

It might help to put x , x 's count, and the block's return value in a table:

 x | count(x) | count(x) > 1
---+----------+-------------
 1 | 3        | true
 1 | 3        | true
 3 | 2        | true
 2 | 1        | false
 6 | 2        | true
 7 | 1        | false
 9 | 2        | true
 6 | 2        | true
 5 | 1        | false
 1 | 3        | true
 8 | 1        | false
 9 | 2        | true
 3 | 2        | true

Your select returns all elements with a count above 1: (those with true in the last column)

array = [1, 1, 3, 2, 6, 7, 9, 6, 5, 1, 8, 9, 3]
array.select { |x| array.count(x) > 1 }
#=> [1, 1, 3, 6, 9, 6, 1, 9, 3]

uniq then gets rid of the duplicates:

array.select { |x| array.count(x) > 1 }.uniq
#=> [1, 3, 6, 9]

You might have noticed that count has to traverse array once for each element in order to count its occurrences.

It's much faster to use a hash for counting the elements:

counts = Hash.new(0)
array.each { |x| hash[x] += 1 }
counts
#=> {1=>3, 3=>2, 2=>1, 6=>2, 7=>1, 9=>2, 5=>1, 8=>1}

Counting occurrences is so common that Ruby 2.7 has a dedicated method tally :

counts = array.tally
#=> {1=>3, 3=>2, 2=>1, 6=>2, 7=>1, 9=>2, 5=>1, 8=>1}

Now we can simple select the keys with a value above 1:

counts.select { |k, v| v > 1 }
#=> {1=>3, 3=>2, 6=>2, 9=>2}

counts.select { |k, v| v > 1 }.keys
#=> [1, 3, 6, 9]

Answer 2

TL;DR

The code is using Array#select to return elements that have more than one match within your Array object , based on an Array#count greater than 1. A breakdown of how #select and #count interact to make this happen is outlined below.

Analysis and Explanation

array.select { |x| array.count(x) > 1}

Array#select is important here, because it's saying:

For each element of array , return that element if the following block evaluates as truthy.

When the element passed to the block has more than one match within the Array, that element is returned. If there's only one match within the Array (zero matches doesn't make sense with your example) then that element is not returned.

In plain language, the block means:

For each element of array temporarily stored in scoped variable x , use the Array#count method to return the number of matching elements in the array that are greater than 1 . The code assumes that the variable stored in x can be compared against an Integer (in this case, the value 1 ).

In short, #select maps elements onto the block, the block evaluates the number of matches using #count, and then the elements that have multiple matches are returned as a new Array object.