One of PHP’s unique features is type juggling, a concept that can be both fascinating and tricky.

Type juggling happens when PHP automatically converts a variable from one data type to another, depending on how it is being used. While it may save you some effort, it can also lead to unexpected behaviour if you are not careful.

In this article, I will explain what PHP type juggling is, and how it works. In the following sections, you will learn how PHP handles type juggling and see examples to make the concept easier to understand.

What is PHP Type Juggling?

Type juggling refers to PHP’s ability to perform implicit type conversions. Instead of requiring you to declare a variable's type, PHP evaluates the context in which the variable is used and changes its type accordingly. This is a direct result of PHP being dynamically typed.

For instance, if you use a string in a mathematical operation, PHP will try to convert that string into a number. Let’s take a look at a quick example:

$number = "10"; // This is a string
$result = $number + 5; // PHP converts $number to an integer
echo $result; // Outputs: 15

Here, $number starts as a string but is treated as an integer during the addition operation. This automatic conversion is what makes PHP type juggling so powerful and, at times, unpredictable.

How Does PHP Handle Type Juggling?

PHP evaluates types based on the context of the operation. When juggling types, it follows specific rules for conversions:

Strings to Numbers

If a string contains a valid numeric value, PHP converts it to a number when needed. For example:

echo "5" + 10; // Outputs: 15

PHP sees the string "5". It understands it’s a number, and changes it to the number 5 before adding it.

Booleans in Numeric Contexts

In a boolean data type, the true value is treated as 1, and false is treated as 0. This can lead to unexpected results if you are not paying attention:

echo true + 10; // Outputs: 11
echo false + 10; // Outputs: 10

This is especially dangerous in comparisons:

var_dump(false == ""); // true
var_dump(true == "1"); // true
var_dump(false == "0"); // true

PHP tries to convert both operands to the same type before comparison, which can lead to unexpected results. For example, false == "" is true because both are loosely interpreted as falsy values.

Arrays and Type Conversion

Arrays cannot be directly converted into strings. If you attempt to do that, PHP will throw an error or a notice depending on the context.

Here is an example:

$array = [1, 2, 3];
echo $array + 5;  
echo $array . "test";

Here is the output with a fatal error:

Fatal error: Uncaught TypeError: Unsupported operand types: array + int in /var/www/test.php:3
Stack trace:
#0 {main}
  thrown in /var/www/test.php on line 3

This because it is trying to use arrays in arithmetic or string operations, which doesn’t work like it does with other types. Instead, you need to explicitly convert them using functions like count() or implode(), depending on what you're trying to achieve:

$array = [1, 2, 3];
echo count($array) + 5; // Outputs: 8

In the following section, we will explore some examples associated with type juggling to help you avoid potential bugs in your code.

Type Juggling Examples

Loose Comparisons (==)

PHP’s loose comparison operator (==) uses type juggling to compare values. This can lead to results that might not align with your expectations:

var_dump(0 == "0"); // true
var_dump(0 == ""); // true
var_dump("123abc" == 123); // true

In this example, PHP converts "123abc" to the number 123 because of the loose comparison, even though "abc" is not numeric.

Strict Comparisons (===) as a Solution

To avoid the problems caused by loose comparisons, use strict comparisons (===). These compare both value and type:

var_dump(0 === "0"); // false
var_dump(123 === "123"); // false

Strict comparisons ensure that the types are not juggled, reducing the risk of unexpected behavior.

So the question is, how can you handle type juggling safely? This is what you’ll learn in the following section.

How to Handle Type Juggling Safely

Use Explicit Type Casting

If you want a variable to be a certain type (like an integer or a float), convert it directly instead of letting PHP guess. This avoids unexpected behavior.

$input = "42cats";
$cleanNumber = (int)$input;

echo $cleanNumber + 10; // Outputs: 52

PHP turns "42cats" into 42. PHP would do this even without casting, but casting shows clearly what you want and keeps behavior consistent.

Note: Any non-empty string (except "0") becomes true when cast to a boolean.

Validate Input Before Use

Always check that input data is the type you expect, especially if it comes from users or outside sources.

$price = $_POST['price'] ?? '';

if (is_numeric($price)) {
    echo $price + 10;
} else {
    echo "Please enter a valid number.";
}

A string like "abc" would turn into 0 without this check, and you'd get 10—which is wrong and misleading.

Here, you have to check if the input is an array:

$data = $_POST['items'] ?? [];

if (is_array($data)) {
    echo count($data);
} else {
    echo "Invalid data format.";
}

This prevents errors when PHP tries to use a string or number as an array.

Prefer Strict Comparisons (===)

Loose comparisons (==) let PHP convert types when comparing values. This can cause mistakes.

var_dump(0 == "0");    // true
var_dump(0 == "");     // false (not expected)
var_dump("abc" == 0);  // false

PHP turns both sides into numbers, so "abc" becomes 0. That’s usually not what you want.

To solve that issue, use strict comparisons (===) to check both the value and the type:

var_dump(0 === "0");     // false
var_dump("123" === 123); // false

Wrapping Up

PHP type juggling is a double-edged sword. On one hand, it allows for flexibility and faster coding, but on the other, it can lead to subtle bugs if you are not cautious.

By understanding how type juggling works and following best practices like strict comparisons, explicit casting, and input validation, you can make your code safer and more predictable.

Stay tuned for my next article. You can explore more helpful PHP tutorials on my blog, FlatCoding. You can also check the PHP manual for more details. Thank you for reading.

In PHP, there are four fundamental logical operators: AND, OR, NOT, and XOR. This guide will help you understand these operators, and I'll explain how they work using code examples and practical use cases.

The Logical AND Operator (&&)

The AND operator, written like “&&,” evaluates to true only if both of its operands are true. It evaluates to false if any of the operands are false, resulting in a false outcome.

This operator is commonly used to combine multiple conditions in an if statement or a loop. It helps ensure that all conditions are satisfied for the overall condition to be true.

// Checking if two conditions are true using the AND operator
$mx = 5;
$my = 10;

if ($mx > 0 && $my > 0) {
    echo "Both conditions are true!";
} else {
    echo "This condition is false.";
}

In the above example, the AND operator verifies that both $x and $y are greater than 0.

So, if both conditions are true, the code inside the if block will execute, displaying “Both conditions are true!”. Alternatively, when the else block is triggered, it suggests that one or more of the conditions are false.

Let's now shift our focus to the counterpart of the AND operator – the OR operator.

The Logical OR Operator (||)

The PHP OR operator, written like “||”, returns true if at least one of its operands is true. It evaluates to false only when both operands are false.

You can use this operator when you want to execute a block of code if any of several conditions are satisfied.

// Checking if at least one condition is true using the OR operator
$mx = 5;
$my = 10;

if ($mx > 0 || $my > 0) {
    echo "At least one condition is true!";
} else {
    echo "Both conditions are false.";
}

In this example, the OR operator checks if either $x or $y (or both) are greater than 0. If any of the conditions is true, the code inside the if block will execute, displaying “At least one condition is true!”.

Otherwise, the else block will execute, indicating that both conditions are false.

Now let's explore the NOT operator and understand how it works.

The Logical NOT Operator (!)

The NOT operator, written like "!", is a unary operator that inverses the value of its operand. When the operand is false, it will return true. cvonversely, when the operand is true, it will return false.

This operator is commonly utilized to invert a condition or verify the absence of a specific state.

// Checking if a condition is false using the NOT operator
$x = 5;

if (!($x > 10)) {
    echo "Condition is false!";
} else {
    echo "Condition is true.";
}

In the above example, the NOT operator negates the result of the condition $x > 10. If the condition is false (which it is in this case), the code inside the if block will execute, displaying “Condition is false!”. If the condition is found to be true, the execution of the else block confirms the validity of the condition.

Finally, let's delve deeper into the XOR operator in PHP and gain a better understanding of its usage and behavior.

The Logical XOR Operator (Exclusive OR)

Although PHP doesn't have a specific XOR operator, we can simulate XOR behavior using a combination of other logical operators. XOR returns true if exactly one of the operands is true, while it returns false if both operands are either true or false.

// XOR operator implementation using AND, OR, and NOT operators
$x = true;
$y = false;

if (($x || $y) && !($x && $y)) {
    echo "Exactly one condition is true (XOR)!";
} else {
    echo "Both conditions are either true or false.";
}

In this example, we create an XOR behavior by checking if either $x or $y is true ($x || $y) and ensuring that both conditions are not true at the same time (!($x && $y)).

If exactly one condition is true, the code inside the if block will execute, displaying “Exactly one condition is true (XOR)!” Otherwise, the else block will execute, indicating that both conditions are either true or false.

Wrapping Up

PHP logical operators are powerful tools in PHP that allow us to manipulate boolean values and evaluate logical conditions. Understanding the functionality and usage of logical operators is essential for building reliable and efficient PHP programs.

By mastering these operators, you can create complex conditional statements and make your code more robust and flexible.

In this article, we explored the four fundamental logical operators in PHP: AND, OR, NOT, and XOR.

We provided explanations, code examples, and practical use cases to demonstrate their functionalities. By applying these operators effectively, you can perform intricate logical operations, control the flow of your programs, and make informed decisions based on various conditions.

Remember to practice implementing logical operators in PHP and experiment with different scenarios to deepen your understanding.

Thank you for reading, If you'd like to read more of my articles, you can find them on FlatCoding. Stay tuned for my next articles.

What is Python?

Python is a high-level programming language designed to do many tasks. It's based on the CPython interpreter which translates the Python code into something the machine can read.

Python gives us the ability to use a lot of modules and packages with our code, which are standard libraries built in with the interpreter.

You can use Python to do many tasks such as:

• Machine Learning

• Artificial Intelligence

• Data Visualization

• Programming Applications

• Web Applications

• Language and Game Development

• Data Analytics

and more.

Additionally, Python's syntax is pretty simple and easy to learn – often it seems that you are just writing a message to someone else. Just make sure you know the indentation rules :).

We can compare Python with other interpreted programming languages such as Java, JavaScript, PHP, and others. But you might be wondering – what is CPython?

In the following section, I am going to focus on the history of the Python interpreter in-depth, then I'll answer this question.

Python History Overview

The first appearance of the Python programming language was in late 1980s. It was created by Guido van Rossum.

Python was designed to replace the ABC programming language which worked with Amoeba operating system.

Rossum started the implementation in 1989 and he worked on Python alone until 2018.

He named it Python because the first version of it was able to read the BBC comedy script “Monty Python's Flying Circus”.

The first release was in 1994 under version 1.0 (Python 1.0) and the second release was in 2000, named version 2.0.

In version 2.0, van Rossum added minor features such as collection systems and comprehensions.

The third version was released in 2008 and fixed a basic flaw of the language. They named this version “Py3K”, or Python 3.0.

How Does the Python Interpreter Work?

The Python interpreter is called “CPython” and it's written in the C programming language. This is the default implementation for Python.

In the following sections, you will understand how the Python interpreter works behind the scenes.

Source Code Analysis

Actually, any translator starts with the source code analysis. Here the Python interpreter receives the source code and initializes some instructions to do the following things:

It follows the indentation rule and checks the Python syntax. Maybe there are some incorrect lines, so it will stop the program from the execution to show the error message.

This phase is called lexical analysis, which means dividing the source code files into a list of tokens

In the following step, the interpreter will generate byte codes. Let's see how that works.

Byte Code Generation

Once the parser of the Python interpreter receives the tokens, it starts to manipulate the lexical tokens. It generates a big structure called the AST (Abstract Syntax Tree).

The interpreter converts this AST to byte code which means machine language. In Python, the byte code can be saved in a file ending with the “.pyc” extension.

In the following section, you will see how the python interpreter executes these byte codes.

The Python Virtual Machine (PVM)

The Python interpreter initializes its runtime engine called PVM which is the Python virtual machine.

The interpreter loads the machine language with the library modules and inputs it into the PVM. This converts the byte code into executable code such as 0s and 1s (binary).

And then it prints the results.

Note that if an error happens during the PVM process, the executor will terminate the operation immediately to display the error.

Now you will learn how to install Python on your operating system.

If you have no Python software or you're using a mobile device, you can use any online Python compiler.

How to Install Python

To install Python on your Ubuntu Linux operating system, follow these instructions:

Open your terminal and run the following command to update the Ubuntu local system repository:

sudo apt update

Install the latest version of Python using the following command:

sudo apt install python3

If you are using Windows OS, you have to follow these steps to install Python on your machine.

1. Navigate to the python official page and download the latest installer.

2. Once you choose the latest version by the above link, you have to select the bit system according to your Windows operating system.

3. Run the installer and follow the written instruction on the installer.

Once you install the program, you have to verify the current version of Python on your operating system by using the following command via terminal or CMD according to your operating system.

Just type python and hit enter – it will show you the result like in the below image:

Verifying Python Version Via CMD

In the next section, you will learn how to write your first program with Python.

How to Write Your First Python Program

In this program, you're going to print the classic “Hello World” message using the Python programming language.

First, create a folder and name it “CodedTag” then create a file inside and name it as a “page.py”.

Then copy and paste the following Python code:

# output: Hello World
print( "Hello World" )

Then open the terminal and navigate to the project directory and run the following command:

python page.py

The output will be like the following image:

Execute Python Message

Congratulations – you just wrote your first Python program.

Wrapping Up

In this article, you learned what Python is and a bit of its history. You also learned how the Python interpreter works.

Let's summarize it in a few points:

1. The interpreter checks and searches for syntax errors and verifies indentation rules. Then it converts the source code via tokenization.

2. The parser receives the lexical tokens and generates an Abstract Syntax Tree.

3. The interpreter converts the AST to Byte Code and initializes the Python Virtual machine to execute the byte code and send back the final result.

Thank you for reading, If you'd like to read more of my articles, you can find them on FlatCoding. Stay tuned for my next articles.

History of PHP

PHP is the most used and popular scripting language generated for web development. You can embed it in HTML documents.

PHP is written in the high-level C programming language. The first generation of PHP was PHP/FI created in 1994 by Rasmus Lerdorf. He wrote it to track visitors to his resume.

The thing that allowed him to easily create the first home page with PHP was the ability to embed the PHP code within HTML markup.

The second generation was released as PHP/FI Version 2 in 1995 which referred to Personal Home Page Tools. At this time PHP depended on a small parser engine to translate and understand a few special instructions and some utilities that were used on the PHP personal home page.

PHP was officially born and become more widely used in 1996. In the beginning, it was being used on more than 15,000 web applications around the world. That number increased to 50,000 the following year.

Currently, PHP is fully dependent on an advanced interpreter called the Zend Engine. To learn more about what PHP is and how to write an advanced PHP program you should read more about its syntax.

As I mentioned before, PHP depends on the Zend Engine interpreter. But the question is, what is an interpreter? And how it does work?

In the next section, I'll explain everything from scratch – from the source code to the PHP server response. But before that you have to know the difference between the interpreter and the compiler.

Let's dive right in.

What's the Difference Between an Interpreter and a Compiler?

The interpreter is a program that takes the source code line by line and translates it into binary bits (0s and 1s) – machine language. During this process, the developer can edit the source code.

It doesn't take long for the interpreter to analyze the code – such as deleting the comments from the source code, whitespaces, and so on. But the overall time for execution is a bit slower.

On the other hand, the compiler is a program that takes the full source code that's already written in a high-level programming language and translates it into binary or machine language.

During this process, you can't edit the source code because it goes in as one piece to the compiler. The compiler is slow to analyze code but translates very quickly.

Let's take a more in-depth look at the PHP interpreter to see how it works.

How Does the PHP Interpreter Work?

As I mentioned before, the PHP interpreter is called the Zend Engine and it has four phases during which it interprets the PHP source code – in this section, we are going to dive more into each phase.

Lexical Analysis

The PHP interpreter takes the source code from the server and starts the first phase called lexical analysis (or tokenization). In this process, the interpreter removes all whitespaces and comment syntax, searches for any errors in the source code, and then generates a token sequence.

The lexical analysis does not cause any errors during this stage because it is only responsible for producing a token sequence. But it throws a fatal parse error to stop this phase directly if it finds any error in the source code.

The Parser

In the following step the parser takes over. In this phase, the parser receives the token sequence and sets some of the instructions to create the Zend Engine VM (Virtual Machine) – which is similar to assembly language – to manipulate the token sequence that was already created with the previous stage.

The Compilation

This phase is already under the parser stage, and here the parser is starting the compilation by generating the AST (Abstract Syntax Tree) – then passing it to the code generator.

The output of the compilation is an intermediate code that already depends on the Zend Engine VM. This is known as Operation Codes (OPCodes). The Opcodes contain some of the instructions to perform all the operations which require the implementation of flow control.

The Execution

This is the last phase, and here the executor receives the intermediate code that was already generated by the previous stage. It can read these OPCodes from the array of the instructions and then execute them one by one.

Overall, the Zend Engine has two separated functions, compiling and executing, which are zend_compile and zend_execute.

In the next section, you are going to write your first PHP program! But before you do that, you have to install a Wamp (for Windows) or XAMPP (for Linux/MacOS) server depending on which operating system you use.

How to Install XAMPP

In this section, I'll explain the XAMPP server and how to run the PHP server on your local machine.

Firstly, XAMPP is a free software used to create a PHP web server. But What does XAMPP mean?

1. "X" refers to Operating Systems such as Windows, Linux, or macOS. So that means we can install the XAMPP server on one of the operating systems we mentioned in this line.

2. "A" refers to Apache, and that is the PHP webserver software.

3. "M" refers to MariaDB - MySQL, the database management systems.

4. "P" refers to PHP (Personal Home Page) – the server-side scripting language that helps us create dynamic web pages.

5. "P" refers to Perl which is used in web development, network programming, or system administration.

So XAMPP refers to all the packages that you need to do web application development.

To install the XAMPP server on your local machine, navigate to the XAMPP official page and download the installer according to your operating system.

Once you've download it, just install the program according to the instructions you read in the installer.

The final result should look like the below image:

The XAMPP Control Panel

You only have to click on the "start" button beside the Apache module to run the PHP server.

Let's explore the important folders inside the XAMPP server app.

XAMPP Important Folders

The above image shows you all the important folders, but we only need to focus on the "htdocs" folder. This folder is the public directory that contains all PHP projects.

So you'll put any new PHP project inside the "htdocs" folder. And to open the result on the web browser, you just need to navigate to "localhost/your_project_folder_name".

Let's write a PHP program to clarify that.

How to Write Your First PHP Program

To help you write your first PHP program, we're just going to print a small message – "Hello World".

Firstly, make sure your PHP server is running on your local machine – I am using the XAMPP server on my local machine.

Second, create a folder inside your server app directory and name it codedtag.

The below image shows you that my public folder in the XAMPP server app is (htdocs) on Windows.

The public folder of the XAMPP server

For the next step, create an index page that ends with a PHP extension. Inside the "codedtag" folder, copy-paste the following PHP code:

<?php 
   echo "Hello World";
?>

To run the script, open the browser and navigate to localhost/codedtag. You will see the print message like the below image:

The PHP Print Message

And that's it! You've printed your first PHP program.

Wrapping Up

In this article, we discussed what PHP is and summarized its history in a few lines. We also learned the difference between the compiler and the interpreter.

Also, we discussed the exact steps of how the PHP interpreter works. To summarize, let’s have a look at the PHP Zend Engine from the top.

1. The first step is lexical analysis. In this stage, the interpreter deletes all whitespaces and comments from the source code and generates a token sequence.

2. The next step is called the parser, and here the parser sets the instructions to create the Zend Engine VM to manipulate the token sequence.

3. The compilation stage creates and passes the AST (Abstract Syntax Tree) to the code generator and the final compilation output is OPCodes.

4. The following step is for the executor, and in this stage the executor is reading and executing the instructions from the array.

If you want to learn more about PHP, here's a full handbook that covers all the basics in depth.

Stay tuned for my next article. You can read more of my articles on FlatCoding.