Essential PHP Course: The Direct Route to Laravel and CodeIgniter

Tools Needed for the Mini-Course

In this section, we'll talk about the tools we will need to carry out this mini-course.

Code Editor

As I always recommend, the most practical thing is to use a code editor. I use Visual Studio Code (VS Code), which looks like this. I have a Python project with Flash open here, but this interface is the same for any type of project.

It is not mandatory to use VS Code; you could even program in Notepad, although that would be quite masochistic of you. I recommend using a high-quality editor, like VS Code, for several reasons:

1. It is cross-platform.
2. It supports multiple technologies.
3. It is stable and works very well on large projects.

If you decide to use VS Code, the only extension you need to install is the PHP one. You can search for it in the extensions section; it's usually called “PHP” and requires no additional configuration.

Web Browser

You can use the browser you prefer. I use Google Chrome, but any modern browser will work perfectly for this course.

PHP and Development Environment

PHP is essential for this course, and there are many ways to install it, depending on the operating system:

Windows or macOS: I recommend Laravel Herd, which is easy to install and configure. Although its name may sound advanced, it's very intuitive and will allow you to have everything ready to work with PHP, Laravel, or CodeIgniter projects.

Linux: Installation here depends on the distribution and requires specific commands. For example, you could use XAMPP, LAMP, or consult guides for your operating system.

 Laravel Herd and similar tools facilitate development, as they automatically create clean URLs for your projects, unlike other environments like XAMPP or WAMP, where everything is manual.

Hello World

Previous steps:

• Start the server. The next thing you need to do is start your server.
  If you use Laravel Herd, all necessary services will start automatically when you open it. For others, like XAMPP, there's usually a button that says 'Start'. You must be aware of any errors, such as if a port is already in use, etc. Remember that you can ONLY have one XAMPP-like service such as Laragon or Laravel Herd active at a time.
  • Once started, when you open localhost in your browser, you should see a welcome page from your server (Apache, Nginx, or whichever you use).
• Editor, select your editor, the recommended VSC, and create a folder on your server:
  • If you are using Laragon or Herd, the default path would be something like:
    • C:\Users\YourUser\Laragon\www
    • C:\Users\YourUser\Herd
  • Create a folder, suggested named “tests” (or "pruebas" if you prefer to keep the original name) and drag it to your VSC.

Writing our first “Hello World”

In PHP, all code goes inside the tags:

C:\Users\YourUser\Herd\test.php

<?php 
  // Your PHP code goes here

To display text on the screen, we use the echo function.

For example:

C:\Users\YourUser\Herd\test.php

<?php echo "Hello World";

The quotes can be single 'Hello World' or double "Hello World".

Each instruction must end with a semicolon ;.

Save the file and reload the page in your browser, in Laravel Herd or Laragon:

http://tests.test/test.php (or http://pruebas.test/test.php)

Others:

http://localhost/tests/test.php (or http://localhost/pruebas/test.php)

There you have your first “Hello World” in PHP!

First Steps with PHP

We are at the point where we have already learned how to display our first Hello World in PHP without complications.

Remember that, to work with PHP and place any dynamic content, we must always use the opening tag <?php ?>. From here, we can take advantage of the full potential of PHP, which allows us to perform dynamic operations, work with object-oriented programming, manage dates, variables, classes, and much more. We will be covering all of this little by little throughout the course.

My goal is not just to teach you how to create variables or functions, but to give you the foundations to understand the logical reasoning behind each action, and to understand the “why” of what we are doing.

RECOMMENDATION: Viewing the Page Source in the Browser

Before moving on, it's advisable to always check the page's source code:

On Windows or Linux: right-click → View page source

On Mac: Ctrl + U

The browser only understands HTML, CSS, and JavaScript, plus static files like PDFs, images, or videos. Everything that PHP generates is interpreted on the server and sent as HTML to the browser. For example, even if your file is PHP, the browser only renders HTML.

Looking at the source code is a useful tool for you to see exactly what is being rendered.

HTML vs PHP

To illustrate this, we can create a file test2.html with the same message we put in PHP. When you open it, you will see that the output in the browser is the same, although the path changes.

This demonstrates a key principle: the browser only understands HTML, CSS, and JavaScript. PHP serves to add dynamism to these pages, for example:

<?php echo 5 + 5; // This will display 10 ?>

With PHP we can:

• Perform dynamic operations
• Display dates
• Connect to databases

Create dynamic content that is then served as HTML

In contrast, if we try to place operations like 5 + 5 with PHP directly in an HTML file, the browser will not know what to do and will simply display it as text.

Best Practices with PHP Tags

When mixing PHP with HTML, it is important to correctly close the tags.

Example:

<?php echo "Hello World"; ?> <h1>This is an HTML title</h1>

The opening <?php indicates the start of the PHP code.

The closing ?> is necessary if HTML content follows.

If the entire file is pure PHP, it is not mandatory to close the tag, and in fact, it is often recommended not to close it to avoid accidental whitespace or injections.

Spaghetti Code in PHP

When we mix logic, HTML, and operations in a single file, we get what is known as spaghetti code:

• Business logic
• Database connections
• User validations
• Static HTML

This works, but it is difficult to maintain and prone to errors. That's why, even though we must learn “pure” PHP to understand the basics, the ideal is to use a framework.

Frameworks to Avoid Spaghetti Code

A framework allows us to:

• Automatically follow best practices
• Separate logic from presentation
• Avoid common errors in pure PHP

Examples of lightweight frameworks we can use to learn:

• Laravel
• CodeIgniter
• Lumen

These frameworks help us create structured and maintainable applications, preventing us from ending up with a single file full of mixed PHP and HTML.

Summary

• PHP is interpreted on the server and delivers HTML to the browser.
• Always use <?php ?> for PHP code.
• Check the browser's source code to understand what is actually sent.
• Close PHP tags if you combine with HTML.
• Avoid spaghetti code by using frameworks.

With this, we have a solid foundation to start working with PHP correctly, understanding the difference between static and dynamic content, and prepared to advance toward more complex operations and the use of frameworks.

Variables in PHP

In this section, we will talk about variables in PHP. Honestly, the data types part doesn't make much sense in this context, as this is a fairly old article that I am updating. But back to the topic: I assume you already know how to program and are here to learn PHP and take the next step, which is then jumping to frameworks, which is one of the goals of this course.

Even so, let's quickly give a definition of a variable:
A variable is simply a way to access memory. That is, we have a piece of information (an integer, a string, a boolean, etc.) and we want to store it so we can use it throughout our application.

For example, suppose you are creating a form to request a person's details, such as name, age, etc. Each of these details can be stored in a variable, such as:

• A variable for the name
• A variable for the age

The use you make of these variables will depend on the purpose of your application, the business logic, and so on. In general terms, this is what a variable is.

Variable Syntax in PHP

In PHP, all variables begin with the $ symbol. This is an interesting peculiarity of PHP, as most other languages like Java, JavaScript, C#, among others, do not use the $.

Some important rules:

• They cannot contain spaces. For example, person name is not valid.
• They cannot start with numbers or special characters.

You can use letters, underscores \_, or uppercase letters, following naming conventions:

• Camel case: personName
• Snake case: person_name

Personally, I prefer camel case, but it's a matter of preference. The important thing is to maintain consistency and readability.

Data Types and Best Practices

In PHP, the data type is optional when declaring a variable, unlike other languages like Java or C#. However, it is always recommended to specify it. For example:

$name = "Andrés"; // string
$edad = 25;       // integer
$activo = true;   // boolean

We can check the data type using the gettype() function:

echo gettype($name); // string
echo gettype($edad); // integer

It is important to remember:

• Do not declare crazy or illegal names for variables.
• Do not use spaces or strange characters.
• You can include numbers after the first letter if necessary.

Types of Variables in PHP

Variables are the mechanism to access memory that programming languages make available to us; in this article we will see how to create a variable in PHP, its particularities, and data types in PHP.

Variable names in PHP must start with the '$' sign (without quotes) followed by the name of the variable, which cannot be null, nor begin with a number or a special character.

Example of Invalid Variables in PHP

$1var;  // no puede comenzar por un numero
$ var;  // no puede comenzar con un espacio vacio
$v ar   // tampoco puede contener espacios vacios
var   // falto el $

Example of Valid Variables in PHP

$var;
$var1;
$_var;

They are case-sensitive.

Example of Distinct Variables in PHP

$Var;
$VAr;
$var;

In PHP it is not necessary to specify the data type before using them; they are declared when a value is assigned to them.

PHP Supports Eight Primitive Types

Four scalar types:

Two compound types:

• object
• array

And two special types:

Finally, we present a simple example of a person's data using several of the variable types we have already seen.

<?php
$age = 24; // Integer type variable.
$name = "pepe"; // String type variable.
$married = true; // Boolean type variable.
$salary = 4025.43; // Float type variable.
// Array of 4 data types
$person_array = array('age' => $age, 'name' => $name, 'married' => $married, 'salary' => $salary);
// Object of 4 data types
$person_object = (object)$person_array;
// We display the values of the variables
echo "Integer type variable: ";
echo $age;
echo "<br>";
echo "String type variable: ";
echo $name;
echo "<br>";
echo "Boolean variable: ";
echo $married;
echo "<br>";
echo "Double type variable: ";
echo $salary;
echo "<br>";
echo "Object type variable: ";
echo $person_object->age;
echo "-";
echo $person_object->name;
echo "-";
echo $person_object->married;
echo "-";
echo $person_object->salary;
echo "<br>";
echo "Array type variable:";
echo "<br>";
var_dump($person_array);
?>

Interpreting the code above:

variable de tipo integer: 24
variable de tipo string: pepe
variable boolean: 1
variable de tipo double: 4025.43
variable de tipo object: 24-pepe-1-4025.43
variable de tipo array:
array(4) { ["anos"]=> int(24) ["nombre"]=> string(4) "pepe" ["casado"]=> bool(true) ["sueldo"]=> float(4025.43) }

Booleans in PHP

This is the simplest data type that exists in PHP; a boolean expresses a truth value, which can only have one of two states: TRUE or FALSE; in both cases, they are case-insensitive.

<?php
$verdad = TRUE; // asigna el valor TRUE
$falso = FALSE; // asigna el valor FALSE
?>

TRUE is equivalent to the value 1 and FALSE is equivalent to the value 0; that is, you can replace the value 1 and 0 with TRUE and FALSE respectively.

Integer in PHP

An integer is by definition a signed number without a decimal part; the same rule applies in PHP.

Notations for Integers in PHP

Integers can be specified using decimal (base 10), hexadecimal (base 16), octal (base 8), or binary (base 2) notation, optionally preceded by a sign (- or +) as the case may be:

• To use octal notation, the number is preceded by a 0 (zero).
• To use hexadecimal notation, the number is preceded by a 0x.
• To use binary notation, the number is preceded by a 0b.

Example: Integer Literals in PHP

<?php
$a = 1234; // decimal number
var_dump($a);
$a = -123; // a negative number
var_dump($a);
$a = 0123; // octal number (equivalent to 83 decimal)
var_dump($a);
$a = 0x1A; // hexadecimal number (equivalent to 26 decimal) 
var_dump($a);
$a = 0b11; // binary number (equivalent to 3 decimal)
var_dump($a);
?>

Interpreting the code above:

int(1234) 
int(-123) 
int(83) 
int(26) 
int(3)

Range of an Integer in PHP (Integer Overflow)

If PHP encounters a number outside the limits of an integer, it will be interpreted as a float instead of an integer.

Example: Integer Overflow on 32-bit Systems in PHP

<?php
$large_number = 2147483647;
var_dump($large_number);                      
$large_number = 2147483648;
var_dump($large_number);                      
?>

Interpreting the code above:

int(2147483647)
float(2147483648)

Example: Integer Overflow on 64-bit Systems in PHP

<?php
$large_number = 9223372036854775807;
var_dump($large_number);                      
$large_number = 9223372036854775808;
var_dump($large_number);                      
?>

Interpreting the code above:

int(9223372036854775807)
float(9.2233720368548E+18)

How to use it in a control structure?

<?php
// it is not necessary to perform the comparison against a boolean type
if ($truth == TRUE) {
    echo "this is true\n";
}
// because it can be written like this
if ($truth) {
    echo "this is true\n";
}
?>

Interpreting the code above:

this is true this is true

Float in PHP

A float or floating-point number is a signed number with a decimal part; the same rule applies for PHP.

Notations for Floating-Point Numbers in PHP

Example of Floating-Point Numbers

<?php
  $a = 1.234;
  var_dump($a);
  $b = 1.2e3; 
  var_dump($b);
  $c = 7E-10;
  var_dump($c);
?>

Interpreting the code above:

  float(1.234) 
  float(1200) 
  float(7.0E-10)

Range of Floating-Point Numbers

The size of a float depends on the platform, although a common value consists of a maximum of ~1.8e308 with a precision of approximately 14 decimal digits (which is a 64-bit value in IEEE format).

NULL in PHP

The NULL value indicates that the variable assigned that value has no value assigned; that is, it indicates that the variable has no value whatsoever.

The variable is considered NULL when:

• The constant NULL has been assigned to it.
• No value has been assigned to it.
• Or it has simply been destroyed with the unset() method.

Type Juggling (Type Conversion)

In this entry, we will talk a little about type conversion in PHP when performing different operations, such as mathematical ones.

PHP is not a strongly typed language, which means that it does not control the data types of variables, and if you want to perform operations, PHP performs a type conversion according to the operation you want to perform; for the following example:

$string1 = "8";
$string2 = "4cuatro";
$stringFinal = $string1 + $string2;
echo "Vamos a sumar $string1 + $string2 <br>";
echo "resultado $stringFinal";

It gives the following output:

We are going to add 8 + 4four 
result 12 

When trying to perform an addition operation, the PHP interpreter automatically converts the text contained in the variable $string1 from "8" to 8. A similar behavior happens with the variable $string2; the interpreter converts to a numerical value until it finds the first character "c", giving an implicit conversion of the value 4 to perform the addition operation, and both values are summed.

If, on the contrary, we apply the following example:

$string1 = "8";
$string2 = "c4uatro";
$stringFinal = $string1 + $string2;
echo "Vamos a sumar $string1 + $string2 <br>";
echo "resultado $stringFinal";

We are going to add 8 + c4four 
result 8 

The interpreter again converts $string1 from "8" to 8, but for the value stored in the variable $string2, the interpreter detects that the first character is not numeric, being "c", and therefore there is nothing to convert, and the variable is evaluated by default as zero.

Other Aspects of the NULL Data Type

The constant NULL is case-insensitive.

Concatenation in PHP

Concatenation in PHP is done with the dot (.), not with the + as in other languages:

echo "Hello " . $name;

This works to join strings. If you want to include variables directly inside a string, you can use double quotes:

echo "Hello $name"; // prints Hello Andrés

With single quotes, the content is taken as literal text:

echo 'Hello $name'; // prints Hello $name

This is useful when you want to print something without PHP interpreting it as a variable.

Operations with Variables

You can perform arithmetic operations according to the data type.

Concatenation only works with strings; other types may require conversion.

Booleans, integers, and floats behave according to their type.

Examples:

$numero = 10;
$decimal = 10.5;
$esValido = true;
echo $numero + 5;       // 15
echo $decimal + 4.5;    // 15
echo $esValido ? 'Sí' : 'No'; // Yes

Single quotes for literal text.

This serves as a basis for understanding how variables work in PHP and practicing their use before moving on to functions, classes, and other more advanced structures.

echo  'Hello '. $name. ' Hello'; 
echo  "Hello $name Hello";

Summary

Variables begin with $.

• They cannot contain spaces or start with numbers.
• Use camel case or snake case for readability.
• Data types are optional, but recommended.
• Concatenation with . or interpolation with double quotes.

Functions

Now let's move on to functions in PHP. How on earth can we implement functions in PHP?
Before that, let's recall the basic concept: functions exist to reuse code.
For example, even though we have seen practically nothing, suppose this is crucial or very important to you, and you want to print it in two parts: one in the header and another in a menu.

So, how would you do it as we have shown up to this point? You would have to duplicate it in those crucial parts. As I mentioned before: open the PHP block here, print the code, then open another block there, print it again... which is obviously a problem.
Imagine that it is more code, that it includes connecting to the database, validations, or that it simply changes in the future. Clearly, this is impractical.

That is why functions arise, which exist in practically every programming language. They are a key piece for modularization, organization, code simplification, and the creation of reusable components.

Creating our first function

Having clarified this, I am going to create a new file so as not to mix so many things. In this case, I called it functions.php.

To declare a function in PHP, just like before, we open the PHP block:

<?php ?>

And now, yes, we create our first function:

function hello() {
   echo "Hi";
}

This is the basic structure:

• The reserved word function.
• The name of the function (no spaces or special characters).
• The parentheses.

The curly braces that contain the reusable code.

As a note: you cannot use reserved names as variables (although in PHP you can use $function because all variables have $, but not in other languages).

If you try to call a function that does not exist, you will get an error. But as long as it is only declared and not invoked, nothing will happen.

To invoke it, you simply do:

hello();

Using Parameters

Now let's move on to another important part: parameters.

Let's design a function that receives a name:

function hello($name) { echo "Hello " . $name; }

If you call it without parameters, PHP will indicate that the function expected one, but received zero.
To use it correctly:

hello("Andrés");

Parameters simply represent the data that the function needs to execute its purpose.

A Function with Multiple Parameters

Now suppose a sum function:

function sum($a, $b) {
   echo $a + $b;
}

We call it like this:

sum(5, 10);

Up to this point, it prints the result, but does not return anything. This becomes problematic when we want to use the calculated value outside the function.

Returning Values

If we want the function to “return” something to be reused, we use return:

function sum($a, $b) {
   return $a + $b;
}

Now we can do:

$result = sum(5, 10); 
var_dump($result);

This returns the type and value to you, thanks to var_dump.

Data Types in Arguments

Another important detail: if you do not declare types, PHP will try to convert the values automatically, which can generate silent errors.
For example, you could pass a string where a number was expected.

To avoid this, you can type like this:

function sum(int $a, int $b) {
   return $a + $b;
}

If you call:

sum("hello", 5);

Now the error will be clear: the argument does not meet the type.

You can also allow multiple types:

function sum(int|float $a, int|float $b) {
   return $a + $b;
}

Declaring the Return Type

In addition to the type of the arguments, you can also type the value that the function will return:

function sum(int $a, int $b): int {
   return $a + $b;
}

This provides more consistency and security to the code.

If the function were to return strings, for example, you would simply indicate : string.

Other Useful Aspects

PHP also supports:

• variadic functions (function test(...$args)),
• arrow functions (fn($a) => $a * 2),
• and many internal functions like var_dump, gettype, etc.
• In general, with this you already have:
• How to declare functions,
• How to invoke them,
• How to use parameters,
• How to return values,
• How to use data types in parameters and returns.

Control Structures: The Use of Conditionals

1. Basic Concept: What is a Conditional?

A conditional is simply a control structure that allows making decisions based on a boolean condition (true or false). It is the equivalent of the if and else structures that exist in most programming languages.

Example: Is your age greater than 18? (True or False).

2. Comparison Operators

To establish a condition, we use comparison operators:

Strict equality (==): Compares if two values are equal. (Different from simple assignment: $age = 18;).

• Greater than (>): $age > 18
• Less than (<): $age < 18
• Greater than or equal to (>=): $age >= 18
• Less than or equal to (<=): $age <= 18
• Not equal to (!= or <>)

Practical Example: Age Validation

Let's consider the validation of the age of majority, which in many places is from 18 years old.

<?php
$age = 18;
// We use the "Greater than or equal to" operator (>=) to include 18
if ($age >= 18) {
    echo "You are an adult. Congratulations, now you have to work.";
} else {
    echo "You are a minor.";
}
?>

• Problem with only > (Greater than): If we use $age > 18, the code will fail if the age is exactly 18, because 18 is not greater than 18.
• Solution: The >= operator solves this by comparing whether it is greater than or exactly equal to the specified value.

Nesting Conditions: elseif

When we have multiple conditions that are mutually exclusive (that is, we only want one of them to be met), we must nest the code using elseif.

If we do not nest the conditionals, all blocks whose condition is met will be executed, which is incorrect for most logic (such as determining a grade range).

Grade Example (Exclusive Logic)

We want to evaluate if a person is excellent, good, or needs improvement, based on ranges:

• Excellent: Greater than or equal to 90.
• Good: Greater than or equal to 70.
• Needs Improvement: Less than 70.

<?php
$grade = 75;
if ($grade >= 90) {
    echo "You are excellent."; // If it enters here, it ignores the rest
} elseif ($grade >= 70) {
    echo "You are good. An average like everything in your life."; // If it enters here, it ignores the 'else'
} elseif ($grade >= 50) {
    echo "You need to improve.";
} else {
    echo "You are a 'zapacuco'."; // If none of the above conditions were met
}
?>

Advantage of elseif: PHP evaluates the first if. If it is true, it executes the block and exits the entire structure. If it is false, it moves to the next elseif and repeats the process. This ensures that only a single block of code is executed, guaranteeing the correct logic.

Example with 75:

• $nota >= 90 (75 >= 90) - False.
• elseif ($nota >= 70) (75 >= 70) - True. - Executes and exits.

⚙️ Control Structures: The use of switch

The switch is another control structure that, while similar to if/else, offers a cleaner and more appropriate implementation for evaluating multiple cases.

1. ❓ The Problem of Multiple Conditions

Although if/else works for any evaluation, its readability becomes complicated when four, five, or more nested or sequential conditions are needed.

For example, if we needed to evaluate the nota variable with multiple ranges (greater than 90, greater than 80, greater than 70, etc.), the chain of else if becomes dense:

if ($grade > 90) {
    // ...
} else if ($grade > 80) {
    // ...
} else if ($grade > 70) {
    // ...
}
// ... and so on.

For these scenarios, the switch is a more suitable and easier-to-read alternative.

2. Basic switch Syntax

The switch structure evaluates a single expression (variable, function return, etc.) against a series of predefined cases (case).

switch ($condition_to_evaluate) {
    case $value1:
        // Code to execute if value1 is met
        break;
    case $value2:
        // Code to execute if value2 is met
        break;
    // ... more cases
    default:
        // Code to execute if no case is met
        break;
}

Key Elements:

• switch (condition): This is where the variable or value we want to evaluate is placed (e.g., grade, day).
• case value:: Defines a specific condition. Note that a colon : is used instead of curly braces {}.
• break;: Essential. Just as else prevents unnecessary re-evaluation in the if/else structure, the break ensures that, once a case is met, the program stops evaluating the subsequent cases and immediately exits the switch.
• If you remove the break, the program will execute the code for that case and continue executing the code for the next case until it finds a break or finishes the structure.

3. The Default Case (default)

The default is the equivalent of else in the if/else structure.

• Function: If none of the case conditions are met, the code block within default will always execute.
• Location: By convention, it is always placed as the last case to evaluate.
• Use: You can use it to handle unexpected values (e.g., if you expect a day of the week, but the user enters "X") or to define a base action if the value does not match any specific case.

Practical Example (Days of the Week)

If we want to evaluate the variable day, a switch is perfect for the seven days.

<?php
$day = "Monday";
switch ($day) {
    case 'Monday':
        echo "The week begins."; // Enters here
        break;
    case 'Friday':
        echo "Last working day.";
        break;
    default:
        echo "It's a normal day."; // Enters if the day is 'Tuesday', 'W', etc.
        // The break here is optional, as it is the last case.
        break; 
}
?>

Reminder: The case conditions are evaluated in the order they are arranged. It is crucial that the order makes sense for your application's logic.

4. Practice Tips

To familiarize yourself with the switch, I recommend:

• Think about the Logic: Create a business scenario (e.g., handling order statuses, assigning categories to scores).
• Implement the switch: Write the structure for that scenario.
• Convert and Compare: Use AI tools (like your editor's code assistant) to convert your switch to an if/else and vice versa. This will help you understand how the two structures are mapped: the default will always be the final else.