Conditional Expressions

Conditional keywords

  • Never use then for multi-line if/unless.
    [link]

    1.   # bad
    2.   if some_condition then
    3.     ...
    4.   end
    6.   # good
    7.   if some_condition
    8.     ...
    9.   end

  • Never use do for multi-line while or
    until.[link]

    1.   # bad
    2.   while x > 5 do
    3.     ...
    4.   end
    6.   until x > 5 do
    7.     ...
    8.   end
    10.   # good
    11.   while x > 5
    12.     ...
    13.   end
    15.   until x > 5
    16.     ...
    17.   end

  • The and, or, and not keywords are banned. It’s
    just not worth it. Always use &&, ||, and ! instead.
    [link]

  • Modifier if/unless usage is okay when
    the body is simple, the condition is simple, and the whole thing fits on
    one line. Otherwise, avoid modifier if/unless.
    [link]

    1.   # bad - this doesn't fit on one line
    2.   add_trebuchet_experiments_on_page(request_opts[:trebuchet_experiments_on_page]) if request_opts[:trebuchet_experiments_on_page] && !request_opts[:trebuchet_experiments_on_page].empty?
    4.   # okay
    5.   if request_opts[:trebuchet_experiments_on_page] &&
    6.        !request_opts[:trebuchet_experiments_on_page].empty?
    8.     add_trebuchet_experiments_on_page(request_opts[:trebuchet_experiments_on_page])
    9.   end
    11.   # bad - this is complex and deserves multiple lines and a comment
    12.   parts[i] = part.to_i(INTEGER_BASE) if !part.nil? && [0, 2, 3].include?(i)
    14.   # okay
    15.   return if reconciled?

  • Never use unless with else. Rewrite
    these with the positive case first.[link]

    1.   # bad
    2.   unless success?
    3.     puts 'failure'
    4.   else
    5.     puts 'success'
    6.   end
    8.   # good
    9.   if success?
    10.     puts 'success'
    11.   else
    12.     puts 'failure'
    13.   end

  • Avoid unless with multiple
    conditions.[link]

    1.     # bad
    2.     unless foo? && bar?
    3.       ...
    4.     end
    6.     # okay
    7.     if !(foo? && bar?)
    8.       ...
    9.     end

  • Avoid unless with comparison operators if you can use if with an opposing comparison operator.[link]

    1.     # bad
    2.     unless x == 10
    3.       ...
    4.     end
    6.     # good
    7.     if x != 10
    8.       ...
    9.     end
    11.     # bad
    12.     unless x < 10
    13.       ...
    14.     end
    16.     # good
    17.     if x >= 10
    18.       ...
    19.     end
    21.     # ok
    22.     unless x === 10
    23.       ...
    24.     end

  • Don’t use parentheses around the
    condition of an if/unless/while.
    [link]

    1.   # bad
    2.   if (x > 10)
    3.     ...
    4.   end
    6.   # good
    7.   if x > 10
    8.     ...
    9.   end

Ternary operator

  • Avoid the ternary operator (?:) except
    in cases where all expressions are extremely trivial. However, do use the
    ternary operator(?:) over if/then/else/end constructs for single line
    conditionals.[link]

    1.   # bad
    2.   result = if some_condition then something else something_else end
    4.   # good
    5.   result = some_condition ? something : something_else

  • Use one expression per branch in a ternary
    operator. This also means that ternary operators must not be nested. Prefer
    if/else constructs in these cases.[link]

    1.   # bad
    2.   some_condition ? (nested_condition ? nested_something : nested_something_else) : something_else
    4.   # good
    5.   if some_condition
    6.     nested_condition ? nested_something : nested_something_else
    7.   else
    8.     something_else
    9.   end

  • Avoid multiple conditions in ternaries.
    Ternaries are best used with single conditions.
    [link]

  • Avoid multi-line ?: (the ternary
    operator), use if/then/else/end instead.
    [link]

    1.   # bad
    2.   some_really_long_condition_that_might_make_you_want_to_split_lines ?
    3.     something : something_else
    5.   # good
    6.   if some_really_long_condition_that_might_make_you_want_to_split_lines
    7.     something
    8.   else
    9.     something_else
    10.   end

Nested conditionals


  • Avoid the use of nested conditionals for flow of control.
    ([More on this][avoid-else-return-early].) [link]

    Prefer a guard clause when you can assert invalid data. A guard clause
    is a conditional statement at the top of a function that returns as soon
    as it can.

    The general principles boil down to:

    • Return immediately once you know your function cannot do anything more.
    • Reduce nesting and indentation in the code by returning early. This makes
      the code easier to read and requires less mental bookkeeping on the part
      of the reader to keep track of else branches.
    • The core or most important flows should be the least indented.
    1. # bad
    2. def compute
    3.   server = find_server
    4.   if server
    5.     client = server.client
    6.     if client
    7.       request = client.make_request
    8.       if request
    9.          process_request(request)
    10.       end
    11.     end
    12.   end
    13. end
    15. # good
    16. def compute
    17.   server = find_server
    18.   return unless server
    19.   client = server.client
    20.   return unless client
    21.   request = client.make_request
    22.   return unless request
    23.   process_request(request)
    24. end

    Prefer next in loops instead of conditional blocks.

    1. # bad
    2. [0, 1, 2, 3].each do |item|
    3.   if item > 1
    4.     puts item
    5.   end
    6. end
    8. # good
    9. [0, 1, 2, 3].each do |item|
    10.   next unless item > 1
    11.   puts item
    12. end

    See also the section “Guard Clause”, p68-70 in Beck, Kent.
    Implementation Patterns. Upper Saddle River: Addison-Wesley, 2008, which
    has inspired some of the content above.