• 当创建一组元素为单词(没有空格或特殊字符)的数组时,倾向使用 而不是 []。此规则只适用于数组元素有两个或以上的时候。
    [link]

    1. # 差
    2. STATES = ['draft', 'open', 'closed']
    3. # 好
    4. STATES = %w[draft open closed]

  • 当创建一组符号类型的数组(且不需要保持 Ruby 1.9 兼容性)时,倾向使用 %i。此规则只适用于数组元素有两个或以上的时候。
    [link]

    1. # 差
    2. STATES = [:draft, :open, :closed]
    3. # 好
    4. STATES = %i[draft open closed]

  • 避免在数组与哈希的字面量语法的最后一个元素之后添加逗号,尤其当元素没有分布在同一行时。
    [link]

    1. # 差 - 尽管移动、新增、删除元素颇为方便,但仍不推荐这种写法
    2. VALUES = [
    3. 1001,
    4. 2020,
    5. 3333,
    6. ]
    7. # 差
    8. VALUES = [1001, 2020, 3333, ]
    9. # 好
    10. VALUES = [1001, 2020, 3333]

  • 避免在数组中创造巨大的间隔。
    [link]

    1. arr = []
    2. arr[100] = 1 # 现在你有一个很多 nil 的数组

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


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


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

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

  • 当哈希键既有符号又有字符串时,不要使用 Ruby 1.9 的字面量语法。
    [link]

    1. # 差
    2. { a: 1, 'b' => 2 }
    3. # 好
    4. { :a => 1, 'b' => 2 }

  • 倾向使用 Hash#key? 而不是 Hash#has_key?,使用 Hash#value? 而不是 Hash#has_value?
    [link]

    1. # 差
    2. hash.has_key?(:test)
    3. hash.has_value?(value)
    4. # 好
    5. hash.key?(:test)
    6. hash.value?(value)

  • 倾向使用 Hash#each_key 而不是 Hash#keys.each,使用 Hash#each_value 而不是 Hash#values.each
    [link]

    1. # 差
    2. hash.keys.each { |k| p k }
    3. hash.values.each { |v| p v }
    4. hash.each { |k, _v| p k }
    5. hash.each { |_k, v| p v }
    6. # 好
    7. hash.each_value { |v| p v }

  • 当处理应该存在的哈希键时,使用 Hash#fetch
    [link]


  • 当提供默认值的求值代码具有副作用或开销较大时,倾向使用 Hash#fetch 的区块形式。
    [link]

    1. batman = { name: 'Bruce Wayne' }
    2. # 差 - 此形式会立即求值,如果调用多次,可能会影响程序的性能
    3. batman.fetch(:powers, obtain_batman_powers) # obtain_batman_powers 开销较大
    4. # 好 - 此形式会惰性求值,只有抛出 KeyError 时,才会产生开销
    5. batman.fetch(:powers) { obtain_batman_powers }

  • 当需要一次性从哈希中获取多个键的值时,使用 Hash#values_at
    [link]

    1. # 差
    2. email = data['email']
    3. username = data['nickname']
    4. # 好
    5. email, username = data.values_at('email', 'nickname')

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


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


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

    1. # 差
    2. Regexp.last_match[1]
    3. # 好
    4. Regexp.last_match(1)

  • 当为集合提供存取器时,尽量支持索引值为 的访问形式。
    [link]