Lesson 5 — Loops and Functions in PHP

Overview

This lesson teaches PHP loops and functions — fundamental tools for building real-world applications. You will learn:

• How for and foreach loops operate and when to use each.
• How to define functions, use parameters, set default values, and return values.
• Practical business examples: processing invoices, generating reports, iterating users, and handling CSV imports.
• Best practices: code reuse, validation, security considerations, and performance tips.

Why loops and functions matter in business apps

Loops let you process lists of customers, orders, or files in bulk. Functions let you package logic into reusable building blocks (e.g., "calculate tax", "format phone number", "send notification"). Together they make code readable, maintainable, and efficient — essential for teams delivering features quickly and safely.

Basics: Loops

The for loop

Use for when you know how many times you need to iterate (e.g., page numbers, fixed counters).

<?php
for ($i = 0; $i <= 10; $i++) {
    echo $i . '<br>';
}
?>

Business example: Generate page numbers for a paginated report where you know total pages beforehand.

The foreach loop

Use foreach to iterate arrays (indexed or associative). It's ideal for lists of rows returned from the database or JSON-decoded arrays.

<?php
// Associative array
$person = [
    "Name" => "John",
    "Age" => 30,
    "Country" => "USA"
];

foreach ($person as $key => $value) {
    echo '<b>' . strtoupper($key) . "</b>: $value<br>";
}
?>

Business example: Loop through a user profile array and render profile fields on an admin panel.

Practical loop patterns

• Filter while iterating: skip records based on conditions (e.g., skip archived orders).
• Batch processing: process N items at a time to limit memory usage (use array_chunk).
• Break and continue: stop early or skip items when required.

Basics: Functions

Functions abstract repeated logic into single places. They improve readability and reduce bugs.

Defining a simple function and returning a value

<?php
function addNumbers() {
    // This function returns a string for demonstration
    return "hello";
}

$result = addNumbers();
var_dump($result);
?>

Note: Typically functions return numbers, arrays or objects; here it's a string for explanation.

Function parameters and default values

Default parameter values allow functions to be called with fewer arguments and provide sensible defaults.

<?php
function greetUser($name = "Guest") {
    echo "Hello, $name!<br>";
}

greetUser();          // Hello, Guest!
greetUser("Ahmed");   // Hello, Ahmed!
?>

Multiple parameters and optional values

<?php
function whereMember($name = "", $country) {
    echo 'Hello I'm ' . $name . ' And I'm from ' . $country . '<br/>';
}

whereMember();                      // name empty, country missing - beware
whereMember("Amar", "Egypt");
whereMember("Sara", "Malaysia");
whereMember("Ramy");                // missing country - leads to warning
?>

Important: Always place optional parameters after required ones or use explicit null and validate inside the function to avoid warnings. Better signature:

<?php
function whereMemberSafe($country, $name = "") {
    if (empty($name)) {
        $name = "Anonymous";
    }
    echo "Hello I'm $name And I'm from $country<br/>";
}
?>

Use typed parameters and return types in modern PHP (7.0+) for better reliability:

<?php
function sum(int $a, int $b): int {
    return $a + $b;
}
?>

Real-world business examples

1. Processing daily invoices (batch)

Imagine you receive a CSV of invoices each morning. Use foreach to iterate rows, validate them with a function, calculate totals, and save to DB in batches.

<?php
// pseudo-code
$rows = csv_to_array('invoices-2025-11-23.csv');

function validateInvoice(array $row): bool {
    // validate required fields and formats
    return isset($row['id'], $row['amount']) && is_numeric($row['amount']);
}

$batch = [];
foreach ($rows as $row) {
    if (!validateInvoice($row)) {
        log_issue($row);
        continue;
    }
    $row['total'] = calculateTax($row['amount']);
    $batch[] = $row;

    if (count($batch) >= 100) {
        saveInvoices($batch); // DB insert many
        $batch = [];
    }
}
// save remaining
if (count($batch)) saveInvoices($batch);
?>

2. Sending notifications to active users

Use a loop to iterate active user list and call a sendNotification() function that handles throttling, personalization, and logging.

<?php
$users = getActiveUsersFromDb();

foreach ($users as $user) {
    $message = buildMessage($user);
    sendNotification($user['email'], $message);
}
?>

3. Generating analytics report

Aggregate metrics by iterating transactions and using functions to update counters and compute averages.

<?php
$totals = ['count' => 0, 'sum' => 0.0];
foreach ($transactions as $t) {
    updateTotals($totals, $t['amount']);
}
function updateTotals(array &$totals, float $amount) {
    $totals['count']++;
    $totals['sum'] += $amount;
}
?>

Best practices

• Single Responsibility: each function should do one thing (calculate tax, format date, validate email).
• Validation & Sanitization: always validate user input before using inside loops or functions.
• Avoid Side Effects: prefer returning values from functions instead of echoing directly; this improves testability.
• Named constants: replace magic numbers (like batch size 100) with named constants.
• Memory: when iterating large datasets, use generators (yield) or stream readers to reduce memory consumption.
• Error handling: catch exceptions in batch jobs and ensure partial failures are retriable.
• Type hints: use parameter and return type hints to reduce runtime bugs.

Common mistakes and how to avoid them

1. Wrong parameter order: optional parameters before required ones — leads to warnings. Fix by reordering or using null defaults and validating inside.
2. Echoing inside helper functions: prevents reuse. Return values and let callers decide output formatting.
3. Processing huge arrays in memory: use streaming or chunking with array_chunk() or DB cursors.
4. Not handling missing array keys: always check with isset() or use null-coalescing ??.

Exercises (practical)

Try implementing these to solidify your knowledge.

1. Batch importer: Build a script that reads a CSV of users, validates each row, inserts in batches of 200, and writes a report of failures.
2. Reusable helper: Create a formatCurrency() function that accepts amount and locale and returns localized currency strings. Use in a loop to render product prices.
3. Pagination generator: Given total count and per-page size, use a for loop to generate pagination links and a function renderPageLink().

FAQ

Q: When should I use for vs foreach?

A: Use for when you have a numeric index or a fixed count; use foreach for arrays (especially associative arrays).

Q: Can functions modify external variables?

A: They can (with & references or globals), but avoid this. Prefer returning results and passing state explicitly.

Q: How do I handle optional parameters safely?

A: Put optional parameters at the end, use default values, or accept an options array and merge with defaults inside the function.

Advanced topics & next steps

• Generators (yield) for memory-efficient iteration.
• Higher-order functions and callbacks (pass a comparator or map function).
• Refactor business logic into services/classes (move functions into methods when using OOP).
• Unit testing functions with PHPUnit to guarantee behavior during refactors.

Original code snippets (from lesson files)

Below are the code examples supplied for this lesson. Keep them as examples and expand them into production-ready helpers in your app.

for-loop.php

<?php
for ($i=0; $i<=10; $i++) {
    echo $i . '<br>';
}
?>

foreach-ASC-example-1.php

<?php
// Associative array
$person = [
    "Name" => "John",
    "Age" => 30, 
    "Country" => "USA"
];
foreach ($person as $key => $value) {
    echo '<b>' . strtoupper($key) . "</b>: $value<br>";
}
?>

function-paramter-default-values-arguments.php

<?php
function whereMember($name="", $country) {
    echo 'Hello I'm '. $name . ' And I'm from '.$country . '<br/>';
}
whereMember();
whereMember("Amar", "Egypt");
whereMember("Sara", "Malysia");
whereMember("Ramy");
whereMember("");
function greetUser($name = "Guest") {
    echo "Hello, $name!<br>";
}
greetUser(); // Uses default value "Guest"
greetUser("Ahmed"); // Uses "Ahmed" instead of default
?>

function-with-return.php

<?php
function addNumbers() {
    // echo " this line will not be printed";
    return "hello"; // Returns the sum
}
$result = addNumbers();
var_dump($result);
?>

SEO & content tips (for publishing)

• Use descriptive title: Loops and Functions in PHP — Process Data, Build Reusable Helpers.
• Add structured data (FAQ schema) if your CMS allows it.
• Include practical code snippets and downloadable examples (zip with scripts) to increase time-on-page and shares.
• Use canonical URLs and add a short meta description (120–155 chars): Learn PHP loops and functions with real business examples — invoice processing, batching, and reusable helpers.
• Break long content into sections with H2/H3 and include a table of contents for long lessons.

Summary

Loops and functions are the backbone of PHP applications. Use loops to process lists and functions to encapsulate logic. Apply default values, validate inputs, return values instead of echoing, and always think about performance and memory when dealing with large datasets. Follow the exercises and best practices in this lesson to convert these basics into robust, production-ready utilities.