In this course, we'll look at the best practices and conventions that make Ruby unique.

The Zen of Ruby

All right! Time to put your new knowledge to work by **refactoring** some existing code. Refactoring is just a fancy way of saying we're improving the structure or appearance of our code without changing what it actually does.

We won't cover every bit of syntax from the previous exercises, but we'll hit the highlights. Ready?

One-Liners

Good! Let's make our code even more streamlined using the ternary operator.

```rb
three = 3
puts three == 3 ? "Of course." : "What?"
# ==> puts "Of course."
```

The example above is just a syntax reminder.

The Ternary Operator

All right! Last one: let's do something about the decidedly un-Ruby `for` loop in the editor.

```rb
10.times do
  puts "Knock knock."
  puts "Who's there?"
end
```

'For' Shame!

You can do the exact same thing with the `unless` statement. The order is the same as before: something for Ruby to do, the `unless` keyword, and then an expression that evaluates to `true` or `false`.

Remember, you don't need an `end` when you write a one-line `if` or `unless`!

The One-Line Unless

Perfect! Now let's review conditional assignment. We'll take a break from strict editing mode and let you do a bit more writing.

Conditional Assignment

We know that methods in Ruby can return values, and we ask a method to `return` a value when we want to use it in another part of our program. What if we don't put a `return` statement in our method definition, though?

For instance, if you don't tell a JavaScript function exactly what to `return`, it'll return `undefined`. For Python, the default return value is `None`. But for Ruby, it's something different: Ruby's methods will return the result of the last evaluated expression.

This means that if you have a Ruby method like this one:

```rb
def add(a,b)
  return a + b
end
```
You can simply write:

```rb
def add(a,b)
  a + b
end
```
And either way, when you call `add(1,1)`, you'll get `2`. 

Implicit Return

If we know the range of numbers we'd like to include, we can use `.upto` and `.downto`. This is a much more Rubyist solution than trying to use a `for` loop that stops when a counter variable hits a certain value.

We might use `.upto` to print out a specific range of values:

```rb
95.upto(100) { |num| print num, " " }
# Prints 95 96 97 98 99 100
```
and we can use `.downto` to do the same thing with descending values.

Do you think `.upto` and `.downto` work on the alphabet? Only one way to find out!

Up the Down Staircase

Sooner or later, you're going to need to perform a repetitive task in your programs. Many programming languages allow you to do this with a `for` loop, and while Ruby does include `for` loops, there are better tools available to us.

If we want to do something a specific number of times, we can use the `.times` method, like so:

```rb
5.times { puts "Odelay!" }
# Prints 5 "Odelay!"s on separate lines
```
If we want to repeat an action for every element in a collection, we can use `.each`:

```rb
[1, 2, 3].each { |x| puts x * 10 }
# Prints 10, 20, 30 on separate lines
```

The Right Tool for the Job

Speaking of pushing to arrays, Ruby has some nice shortcuts for common method names. As luck would have it, one is for `.push`!

Instead of typing out the `.push` method name, you can simply use `<<`, the **concatenation operator** (also known as "the shovel") to add an element to the end of an array:

```rb
[1, 2, 3] << 4
# ==> [1, 2, 3, 4]
```
Good news: it also works on strings! You can do:

```rb
"Yukihiro " << "Matsumoto"
# ==> "Yukihiro Matsumoto"
```

Being Pushy

Recall that we have the boolean operators **and** (`&&`) and **or** (`||`) in Ruby. The `&&` operator only returns `true` when the expressions on *both* sides of the operator are true; `||` returns `true` when one *or* the other *or both* of the expressions involved are true. 

Ruby does this via **short-circuit evaluation**. That means that Ruby doesn't look at both expressions unless it has to; if it sees
```rb
false && true
```
it stops reading as soon as it sees `&&` because it knows `false &&` anything *must* be false.

Remember how Ruby returns the result of the last expression it evaluated? We can use that to show short-circuit evaluation in action.

Short-Circuit Evaluation

We've seen that we can use the `=` operator to assign a value to a variable. But what if we only want to assign a variable if it hasn't already been assigned? 

For this, we can use the conditional assignment operator: `||=`. It's made up of the or (`||`) logical operator and the normal `=` assignment operator.

You've seen the Ruby `if` statement before:
```rb
if condition
  # Do something!
end
```
If the "do something" is a short, simple expression, however, we can move it up into a single line (as you saw in the last exercise). The syntax looks like this:
```rb
expression if boolean
```
Ruby will expect an expression followed by `if` followed by a boolean. The order is important. You can do this:
```rb
puts "It's true!" if true
```
but not this:
```rb
if true puts "It's true!"
```
It's also important to note that you don't need an `end` when you write your `if` statement all on one line.

A Simpler 'If'

Excellent. Regular `if`/`else` statements aren't the only ones we can refactor, though—a chain of `if`/`elsif`/`else` statements can clean up really nicely, too!

In Case of Many Options

Remember when we mentioned that [symbols are awesome](https://www.codecademy.com/courses/learn-ruby/lessons/hashes-and-symbols/exercises/what-are-symbols-used-for) for referencing method names? Well, `.respond_to?` takes a symbol and returns `true` if an object can receive that method and `false` otherwise. For example,

```rb
[1, 2, 3].respond_to?(:push)
```
would return `true`, since you can call `.push` on an array object. However,

```rb
[1, 2, 3].respond_to?(:to_sym)
```
would return `false`, since you can't turn an array into a symbol.

Call and Response

You can always use plain old `+` or `<<` to add a variable value into a string:

```rb
drink = "espresso"
"I love " + drink
# ==> I love espresso
"I love " << drink
# ==> I love espresso
```

But if you want to do it for non-string values, you have to use `.to_s` to make it a string:

```rb
age = 26
"I am " + age.to_s + " years old."
# ==> "I am 26 years old."
"I am " << age.to_s << " years old."
# ==> "I am 26 years old."
```

This is complicated, and complicated is not the Ruby way. A better way to do this is with **string interpolation**. The syntax looks like this:

```rb
"I love #{drink}."
# ==> I love espresso.
"I am #{age} years old."
# ==> I am 26 years old.
```

All you need to do is place the variable name inside `#{}` within a string!

String Interpolation

Now You Try!

As a language, Ruby prioritizes programmer productivity over program optimization. This means that Ruby may not always run a program in the fastest way possible, but it strives to be a language that programmers (like you!) find easy and fun to use. The more intuitive a language's syntax is, the more productive its users can be. You're in control, not the machine!

Check out the code in the editor. It looks almost like English, doesn't it?

Ruby is a Delight

During your Ruby adventures, you've seen that you often have many options when it comes to accomplishing any one goal. The `if` statement is no exception!

An even more concise version of `if`/`else` is the **ternary conditional expression**. It's called "ternary" because it takes three arguments: a boolean, an expression to evaluate if the boolean is `true`, and an expression to evaluate if the boolean is `false`.

The syntax looks like this:

```rb
boolean ? Do this if true: Do this if false
```
An example might be

```rb
puts 3 < 4 ? "3 is less than 4!" : "3 is not less than 4."
```
Remember: the order of arguments is important, and you don't need an `end` for this version of `if`/`else`.

One Good Turn Deserves a Ternary

Next up: let's simplify our method madness by removing unnecessary `return`s from our code.

The `if`/`else` statement is powerful, but we can get bogged down in `if`s and `elsif`s if we have a lot of conditions to check. Thankfully, Ruby provides us with a concise alternative: the `case` statement. The syntax looks like this:

```rb
case language
  when "JS"
    puts "Websites!"
  when "Python"
    puts "Science!"
  when "Ruby"
    puts "Web apps!"
  else
    puts "I don't know!"
end
```
But you can fold it up like so:

```rb
case language
  when "JS" then puts "Websites!"
  when "Python" then puts "Science!"
  when "Ruby" then puts "Web apps!"
  else puts "I don't know!"
end
```