集合

集合

  • 对于数组与哈希，倾向使用字面量语法来构建实例（除非你需要给构造器传递参数）。
    [link]
## 差
arr = Array.new
hash = Hash.new

## 好
arr = []
hash = {}
  • 当创建一组元素为单词（没有空格或特殊字符）的数组时，倾向使用 %w 而不是 []。此规则只适用于数组元素有两个或以上的时候。
    [link]
## 差
STATES = ['draft', 'open', 'closed']

## 好
STATES = %w[draft open closed]
  • 当创建一组符号类型的数组（且不需要保持 Ruby 1.9 兼容性）时，倾向使用 %i。此规则只适用于数组元素有两个或以上的时候。
    [link]
## 差
STATES = [:draft, :open, :closed]

## 好
STATES = %i[draft open closed]
  • 避免在数组与哈希的字面量语法的最后一个元素之后添加逗号，尤其当元素没有分布在同一行时。
    [link]
## 差 - 尽管移动、新增、删除元素颇为方便，但仍不推荐这种写法
VALUES = [
           1001,
           2020,
           3333,
         ]

## 差
VALUES = [1001, 2020, 3333, ]

## 好
VALUES = [1001, 2020, 3333]
  • 避免在数组中创造巨大的间隔。
    [link]
arr = []
arr[100] = 1 # 现在你有一个很多 nil 的数组

  • 当访问数组的首元素或尾元素时，倾向使用 first 或 last 而不是 [0] 或 [-1]。
    [link]

  • 当处理的对象不存在重复元素时，使用 Set 来替代 Array。Set 是实现了无序且无重复元素的集合类型。它兼具 Array 的直观操作与 Hash 的快速查找。
    [link]

  • 倾向使用符号而不是字符串作为哈希键。
    [link]

## 差
hash = { 'one' => 1, 'two' => 2, 'three' => 3 }

## 好
hash = { one: 1, two: 2, three: 3 }

  • 避免使用可变对象作为哈希键。
    [link]

  • 当哈希键为符号时，使用 Ruby 1.9 的字面量语法。
    [link]

## 差
hash = { :one => 1, :two => 2, :three => 3 }

## 好
hash = { one: 1, two: 2, three: 3 }
  • 当哈希键既有符号又有字符串时，不要使用 Ruby 1.9 的字面量语法。
    [link]
## 差
{ a: 1, 'b' => 2 }

## 好
{ :a => 1, 'b' => 2 }
  • 倾向使用 Hash#key? 而不是 Hash#has_key?，使用 Hash#value? 而不是 Hash#has_value?。
    [link]
## 差
hash.has_key?(:test)
hash.has_value?(value)

## 好
hash.key?(:test)
hash.value?(value)
  • 倾向使用 Hash#each_key 而不是 Hash#keys.each，使用 Hash#each_value 而不是 Hash#values.each。
    [link]
## 差
hash.keys.each { |k| p k }
hash.values.each { |v| p v }
hash.each { |k, _v| p k }
hash.each { |_k, v| p v }

## 好
hash.each_key { |k| p k }
hash.each_value { |v| p v }
  • 当处理应该存在的哈希键时，使用 Hash#fetch。
    [link]
heroes = { batman: 'Bruce Wayne', superman: 'Clark Kent' }

## 差 - 如果我们打错了哈希键，则难以发现这个错误
heroes[:batman] # => 'Bruce Wayne'
heroes[:supermann] # => nil

## 好 - fetch 会抛出 KeyError 使这个错误显而易见
heroes.fetch(:supermann)
  • 当为哈希键的值提供默认值时，倾向使用 Hash#fetch 而不是自定义逻辑。
    [link]
batman = { name: 'Bruce Wayne', is_evil: false }

## 差 - 如果仅仅使用 || 操作符，那么当值为假时，我们不会得到预期结果
batman[:is_evil] || true # => true

## 好 - fetch 在遇到假值时依然可以正确工作
batman.fetch(:is_evil, true) # => false
  • 当提供默认值的求值代码具有副作用或开销较大时，倾向使用 Hash#fetch 的区块形式。
    [link]
batman = { name: 'Bruce Wayne' }

## 差 - 此形式会立即求值，如果调用多次，可能会影响程序的性能
batman.fetch(:powers, obtain_batman_powers) # obtain_batman_powers 开销较大

## 好 - 此形式会惰性求值，只有抛出 KeyError 时，才会产生开销
batman.fetch(:powers) { obtain_batman_powers }
  • 当需要一次性从哈希中获取多个键的值时，使用 Hash#values_at。
    [link]
## 差
email = data['email']
username = data['nickname']

## 好
email, username = data.values_at('email', 'nickname')

  • 利用“Ruby 1.9 之后的哈希是有序的”的这个特性。
    [link]

  • 当遍历集合时，不要改动它。
    [link]

  • 当访问集合中的元素时，倾向使用对象所提供的方法进行访问，而不是直接调用对象属性上的 [n] 方法。这种做法可以防止你在 nil 对象上调用 []。
    [link]

## 差
Regexp.last_match[1]

## 好
Regexp.last_match(1)
  • 当为集合提供存取器时，尽量支持索引值为 nil 的访问形式。
    [link]
## 差
def awesome_things
  @awesome_things
end

## 好
def awesome_things(index = nil)
  if index && @awesome_things
    @awesome_things[index]
  else
    @awesome_things
  end
end