rust conditional assignment

• Course List
• Introduction to Rust
• Environment Setup
• First Rust Application
• Variables & Constants
• Control Flow
• if, else if, else, match
• while, for loops
• break & continue
• Intermediate
• Borrowing & Referencing
• Structs (Structures)
• Enums (Enumerations)
• Collections
• Vector Collection
• HashMap Collection
• Advanced Types
• Memory Management
• Smart Pointers
• Multi-Threading
• Concurrency

Rust Conditional Control (if, else if, else, match) Tutorial

In this Rust tutorial we learn how to control the flow of our Rust application with if, else if, else, and match conditional statements.

We also cover how to nest conditional statements inside other conditional statements as well as how to conditionally assign a value to a variable if the if let expression.

• What is conditional control flow
• The if conditional statement
• How to evaluate multiple if conditions
• The conditional else if ladder
• The conditional fallback else statement
• How to nest if, else if and else statements
• The conditional match statement
• Conditional variable assignment (if let)
• The Rust ternary operator
• Summary: Points to remember

Rust allows us to control the flow of our program through specific expressions that evaluate conditions. Based on the result of these conditions, Rust will execute sections of specified code.

As an example, let’s consider a application with a dedicated area for members. Before a user can gain access to the member area, they need to provide the correct login credentials.

If they provide the correct credentials, they are allowed into the exclusive member area. Otherwise, they will be given the option to try again or reset their password if they have forgotten it.

Based on this logic, we can imagine that our code would look something like this.

Our actual code will not look exactly like the example above, but it serves to give you an example of what conditional control is.

We control the flow of our program with the following statements, in combination with relational comparison and logical operators.

We give an if statement a condition to evaluate. If the condition proves true, the compiler will execute the if statement’s code block.

If the condition proves false, the compiler will move on to code below the if statement’s code block.

An if statement is written with the keyword if , followed by the condition(s) we want it to evaluate.

Then, we specify a code block with open and close curly braces. Inside the code block we write one or more expressions to be executed if the evaluation proves true.

Note that an if statement is not terminated with a semicolon. The closing curly brace will tell the compiler where the if statement ends.

In the example above, our variable a has a value less than 10, so the condition proves true. The compiler then prints the message inside the if statement’s code block.

When the compiler has finished executing the if statement, it will move on to any code after it. The same is true when our if statement proves false, the compiler will move on to the next piece of code outside and below the if statement.

In the example above, our if condition proves false. The compiler then moves on to the next section of code after the if statement.

We can evaluate more than one condition in an if statement with the help of the two logical operators && and ||.

Conditional AND is used to test if one condition and another proves true. Both conditions must prove true before the code will execute.

To evaluate multiple conditions with AND, we separate them with the && operator.

In the example above, both of our conditions prove true so the code inside the if code block executes.

The conditional OR is used to test if one condition or another proves true. Only one of the conditions must prove true before the code will execute.

To evaluate multiple conditions with OR, we separate them with the || operator.

In the example above, the first condition proves false, but the second condition proves true so the compiler is allowed to execute the code in the code block.

When we have multiple types of conditions that do not fit within a single if condition, we can write more if statements and combine them into an else if ladder.

The compiler will move to evaluate each if statement in the ladder when it’s done with previous one.

To write a conditional else if statement, we add another if statement below our first, separated by the else keyword.

In the example above, we add a secondary if statement at the end of the first, separated by the else keyword.

Note that an else if statement can only follow an if statement, it cannot stand on its own. The first conditional must always be an if.

We can have as many else if statements in a ladder as we need.

The else statement works as a catch-all fallback for anything that isn’t covered by an if statement or else if ladder.

Because it acts as a catch-all, the else statement doesn’t have a conditional block, only an execution code block.

In the example above, the else statement will execute any result other than number == 10. Because number is not 10, the compiler executes the else execution code block.

We can place if statements inside other if statements, a technique known as nesting. The compiler will perform the evaluations hierarchically, that’s to say, it will start out the outer if statement and move inwards.

To nest an if statement, we simply write it inside the execution code block of another if statement.

In the example above, our outer if statement condition proves true. The compiler then evaluates the inner if statement and executes its code block if its condition proves true.

Nested if statements are used when we want to evaluate conditions only if other conditions are true.

Note that if you find yourself nesting more than 3 levels deep, you should consider finding a different method. Perhaps a loop.

The match statement will check a single value against a list of values.

If you’re familiar with a languages in the C family, it would be similar to a switch statement, although the syntax is different.

Let’s take a look at the syntax before we explain.

There’s a lot going on here and it may seem confusing at first, so let’s take it step by step.

1. The match statement returns a value, so we can assign the whole statement to a variable to get the result.

2. Now we write the match statement itself. We use the keyword match, followed by the main value we are going to compare any other values to. Finally, we define a code block.

Note that the code block is terminated with a semicolon after the closing curly brace.

3. Inside the code block we will write the values that we want to try and match with the main value.

First, we specify the value we want to match, followed by a => operator. Then, inside another code block, we specify the execution statements if that value matches with the main value.

Each of these values are separated with a comma, and we can have as many as we need.

The final value to match is simply an underscore. The single, standalone, underscore in a match statement represents a catch-all situation if none of the values matched to the main value. Think of it as an else statement.

Now, let’s see a practical example of the match statement.

In the example above, we give a student a grade and store it in a variable. Then we check to see which grade score in the match statement the student’s score matches.

If the compiler finds a match on the left of the => operator, it will execute whatever statement is on the right of the => operator.

In this case, it matched to “B” on the left and so it printed the string “Great job, you got a B!”.

Note that we don’t use the result variable in the example above. This is simply because we don’t need to, the execution statement of the match already prints a message.

If we want to return an actual value, we specify the value instead of an action like println.

In the example above, we replaced the println!() statements with simple string values.

When the compiler finds a match on the left of the => operator, it will return the value on the right of the => into the result variable.

This time, the compiler matched to “A” on the left, so it stored the string “Excellent!” into the result variable.

We then used it in the println!() below the match statement.

We can conditionally assign a value to a variable with an if let expression. To do this, we simply write the if statement where the value should be in the variable initialization.

It’s important to note a few differences here to a normal if statement.

• We must have both an if and else statement.
• The execution expressions must provide a value to be assigned to the variable.
• The individual statements in the code blocks are not terminated with a semicolon.
• The if statement itself is terminated with a semicolon after the else closing curly brace.

In the example above, the if statement will prove true so the value assigned to the number variable is 1.

Let’s see another example.

As we know, a variable can only hold one type of value. If we try to assign different types of values to it through the if statement, the compiler will raise an error.

In the example above, the values we want to assign is of different types.

Eclipse will highlight the potential error for us before we compile. If we go ahead and compile anyway, the following error is raised.

Rust does not have a ternary operator anymore.

In many languages, such as C or Python we can write a shortened version of a simple if/else statement, known as the ternary operator.

Rust, removed the ternary operator back in 2012 . The language doesn’t support a ternary operator anymore.

• We can control the flow of our application with conditional logic through if , else if , else and match statements.
• The if and else if conditional statements must include a condition to evaluate.
• The else statement is a catch-all fallback to if and else if and as such cannot have a condition.
• We can nest if statements inside other if statements. The compiler will evaluate them hierarchically.
• The match statement is similar to a switch statement in many other languages such as C,C++.
• An if let expression places the if statement as the value of a variable declaration.
• An if let expression is terminated with a semicolon after the code block closing brace.
• Values inside the code blocks of an if let expression are not terminated with a semicolon.

Rust If-Else Statements: Key Concepts And Usage

The essentials of Rust if-else statements in this focused article. Designed for developers, we delve into the syntax, best practices, and practical applications of if-else logic in Rust programming.

Rust's if-else statements are a fundamental part of controlling the flow of your programs. They allow you to execute different code paths based on specific conditions. This article explores how these statements work in Rust, providing clear examples to enhance your understanding and application in real-world scenarios.

Basic Structure Of If-Else Statements In Rust

Writing conditional expressions, implementing if-else logic in code, nested if-else statements, using if-else with match statements, frequently asked questions, if-else statement, evaluating conditions, using else if, omitting the else block.

The if-else statement in Rust is a control flow construct that allows you to execute different code paths based on a condition. At its core, the if statement evaluates a condition that returns a Boolean value ( true or false ).

In Rust, the condition in an if statement must be a Boolean expression. This is different from languages like C or Python, where non-Boolean expressions, such as integers or strings, can be used as conditions.

For multiple conditions, Rust allows the use of else if . This is useful for checking more than two possible outcomes.

In Rust, the else block is optional. If omitted and the if condition is false, the program simply skips the if block and continues.

Using Comparison Operators

Logical operators, combining conditions.

In Rust, conditional expressions are crucial for controlling the flow of a program. These expressions evaluate to a Boolean value ( true or false ), determining the path your program will take.

Commonly, conditional expressions involve comparison operators such as == (equality), != (inequality), > (greater than), < (less than), >= (greater than or equal to), and <= (less than or equal to).

To combine multiple conditions, Rust uses logical operators like && (and), || (or), and ! (not). These operators allow for more complex conditional expressions.

You can combine multiple conditions in a single if statement for more complex logic. This approach is useful for checking various scenarios in one go.

Basic If-Else Implementation

Handling multiple conditions, conditional assignment.

In Rust, implementing if-else logic is straightforward. It involves evaluating conditions and executing code blocks based on these evaluations.

Start with a basic if-else structure. The if block executes when the condition is true, and the else block executes when the condition is false.

For more than two outcomes, use else if to handle multiple conditions . Each condition is checked in order until one is true.

Rust allows for conditional assignment using if-else. This is a concise way to assign values based on a condition.

Implementing Nested Logic

Avoiding deep nesting.

Nested if-else statements in Rust allow for more complex decision-making by placing one if-else block inside another. This is useful for checking multiple layers of conditions.

When implementing nested logic, the inner if-else block is placed within the outer block. This structure is ideal for evaluating conditions that depend on the outcome of a previous condition.

While nesting is powerful, deep nesting can make code hard to read and maintain. It's often better to use other constructs like match or separate functions for complex logic.

Sometimes, combining conditions using logical operators can be a simpler alternative to nesting.

Match As A Cleaner Alternative

Combining match and if-else, simplifying nested conditions.

In Rust, combining if-else statements with match constructs can lead to more concise and readable code. This approach is particularly useful when dealing with multiple conditions.

The match statement in Rust is similar to switch-case in other languages. It's a cleaner alternative to multiple if-else blocks, especially when dealing with enumerated types.

Sometimes, you might need to use if-else within a match arm to handle more complex conditions.

Using match with if-else can simplify nested conditions, making your code more organized and easier to follow.

Combining if-else with match statements in Rust provides a powerful tool for handling complex conditional logic in a structured and readable manner.

Is it mandatory to have an else block in an if-else statement?

No, the else block is optional in Rust. If the if condition is false and there is no else block, the program simply skips the if block.

What is the best practice for handling multiple conditions in Rust?

For multiple conditions, using match statements is often cleaner and more readable than multiple else if blocks, especially when working with enums.

How do I handle default cases in match statements?

Use the underscore _ as a catch-all pattern for default cases in match statements. This arm will match any value that hasn't been matched by the previous arms.

Let's see what you learned!

What is the correct syntax for an if-else statement in Rust?

Subscribe to our newsletter, subscribe to be notified of new content on marketsplash..

• Twitter / X
• to navigate

If let Expression

If let expression link, what is an if let expression link.

if let is a conditional expression that allows pattern matching. The block of code in the construct executes if the pattern in the condition matches with that of scrutinee expression.

• Syntax The if let expression begins with an if followed by a let and then a pattern having values enclosed within round brackets. Then an equal to (=) followed by a scrutinee expression. Then there is a block of code enclosed within braces{} .Then there is also an optional else block after this.

Note: When it says matching of pattern, it means that the defined pattern has the same number of values as that of the scrutinee expression.

Examples link

The following examples show how the different cases of if let expression can work:

If the first value or second value matches, it can guess the third value.

If the first value matches, it can guess the other two values.

Case 2: When the Pattern is Not Matched link

In the example below, the defined pattern does not match with the scrutinee expression so the statement in the else block gets executed.

Case 3: When the Pattern is Replaced With _ link

In the example below, the pattern is not defined. Rather it is replaced with an _ . In this case, the statement within the if let block executes.

Note: A warning, ⚠️, is generated by the compiler because the Rust compiler complains that it doesn’t make sense to use if let with an irrefutable pattern.

Last updated 25 Jan 2024, 05:11 +0530 . history

navigate_before If Expression

Match Expression navigate_next

• conditional-assignment 0.2.0
• Docs.rs crate page
• MIT OR Apache-2.0
• Dependencies
• 25% of the crate is documented
• i686-pc-windows-msvc
• i686-unknown-linux-gnu
• x86_64-apple-darwin
• x86_64-pc-windows-msvc
• x86_64-unknown-linux-gnu
• Feature flags
• About docs.rs
• Privacy policy
• Rust website
• Standard Library API Reference
• Rust by Example
• The Cargo Guide
• Clippy Documentation

Crate conditional_assignment

Conditional-assignment.

This is a very simple, small crate to help make conditional assignments more ergonomic.

The goal is to make the below look a little better.

Minimum Supported Rust Version (MSRV)

According to cargo-msrv , the MSRV is 1.56.1 . Given how simple this crate is, I wouldn’t be surprised if the MSRV is lower, but I didn’t check. Try it!

Licensed under either of

• Apache License, Version 2.0, ( LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0 )
• MIT license ( LICENSE-MIT or http://opensource.org/licenses/MIT )

at your option.

Contribution

Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.

Learn Python practically and Get Certified .

Popular Tutorials

Popular examples, reference materials, learn python interactively, rust introduction.

• Getting Started with Rust
• Rust Hello World
• Rust Comments
• Rust Print Output
• Rust Variables and Mutability

Rust Data Types

• Rust Type Casting
• Rust Operators

Rust Control Flow

Rust if...else.

• Rust while Loop
• Rust for Loop
• Rust break and continue
• Rust Struct

Rust Functions

• Rust Function
• Rust Variable Scope
• Rust Closure

Rust Standard Library

• Rust Stack and Heap
• Rust Vector
• Rust String
• Rust HashMap
• Rust HashSet
• Rust Iterator

Rust Error and Memory

• Rust Error Handling
• Rust Unwrap and Expect
• Rust Ownership
• Rust References and Borrowing

Rust Modules and Packages

• Rust Modules
• Rust Crate and Package
• Rust Cargo Package Manager

Rust Additional Topics

• Rust Pattern Matching
• Rust Generics
• Rust Traits
• Rust File Handling
• Rust Macros
• Rust Threads

Rust Tutorials

In computer programming, we use the if and if..else statements/expressions to run a block of code when a specific condition is met.

For example, a student can be assigned grades to a subject based on their overall score.

• if the score is above 90, assign grade A
• if the score is above 75, assign grade B
• if the score is above 65, assign grade C
• Boolean Expression

Before we learn about if..else expressions, let's quickly understand boolean expressions.

A boolean expression is an expression (produces a value) which returns either true or false (boolean) as the output. For example,

Here, x > 5 is a boolean expression that checks whether the value of variable x is greater than 5 . As 7 , the value of variable x is greater than 5 , the condition variable is assigned to true .

Hence, condition is true is seen as output.

• Rust if Expression

An if expression executes the code block only if the condition is true . The syntax of the if expression in Rust is:

If the condition evaluates to

• true - the code inside the if block is executed
• false - the code inside of the if block is not executed

Example: if expression

In the example above, we created a variable number and checked whether its value is greater than 0 . Notice the condition ,

Since the variable number is greater than 0 , the condition evaluates to true . As a result, we see the code block inside of curly braces being executed.

Suppose we change the number variable to a negative integer. Let's say -2 .

The output will be:

This is because the condition -2 > 0 evaluates to false and the body of if is skipped.

• Rust if..else Expressions

The if expression can occasionally also include an optional else expression. The else expression is executed if the condition in if is false .

The syntax for the if..else expression in Rust is:

1. If condition evaluates to true ,

• the code block inside if is executed
• the code block inside else is skipped

2. If condition evaluates to false ,

• the code block inside the if block is skipped
• the code block inside the else block is executed

Example: if..else expression

Here, the variable number has a value of -2 , so the condition number > 0 evaluates to false . Hence, the code block inside of the else statement is executed.

If we change the variable to a positive number. Let's say 10.

The output of the program will be:

Here, the condition number > 0 evaluates to true . Hence, the code block inside of the if statement is executed.

• Rust if..else if Expressions

We can evaluate multiple conditions by combining if and else in an else if expression. An if..else if expression is particularly helpful if you need to make more than two choices. The syntax for if with else if expression looks like this:

1. If condition1 evaluates to true,

• code block 1 is executed
• code block 2 and code block 3 is skipped

2. If condition2 evaluates to true,

• code block 2 is executed
• code block 1 and code block 3 is skipped

3. If both condition1 and condition2 evaluate to false,

• code block 3 is executed
• code block 1 and code block 2 is skipped

Example: if..else if..else Conditional

In this example, we check whether a number is positive, negative or zero. Because number = -2 is less than 0 which satisfies the condition : number < 0 , the else if block is executed.

• Nested if..else

You can use if..else expressions inside the body of other if..else expressions. It is known as nested if..else in Rust.

Example: Nested if..else

In this example,

• The outer_condition number < 0 evaluates to true as the number variable is assigned to a value of -2 . Thus, the outer code block is evaluated.
• The outer code block contains an inner_condition to check number == -2 , which is again true . Thus, the inner code block of the inner if expression is executed.
• The inner code block prints " The current number is -2 " to the screen.
• The inner else block is skipped because the inner_condition evaluated to true .

Table of Contents

• Introduction

Your daily dose of the Rust programming Language.

Conditional Assignment

• if let is a shorthand syntax for matching and binding on a single pattern.
• It can be used to conditionally assign a value to a variable.
• It is useful when you only care about one pattern and want to avoid writing a full match expression.

Matching Multiple Conditions

• if let can also be used in combination with else if statements to match multiple conditions.
• This can help to simplify code and avoid nested match expressions.

Struct Matching

• if let can also be used to match on structs and extract their fields.
• This can be useful when you only care about one or two fields in a struct

Enums Matching

• if let can also be used to match on enums and extract their variants.
• This can be useful when you only care about one or two variants of an enum.

Using if let with Result

• The Result type in Rust can be either an Ok variant or an Err variant.
• We can use the if let expression to match the Ok variant and extract the value from it.
• The if let expression can also handle the Err variant with an else block.

if let with while let

• if let can be used in combination with while let to handle pattern matching in a loop.
• This is useful when you want to keep looping while a certain pattern matches.

if let with a wildcard

• If let can also be used with a wildcard (_) to match any value in a particular variable.
• This is particularly useful when we are only interested in knowing if the pattern matches or not.
• Using a wildcard (_) is the same as using a variable without assigning it to a value.
• The underscore (_) is used to discard values and it is a special variable in Rust.

if let with closures

• You can use if let statements to simplify closures by removing unnecessary match statements.
• If a closure only has a single pattern match, you can use if let to simplify the code and make it more readable.
• The closure will only be executed if the pattern match is successful.

if let with early return

• You can use if let with an early return statement to simplify code and reduce nesting.
• If the pattern match is successful, the return statement will be executed immediately, without any additional code in the block being executed.
• This can be useful for cases where you want to exit a function early if a certain condition is met.

if let with find

• Rust’s standard library provides a find method for searching an iterator for an element that satisfies a predicate.
• We can use if let with find to extract the found value if it exists.

if let with options

• Rust’s Option type is used to represent the presence or absence of a value.
• We can use if let to extract the value from the Option if it contains a value, otherwise do nothing.
• This can be useful when we only care about the case where the Option has a value and want to handle it specially.

You can refer to this Twitter thread for reference

For now, this reference is a best-effort document. We strive for validity and completeness, but are not yet there. In the future, the docs and lang teams will work together to figure out how best to do this. Until then, this is a best-effort attempt. If you find something wrong or missing, file an issue or send in a pull request.

• Light (default)

The Rust Reference

If and if let expressions, if expressions.

Syntax IfExpression :    if Expression except struct expression BlockExpression    ( else ( BlockExpression | IfExpression | IfLetExpression ) ) ?

An if expression is a conditional branch in program control. The form of an if expression is a condition expression, followed by a consequent block, any number of else if conditions and blocks, and an optional trailing else block. The condition expressions must have type bool . If a condition expression evaluates to true , the consequent block is executed and any subsequent else if or else block is skipped. If a condition expression evaluates to false , the consequent block is skipped and any subsequent else if condition is evaluated. If all if and else if conditions evaluate to false then any else block is executed. An if expression evaluates to the same value as the executed block, or () if no block is evaluated. An if expression must have the same type in all situations.

if let expressions

Syntax IfLetExpression :    if let Pattern = Expression except struct expression BlockExpression    ( else ( BlockExpression | IfExpression | IfLetExpression ) ) ?

An if let expression is semantically similar to an if expression but in place of a condition expression it expects the keyword let followed by a refutable pattern, an = and an expression. If the value of the expression on the right hand side of the = matches the pattern, the corresponding block will execute, otherwise flow proceeds to the following else block if it exists. Like if expressions, if let expressions have a value determined by the block that is evaluated.

if and if let expressions can be intermixed:

Conditionals

Examples using conditionals in Rust.

Basic If-Else

An example of a basic If-Else statement in Rust.

Here is an equivalent conditional, one of my favorite features of Rust is using if assignments.

The last line of a block is used as the return value.

The Rust equivalent of switch is match which allows for powerful pattern matching.

Like if statement above, you can also use match for assignment.

Error Matching

The match command is used often for error handling.

Option Matching

In Rust numerous functions will return an option that needs to be handled, typically the match command is used. In this vector example, .pop() returns an Option since a vector may be empty and there is no last value.

The above is a little awkward, and a bit contrived, but a more likely use would be moving the Some() into the loop, like so:

• Introduction to Rust Programming 🦀

Rust Basics 🦀

• Rust Basics Series #1: Create and Run Your First Rust Program
• Rust Basics Series #2: Using Variables and Constants in Rust Programs
• Rust Basics Series #3: Data Types in Rust
• Rust Basics Series #4: Arrays and Tuples in Rust
• Rust Basics Series #5: Functions in the Rust Programming Language

Rust Basics Series #6: Conditional Statements

• Rust Basics Series #7: Using Loops in Rust
• Rust Basics Series #8: Write the Milestone Rust Program

You can control the flow of your program by using conditional statements. Learn to use if-else in Rust.

In the previous article in this series, you looked at Functions. In this article, let's look at managing the control flow of our Rust program using conditional statements.

What are conditional statements?

When writing some code, one of the most common tasks is to perform a check for certain conditions to be true or false . "If the temperature is higher than 35°C, turn on the air conditioner."

By using keywords like if and else (sometimes in combination), a programmer can change what the program does based on conditions like the number of arguments provided, the options passed from the command line, the names of files, error occurrence, etc.

So it is critical for a programmer to know control flow in any language, let alone in Rust.

Conditional operators

The following table shows all the frequently used operators for an individual condition:

And following is the table for logical operators, they are used between one or more conditions:

Using if else

To handle the basic flow of Rust code, two keywords are used: if and else . This helps you create two "execution paths" based on the state of the provided condition.

The syntax of a simple if block with an alternative execution path is as follows:

Let's look at an example.

Here, I have declared two integer variables a and b with the values '36' and '25'. On line 5, I check if the value stored in variable a is greater than the value stored in variable b . If the condition evaluates to true , the code on line 6 will be executed. If the condition evaluates to false , due to the fact that we have an else block (which is optional), the code on line 8 will get executed.

Let's verify this by looking at the program output.

Let's modify the value of variable a to be less than value of variable b and see what happens. I will change a 's value to '10'. Following is the output after this modification:

But, what if I store the same value in variables a and b ? To see this, I will set both variables' value to be '40'. Following is the output after this particular modification:

Huh? Logically, this doesn't make any sense... :(

But this can be improved! Continue reading.

Using 'else if' conditional

Like any other programming language, you can put an else if block to provide more than two execution paths. The syntax is as follows:

Now, with the use of an else if block, I can improve the logic of my program. Following is the modified program.

Now, the logic of my program is correct. It has handled all edge cases (that I can think of). The condition where a is equal to b is handled on line 5. The condition where a might be greater than b is handled on line 7. And, the condition where a is less than b is intrinsically handled by the else block on line 9.

Now, when I run this code, I get the following output:

Now that's perfect!

Example: Find the greatest

I know that the use of if and else is easy, but let us look at one more program. This time, let's compare three numbers. I will also make use of a logical operator in this instance!

This might look complicated at first sight, but fear not; I shall explain this!

Initially, I declare three variables a , b and c with random values that I could think of at that time. Then, on line 6, I check for the condition where no variable's value is same as any other variable. First, I check the values of a and b , then a and c and then b and c . This way I can be sure that there are no duplicate values stored in either variable.

Then, on line 7, I check if the value stored in variable a is the greatest. If that condition evaluates to true , code on line 8 gets executed. Otherwise the execution path on line 9 is checked.

On line 9, I check if the value stored in variable b is the greatest. If this condition evaluates to true , code on line 10 gets executed. If this condition is also false , then it means only one thing. Neither variable a , nor variable b is the greatest among all 3.

So naturally, in the else block, I print that the variable c holds the greatest value.

Let's verify this with the program output:

And this is as expected. Try and modify the values assigned to each variable and test it out yourself! :)

You learned to use if and else statements. Before you go on making your own AI with lost of if else-if statements (haha), let' learn about loops in Rust in the next chapter of the series.

Stay tuned.

On this page

Introduction to Conditional Expression

This lesson gets you acquainted with the conditional statements in Rust.

• What Are Conditional Expression?
• Types of Conditional Expression

What Are Conditional Expression? #

Conditions basically give the power to make decisions. They check the condition of the expression and act accordingly.

Create a free account to access the full course.

By signing up, you agree to Educative's Terms of Service and Privacy Policy

This browser is no longer supported.

Upgrade to Microsoft Edge to take advantage of the latest features, security updates, and technical support.

Test conditions with if/else expressions in Rust

Explore Rust compound data types like arrays and vectors. Discover how to use if/else statements to test conditions.

Learning objectives

In this module, you will:

• Explore Rust compound data types: arrays and vectors
• Discover how to use if/else statements to test conditions in a Rust program
• Create, compile, and run a Rust program to process compound data and test values

Prerequisites

• Have your Rust development environment already set up.
• Know how to create, edit, and run Rust code by using Cargo or by working in the Rust playground.
• Introduction min
• Create and use arrays min
• Explore the vector data type min
• Exercise: Work with compound types min
• Use if/else conditions min
• Exercise: Work with if/else conditions min
• Summary min