KAHIBARO
Discord Login Register ☰
☰

4.3 Conditions

Table of Contents

Understanding Conditions

Conditions let your program make decisions. Without conditions, your code can only run in a straight line from top to bottom. With conditions, your program can choose different paths: “if this happens, do that, otherwise do something else”.

You will see conditions in every backend project, from validating inputs in an API to checking if a user is allowed to access a resource.

In examples below, we will use Python-like syntax, but the concepts are the same in other languages.

The Idea of Boolean Logic

Conditions are built on Boolean values:

A condition is any expression that evaluates to either True or False.

Examples:

python 
5 > 3        # True
10 == 2 * 5  # True
"admin" == "user"  # False
len("hi") > 3      # False

Many places in a backend need a yes/no decision:

All of these are conditions that evaluate to true or false.

Key idea: A condition is any expression that results in exactly one of two values: True or False.

Basic If Statements

The simplest conditional structure is if.

Python style:

python 
if condition:
    # do something

For example:

python 
age = 20
if age >= 18:
    print("You are an adult.")

In a backend:

python 
user_is_admin = True
if user_is_admin:
    return "You can access the admin panel."

If user_is_admin is False, the return line is never executed.

Indentation and Block Structure

In Python, indentation defines the block that belongs to the if.

python 
if age >= 18:
    print("You can vote.")
    print("You can also drive in many countries.")
print("This line always runs.")

In languages like JavaScript or C, blocks are usually defined by {}:

javascript 
if (age >= 18) {
    console.log("You can vote.");
    console.log("You can also drive in many countries.");
}
console.log("This line always runs.");

If-Else: Either This or That

Often you want to do one thing if a condition is true, and a different thing if it is false.

python 
age = 15
if age >= 18:
    print("Adult")
else:
    print("Minor")

Only one branch runs.

Backend example, deciding HTTP status:

python 
is_authenticated = False
if is_authenticated:
    status_code = 200   # OK
else:
    status_code = 401   # Unauthorized

Chained Conditions with Elif

Sometimes there are multiple options.

You can chain conditions with elif (else if):

python 
temperature = 5
if temperature > 30:
    print("Hot")
elif temperature > 20:
    print("Warm")
elif temperature > 10:
    print("Cool")
else:
    print("Cold")

Rules:

Backend style example:

python 
status_code = 404
if status_code >= 500:
    message = "Server error"
elif status_code >= 400:
    message = "Client error"
elif status_code >= 300:
    message = "Redirection"
elif status_code >= 200:
    message = "Success"
else:
    message = "Informational"

Rule: In an if / elif / else chain at most one block runs. As soon as one condition is True, the rest are skipped.

Relational Operators in Conditions

Conditions usually use relational (comparison) operators.

OperatorMeaningExampleResult
==equal to5 == 5True
!=not equal to5 != 3True
>greater than10 > 3True
<less than2 < 1False
>=greater than or equal to3 >= 3True
<=less than or equal to4 <= 5True

Examples in backend context:

python 
# Check if password is long enough
if len(password) < 8:
    print("Password too short")
# Check user role
if role == "admin":
    print("Show admin dashboard")
# Check remaining quota
if requests_made >= max_requests:
    print("Rate limit exceeded")

Be careful with == vs =:

Logical Operators: And, Or, Not

Sometimes one condition is not enough. You want to combine multiple conditions.

Logical AND

and means both conditions must be true.

python 
age = 25
has_license = True
if age >= 18 and has_license:
    print("You are allowed to drive.")

The output only happens when:

Backend example, allowing access:

python 
is_authenticated = True
is_admin = False
if is_authenticated and is_admin:
    print("Access admin features")

Here, the user must both be authenticated and an admin.

Logical OR

or means at least one condition must be true.

python 
is_weekend = True
is_holiday = False
if is_weekend or is_holiday:
    print("You do not have work today.")

Backend example, allowing guest or logged-in:

python 
is_logged_in = False
has_guest_token = True
if is_logged_in or has_guest_token:
    print("You can continue.")

Logical NOT

not flips a boolean.

python 
is_authenticated = False
if not is_authenticated:
    print("Please log in.")

Backend example, blocking banned users:

python 
is_banned = True
if not is_banned:
    print("Access allowed.")
else:
    print("Access denied.")

Key rules:

  • A and B is True only if both A and B are True.
  • A or B is True if at least one of A or B is True.
  • not A is True if A is False, and False if A is True.

Truth Table Overview

ABA and BA or B
TrueTrueTrueTrue
TrueFalseFalseTrue
FalseTrueFalseTrue
FalseFalseFalseFalse

Grouping Conditions with Parentheses

When you mix and, or, and not, you must be very clear about the intended order.

Example:

python 
is_admin = False
has_premium = True
has_trial = False
if is_admin or has_premium and has_trial:
    print("Access granted")
else:
    print("Access denied")

In Python, and has higher precedence than or. So it is read as:

python 
if is_admin or (has_premium and has_trial):
    ...

If that is not what you mean, add parentheses:

python 
if (is_admin or has_premium) and has_trial:
    ...

These two conditions are different:

  1. is_admin or (has_premium and has_trial)
  2. (is_admin or has_premium) and has_trial

Backend example, complex access rule:

python 
is_admin = False
is_staff = True
has_two_factor = True
# Option 1: Admins can skip 2FA, staff cannot.
if is_admin or (is_staff and has_two_factor):
    print("Access granted")
# Option 2: Everyone must have 2FA
if (is_admin or is_staff) and has_two_factor:
    print("Access granted")

Always use parentheses when conditions start to look complex. It makes the code easier to read and avoids subtle bugs.

Nested Conditions

You can put one if inside another.

python 
age = 20
has_license = True
if age >= 18:
    if has_license:
        print("You can drive.")
    else:
        print("You need a license.")
else:
    print("You are too young to drive.")

Backend example, checking multiple things:

python 
is_authenticated = True
has_paid_subscription = False
if is_authenticated:
    if has_paid_subscription:
        print("Access premium content")
    else:
        print("Please upgrade your plan")
else:
    print("Please log in first")

Nested conditions can be powerful, but too many levels of nesting can make code hard to read. When logic gets complicated, it is often better to refactor into functions or simplify conditions.

Common Backend Use Cases for Conditions

Conditions appear everywhere in backend development. Here are some typical patterns.

Validating Request Data

Check that required fields are present and valid.

python 
username = request_data.get("username")
password = request_data.get("password")
if not username or not password:
    return {"error": "username and password are required"}

Here, not username is True when username is None or an empty string.

Permission Checks

python 
user_role = "editor"
if user_role == "admin":
    can_delete = True
elif user_role == "editor":
    can_delete = False
else:
    can_delete = False

More compact:

python 
can_delete = (user_role == "admin")

Choosing Status Codes

python 
if not resource_exists:
    status = 404
elif not is_authorized:
    status = 403
else:
    status = 200

Handling Different Environments

python 
env = "production"  # or "development", "test"
if env == "production":
    debug_mode = False
else:
    debug_mode = True

Short-Circuit Evaluation

Languages like Python and JavaScript use short-circuit evaluation for and and or.

For `and`

In A and B:

python 
user = None
# Avoids error, because user is None and first condition is False
if user is not None and user.is_active:
    print("Active user")

If user is not None is False, Python will not check user.is_active, so you do not get an error.

For `or`

In A or B:

Backend example, fallback defaults:

python 
limit = request_query.get("limit") or 10

If limit parameter is missing or falsy, use default value 10.

Important: With short-circuit evaluation, sometimes the second part of a condition is never executed. Use this to avoid errors like accessing attributes on None.

Truthy and Falsy Values

Many languages treat some non-boolean values as truthy or falsy when used in conditions.

In Python, the following values are considered falsy:

Everything else is truthy.

Examples:

python 
if []:
    print("This will NOT run")
if [1, 2, 3]:
    print("This WILL run")
if "":
    print("This will NOT run")
if "hello":
    print("This WILL run")

Backend examples:

python 
items = []
if not items:
    print("No items found")  # True, because empty list is falsy
api_key = ""
if not api_key:
    print("API key is missing")  # True, because empty string is falsy

Be careful when 0 is a valid value.

python 
limit = 0
if not limit:
    print("Limit is missing")  # This runs, but maybe 0 is a valid choice.

In such cases, be explicit:

python 
if limit is None:
    print("Limit is missing")

Ternary (Conditional) Expressions

Sometimes you want a very short conditional assignment. Many languages have a ternary operator.

Python style:

python 
result = "adult" if age >= 18 else "minor"

This is equivalent to:

python 
if age >= 18:
    result = "adult"
else:
    result = "minor"

Backend examples:

python 
status_code = 200 if is_valid else 400
role = "admin" if is_superuser else "user"

Use ternary expressions for simple, clear decisions. For more complex logic, use a normal if / elif / else block.

Guard Clauses: Early Returns

In backend functions, it is often cleaner to return early when a condition fails. These are sometimes called guard clauses.

Instead of:

python 
def create_user(data):
    if "email" in data:
        if "password" in data:
            # long logic here
            return {"ok": True}
        else:
            return {"error": "password required"}
    else:
        return {"error": "email required"}

You can write:

python 
def create_user(data):
    if "email" not in data:
        return {"error": "email required"}
    if "password" not in data:
        return {"error": "password required"}
    # long logic here
    return {"ok": True}

This pattern keeps nesting shallow and conditions clear.

Common Mistakes with Conditions

Using `=` Instead of `==`

Wrong (Python will raise an error):

python 
if x = 5:
    ...

Correct:

python 
if x == 5:
    ...

Forgetting That Strings Are Case-Sensitive

python 
role = "Admin"
if role == "admin":
    print("Admin")  # Will NOT run

Use a consistent case, or normalize:

python 
if role.lower() == "admin":
    print("Admin")

Incorrectly Combining Conditions

You might think this works:

python 
if status_code == 400 or 404:
    ...

But in Python it means:

python 
if (status_code == 400) or (404):

Since 404 is truthy, the condition is always True.

Correct version:

python 
if status_code == 400 or status_code == 404:
    ...
# or
if status_code in (400, 404):
    ...

Overcomplicating Conditions

Sometimes conditions can be simplified for clarity.

Instead of:

python 
if not (age < 18):
    print("Adult")

Just write:

python 
if age >= 18:
    print("Adult")

Readable conditions are easier to maintain and debug.

Summary

You will use conditions tightly together with loops, functions, and error handling in almost every backend task, such as validating inputs, enforcing permissions, and controlling the flow of request handling.

Views: 8

Comments

Please login to add a comment.

Don't have an account? Register now!

© 2025 Kahibaro
Visitors: 3134 / 24h
Impressum / Imprint
Datenschutz / Data Policy