# conditional (if)

## Objectives

* Define control flow for when a Ruby program is executed.
* Implement control flow in different ways.
* Use `if`, `else`, and `elsif` statements.

## Video

&#x20;\<iframe width="560" height="315" src="<https://www.youtube.com/embed/dcNgPOZCaBk>" frameborder="0" allowfullscreen>\</iframe>

[Ruby Conditionals](https://www.youtube.com/watch?v=dcNgPOZCaBk)

## Define Control Flow

> A control flow construct is a language feature which disrupts the normal progression to the next statement and conditionally or unconditionally branches to another location in source code. –– [Robert Klemme](http://blog.rubybestpractices.com/posts/rklemme/004-Control_Flow.html)

In other words, control flow lets you tell your program what code to execute conditionally. As humans, we actually enact flow control *every day*. For instance, if you are hungry, you will go and get a snack. Otherwise, you'll stay put and continue to read this awesome readme.

Control flow is an important part of Ruby programming and web development. In the context of a web application, for example, you can easily think of content or functionality on a website you've visited that is only available to a user *if* that user is logged in.

## Implementing Control Flow

There are several ways to tell your program to conditionally execute certain code, the basic forms of which are:

* `if`, `else`, and `elsif` statements,
* `case` statements,
* loops.

In this reading, we're going to discuss the first group of these "conditional" statements: `if`, `else`, and `elsif`.

Use IRB, copying the provided code snippets, to follow along in this lesson.

### `if` Statements

One of the most common ways to enact control flow is the `if` statement. Whatever block of code that follows the `if` statement will get evaluated—i.e. read and enacted by the computer. If this evaluation of the `if` statement results in `true`, then the code through to the associated `end` statement will run.

Let's look at a few examples:

```
if 5 > 2
  print "5 is greater than 2"
end
```

* The code above will print "5 is greater than 2" because the `if` statement evaluates as `true`.

Meanwhile:

```
if 2 > 5
  puts "2 is greater than 5"
end
```

* The code above will not print anything because the `if` statement evaluates as `false`.

So what if we want our program to print something *else* when the `if` condition evaluates as `false`?

### The `else` Keyword

To accomplish this, we can follow an `if` statement with an `else` statement. Take a look:

```
if false
   puts "This will never get printed because the above
     statement evaluates to false."
else
   puts "This will get printed!"
end
```

An `else` statement sets a "default" condition for when your `if` statement's conditional evaluates as `false`. Every condition that doesn't evaluate as `true` will instead pass through the `else` statement.

#### Further Examples

So far, we've seen `if` statements that rely on the explicit use of the `true` and `false` booleans. Let's look at some examples that require a little more thought.

**Example 1**

```
if 6 + 3 == 9
  puts "Giraffes have no vocal cords."
end
# └── "Giraffes have no vocal cords."
```

* The code above will print `Giraffes have no vocal cords.` Since `6 + 3` equals `9` (i.e. `9` is equal to `9`), the `if` statement's conditional evaluates as `true`.

**Top-tip:** *Remember that the comparative operator* `==` *("double-equals") is used to check equality. This is distinct from the assignment operator* `=`*("single-equals"), which is used to set the value of a variable.*

**Example 2**

```
if 6 + 3 < 5
  puts "The hummingbird is the only animal that can fly backwards"
end
```

* The code above will not print anything because `6 + 3`, which is equivalent to `9`, is *not* less than `5`, making the `if` statement's conditional evaluate as `false`.

**Example 3**

```
dog = "satisfied"

if dog == "hungry"
  puts "Refilling food bowl."
else
  puts "Reading newspaper."
end

#  └── "Reading newspaper."
```

### `elsif` Statements

Sometimes, we want to control the flow of our program based on more than one condition. For example, if I am hungry, then I will get a snack. If I am thirsty, then I will get a drink of water. Otherwise, I will stay here and continue learning more about control flow.

We can add additional layers of complexity to our `if` and `else` statements by using the `elsif` keyword.

Let's add an `elsif` statement to Example 3 from above:

```
dog = "thirsty"

if dog == "hungry"
  puts "Refilling food bowl."
elsif dog == "thirsty"
  puts "Refilling water bowl."
else
  puts "Reading newspaper."
end

#  └── "Refilling water bowl."
```

We can cascade as many `elsif` statements as we wish, however `elsif` statements can only be used following an `if` statement, and must precede the associated `else` statement (if used).

```
dog = "cuddly"

if dog == "hungry"
  puts "Refilling food bowl."
elsif dog == "thirsty"
  puts "Refilling water bowl."
elsif dog == "playful"
  puts "Playing tug-of-war."
elsif dog == "cuddly"
  puts "Snuggling."
else
  puts "Reading newspaper."
end

#  └── "Snuggling."
```

That's all for now—we'll discuss `case` statements and looping in upcoming lessons.

View [Control Flow](https://learn.co/lessons/conditional-readme) on Learn.co and start learning to code for free.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://certil-remy.gitbook.io/learn/intro-to-tic-tac-toe/untitled-24.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.