C# (C Sharp) offers multiple ways to do these things, and I’m about to show you some of the most common ones. We’ll discuss the pros and cons of each method, and which ones are more suited for particular scenarios.

Table of Contents

• What You Will Learn In This Article

• If / Else if / Else Statements

• Replacing If / Else with Ternary Operator

• Switch Case Statements

• Switch Statements - Expression Syntax

• Performance Summary

• Conclusion

What You Will Learn In This Article

I will teach you all about the following conditional coding mechanisms within C#.

• If / Else If / Else statements

• Ternary statements

• Switch-Case statements

• Analysing performance of conditional coding options

Pre-requisites:

• Very basic knowledge of the C# coding language

• Coding IDE (to code along if you wish)

If / Else if / Else Statements

When first learning a new programming language, the If statement is a staple in any developer’s learning syllabus. It’s the easiest way in which you can conditionally route the flow of your code’s execution.

Let’s take a look at building up the complexity of the the If statement syntax. In its most basic form, you can use it as a simple if clause, meaning the code within the if block will only be executed if a condition is met.

Example:

// For the demo we're using a hard coded age.
int age = 22;

//check person is of legal age in the UK
if (!string.IsNullOrEmpty(age) && age >= 18)
{
   // If true, run the following code
   AllowAccessToNightClub();
}

Going one step further, if we wanted to carry out some code where the statement results in false, we can do that using an if / else statement like so:

var ageLimit = 18;
var customersAge = 17

if(customersAge >= ageLimit){
{   
    AllowAccessToTheClub();
} else{
    // Deny Access
    DenyAccess();
    // we can also nest if statements
    // if the customer doesn't leave call the Police!
    if(!CustomerLeaves()){
        CallThePolice();
    };
}

The above example illustrates how you can use if / else statements to control your flow of code. You’ve seen how you can handle specific scenarios with nested statements, allowing you to check future outcomes.

In the above code, we are checking if CustomerLeaves() returns a true or false value, and depending on the outcome, we see whether we need to CallThePolice() or not.

For situations where you want to check more than one condition before defaulting to else, you can use the if / else if / else syntax. Let's see how it works:

int age = 17;

if(age >= 18){
    Console.WriteLine("You can drink alcohol in the UK");
    Console.WriteLine("You can vote in the UK");
    Console.WriteLine("You can get a tattoo");
} else if(age >= 16 && age < 18){
    Console.WriteLine("You can join the royal forces in the UK");
} else{
   Console.WriteLine("Stay in School!");
}

The example above uses if / else if / else to display different text based on which condition is met. Only one block will ever run, as you can only match a single condition with this syntax.

Let’s say you wanted to build a stringup based on multiple conditions, but you wanted all conditions to be checked individually. In that case, you could utilise multiple if statements to accomplish this. Be aware, though, that this can make your code less performant and harder to read.

using System.Text;

int age = 20;
bool hasDrivingLicense = true;
bool hasVoterID = false;

var builder = new StringBuilder();

// Multiple independent if statements
if (age >= 18)
{
    builder.Append("You are an adult.");
}

if (hasDrivingLicense)
{
    builder.Append("You can drive.");
}

if (hasVoterID)
{
    builder.Append("You are eligible to vote.");
}

Console.WriteLine(builder.ToString());
Console.WriteLine(builder.ToString());
/* Output
You are an adult.You can drive.
*/

The above code demonstrates using multiple if statements instead of if, else if, else. This allows multiple conditions to be checked independently, so multiple code blocks can run if the conditions are met. This is useful when wanting to assign values to an object’s properties based on different criteria or independent conditions.

Replacing If / Else with Ternary Operator

If / Else statements are very useful, but sometimes they can take up a lot of space for really simple assignment code. The ternary operator is perfect for these situations. Its syntax uses ? and : to represent what happens if the condition is true or false, eliminating the need for brackets.

Here’s an example:

var backgroundColor = isDarkMode ? "black" : "white";

Explanation:

• backgroundColor: The variable being assigned.

• isDarkMode: A boolean condition being evaluated.

• ?: Marks the start of the ternary operator. If isDarkMode is true, the value after ? ("black") is assigned.

• :: Separates the true case from the false case. If isDarkMode is false, the value after : ("white") is assigned.

The ternary statement is shorthand for simple conditional assignments, making your code more compact. I would recommend using it for simple variable assignment or simple binary calling of functions (like call A or call B).

Here’s an example:

isLoggedIn ? ShowWelcomeMessage() : PromptLogin();

void ShowWelcomeMessage()
{
    Console.WriteLine("Welcome back, user!");
}

void PromptLogin()
{
    Console.WriteLine("Please log in to continue.");
}

Ternary operations can be nested also like so:

var isDarkMode = true;
var isAccessibilityActive = true;

var backgroundColor = isDarkMode ? isAccessibilityActive ? "green" : "black" : "white";

Console.WriteLine(backgroundColor);

The above example uses nested ternary operators to replace a nested if / else statement. Just keep in mind that the flow is different from a regular ternary operation. It would read like this:

IF isDarkMode is true, then check if isAccessibilityActive is true

IF isAccessibility is true, set the value to “green” otherwise return “black”

IF isDarkMode is false it will skip the inner checks, and return “white”;

I’d avoid using nested ternary operators where you can, as they’re messy and can be difficult to read.

Switch Case Statements

Switch case statements work by testing a variable (switch) against multiple possibilities (case).

string userRole = "Admin";

// check the user role against following criteria.
switch (userRole)
{
    case "Admin":
        Console.WriteLine("You have full access.");
        break;
    case "Moderator":
        Console.WriteLine("You can moderate content.");
        break;
    case "User":
        Console.WriteLine("You have limited access.");
        break;
    default:
        Console.WriteLine("Role not recognised.");
        break;
}

Note: the value and type of variable being evaluated must match. For example, you can’t compare a string with a integer (without casting / parsing first). If none of the cases match, the default block is executed, similar to the else in an if/else structure, usually used for a fallback case.

Why Use Switch-Case Over If Statement?

Readability: When handling multiple distinct values (like roles, commands, or enum types), switch is easier to read and maintain because it organises conditions more cleanly, without multiple if and else if blocks.

Performance: In some cases, switch statements can be more efficient than multiple if / else if blocks, especially when dealing with multiple possible values of a single variable. Some compilers optimise switch statements into lookup tables, improving performance

Scalability: When managing a long list of distinct options or conditions, a switch case scales better. Adding new cases is simpler and doesn't involve updating long chains of if / else if.

Clean Defaults: The default case provides a clear way to handle unrecognised or unexpected scenarios, similar to the else block in an if / else if statement, but it feels more naturally integrated with the switch structure. This can be handy for throwing exceptions, logging, and so on.

Switch Statements - Expression Syntax

There are times where you need slightly more complex conditions to be evaluated yet still wish to utilise the switch syntax. In this scenario you can utilise the switch expression syntax which was introduced in C# 8.

string userType = "VIP";
decimal purchaseAmount = 500m;

decimal discount = userType switch
{
    "Regular" when purchaseAmount < 100 => 0.05m,  
    "Regular" => 0.10m,  
    "VIP" when purchaseAmount < 500 => 0.15m,  
    "VIP" => 0.20m,  
    "Employee" => 0.25m,  
    _ => 0m 
};

Console.WriteLine($"Your discount is: {discount * 100}%");

This syntax is great when needing to assign a value to the outcome of the case.

• userType switch { ... }: a switch expression that returns a value (in this case, the discount) based on the userType and optional conditions (like purchaseAmount).

• The when clause allows for more complex conditions, such as checking the purchaseAmount in addition to the userType to alter the discount amount.

Default Case / Fallback

The default case in this syntax uses the _ character. In our example, if none of the above cases are met, the default case is met and we return 0m (no discount).

Benefits of Switch Expressions Over Conventional switch Statements:

Concise and Readable: The switch expression is more compact and readable, especially when returning values directly based on conditions, without needing to declare variables or use break statements.

Pattern Matching: It supports pattern matching (when), making it easier to add complex conditions to each case, something that would require more verbose if checks in a traditional switch statement.

Returns a Value: The switch expression is an expression that directly returns a value, making it ideal for assignments or inline use, reducing boilerplate code. Below, you’ll find an example using a switch expression as the return value in a method without assigning it to a variable.

Simplifies Complex Logic: It's excellent for scenarios like this one, where multiple conditions affect the outcome, handling them concisely without deeply nested if / else if blocks.

decimal CalculateDiscount(string userType, decimal purchaseAmount) =>
    userType switch
    {
        "Regular" when purchaseAmount < 100 => 0.05m,
        "Regular" => 0.10m,
        "VIP" when purchaseAmount < 500 => 0.15m,
        "VIP" => 0.20m,
        "Employee" => 0.25m,
        _ => 0m
    };

// Usage
decimal discount = CalculateDiscount("VIP", 500m);
Console.WriteLine($"Your discount is: {discount * 100}%");

Performance Summary

To help you decide, here are is a quick Benchmarking project (using BenchmarkDotNet package, which you can install with dotnet add package BenchmarkDotnet):

using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Order;
using System.Collections.Generic;

namespace Csharp_Console_Playground
{
    [MemoryDiagnoser]
    [Orderer(SummaryOrderPolicy.FastestToSlowest)]
    public class BenchMarkRunner
    {
        private static readonly Dictionary<int, string> RankingMessages = new()
        {
            { 0, "Do not stay in this hotel" },
            { 1, "It's cheap and cheerful" },
            { 2, "It's clean and tidy" },
            { 3, "In the middle hotel, good service and great amenities" },
            { 4, "It's a nice hotel, but the price is not too high" },
            { 5, "It's the best hotel in the area" }
        };

        private int ranking = 5;

        [Benchmark]
        public string BenchMarkIfElse()
        {
            var winningMessage = "";

            if (ranking == 0)
            {
                winningMessage = "Do not stay in this hotel";
            }
            else if (ranking == 1)
            {
                winningMessage = "It's cheap and cheerful";
            }
            else if (ranking == 2)
            {
                winningMessage = "It's clean and tidy";
            }
            else if (ranking == 3)
            {
                winningMessage = "In the middle hotel, good service and great amenities";
            }
            else if (ranking == 4)
            {
                winningMessage = "It's a nice hotel, but the price is not too high";
            }
            else if (ranking == 5)
            {
                winningMessage = "It's the best hotel in the area";
            }

            return winningMessage;
        }

        [Benchmark]
        public string BenchMarkSwitchCaseExpression()
        {
            var winningMessage = ranking switch
            {
                0 => "Do not stay in this hotel",
                1 => "It's cheap and cheerful",
                2 => "It's clean and tidy",
                3 => "In the middle hotel, good service and great amenities",
                4 => "It's a nice hotel, but the price is not too high",
                5 => "It's the best hotel in the area",
                _ => ""
            };

            return winningMessage;
        }

        [Benchmark]
        public string BenchMarkSwitchCase()
        {
            var winningMessage = "";
            switch (ranking)
            {
                case 0:
                    winningMessage = "Do not stay in this hotel";
                    break;
                case 1:
                    winningMessage = "It's cheap and cheerful";
                    break;
                case 2:
                    winningMessage = "It's clean and tidy";
                    break;
                case 3:
                    winningMessage = "In the middle hotel, good service and great amenities";
                    break;
                case 4:
                    winningMessage = "It's a nice hotel, but the price is not too high";
                    break;
                case 5:
                    winningMessage = "It's the best hotel in the area";
                    break;
                default:
                    winningMessage = "Invalid ranking";
                    break;
            }

            return winningMessage;
        }

        [Benchmark]
        public string? BenchMarkDictionary()
        {
            return RankingMessages.TryGetValue(ranking, out var rankingMessage) ? rankingMessage : null;
        }
    }
}

You can then run these tests in your Program.cs:

using BenchmarkDotNet.Running;
using Csharp_Console_Playground;

BenchmarkRunner.Run<BenchMarkRunner>();

Make sure you use your Release build profile in order to run the benchmarks.

 dotnet build -c Release

then execute dotnet on your build location, for example:

dotnet bin/Release/net8.0/FCC-Conditions.dll

Results:

switch statements can be faster than dictionaries because the compiler helps optimise them. When the compiler sees a switch, it can create a special lookup table (jump table, or binary search tree) that allows it to find the right case quickly, especially when the cases are close together (like numbers 1, 2, and 3). This means it can check the value almost instantly.

The reason the dictionary is the slowest is due to memory allocation. Within our bench mark test, we needed to create an in-memory variable for the dictionary to be created and stored (time consuming), and then retrieval also needs to be carried out when doing the lookup.

Switch-Case Expressions:

Compile-Time Optimisation: Switch cases are typically optimised at compile-time (when you build your code). The compiler analyses the possible case values and generates efficient machine code to handle them. Depending on the cases, this could be via jump tables, or branching / binary search mechanisms.

Since this is all done during compilation, the switch statement has no additional overhead at runtime beyond what the compiler has set up.

Dictionaries:

Runtime Construction: In contrast, a dictionary (for example, Dictionary<TKey, TValue> in C#) is built at runtime. The dictionary uses a hash table under the hood, where keys are hashed to generate an index that maps to a value. Here’s the key difference:

• Hash Function: When you add a key to a dictionary, the hash function is applied to the key to determine where the value should be stored.

• Collision Handling: If two keys happen to have the same hash (a "collision"), the dictionary has to resolve it (usually by chaining or probing), which can introduce some additional overhead.

Since dictionaries are built and modified at runtime, they have to perform these operations dynamically, which adds more overhead compared to the static structure of switch cases.

Conclusion

Understanding how to control the flow of your code through conditional logic is a foundational skill in programming, and C# offers various tools to achieve this. Whether you're using if/else statements for simple conditions, the ternary operator for concise assignments, or switch statements for complex logic, each approach has its strengths and ideal use cases.

Switch statements provide clarity and performance optimisations, especially when handling multiple conditions. On the other hand, dictionaries offer flexibility but come with a runtime overhead. Knowing when to use each method allows you to write more efficient, readable, and maintainable code tailored to specific scenarios.

As always if you want to chat about any of my articles you can follow me on Twitter.

But what is a boolean context? It's a situation where a boolean value is expected. Examples include if statements, logical operators, and so on. When you use a non-boolean value in a boolean context, JavaScript will convert the value to its boolean equivalent.

In this article, you will learn about falsy values in JavaScript and how to check if a value is falsy. The article also covers some best practices to consider when checking the boolean equivalent of a value.

Let's get started!

Table of Contents

• The Six Falsy Values in JavaScript

• How to Check if a Value is Falsy

• Truthy Values That May Appear as Falsy Values

• Best Practices When Checking Boolean Equivalent

• Conclusion

The Six Falsy Values in JavaScript

Falsy values in JavaScript are unique because there are only six of them. Apart from these six, all other values are truthy values.

You can commit these falsy values to memory. That way, when you come across any value that isn't one of the six, you know it's a truthy value.

Here are the six falsy values in JavaScript:

• false: The boolean value false.

• 0: The number zero.

• "" or '' or ````: An empty string.

• null: The null keyword, representing the absence of any object value.

• undefined: The undefined keyword, representing an uninitialized value.

• NaN: Stands for "Not a Number". It represents a special value returned from an operation that should return a numeric value but doesn't.

Now, let's see some practical examples of these falsys valsues in JavaScript.

Example 1 – The boolean value false.

let isOnline = false

function checkStatus(status) {
  return Boolean(status) ? "ONLINE" : "OFFLINE"
}

checkStatus(isOnline) // "OFFLINE"

When you pass the isOnline variable to the checkStatus function, it returns the string "OFFLINE". And this is because the value is false in this context. Here, we are using a tenary operator based on the boolean value of the status argument.

Example 2 – The number zero.

let unreadMessages = 0
let hasUnreadMessages = Boolean(unreadMessages)
console.log(hasUnreadMessages) // false

This examples checks whether a user has unread messages or not. We use the in built Boolean function to get the boolean value of the unreadMessages variable. This means anytime the number of unreadMessages is zero, hasUnreadMessages will be false.

Example 3 – An empty string.

let userInput = "";
let defaultText = "No input provided";

let displayText = Boolean(userInput) || defaultText;

console.log(displayText); // No input provided

This example uses the logical OR operator || to determine the value of the displayText. It will assign the value of userInput to displayText if it's a truthy value. Or it will assign the defaultText to displayText if userInput is a falsy value as it is in this case.

Example 4 – null

let user = null;

if (user && user.name) {
    console.log("Welcome, " + user.name + "!");
} else {
    console.log("Please log in to access the website.");
}

The following example assumes the user isn't logged in and so the value of user object is null. This means the if statement will evaluate to false. The expected behaviour then will be that the code executes the else block.

Example 5 – undefined

let age;
if (age === undefined) {
    console.log("The age is undefined.");
}

When a variable is declared but not initialized with a value, JavaScript assigns it the value undefined by default. In the code example above, since the age variable is declared but not assigned a value, its value is undefined. This means the code in the if statement will run.

Example 6 – NaN

let value1 = "Ten"
let value2 = 10

let result = value1 / value2

if (isNaN(result)) {
    console.log("The result is not a number.");
} else {
    console.log(result);
}

This example divides value1 (a string) by value2 (a number). This will result in a NaN value because you cannot divide a string by a number. This means the code in the if block will run. And log The result is not a number to the console.

How to Check if a Value is Falsy in JavaScript

A safe way to check whether a value is falsy or not is to use the Boolean function. The Boolean function returns the boolean value of the value of the argument passed to it.

Example:

console.log(Boolean(false))
console.log(Boolean(0))
console.log(Boolean(""))
console.log(Boolean(null))
console.log(Boolean(undefined))
console.log(Boolean(NaN))

Boolean log results for all six falsy values.

Here, we are checking the boolean value of all six falsy values. And as expected, each returns false.

When you pass any other value that's not one of these six falsy values to the Boolean function, it will return true.

Example:

console.log(Boolean('hello'))
console.log(Boolean(24))

Example boolean log results for truthy values.

Truthy Values that May Appear as Falsy Values

There are some truthy values that, at a glance, may appear to be falsy values but aren't. As already mentioned, only six values in JavaScript are falsy values. Anything else is a truthy value.

The following are some of those values that aren't falsy but may appear as such.

console.log(Boolean('false')) // An empty object
console.log(Boolean(' ')) // An empty object
console.log(Boolean('0')) // An empty object
console.log(Boolean([])) // An empty array
console.log(Boolean({})) // An empty object

Log results for truthy values that appear as falsy.

The first three strings contains text that may look like falsy values. First is the string with the text "false", another one with some whitespace, and the third with zero.

Remember that the only string considered a falsy value is an empty string. All non-empty strings in JavaScript are truthy values including strings with only whitespace.

Also, note that unlike strings, both an empty array and an empty object return true in a boolean context.

Best Practices When Checking Boolean Equivalent

The following tips will help make your code more readable and easier to maintain.

1. Use the Boolean function

It's always better to use the built-in Boolean function when you want to check whether a value is truthy or falsy. The function works by coercing any value into its corresponding boolean. It also makes your intention clear to anyone reading the code.

Example:

// Example without the Boolean function
const value = ''; 

if (value) {
    console.log('It is a TRUTHY value');
} else {
    console.log('It is a FALSY value');
}

// Example with the Boolean function
const value = ''

if (Boolean(value)) {
    console.log('It is a TRUTHY value');
} else {
    console.log('It is a FALSY value');
}

Both examples do the same thing. But in the second example, it's explicit that you're checking the boolean representation of the given value.

2. Use strict equality === instead of loose equality ==

When you're comparing values for truthiness or falsiness, it's recommended to use strict equality (===) over loose equality (==). Strict equality compares both the value and the type. Loose equality performs type coercion before comparing the values, and this can lead to unexpected results.

Example:

// Strict Equality Example

if (1 === [1]) {
  console.log('EQUAL')
} else {
  console.log('NOT EQUAL')
}

Log result for strict equality example.

// Loose Equality Example
if (1 == [1]) {
  console.log('EQUAL')
} else {
  console.log('NOT EQUAL')
}

Log result for loose equality example.

Both examples above compare the same values. But the strict equality example logs "NOT EQUAL". This is because the number 1 is not equal to an array containing the number 1. With the loose equality, it coerces the type of the values to make them of the same type. That is why it logs "EQUAL" to the console.

3. Add comments to document your code

To make your code more readable and easier to maintain, consider adding comments when necessary to explain your logic when dealing with truthy and falsy values.

Documenting your code is a good practice to help developers on your team (or your future self) understand the intended behaviour of a piece of code.

Example:

let selectedUser = USER_OBJ

// Check if no user is selected
if (!selectedUser) {
    console.log("Please select a user.");
} else {
    console.log("User address: " + selectedUser.address);
}

In the example above, the comment added before the if statement makes it clear that the code is checking if no user has been selected.

Using the logical NOT operator (!) can make it seem like you're checking if a user is selected rather than checking if no user is selected. So a comment in an instance like helps provide clarity.

Conclusion

In this article, you have learned about the six falsy values in JavaScript and how they differ from truthy values. You also learned about some truthy values that may appear as falsy, but actually aren't. And you also saw some best practices to consider when working with falsy values.

A good understanding of the concept of falsy and truthy values and how they affect comparisons and conditional statement will come in handy when debugging JavaScript applications.

Thanks for reading. And happy coding! For more in-depth tutorials, feel free to subscribe to my YouTube channel.

In this article, you'll learn how to use the ternary operator in Python. You'll see its syntax along with some practical examples.

What Is the Ternary Operator Used for in Python?

The ternary operator in Python is simply a shorter way of writing an if and if...else statements.

Here's what an if...else statement looks like in Python:

user_score = 90

if user_score > 50:
    print("Next level")
else:
    print("Repeat level")

In the code above, we created a variable user_score with a value of 90.

We then printed either of two statements based on a predefined condition — if user_score > 50.

So if the user_score variable is greater than 50, we print "Next level". If it's less than user_score, we print "Repeat level".

You can shorten the if...else statement using the ternary operator syntax.

Python Ternary Operator Example

In the last example, we saw how to use an if...else statement in Python.

You can shorten it using the ternary operator. Here's what the syntax looks like:

[option1] if [condition] else [option2]

In the syntax above, option1 will be executed if the condition is true. If the condition is false then option2 will be executed.

In other words, the ternary operator is just a shorthand of the if and if...else statements. You can use it in just a single line of code.

Here's a more practical example:

user_score = 90

print("Next level") if user_score > 50 else print("Repeat level")

In the code above, "Next level" will be printed out because the condition is true.

Summary

In this article, we talked about the ternary operator in Python. It's a shorter way of writing if and if...else statements.

You can use ternary operators to execute code based on predefined conditions.

Happy coding! I also write about Python on my blog.

In this article, we'll explore how to use if, else, and elif statements in Python, along with some examples of how to use them in practice.

How to Use the if Statement in Python

The if statement allows you to execute a block of code if a certain condition is true. Here's the basic syntax:

if condition:
    # code to execute if condition is true

The condition can be any expression that evaluates to a Boolean value (True or False). If the condition is True, the code block indented below the if statement will be executed. If the condition is False, the code block will be skipped.

Here's an example of how to use an if statement to check if a number is positive:

num = 5

if num > 0:
    print("The number is positive.")

Output:

The number is positive.

In this example, we use the > operator to compare the value of num to 0. If num is greater than 0, the code block indented below the if statement will be executed, and the message "The number is positive." will be printed.

How to Use the else Statement in Python

The else statement allows you to execute a different block of code if the if condition is False. Here's the basic syntax:

if condition:
    # code to execute if condition is true
else:
    # code to execute if condition is false

If the condition is True, the code block indented below the if statement will be executed, and the code block indented below the else statement will be skipped.

If the condition is False, the code block indented below the else statement will be executed, and the code block indented below the if statement will be skipped.

Here's an example of how to use an if-else statement to check if a number is positive or negative:

num = -5

if num > 0:
    print("The number is positive.")
else:
    print("The number is negative.")

Output:

The number is negative.

In this example, we use an if-else statement to check if num is greater than 0. If it is, the message "The number is positive." is printed. If it is not (that is, num is negative or zero), the message "The number is negative." is printed.

How to Use the elif Statement in Python

The elif statement allows you to check multiple conditions in sequence, and execute different code blocks depending on which condition is true. Here's the basic syntax:

if condition1:
    # code to execute if condition1 is true
elif condition2:
    # code to execute if condition1 is false and condition2 is true
elif condition3:
    # code to execute if condition1 and condition2 are false, and condition3 is true
else:
    # code to execute if all conditions are false

The elif statement is short for "else if", and can be used multiple times to check additional conditions.

Here's an example of how to use an if-elif-else statement to check if a number is positive, negative, or zero:

num = 0

if num > 0:
    print("The number is positive.")
elif num <

Use Cases For Conditional Statements

Example 1: Checking if a number is even or odd.

num = 4

if num % 2 == 0:
    print("The number is even.")
else:
    print("The number is odd.")

Output:

The number is even.

In this example, we use the modulus operator (%) to check if num is evenly divisible by 2.

If the remainder of num divided by 2 is 0, the condition num % 2 == 0 is True, and the code block indented below the if statement will be executed. It will print the message "The number is even."

If the remainder is not 0, the condition is False, and the code block indented below the else statement will be executed, printing the message "The number is odd."

Example 2: Assigning a letter grade based on a numerical score

score = 85

if score >= 90:
    grade = "A"
elif score >= 80:
    grade = "B"
elif score >= 70:
    grade = "C"
elif score >= 60:
    grade = "D"
else:
    grade = "F"

print("Your grade is:", grade)

Output:

Your grade is: B

In this example, we use an if-elif-else statement to assign a letter grade based on a numerical score.

The if statement checks if the score is greater than or equal to 90. If it is, the grade is set to "A". If not, the first elif statement checks if the score is greater than or equal to 80. If it is, the grade is set to "B". If not, the second elif statement checks if the score is greater than or equal to 70, and so on. If none of the conditions are met, the else statement assigns the grade "F".

Example 3: Checking if a year is a leap year

year = 2000

if year % 4 == 0:
    if year % 100 == 0:
        if year % 400 == 0:
            print(year, "is a leap year.")
        else:
            print(year, "is not a leap year.")
    else:
        print(year, "is a leap year.")
else:
    print(year, "is not a leap year.")

Output:

2000 is a leap year.

In this example, we use nested if statements to check if a year is a leap year. A year is a leap year if it is divisible by 4, except for years that are divisible by 100 but not divisible by 400.

The outer if statement checks if year is divisible by 4. If it is, the inner if statement checks if it is also divisible by 100. If it is, the innermost if statement checks if it is divisible by 400. If it is, the code block indented below that statement will be executed, printing the message "is a leap year."

If it is not, the code block indented below the else statement inside the inner if statement will be executed, printing the message "is not a leap year.".

If the year is not divisible by 4, the code block indented below the else statement of the outer if statement will be executed, printing the message "is not a leap year."

Example 4: Checking if a string contains a certain character

string = "hello, world"
char = "w"

if char in string:
    print("The string contains the character", char)
else:
    print("The string does not contain the character", char)

Outcome:

The string contains the character w

In this example, we use the in operator to check if the character char is present in the string string. If it is, the condition char in string is True, and the code block indented below the if statement will be executed, printing the message "The string contains the character" followed by the character itself.

If char is not present in string, the condition is False, and the code block indented below the else statement will be executed, printing the message "The string does not contain the character" followed by the character itself.

Conclusion

Conditional statements (if, else, and elif) are fundamental programming constructs that allow you to control the flow of your program based on conditions that you specify. They provide a way to make decisions in your program and execute different code based on those decisions.

In this article, we have seen several examples of how to use these statements in Python, including checking if a number is even or odd, assigning a letter grade based on a numerical score, checking if a year is a leap year, and checking if a string contains a certain character.

By mastering these statements, you can create more powerful and versatile programs that can handle a wider range of tasks and scenarios.

It is important to keep in mind that proper indentation is crucial when using conditional statements in Python, as it determines which code block is executed based on the condition.

With practice, you will become proficient in using these statements to create more complex and effective Python programs.

Let’s connect on Twitter and Linkedin.

For example, if you are coding a bot, you can have it respond with different messages based on a set of commands it receives.

In this article, I will explain what an if...else statement is and provide code examples. We will also look at the conditional (ternary) operator which you can use as a shorthand for the if...else statement.

What is an if...else statement in JavaScript?

The if...else is a type of conditional statement that will execute a block of code when the condition in the if statement is truthy. If the condition is falsy, then the else block will be executed.

Truthy and falsy values are converted to true or false in if statements.

if (condition is true) {
   // code is executed
} else {
   // code is executed
}

Any value that is not defined as falsy would be considered truthy in JavaScript.

Here is a list of falsy values:

• false
• 0 (zero)
• -0 (negative zero)
• 0n (BigInt zero)
• "", '', ```` (empty string)
• null
• undefined
• NaN (not a number)

Examples of if...else statements in JavaScript

In this example, the condition for the if statement is true so the message printed to the console would be "Nick is an adult."

const age = 18;

if (age >= 18) {
  console.log("Nick is an adult.");
} else {
  console.log("Nick is a child.");
}

But if I change the age variable to be less than 18, then the condition would be false and the code would execute the else block instead.

const age = 12;

if (age >= 18) {
  console.log("Nick is an adult.");
} else {
  console.log("Nick is a child.");
}

Examples of multiple conditions (if...else if...else statements) in JavaScript

There will be times where you want to test multiple conditions. That is where the else if block comes in.

if (condition 1 is true) {
   // code is executed
} else if (condition 2 is true) {
  // code is executed
} else {
   // code is executed
}

When the if statement is false, the computer will move onto the else if statement. If that is also false, then it will move onto the else block.

In this example, the else if block would be executed because Alice is between the ages of 18 and 21.

const age = 18;

if (age < 18) {
  console.log("Alice is under 18 years old.");
} else if (age >= 18 && age <= 21) {
  console.log("Alice is between the ages of 18 and 21.");
} else {
  console.log("Alice is over 21 years old.");
}

When to use switch statements over if...else statements?

There are times in JavaScript where you might consider using a switch statement instead of an if else statement.

switch statements can have a cleaner syntax over complicated if else statements.

Take a look at the example below – instead of using this long if else statement, you might choose to go with an easier to read switch statement.

const pet = "dog";

if (pet === "lizard") {
  console.log("I own a lizard");
} else if (pet === "dog") {
  console.log("I own a dog");
} else if (pet === "cat") {
  console.log("I own a cat");
} else if (pet === "snake") {
  console.log("I own a snake");
} else if (pet === "parrot") {
  console.log("I own a parrot");
} else {
  console.log("I don't own a pet");
}

const pet = "dog";

switch (pet) {
  case "lizard":
    console.log("I own a lizard");
    break;
  case "dog":
    console.log("I own a dog");
    break;
  case "cat":
    console.log("I own a cat");
    break;
  case "snake":
    console.log("I own a snake");
    break;
  case "parrot":
    console.log("I own a parrot");
    break;
  default:
    console.log("I don't own a pet");
    break;
}

switch statements will not be appropriate to use in all situations. But if you feel like the if else statements are long and complicated, then a switch statement could be an alternative option.

The logical AND (&&) operator and if...else statements in JavaScript

In the logical AND (&&) operator, if both conditions are true, then the if block will be executed. If one or both of the conditions are false, then the else block will be executed.

In this example, since age is greater than 16 and the ownsCar variable is true, the if block will run. The message printed to the console will be "Jerry is old enough to drive and has his own car."

const age = 17;
const ownsCar = true;

if (age >= 16 && ownsCar) {
  console.log("Jerry is old enough to drive and has his own car.");
} else {
  console.log("Jerry does not drive.");
}

If I change the age variable to be less than 16, then both conditions are no longer true and the else block would be executed instead.

const age = 13;
const ownsCar = true;

if (age >= 16 && ownsCar) {
  console.log("Jerry is old enough to drive and has his own car.");
} else {
  console.log("Jerry does not drive.");
}

The logical OR (||) operator and if...else statements in JavaScript

In the logical OR (||) operator, if one or both of the conditions are true, then the code inside the if statement will execute.

In this example, even though the isSale variable is set to false, the code inside the if block will still execute because the boyfriendIsPaying variable is set to true.

const boyfriendIsPaying = true;
const isSale = false;

if (boyfriendIsPaying || isSale) {
  console.log("Jesse will go shopping.");
} else {
  console.log("Jesse will not go shopping.");
}

If I were to change the value of the boyfriendIsPaying variable to false, then the else block would execute because both conditions are false.

const boyfriendIsPaying = false;
const isSale = false;

if (boyfriendIsPaying || isSale) {
  console.log("Jesse will go shopping.");
} else {
  console.log("Jesse will not go shopping.");
}

The logical NOT (!) operator and if...else statements in JavaScript

The logical NOT (!) operator will take something that is true and make it false. It will also take something that is false and make it true.

We can modify the example from earlier to use the ! operator to make the boyfriendIsPaying variable false. Since both conditions are false, the else block would be executed.

const boyfriendIsPaying = true;
const isSale = false;

if (!boyfriendIsPaying || isSale) {
  console.log("Jesse will go shopping.");
} else {
  console.log("Jesse will not go shopping.");
}

Conditional (ternary) operator in JavaScript

If you have a short if else statement, then you might choose to go with the ternary operator. The word ternary means something composed of three parts.

This is the basic syntax for a ternary operator:

condition ? if condition is true : if condition is false

The condition goes before the ? mark and if it is true, then the code between the ? mark and : would execute. If the condition is false, then the code after the : would execute.

In this example, since age is greater than 18, then the message to the console would be "Can vote".

const age = 32;
const citizen = age >= 18 ? "Can vote" : "Cannot vote";
console.log(citizen);

This is what the code would look like using an if else statement:

const age = 32;
let citizen;

if (age >= 18) {
  citizen = "Can vote";
} else {
  citizen = "Cannot vote";
}

console.log(citizen);

Conclusion

if else statements will execute a block of code when the condition in the if statement is truthy. If the condition is falsy, then the else block will be executed.

There will be times where you want to test multiple conditions and you can use an if...else if...else statement.

If you feel like the if else statement is long and complicated, then a switch statement could be an alternative option.

Using logical operators to test multiple conditions can replace nested if else statements.

The ternary operator can be used to write shorter code for a simple if else statement.

Instead, you might want certain code to run only when a specific condition is met, and a different set of code to run when the condition is not satisified.

That's where conditional statements come in handy.

Conditional statements allow you to control the logical flow of programs in a clean and compact way.

They are branches – like forks in the road – that modify how code is executed and handle decision making.

This tutorial goes over the basics of if, if..else, and elif statements in the Python programming language, using examples along the way.

Let's get started!

The syntax of a basic if statement

An if statement in Python essentially says:

"If this expression evaluates to True, then run once the code that follows the exprerssion. If it isn't True, then don't run the block of code that follows."

The general syntax for a basic if statement looks something like this:

if condition:
    execute statement

An if statement consists of:

• The if keyword, which starts the if statement.
• Then comes a condition. A condition can evaluate to either True or False. Parentheses (()) surrounding the condition are optional, but they do help improve the readability of the code when more than one condition is present.
• A colon : that separates the condition from the executable statement that follows.
• A new line.
• A level of indentation of 4 spaces, which is a Python convention. The level of indentation is associated with the body of the statement that follows.
• Lastly comes the body of the statement. This is the code that will run only if the statement evaluated to True. We can have multiple lines in the body that can be executed, and in that case we need to be careful they all have the same level of indentation.

Let's take the following example:

a = 1
b = 2

if b > a:
    print(" b is in fact bigger than a")

Output:

b is in fact bigger than a

In the example above, we created two variables, a and b, and assigned them the values 1 and 2, respectively.

The phrase in the print statement does in fact get printed to the console because the condition b > a evaluated to True, so the code that followed it ran. If it wasn't True, nothing would have happend. No code would have run.

If we had instead done this:

a = 1
b = 2

if a > b
    print("a is in fact bigger than b")

No code would have been executed and nothing would have been printed to the console.

How do Python if..else statements work?

An if statement runs code only when a condition is met. Nothing happens otherwise.

What if we also want code to run when the condition is not met? That's where the else part comes in.

The syntax of an if..else statement looks like this:

if condition:
    execute statement if condition is True
else:
     execute statement if condition is False

An if..else statement in Python means:

"When the if expression evaluates to True, then execute the code that follows it. But if it evalates to False, then run the code that follows the else statement"

The else statement is written on a new line after the last line of indented code and it can't be written by itself. An else statement is part of an if statement.

The code following it also needs to be indented with 4 spaces to show it is part of the else clause.

The code following the else statement gets executed if and only if the if statement is False. If your if statement is True and therefore the code ran, then the code in the else block will never run.

a = 1
b = 2

if a < b:
    print(" b is in fact bigger than a")
else:
    print("a is in fact bigger than b")

Here, the line of code following the else statement, print("a is in fact bigger than b"), will never run. The if statement that came before it is True so only that code runs instead.

The else block runs when:

a = 1
b = 2

if a > b:
    print(" a is in fact bigger than b")
else:
    print("b is in fact bigger than a")

Output:

b is in fact bigger than a

Be aware that you can't write any other code between if and else. You'll get a SyntaxError if you do so:

if 1 > 2:
   print("1 is bigger than 2")
print("hello world")
else:
   print("1 is less than 2")

Output:

File "<stdin>", line 3
print("hello world")
^
SyntaxError: invalid syntax

How does elif work in Python?

What if we want to have more than just two options?

Instead of saying: "If the first condition is true do this, otherwise do that instead", now we say "If this isn't True, try this instead, and if all conditions fail to be True, resort to doing this".

elif stands for else, if.

The basic syntax looks like this:

if first_condition:
    execute statement
elif second_condition:
    execute statement
else:
    alternative executable statement if all previous conditions are False

We can use more than one elif statement. This gives us more conditions and more options.

For example:

x = 1

if x > 10:
    print(" x is greater than 10!")
elif x < 10:
      print("x is less than 10!")
elif x < 20 :
      print("x is less than 20!")
else:
     print("x is equal to 10")

Output:

x is less than 10!

In this example, the if statement tests a specific condition, the elif blocks are two alternatives, and the else block is the last solution when all the previous conditions have not been met.

Be aware of the order in which you write your elif statements.

In the previous example, if you had written:

x = 1

if x > 10:
    print(" x is greater than 10!")
elif x < 20 :
      print("x is less than 20!")
elif x < 10:
      print("x is less than 10!")
else:
     print("x is equal to 10")

The line x is less than 20! would have been executed because it came first.

The elif statement makes code easier to write. You can use it instead of keeping track of if..else statements as programs get more complex and grow in size.

If all the elif statements are not considered and are False, then and only then as the last resort will the code following the else statement run.

For example, here's a case when the else statement would run:

x = 10

if x > 10:
    print(" x is greater than 10!")
elif x < 10:
      print("x is less than 10!")
elif x > 20 :
      print("x is greater than 20!")
else:
     print("x is equal to 10")

Output

x is equal to 10

Conclusion

And that's it!

Those are the basic principles of if,if..else and elif in Python to get you started with conditional statements.

From here the statements can get more advanced and complex.

Conditional statements can be nested inside of other conditional statements, depending on the problem you're trying to solve and the logic behind the solution.

Thanks for reading and happy coding!

Good conditionals are an essential part of any React application. We use conditionals to show or hide elements or components in our applications.

In short – to be an effective React developer, you must know how to write good conditionals.

Let's go over all of the major patterns you need to know to write clean, concise conditionals, plus what anti-patterns you should avoid.

Want Your Own Copy?‬ 📄

Download the cheatsheet in PDF format here (it takes 5 seconds).

Here are some quick wins from grabbing the downloadable version:

• Quick reference guide to review however and whenever
• Tons of copyable code snippets for easy reuse
• Read this massive guide wherever suits you best. On the train, at your desk, standing in line... anywhere.

There's a ton of great stuff to cover, so let's get started.

1. Use if-statements primarily. No need for else or else-if.

Let's start with the most basic type of conditional in React. If we have data, we want to display it. If not, we want to show nothing.

Simple! How would we write that?

Let's say we are fetching an array of posts data from an API. When it is fetching the data, posts has a value of undefined.

We can check for that value with a simple if-statement.

export default function App() {
  const { posts } = usePosts(); // posts === undefined at first

  if (!posts) return null;

  return (
    <div>
      <PostList posts={posts} />
    </div>
  );
}

The reason this pattern works is that we are returning early. If it meets the condition (if !posts is has a boolean value of true), we display nothing in our component by returning null.

If statements also work when you have multiple conditions that you want to check for.

For example, if you want to check for loading and error states before you display your data:

export default function App() {
  const { isLoading, isError, posts } = usePosts();

  if (isLoading) return <div>Loading...</div>;
  if (isError) return <div>Error!</div>;

  return (
    <div>
      <PostList posts={posts} />
    </div>
  );
}

Notice that we can reuse the if-statement and do not have to write if-else or if-else-if, which cuts down on the code that we have to write and is still just as readable.

2. Use the ternary operator to write conditionals in your JSX

If-statements are great when we want to exit early and display nothing or a totally different component.

However, what if we don't want to write a conditional separate from our returned JSX, but directly within it?

In React, we must include expressions (something that resolves to a value), not statements within our JSX.

This is why we must write conditionals in our JSX only with ternaries and not if-statements.

For example, if we wanted to display one nested component on a mobile-sized screen and another on a larger screen, a ternary would be a perfect choice:

function App() {
  const isMobile = useWindowSize()

  return (
    <main>
      <Header />
      <Sidebar />
      {isMobile ? <MobileChat /> : <Chat />}
    </main>
  )
}

Most developers think this the only pattern they can leverage when it comes to using ternaries.

In fact, you don't have to clutter your component tree by including all of these ternaries directly in your returned JSX.

Since ternaries resolve to a value, remember that you can assign the result of a ternary to a variable, which you can then use where you like:

function App() {
  const isMobile = useWindowSize();

  const ChatComponent = isMobile ? <MobileChat /> : <Chat />;

  return (
    <main>
      <Header />
      <Sidebar />
      {ChatComponent}
    </main>
  )
}

3. No else condition? Use the && (and) operator

In many cases, you will want to use a ternary in your JSX, but will realize that if that condition is not met, you don't want to display anything.

This ternary would look like the following: condition ? <Component /> : null.

If you don't have an else condition, use the && operator:

export default function PostFeed() {
  const { posts, hasFinished } = usePosts()

  return (
    <>
      <PostList posts={posts} />
      {hasFinished && (
        <p>You have reached the end!</p>
      )}
    </>
  )
}

4. Switch statements for multiple conditions

What if we are in a situation where have many different conditions, more than just one or two?

We could certainly write multiple if-statements, but all of these if statements, as we've seen earlier, go above our returned JSX.

Too many if-statements can clutter our components. How do we make our code cleaner?

We can often extract multiple conditions to a separate component which contains a switch statement.

For example, we have a Menu component that we can toggle and display different tabs.

We have tabs that can display user, chat, and room data as you see below:

export default function Menu() {
  const [menu, setMenu] = React.useState(1);

  function toggleMenu() {
    setMenu((m) => {
      if (m === 3) return 1;
      return m + 1;
    });
  }

  return (
    <>
      <MenuItem menu={menu} />
      <button onClick={toggleMenu}>Toggle Menu</button>
    </>
  );
}

function MenuItem({ menu }) {
  switch (menu) {
    case 1:
      return <Users />;
    case 2:
      return <Chats />;
    case 3:
      return <Rooms />;
    default:
      return null;
  }
}

Since we are using a dedicated MenuItem component with a switch statement, our parent Menu component is not cluttered by conditional logic and we can easily see what component will be displayed given the menu state.

5. Want conditionals as components? Try JSX Control Statements

It's greatly beneficial to be able to use plain JavaScript within our React components. But if you want even more declarative and straightforward conditionals, check out the React library JSX control statements.

You can bring it into your React projects by running the following command:

npm install --save-dev babel-plugin-jsx-control-statements

Additionally, you can list it in your .babelrc file like so:

{
  "plugins": ["jsx-control-statements"]
}

This is a Babel plugin that allows you to use React components directly within your JSX to write very easy to understand conditionals.

The best way to understand the use of such a library is by taking a look at an example. Let's rewrite one of our previous examples with the help of JSX control statements:

export default function App() {
  const { isLoading, isError, posts } = usePosts();

  return (
    <Choose>
      <When condition={isLoading}>
        <div>Loading...</div>
      </When>
      <When condition={isError}>
        <div>Error!</div>
      </When>
      <Otherwise>
        <PostList posts={posts} />
      </Otherwise>
    </Choose>
  );
}

You can see that there's no if or ternary statement in sight and we have a very readable component structure.

Give JSX control statements a try in your next React project and see if a library like this is for you.

What's Next

I hope this guide gave you some helpful patterns to write great React conditionals.

If you want a copy of this cheatsheet to keep for learning purposes, you can download a complete PDF version of this cheatsheet here.

Also check out these ultimate resources, made to take your React skills to the next level, including:

• React for beginners: The complete guide
• How to fetch data in React from front to back
• How to build fullstack apps in React with Node

Become a Professional React Developer

React is hard. You shouldn't have to figure it out yourself.

I've put everything I know about React into a single course, to help you reach your goals in record time:

Introducing: The React Bootcamp

It’s the one course I wish I had when I started learning React.

Click below to try the React Bootcamp for yourself:

Click to get started

This article is a beginner's introduction to JavaScript conditionals. It covers why we need them, and how they fit into the front-end context. And why you will end up using them regularly.

Introduction

I came into development from a non-traditional path. One thing was always particularly hard – to be able to go beyond the syntax of a new concept and place it in a context that made sense.

Conditionals are a little more intuitive than other concepts, but I want to show you the big picture. In this article, I'll explain why we need conditionals and how we can use them as front-end developers.

With the help of a beginner-friendly practical example, you'll see how you can use conditionals to process data in different ways and why they're a fundamental tool in development. Feel free to follow along while reading through this article.

The only prerequisite is a basic understanding of arrays and loops. I've covered those in two previous articles:

Arrays: https://www.freecodecamp.org/news/what-in-the-world-is-a-javascript-array/

Loops: https://www.freecodecamp.org/news/what-in-the-world-is-a-javascript-loop-for/

The setup

Let’s imagine that we are working on an online platform that allows us to do our grocery shopping from a website. That's a real-world application of the things we want to talk about here.

Take a look at Lola Market, which is where I work, for an example of what this would look like.

In the example we set up in the previous articles, we took a bunch of products (mushrooms, steak, fish, aubergines, and lentils) and organised them inside an array. We then stored that array as a variable and used a forEach loop to iterate over the list.

We are assuming that this list of products is now displayed on our website. Our task is to add a "(v)" next to vegetarian items on this list. This is just the kind of thing we regularly do on the front end.

Conditionals

Conditionals are essential building blocks of programming. They are a way to do something only if certain conditions are met. The simplest and most common conditional in JavaScript is the if statement. Take a look at an example:

if (product === 'steak') {
    // do stuff
}

Let’s start by translating this to English: “If the variable called product is exactly the string of characters 'steak' then execute the code within.”

Here’s a closer look

• if: This is the conditional.
• (product === ‘steak’): This is our condition. There are a lot of ways you can construct conditions. We don’t need to worry about this yet. For now, bear in mind that whatever we put here will always be evaluated to either true or false.
• // do stuff: The statement. This is where the code we want to run goes. It will be executed only if the result of the evaluation of the condition is true. Otherwise, it will be ignored.

This bit of code will work on its own just fine, but we can have much more detailed control by using its friends else if and else. else if adds another condition to check and executes another separate block of code, while else becomes the default action to take if none of the conditions are met.

_Photo by [Unsplash](https://unsplash.com/@jckbck?utm_source=ghost&utm_medium=referral&utm_campaign=api-credit">Jakub Dziubak / <a href="https://unsplash.com/?utm_source=ghost&utm_medium=referral&utmcampaign=api-credit)

Vegetarian Friendly

Let’s focus back on our original objective, which is to log a “(v)” next to the name of vegetarian items. This is a prime example of when we need to use a conditional. We want code that, if the product in the array is vegetarian, to print its name and add to it the “(v)”. And if it’s not vegetarian, to only print the name of the product.

First, we need to identify vegetarian items. Normally this information will be included with the data we requested from our database. But since we are using a simplified example, we will do it manually. We know that steak and fish are not vegetarian.

Notice, the condition I’m testing is if a product is not vegetarian. This is only because there are more vegetarian products on this list and I want the condition to be simple and the conditional to do the least amount of work. I could have just as easily tested for vegetarian items instead.

There are often many conditions that can be used to achieve the same goal. Writing good conditions that are efficient and readable is a useful skill that comes with practice.

So let’s write the condition that separates vegetarian from non-vegetarian.

if (product === 'steak' || product === 'fish') {
    console.log(product)
} else {
    console.log(product + '(v)')
}

Following on from the example in my previous articles (linked above) we want to place the conditional inside the loop. The loop gives us each product in the list to process individually. This conditional block is the code that we are executing for each product in our array of products now.

Refresh the browser to start with a fresh console, then enter the following:

• The variable product storing our array of products.
• The forEach loop iterating over the array.
• And our conditional block inside.

The conditional block running inside of a loop

Execution

If we read the conditional code in plain English it says: “If the currently selected product is exactly ‘steak’ or ‘fish’ then log product to the console. Otherwise, in all other cases log product to the console but also add a string “(v)” to the end of it.”

Quick note, the === operator checks that the left and right expressions are exactly the same. and the || operator means or. We have two conditions to check here (steak or fish). If either of the two conditions is true it will execute the code within.

Hit enter to run the code and see the results.

The result of the loop with the conditionals

And there it is. Every time the loop runs, it checks the currently selected element product and goes through the conditionals.

• Is product exactly the string ‘steak’?
• No. Check the following condition.
• Is product exactly the string ‘fish’?
• No. This condition is not met, the code inside will not execute. Go to the default code specified in the else block.
• Print product and add (v) to it.
• This iteration is finished. Start the next iteration.

If it finds ‘steak’ or ‘fish’ it will execute the code within that condition logging the product name without the "(v)". Then the loop finishes that iteration and starts the next, and so on. This process repeats for each element in the array until it’s all completed and the loop has logged the correct message for each one.

Conclusion

To recap, a conditional statement sets certain conditions. When met (which means when the condition evaluates to true) the code specified inside the conditional block executes. Otherwise, it is ignored and not executed.

In our example, we have only logged messages to the console. But we can use the same idea to manipulate the DOM to display and modify content on a website.

Here are a few things you will need to further expand your knowledge and understand these concepts more in-depth:

• Conditionals: The if statement is one of the most commonly-used conditionals. But you will need to learn about others like the while statement, the switch statement, or the very useful ternary operator.
• Conditions: Understand how to create conditions and how they are evaluated. For that, you need to become familiar with the concepts of “truthy” and “falsy”. This is when values that are not explicitly true or false are evaluated as such. For example, a string like 'mushrooms' is considered true whereas an empty string '' is always considered false.
• Logical operators and comparison operators: We saw those in our conditions. Logical operators like “and” and “or”, written && and ||. Comparison operators like “equals” and “greater than”, written === and >. These are simple concepts that are the bread and butter of writing code.

Closure

Thanks for reading. I hope you found this useful. And if you enjoyed it, sharing it around would be greatly appreciated. If you have any questions or comments I’m on Twitter @Syknapse and I would love to hear from you.

Photo by Claudia

My name is Syk and I’m a front-end developer at Lola Market in Madrid. I career-changed into web dev from an unrelated field, so I try to create content for those on a similar journey. My DMs are always open for aspiring web developers in need of some support. You can also read about my transformation in this article.