Ruby Coding Style Guides

Ruby Coding Style Guides

The Ruby Style Guide

Ruby 风格指南

目录表单

源代码布局

UTF-8

# bad - four spaces
def some_method
do_something
end

# good
def some_method
do_something
end

$ git config --global core.autocrlf true

;

# bad
puts 'foobar'; # superfluous semicolon

puts 'foo'; puts 'bar' # two expression on the same line

# good
puts 'foobar'

puts 'foo'
puts 'bar'

puts 'foo', 'bar' # this applies to puts in particular

# bad
class FooError < StandardError
end

# okish
class FooError < StandardError; end

# good
FooError = Class.new(StandardError)

# bad
def too_much; something; something_else; end

# okish - notice that the first ; is required
def no_braces_method; body end

# okish - notice that the second ; is optional
def no_braces_method; body; end

# okish - valid syntax, but no ; make it kind of hard to read
def some_method() body end

# good
def some_method
body
end

# good
def no_op; end

{

}

sum = 1 + 2
a, b = 1, 2
1 > 2 ? true : false; puts 'Hi'
[1, 2, 3].each { |e| puts e }

# bad
e = M * c ** 2

# good
e = M * c**2

{

}

# good - space after { and before }
{ one: 1, two: 2 }

# good - no space after { and before }
{one: 1, two: 2}

# good - no spaces
"string#{expr}"

# ok - arguably more readable
"string#{ expr }"

(

[

]

)

some(arg).other
[1, 2, 3].length

!

# bad
! something

# good
!something

when

case

# bad
case
when song.name == 'Misty'
puts 'Not again!'
when song.duration > 120
puts 'Too long!'
when Time.now.hour > 21
puts "It's too late"
else
song.play
end

# good
case
when song.name == 'Misty'
puts 'Not again!'
when song.duration > 120
puts 'Too long!'
when Time.now.hour > 21
puts "It's too late"
else
song.play
end

case
when song.name == 'Misty'
puts 'Not again!'
when song.duraton > 120
puts 'Too long!'
when Time.now > 21
puts "It's too late"
else
song.play
end

# bad - pretty convoluted
kind = case year
when 1850..1889 then 'Blues'
when 1890..1909 then 'Ragtime'
when 1910..1929 then 'New Orleans Jazz'
when 1930..1939 then 'Swing'
when 1940..1950 then 'Bebop'
else 'Jazz'
end

result = if some_cond
calc_something
else
calc_something_else
end

# good - it's apparent what's going on
kind = case year
when 1850..1889 then 'Blues'
when 1890..1909 then 'Ragtime'
when 1910..1929 then 'New Orleans Jazz'
when 1930..1939 then 'Swing'
when 1940..1950 then 'Bebop'
else 'Jazz'
end

result = if some_cond
calc_something
else
calc_something_else
end

# good (and a bit more width efficient)
kind =
case year
when 1850..1889 then 'Blues'
when 1890..1909 then 'Ragtime'
when 1910..1929 then 'New Orleans Jazz'
when 1930..1939 then 'Swing'
when 1940..1950 then 'Bebop'
else 'Jazz'
end

result =
if some_cond
calc_something
else
calc_something_else
end

def some_method
data = initialize(options)

data.manipulate!

data.result
end

def some_methods
result
end

# bad - easier to move/add/remove parameters, but still not preferred
some_method(
size,
count,
color,
)

# bad
some_method(size, count, color, )

# good
some_method(size, count, color)

=

# bad
def some_method(arg1=:default, arg2=nil, arg3=[])
# do something...
end

# good
def some_method(arg1 = :default, arg2 = nil, arg3 = [])
# do something...
end

\

# bad
result = 1 - \
2

# good (but still ugly as hell)
result = 1 \
- 2

long_string = 'First part of the long string' \
' and second part of the long string'

.

.

.

# bad - need to consult first line to understand second line
one.two.three.
four

# good - it's immediately clear what's going on the second line
one.two.three
.four

.

# bad - need to read ahead to the second line to know that the chain continues
one.two.three
.four

# good - it's immediately clear that the expression continues beyond the first line
one.two.three.
four

# starting point (line is too long)
def send_mail(source)
Mailer.deliver(to: 'bob@example.com', from: 'us@example.com', subject: 'Important message', body: source.text)
end

# bad (double indent)
def send_mail(source)
Mailer.deliver(
to: 'bob@example.com',
from: 'us@example.com',
subject: 'Important message',
body: source.text)
end

# good
def send_mail(source)
Mailer.deliver(to: 'bob@example.com',
from: 'us@example.com',
subject: 'Important message',
body: source.text)
end

# good (normal indent)
def send_mail(source)
Mailer.deliver(
to: 'bob@example.com',
from: 'us@example.com',
subject: 'Important message',
body: source.text
)
end

# bad - single indent
menu_item = ['Spam', 'Spam', 'Spam', 'Spam', 'Spam', 'Spam', 'Spam', 'Spam',
'Baked beans', 'Spam', 'Spam', 'Spam', 'Spam', 'Spam']

# good
menu_item = [
'Spam', 'Spam', 'Spam', 'Spam', 'Spam', 'Spam', 'Spam', 'Spam',
'Baked beans', 'Spam', 'Spam', 'Spam', 'Spam', 'Spam'
]

# good
menu_item =
['Spam', 'Spam', 'Spam', 'Spam', 'Spam', 'Spam', 'Spam', 'Spam',
'Baked beans', 'Spam', 'Spam', 'Spam', 'Spam', 'Spam']

# bad - how many 0s are there?
num = 1000000

# good - much easier to parse for the human brain
num = 1_000_000

def

# bad
== begin
comment line
another comment line
== end

# good
# comment line
# another comment line

def

语法

::

Array()

Nokogiri::HTML()

::

# bad
SomeClass::some_method
some_object::some_method

# good
SomeClass.some_method
some_object.some_method
SomeModule::SomeClass::SOME_CONST
SomeModule::SomeClass()

def

# bad
def some_method()
# body omitted
end

# good
def some_method
# body omitted
end

# bad
def some_method_with_arguments arg1, arg2
# body omitted
end

# good
def some_method_with_arguments(arg1, arg2)
# body omitted
end

for

for

for

each

for

each

arr = [1, 2, 3]

# bad
for elem in arr do
puts elem
end

# note that elem is accessible outside of the for loop
elem #=> 3

# good
arr.each { |elem| puts elem }

# elem is not accessible outside each's block
elem #=> NameError: undefined local variable or method `elem'

if/unless

then

# bad
if some_condition then
# body omitted
end

# good
if some_condition
# body omitted
end

if/unless

if/unless

# bad
if
some_condition
do_something
do_something_else
end

# good
if some_condition
do_something
do_something_else
end

?:

if/then/else/end

# bad
result = if some_condition then something else something_else end

# good
result = some_condition ? something : something_else

if/else

# bad
some_condition ? (nested_condition ? nested_something : nested_something_else) : something_else

# good
if some_condition
nested_condition ? nested_something : nested_something_else
else
something_else
end

if
x: ...

# bad
result = if some_condition then something else something_else end

# good
result = some_condition ? something : something_else

if

case

# bad
if condition
result = x
else
result = y
end

# good
result =
if condition
x
else
y
end

when
x then ...

when
x: xxx

when
x; ...

!

not

# 差 - 因为操作符有优先级，需要用括号。
x = (not something)

# good
x = !something

!!

# bad
x = 'test'
# obscure nil check
if !!x
# body omitted
end

x = false
# double negation is useless on booleans
!!x # => false

# good
x = 'test'
unless x.nil?
# body omitted
end

and

or

&&

||

# bad
# boolean expression
if some_condition and some_other_condition
do_something
end

# control flow
document.saved? or document.save!

# good
# boolean expression
if some_condition && some_other_condition
do_something
end

# control flow
document.saved? || document.save!

?
:

if/unless

if/unless

&&/||

# bad
if some_condition
do_something
end

# good
do_something if some_condition

# another good option
some_condition && do_something

&&/||

and/or

# boolean expression
if some_condition && some_other_condition
do_something
end

# control flow
document.save? or document.save!

?:

if/unless

if/unless

and/or

# bad
if some_condition
do_something
end

# good
do_something if some_condition

# another good option
some_condition and do_something

unless

else

# bad
unless success?
puts 'failure'
else
puts 'success'
end

# good
if success?
puts 'success'
else
puts 'failure'
end

if/unless/while

# bad
if (x > 10)
# body omitted
end

# good
if x > 10
# body omitted
end

while/until

while/until
condition do

# bad
while x > 5 do
# body omitted
end

until x > 5 do
# body omitted
end

# good
while x > 5
# body omitted
end

until x > 5
# body omitted
end

while/until

# bad
while some_condition
do_something
end

# good
do_something while some_condition

until

while

# bad
do_something while !some_condition

# good
do_something until some_condition

Kernel#loop

break

begin/end/until

begin/end/while

# bad
begin
puts val
val += 1
end while val < 0

# good
loop do
puts val
val += 1
break unless val < 0
end

attr_reader

puts

class Person
attr_reader :name, :age

# omitted
end

temperance = Person.new('Temperance', 30)
temperance.name

puts temperance.age

x = Math.sin(y)
array.delete(e)

bowling.score.should == 0

# bad
user.set({ name: 'John', age: 45, permissions: { read: true } })

# good
user.set(name: 'John', age: 45, permissions: { read: true })

class Person < ActiveRecord::Base
# bad
validates(:name, { presence: true, length: { within: 1..10 } })

# good
validates :name, presence: true, length: { within: 1..10 }
end

# bad
Kernel.exit!()
2.even?()
fork()
'test'.upcase()

# good
Kernel.exit!
2.even?
fork
'test'.upcase

{...}

do...end

{...}

do...end

流程控制

方法定义

do...end

names = ['Bozhidar', 'Steve', 'Sarah']

# bad
names.each do |name|
puts name
end

# good
names.each { |name| puts name }

# bad
names.select do |name|
name.start_with?('S')
end.map { |name| name.upcase }

# good
names.select { |name| name.start_with?('S') }.map { |name| name.upcase }

{...}

require 'tempfile'

# bad
def with_tmp_dir
Dir.mktmpdir do |tmp_dir|
Dir.chdir(tmp_dir) { |dir| yield dir }  # block just passes arguments
end
end

# good
def with_tmp_dir(&block)
Dir.mktmpdir do |tmp_dir|
Dir.chdir(tmp_dir, &block)
end
end

with_tmp_dir do |dir|
puts "dir is accessible as parameter and pwd is set: #{dir}"
end

return

# bad
def some_method(some_arr)
return some_arr.size
end

# good
def some_method(some_arr)
some_arr.size
end

self

self

# bad
def ready?
if self.last_reviewed_at > self.last_updated_at
self.worker.update(self.content, self.options)
self.status = :in_progress
end
self.status == :verified
end

# good
def ready?
if last_reviewed_at > last_updated_at
worker.update(content, options)
self.status = :in_progress
end
status == :verified
end

class Foo
attr_accessor :options

# ok
def initialize(options)
self.options = options
# both options and self.options are equivalent here
end

# bad
def do_something(options = {})
unless options[:when] == :later
output(self.options[:message])
end
end

# good
def do_something(params = {})
unless params[:when] == :later
output(options[:message])
end
end
end

=

# bad (+ a warning)
if v = array.grep(/foo/)
do_something(v)
...
end

# good (MRI would still complain, but RuboCop won't)
if (v = array.grep(/foo/))
do_something(v)
...
end

# good
v = array.grep(/foo/)
if v
do_something(v)
...
end

self
assignment

# bad
x = x + y
x = x * y
x = x**y
x = x / y
x = x || y
x = x && y

# good
x += y
x *= y
x **= y
x /= y
x ||= y
x &&= y

||=

# set name to Vozhidar, only if it's nil or false
name ||= 'Bozhidar'

||=

false

# bad - would set enabled to true even if it was false
enable ||= true

# good
enabled = true if enabled.nil?

&&=

&&=

if

# bad
if something
something = something.downcase
end

# bad
something = something ? nil : something.downcase

# ok
something = something.downcase if something

# good
something = something && something.downcase

# better
something &&= something.downcase

===

case

case

# bad
Array === something
(1..100) === 7
/something/ === some_string

# good
something.is_a?(Array)
(1..100).include?(7)
some_string =~ /something/

$:

$;

English

# bad
$:.unshift File.dirname(__FILE__)

# good
require 'English'
$LOAD_PATH.unshift File.dirname(__FILE__)

# bad
f (3+2) + 1

# good
f(3 + 2) +1

f((3
+ 2) + 1)

-w

lambda

# bad
l = lambda { |a, b| a + b }
l.call(1, 2)

# correct, but looks extremely awkward
l = ->(a, b) do
tmp = a * 7
tmp * b / 50
end

# good
l = ->(a, b) { a + b }
l.call(1, 2)

l = lambda do |a, b|
tmp = a * 7
tmp * b / 50
end

proc

Proc.new

# bad
p = Proc.new { |n| puts n }

# good
p = proc { |n| puts n }

proc.call()

proc[]

proc.()

# bad - looks similar to Enumeration access
l = ->(v) { puts v }
l[1]

# also bad - uncommon syntax
l = ->(v) { puts v }
l.(1)

# good
l = ->(v) { puts v }
l.call(1)

_

_

# bad
result = hash.map { |k, v| v + 1 }

def something(x)
unused_var, used_var = something_else(x)
# ...
end

# good
result = hash.map { |_k, v| v + 1 }

def something(x)
_unused_var, used_var = something_else(x)
# ...
end

# good
result = hash.map { |_, v| v + 1 }

def something(x)
_, used_var = something_else(x)
# ...
end

$stdout/$stderr/$stdin

STDOUT/STDERR/STDIN

STDOUT/STDERR/STDIN

warn

$stderr.puts

warn

-W0

sprintf

format

String#%

# bad
'%d %d' % [20, 10]
# => '20 10'

# good
sprintf('%d %d', 20, 10)
# => '20 10'

# good
sprintf('%{first} %{second}', first: 20, second: 10)
# => '20 10'

format('%d %d', 20, 10)
# => '20 10'

# good
format('%{first} %{second}', first: 20, second: 10)
# => '20 10'

Array#join

Array#*

# bad
%w(one two three) * ', '
# => 'one, two, three'

# good
%w(one two three).join(', ')
# => 'one, two, three'

[*var]

Array()

Array

# bad
paths = [paths] unless paths.is_a? Array
paths.each { |path| do_something(path) }

# good
[*paths].each { |path| do_something(path) }

# good (and a bit more readable)
Array(paths).each { |path| do_something(path) }

Comparable#between?

# bad
do_something if x >= 1000 && x <= 2000

# good
do_something if (1000..2000).include?(x)

# good
do_something if x.between?(1000, 2000)

==

# bad
if x % 2 == 0
end

if x % 2 == 1
end

if x == nil
end

# good
if x.even?
end

if x.odd?
end

if x.nil?
end

if x.zero?
end

if x == 0
end

BEGIN

Kernel#at_exit

END

# bad

END { puts 'Goodbye!' }

# good

at_exit { puts 'Goodbye!' }

# bad
def compute_thing(thing)
if thing[:foo]
update_with_bar(thing)
if thing[:foo][:bar]
partial_compute(thing)
else
re_compute(thing)
end
end
end

# good
def compute_thing(thing)
return unless thing[:foo]
update_with_bar(thing[:foo])
return re_compute(thing) unless thing[:foo][:bar]
partial_compute(thing)
end

命名

# bad - identifier using non-ascii characters
заплата = 1_000

# bad - identifier is a Bulgarian word, written with Latin letters (instead of Cyrillic)
zaplata = 1_000

# good
salary = 1_000

snake_case

# bad
:'some symbol'
:SomeSymbol
:someSymbol

someVar = 5

def someMethod
...
end

def SomeMethod
...
end

# good
:some_symbol

def some_method
...
end

CamelCase(駝峰式大小寫)

# bad
class Someclass
...
end

class Some_Class
...
end

class SomeXml
...
end

# good
class SomeClass
...
end

class SomeXML
...
end

snake_case

hello_world.rb

SCREAMING_SNAKE_CASE

# bad
SomeConst = 5

# good
SOME_CONST = 5

self

exit!

exit

# bad - there is not matching 'safe' method
class Person
def update!
end
end

# good
class Person
def update
end
end

# good
class Person
def update!
end

def update
end
end

class Array
def flatten_once!
res = []

each do |e|
[*e].each { |f| res << f }
end

replace(res)
end

def flatten_once
dup.flatten_once!
end
end

reduce

|a,
e|

#Combines all elements of enum枚举 by applying a binary operation, specified by a block or a symbol that names a method or operator.
# Sum some numbers
(5..10).reduce(:+)                            #=> 45#reduce
# Same using a block and inject
(5..10).inject {|sum, n| sum + n }            #=> 45 #inject注入
# Multiply some numbers
(5..10).reduce(1, :*)                         #=> 151200
# Same using a block
(5..10).inject(1) {|product, n| product * n } #=> 151200

other

<<

[]

def +(other)
# body omitted
end

map

collect

find

detect

select

find_all

reduce

inject

size

length

collect

detect

inject

select

find_all

select

reject

count

size

Enumerable

Array

# bad
some_hash.count

# good
some_hash.size

flat_map

map

flatten

users.first.songs
== ['a', ['b', 'c']]

map
+ flatten

flat_map

flat_map

flatten

# bad
all_songs = users.map(&:songs).flatten.uniq

# good
all_songs = users.flat_map(&:songs).uniq

reverse_each

reverse.each

reverse_each

# bad
array.reverse.each { ... }

# good
array.reverse_each { ... }

注释

# bad
counter += 1 # increments counter by one

注解

#

def bar
# FIXME: This has crashed occasionally since v3.2.1. It may
#  be related to the BarBazUtil upgrade.
baz(:quux)
end

def bar
sleep 100 # OPTIMIZE
end

TODO

FIXME

OPTIMIZE

HACK

REVIEW

REVIEW:
你确定客户端是怎样正确的完成 X 的吗？

README

类与模块

class

class Person
# extend and include go first
extend SomeModule
include AnotherModule

# constants are next
SOME_CONSTANT = 20

# afterwards we have attribute macros
attr_reader :name

# followed by other macros (if any)
validates :name

# public class methods are next in line
def self.some_method
end

# followed by public instance methods
def some_method
end

# protected and private methods are grouped near the end
protected

def some_protected_method
end

private

def some_private_method
end
end

module

class

# bad
class SomeClass
def self.some_method
# body omitted
end

def self.some_other_method
end
end

# good
module SomeClass
module_function

def some_method
# body omitted
end

def some_other_method
end
end

class

module_function

extend
self

# bad
module Utilities
extend self

def parse_something(string)
# do stuff here
end

def other_utility_method(number, string)
# do some more stuff
end
end

# good
module Utilities
module_function

def parse_something(string)
# do stuff here
end

def other_utility_method(number, string)
# do some more stuff
end
end

父类的实例

to_s

class Person
attr_reader :first_name, :last_name

def initialize(first_name, last_name)
@first_name = first_name
@last_name = last_name
end

def to_s
"#@first_name #@last_name"
end
end

attr

# bad
class Person
def initialize(first_name, last_name)
@first_name = first_name
@last_name = last_name
end

def first_name
@first_name
end

def last_name
@last_name
end
end

# good
class Person
attr_reader :first_name, :last_name

def initialize(first_name, last_name)
@first_name = first_name
@last_name = last_name
end
end

attr

attr_reader

attr_accessor

# bad - creates a single attribute accessor (deprecated in 1.9)
attr :something, true
attr :one, :two, :three # behaves as attr_reader

# good
attr_accessor :something
attr_reader :one, :two, :three

Struct.new

accessors

constructor

comparison

# good
class Person
attr_reader :first_name, :last_name

def initialize(first_name, last_name)
@first_name = first_name
@last_name = last_name
end
end

# better
class Person < Struct.new(:first_name, :last_name)
end

Struct.new

# good
class Person
attr_accessor :first_name, :last_name

def initialize(first_name, last_name)
@first_name = first_name
@last_name = last_name
end
end

# better
Person = Struct.new(:first_name, :last_name) do
end

extend

Struct.new

class

class

class Person
def self.create(potions_hash)
# body omitted
end
end

# bad
class Animal
# abstract method
def speak
end
end

# extend superclass
class Duck < Animal
def speak
puts 'Quack! Quack'
end
end

# extend superclass
class Dog < Animal
def speak
puts 'Bau! Bau!'
end
end

# good
class Duck
def speak
puts 'Quack! Quack'
end
end

class Dog
def speak
puts 'Bau! Bau!'
end
end

@@

@@

class Parent
@@class_var = 'parent'

def self.print_class_var
puts @@class_var
end
end

class Child < Parent
@@class_var = 'child'
end

Parent.print_class_var # => will print "child"

private

protected

public

public

protected

private

class SomeClass
def public_method
# ...
end

private

def private_method
# ...
end

def another_private_method
# ...
end
end

def
self.method

class TestClass
# bad
def TestClass.some_method
# body omitted
end

# good
def self.some_other_method
# body omitted
end

# Also possible and convenient when you
# have to define many singleton methods.
class << self
def first_method
# body omitted
end

def second_method_etc
# body omitted
end
end
end

class SingletonTest
def size
25
end
end

test1 = SingletonTest.new
test2 = SingletonTest.new
def test2.size
10
end
test1.size # => 25
test2.size # => 10

异常

fail

begin
fail 'Oops'
rescue => error
raise if error.message != 'Oops'
end

fail/raise

RuntimeError

# bad
fail RuntimeError, 'message'

# good - signals a RuntimeError by default
fail 'message'

fail/raise

# bad
fail SomeException.new('message')
# Note that there is no way to do `fail SomeException.new('message'), backtrace`.

# good
fail SomeException, 'message'
# Consistent with `fail SomeException, 'message', backtrace`.

ensure

ensure

def foo
begin
fail
ensure
return 'very bad idea'
end
end

begin

# bad
def foo
begin
# main logic goes here
rescue
# failure handling goes here
end
end

# good
def foo
# main logic goes here
rescue
# failure handling goes here
end

begin

# bad
begin
something_that_might_fail
rescue IOError
# handle IOError
end

begin
something_else_that_might_fail
rescue IOError
# handle IOError
end

# good
def with_io_error_handling
yield
rescue IOError
# handle IOError
end

with_io_error_handling { something_that_might_fail }

with_io_error_handling { something_else_that_might_fail }

# bad
begin
# an exception occurs here
rescue SomeError
# the rescue clause does absolutely nothing
end

# bad
do_something rescue nil

rescue

# bad - this catches exceptions of StandardError class and its descendant classes
read_file rescue handle_error($!)

# good - this catches only the exceptions of Errno::ENOENT class and its descendant classes
def foo
read_file
rescue Errno::ENOENT => ex
handle_error(ex)
end

# bad
begin
n / d
rescue ZeroDivisionError
puts "Cannot divide by 0!"
end

# good
if d.zero?
puts "Cannot divide by 0!"
else
n / d
end

Exception

exit

kill
-9

# bad
begin
# calls to exit and kill signals will be caught (except kill -9)
exit
rescue Exception
puts "you didn't really want to exit, right?"
# exception handling
end

# good
begin
# a blind rescue rescues from StandardError, not Exception as many
# programmers assume.
rescue => e
# exception handling
end

# also good
begin
# an exception occurs here

rescue StandardError => e
# exception handling
end

# bad
begin
# some code
rescue Exception => e
# some handling
rescue StandardError => e
# some handling
end

# good
begin
# some code
rescue StandardError => e
# some handling
rescue Exception => e
# some handling
end

ensure

f = File.open('testfile')
begin
# .. process
rescue
# .. handle error
ensure
f.close unless f.nil?
end

集合

# bad
arr = Array.new
hash = Hash.new

# good
arr = []
hash = {}

%w

# bad
STATES = ['draft', 'open', 'closed']

# good
STATES = %w(draft open closed)

%i

# bad
STATES = [:draft, :open, :closed]

# good
STATES = %i(draft open closed)

Array

Hash

# bad - easier to move/add/remove items, but still not preferred
VALUES = [
1001,
2020,
3333,
]

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

# good
VALUES = [1001, 2020, 3333]

arr = []
arr[100] = 1 # now you have an array with lots of nils

first

last

[0]

[-1]

Set

Array

Set

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

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

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

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

# bad
{ a: 1, 'b' => 2 }

# good
{ :a => 1, 'b' => 2 }

Hash#key?

Hash#has_key?

Hash#value?

Hash#has_value?

# bad
hash.has_key?(:test)
hash.has_value?(value)

# good
hash.key?(:test)
hash.value?(value)

fetch

heroes = { batman: 'Bruce Wayne', superman: 'Clark Kent' }
# bad - if we make a mistake we might not spot it right away
heroes[:batman] # => "Bruce Wayne"
heroes[:supermann] # => nil

# good - fetch raises a KeyError making the problem obvious
heroes.fetch(:supermann)

fetch

batman = { name: 'Bruce Wayne', is_evil: false }

# bad - if we just use || operator with falsy value we won't get the expected result
batman[:is_evil] || true # => true

# good - fetch work correctly with falsy values
batman.fetch(:is_evil, true) # => false

fetch

batman = { name: 'Bruce Wayne' }

# bad - if we use the default value, we eager evaluate it
# so it can slow the program down if done multiple times
batman.fetch(:powers, get_batman_powers) # get_batman_powers is an expensive call

# good - blocks are lazy evaluated, so only triggered in case of KeyError exception
batman.fetch(:powers) { get_batman_powers }

Hash#values_at

# bad
email = data['email']
nickname = data['nickname']

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

字符串

字符串插值

字符串串联

# bad
email_with_name = user.name + ' <' + user.email + '>'

# good
email_with_name = "#{user.name} <#{user.email}>"

# good
email_with_name = format('%s <%s>', user.name, user.email)

"#{ user.last_name }, #{ user.first_name }"

"#{ user.last_name }, #{ user.first_name }"

\t

\n

'

# bad
name = "Bozhidar"

# good
name = 'Bozhidar'

"

"

# bad
name = 'Bozhidar'

# good
name = "Bozhidar"

?x

?x

x

# bad
char = ?c

# good
char = 'c'

{}

class Person
attr_reader :first_name, :last_name

def initialize(first_name, last_name)
@first_name = first_name
@last_name = last_name
end

# bad - valid, but awkward
def to_s
"#@first_name #@last_name"
end

# good
def to_s
"#{@first_name} #{@last_name}"
end
end

$global = 0
# bad
puts "$global = #$global"

# good
puts "$global = #{$global}"

Object#to_s

# bad
message = "This is the #{result.to_s}."

# good
message = "This is the #{result}."

String#+

String#<<

String#+

# good and also fast
html = ''
html << '<h1>Page title</h1>'

paragraphs.each do |paragraph|
html << "<p>#{paragraph}</p>"
end

code = <<-END.gsub(/^\s+\|/, '')
|def test
|  some_method
|  other_method
|end
END
#=> "def test\n  some_method\n  other_method\nend\n"

正则表达式

text

string['text']

match = string[/regexp/]             # get content of matched regexp
first_group = string[/text(grp)/, 1] # get content of captured group
string[/text (grp)/, 1] = 'replace'  # string => 'text replace'

/(first|second)/   # bad
/(?:first|second)/ # good

$1

$2

Regexp.last_match

/(regexp)/ =~ string
...

# bad
process $1

# good
process Regexp.last_match[1]

# bad
/(regexp)/ =~ string
...
process Regexp.last_match[1]

# good
/(?<meaningful_var>regexp)/ =~ string
...
process meaningful_var

^

-

\

]

.

[]

^

$

\A

\Z

string = "some injection\nusername"
string[/^username$/]   # matches
string[/\Ausername\Z/] # don't match

regexp = %r{
start         # some text
\s            # white space char
(group)       # first group
(?:alt1|alt2) # some alternation
end
}x

sub

gsub

百分号和字面值

%()

%Q

# bad (no interpolation needed)
%(<div class="text">Some text</div>)
# should be '<div class="text">Some text</div>'

# bad (no double-quotes)
%(This is #{quality} style)
# should be "This is #{quality} style"

# bad (multiple lines)
%(<div>\n<span class="big">#{exclamation}</span>\n</div>)
# should be a heredoc.

# good (requires interpolation, has quotes, single line)
%(<tr><td class="name">#{name}</td>)

'

"

%q

# bad
name = %q(Bruce Wayne)
time = %q(8 o'clock)
question = %q("What did you say?")

# good
name = 'Bruce Wayne'
time = "8 o'clock"
question = '"What did you say?"'

%r

/

# bad
%r(\s+)

# still bad
%r(^/(.*)$)
# should be /^\/(.*)$/

# good
%r(^/blog/2011/(.*)$)

%x

# bad
date = %x(date)

# good
date = `date`
echo = %x(echo `date`)

%s

:"some
string"

%

()

%r

{

# bad
%w[one two three]
%q{"Test's king!", John said.}

# good
%w(one two three)
%q("Test's king!", John said.)

元编程

__FILE__

__LINE__

class_eval 'def use_relative_model_naming?; true; end', __FILE__, __LINE__

define_method

class_eval{
def ... }

class_eval

eval

# from activesupport/lib/active_support/core_ext/string/output_safety.rb
UNSAFE_STRING_METHODS.each do |unsafe_method|
if 'String'.respond_to?(unsafe_method)
class_eval <<-EOT, __FILE__, __LINE__ + 1
def #{unsafe_method}(*args, &block)       # def capitalize(*args, &block)
to_str.#{unsafe_method}(*args, &block)  #   to_str.capitalize(*args, &block)
end                                       # end

def #{unsafe_method}!(*args)              # def capitalize!(*args)
@dirty = true                           #   @dirty = true
super                                   #   super
end                                       # end
EOT
end
end

method_missing

#methods

nukes.launch_state
= false

define_method

method_missing

respond_to_missing?

# bad
def method_missing?(meth, *args, &block)
if /^find_by_(?<prop>.*)/ =~ meth
# ... lots of code to do a find_by
else
super
end
end

# good
def method_missing?(meth, *args, &block)
if /^find_by_(?<prop>.*)/ =~ meth
find_by(prop, *args, &block)
else
super
end
end

# best of all, though, would to define_method as each findable attribute is declared

杂项

ruby
-w

private

#bad
$foo_bar = 1

#good
class Foo
class << self
attr_accessor :bar
end
end

Foo.bar = 1

alias_method

alias

OptionParser

ruby
-s

Time.now

Time.new

工具

RuboCop

RubyMine

Contributing

How to Contribute?

License

Spread the Word