Question

据我所知，

的结果

["a", "A"].uniq

是

["a", "A"]

我的问题是：

如何制作[“a”，“A”] .uniq给我[“a”]或[“A”]

Answer 1

还有另一种方法可以做到这一点。您实际上可以将块传递给可用于评估每个元素的uniq或uniq!。

["A", "a"].uniq { |elem| elem.downcase }  #=>  ["A"]

或

["A", "a"].uniq { |elem| elem.upcase }  #=>  ["A"]

在这种情况下，所有内容都不区分大小写，因此它将始终返回数组["A"]

Answer 2

首先让案件保持一致。

e.g：

["a","A"].map{|i| i.downcase}.uniq

编辑：如果像mikej建议的那样，返回的元素必须与原始数组中的元素完全相同，那么这将为您完成：

a.inject([]) { |result,h| result << h unless result.map{|i| i.downcase}.include?(h.downcase); result }

Edit2 应该满足mikej的解决方案： - ）

downcased = [] 
a.inject([]) { |result,h| 
        unless downcased.include?(h.downcase);
            result << h
            downcased << h.downcase
        end;
        result}

Answer 3

你可以在case-normalized（例如downcased）值和实际值之间构建一个映射（Hash），然后只取哈希值：

["a", "b", "A", "C"]\
.inject(Hash.new){ |h,element| h[element.downcase] = element ; h }\
.values

选择给定单词的最后一次出现（不区分大小写）：

["A", "b", "C"]

如果你想要第一次出现：

["a", "b", "A", "C"]\
.inject(Hash.new){ |h,element| h[element.downcase] = element  unless h[element.downcase]  ; h }\
.values

Answer 4

["a", "A"].map{|x| x.downcase}.uniq
=> ["a"]

或

["a", "A"].map{|x| x.upcase}.uniq
=> ["A"]

Answer 5

如果您使用的是ActiveSupport，则可以使用 uniq_by 。它不会影响最终输出的情况。

['A','a'].uniq_by(&:downcase) # => ['A']

Answer 6

更有效率和方法是在哈希中使用uniq键，所以请检查：

["a", "A"].inject(Hash.new){ |hash,j| hash[j.upcase] = j; hash}.values

将返回最后一个元素，在本例中为

["A"]

而使用 || = 作为赋值运算符：

["a", "A"].inject(Hash.new){ |hash,j| hash[j.upcase] ||= j; hash}.values

将返回第一个元素，在本例中为

["a"]

特别是对于大型阵列，这应该更快，因为我们每次都不使用 include来搜索数组？

...欢呼声

Answer 7

更通用的解决方案（虽然不是最有效的）：

class EqualityWrapper
  attr_reader :obj

  def initialize(obj, eq, hash)
    @obj = obj
    @eq = eq
    @hash = hash
  end

  def ==(other)
    @eq[@obj, other.obj]
  end

  alias :eql? :==

  def hash
    @hash[@obj]
  end
end

class Array
  def uniq_by(eq, hash = lambda{|x| 0 })
    map {|x| EqualityWrapper.new(x, eq, hash) }.
    uniq.
    map {|x| x.obj }
  end

  def uniq_ci
    eq = lambda{|x, y| x.casecmp(y) == 0 }
    hash = lambda{|x| x.downcase.hash }
    uniq_by(eq, hash)
  end
end

uniq_by方法接受一个检查相等性的lambda和一个返回哈希的lambda，并删除这些数据定义的重复对象。

在此基础上实现，uniq_ci方法使用不区分大小写的比较来删除字符串重复项。

如何使数组不区分大小写

7 个答案: