3. Data Types, Variables and Constants.

March 17, 2024 Roudi Bronkhorst Basics of PHP

3. Data Types, Variables and Constants.

Data Types in PHP:

In programming, data types define the type of data that can be stored and manipulated by a program. PHP supports various data types, each serving a specific purpose. Let’s explore the most common data types in PHP:

String:
- A string is a sequence of characters enclosed within single (‘ ‘) or double (” “) quotes.
- Example: $name = "John";
- Strings can contain letters, numbers, symbols, and special characters.
Integer:
- An integer is a whole number without any decimal point.
- Example: $age = 25;
- Integers can be positive or negative.
Float (Double):
- A float, also known as a double, is a number with a decimal point or a number in exponential form.
- Example: $price = 10.99;
- Floats are used to represent fractional numbers or very large/small numbers.
Boolean:
- A boolean represents a value that is either true or false.
- Example: $is_logged_in = true;
- Booleans are often used in conditional statements and logical operations.
Array:
- An array is a data structure that can hold multiple values of different data types.
- Example: $colors = array("red", "green", "blue");
- Arrays can be indexed (numeric) or associative (key-value pairs).
Object:
- An object is an instance of a class, which contains properties (variables) and methods (functions).
- Objects are used in object-oriented programming (OOP) to model real-world entities and encapsulate functionality.

Each data type in PHP serves a specific purpose and is used in different contexts within a PHP script. Understanding data types is essential for manipulating data effectively and writing efficient code. Additionally, PHP provides functions for type casting and type checking to convert data between different types or validate data against specific types.

Variables in PHP:

In PHP, a variable is a named container that stores data values. Unlike other programming languages, PHP variables are loosely typed, meaning you don’t need to declare the data type when creating a variable. PHP determines the data type dynamically based on the value assigned to the variable.

Creating Variables:

To create a variable in PHP, you simply use the dollar sign ($) followed by the variable name, followed by an assignment operator (=) and the value you want to assign to the variable. When naming variables in PHP, it’s important to follow certain rules and conventions to ensure clarity, consistency, and maintainability in your code. Here are some guidelines for naming variables in PHP:

Naming Rules:
- Variable names must start with a letter (a-z, A-Z) or an underscore (_). They cannot start with a number.
- After the first character, variable names can contain letters, numbers, and underscores.
- Variable names are case-sensitive. $name, $Name, and $NAME are considered different variables.
Naming Conventions:
- Use descriptive names that clearly indicate the purpose or content of the variable. This makes your code easier to understand and maintain.
- Use camelCase or snake_case for multi-word variable names. Both are widely accepted conventions:
  - camelCase: The first word is lowercase, and subsequent words start with uppercase letters, e.g., $userName, $userAge.
  - snake_case: Words are separated by underscores, e.g., $user_name, $user_age.
- Avoid using single-letter variable names (e.g., $x, $y) unless they represent loop counters or similar short-lived variables.
- Use meaningful prefixes or suffixes for variable names to indicate their data type or purpose, if necessary. For example:
  - Prefix $str_ for string variables, $int_ for integer variables, $bool_ for boolean variables, etc.
  - Suffix _list for arrays, _obj for objects, _flag for boolean flags, etc.
- Be consistent with your naming conventions throughout your codebase. Consistency improves readability and makes it easier for other developers to understand your code.
Reserved Words:
- Avoid using PHP reserved words (keywords) as variable names. These words have special meaning in PHP and cannot be used as identifiers. Examples include echo, if, else, foreach, function, etc.

Following these rules and conventions ensures that your variable names are clear, meaningful, and consistent, making your code more maintainable and easier to understand by yourself and other developers.

Here’s an example:

$name = "John";
$age = 25;
$price = 10.99;
$is_logged_in = true;

In this example:

$name is a string variable containing the value “John”.
$age is an integer variable containing the value 25.
$price is a float variable containing the value 10.99.
$is_logged_in is a boolean variable containing the value true.

Using Variables:

Once you’ve created a variable, you can use it throughout your PHP script by simply referencing its name. For example:

echo "Name: " . $name . "<br>";
echo "Age: " . $age . "<br>";
echo "Price: $" . $price . "<br>";

if ($is_logged_in) {
    echo "User is logged in.<br>";
} else {
    echo "User is not logged in.<br>";
}

This code snippet demonstrates how to use variables in PHP to display information such as name, age, price, and user login status.

Now, let’s create an example program called “variables.php” to demonstrate the usage and function of variables:

<?php
    // Define variables
    $name = "John";
    $age = 25;
    $price = 10.99;
    $is_logged_in = true;

    // Output variable values
    echo "Name: " . $name . "<br>";
    echo "Age: " . $age . "<br>";
    echo "Price: $" . $price . "<br>";
    
    // Check user login status
    if ($is_logged_in) {
        echo "User is logged in.<br>";
    } else {
        echo "User is not logged in.<br>";
    }
?>

Now, let’s break it down:

<?php: This is the PHP opening tag, indicating the beginning of a PHP script.
// Define variables: This is a comment line. Comments are ignored by the PHP interpreter and are used to provide explanations or notes to the reader. In this case, it indicates that we’re about to define variables.
$name = "John";: This line defines a variable named $name and assigns it the value “John”. Here, $name is a string variable containing the name “John”.
$age = 25;: This line defines a variable named $age and assigns it the value 25. Here, $age is an integer variable representing a person’s age.
$price = 10.99;: This line defines a variable named $price and assigns it the value 10.99. Here, $price is a float variable representing a price value.
$is_logged_in = true;: This line defines a variable named $is_logged_in and assigns it the value true. Here, $is_logged_in is a boolean variable indicating the login status of a user.
// Output variable values: Another comment line indicating that we’re about to output the values of the variables.
echo "Name: " . $name . " ";: This line uses the echo construct to output the value of the $name variable. The concatenation operator (.) is used to concatenate the string “Name: ” with the value of $name.   is HTML code for a line break.
echo "Age: " . $age . " ";: Similar to the previous line, this line outputs the value of the $age variable.
echo "Price: $" . $price . " ";: This line outputs the value of the $price variable, preceded by the string “Price: $”.
// Check user login status: Another comment line indicating that we’re about to check the user login status.
if ($is_logged_in) {: This line starts a conditional statement (if statement) to check the value of the $is_logged_in variable.
echo "User is logged in. ";: If the $is_logged_in variable is true, this line outputs the message “User is logged in.”.
} else {: This line starts the else block of the conditional statement, indicating what to do if the condition in the if statement evaluates to false.
echo "User is not logged in. ";: If the $is_logged_in variable is false, this line outputs the message “User is not logged in.”.
?>: This is the PHP closing tag, indicating the end of the PHP script.

Save this code in a file named “variables.php” and run it in your PHP environment. Navigate to http://localhost/php-basics/variables.php (adjust the URL based on your project directory name if different). You’ll see the output displaying the values of the variables and the user login status based on the boolean variable. This example illustrates how variables are created, assigned values, and used in PHP scripts to store and manipulate data.

Constants in PHP:

Constants in PHP are similar to variables, but their values cannot be changed once they are defined. Constants are useful for defining values that remain constant throughout the execution of a script, such as configuration settings, mathematical constants, or global values.

Naming Conventions for Constants:

Uppercase Letters: Constant names are conventionally written in uppercase letters to distinguish them from variables.
Underscore Separation for Multiple Words: To improve readability, use underscores (_) to separate words in constant names. This convention is commonly known as “snake_case.”
Descriptive Names: Use descriptive names for constants that clearly indicate their purpose or meaning. This enhances code readability and understanding.
Avoid Special Characters: Constant names should not contain special characters, except for underscores (_). They should only consist of letters, numbers, and underscores.

Defining Constants:

In PHP, constants are defined using the define() function. The syntax for defining a constant is as follows:

define(name, value, case-insensitive);

name: The name of the constant. It follows the same naming rules as variables.
value: The value assigned to the constant.
case-insensitive: An optional boolean parameter indicating whether the constant name should be case-insensitive. By default, constants are case-sensitive.

Here’s an example of defining constants in PHP:

define("SITE_NAME", "My Website");
define("PI", 3.14);
define("DEBUG_MODE", true);

In this example:

SITE_NAME is a string constant representing the name of the website.
PI is a float constant representing the mathematical constant pi.
DEBUG_MODE is a boolean constant indicating whether debugging mode is enabled.

Using Constants:

Once defined, constants can be used throughout your PHP script by referencing their names. Unlike variables, constants do not use the dollar sign ($) prefix.

echo SITE_NAME; // Outputs: My Website
echo PI; // Outputs: 3.14

if (DEBUG_MODE) {
    // Debugging code here
}

Advantages of Constants:

Constants improve code readability by providing meaningful names for values that do not change.
Constants prevent accidental modification of values, enhancing code reliability and predictability.
Constants facilitate global access to important values or configuration settings.

Conventions for Constants:

Constant names are conventionally written in uppercase letters, with words separated by underscores (_). For example: SITE_NAME, DEBUG_MODE.
Although not required, using uppercase letters for constant names helps distinguish them from variables and enhances readability.

Note: Unlike variables, constants are not preceded by the dollar sign ($) when referencing them.

Let’s create a PHP script named “constants.php” to demonstrate the use of constants:

<?php
// Define constants
define("SITE_NAME", "My Website");
define("MAX_FILE_SIZE", 1048576); // Represents 1 MB
define("DEBUG_MODE", true);

// Output constant values
echo "Site Name: " . SITE_NAME . "<br>";
echo "Max File Size: " . MAX_FILE_SIZE . " bytes<br>";

// Check debug mode
if (DEBUG_MODE) {
    echo "Debug Mode is enabled.<br>";
} else {
    echo "Debug Mode is disabled.<br>";
}

// Attempt to change constant value (will generate a warning)
define("SITE_NAME", "New Website");

// Output constant values again
echo "Site Name: " . SITE_NAME . "<br>";
?>

This script demonstrates the use of constants in PHP:

Defining Constants: We define three constants using the define() function:
- SITE_NAME: Represents the name of the website.
- MAX_FILE_SIZE: Represents the maximum file size allowed.
- DEBUG_MODE: Represents whether debugging mode is enabled.
Outputting Constant Values: We use echo statements to output the values of the defined constants. Note that constants are accessed without the dollar sign ($).
Checking Debug Mode: We use an if statement to check whether debug mode is enabled. If DEBUG_MODE is true, we output a message indicating that debug mode is enabled; otherwise, we output a message indicating that it’s disabled.
Attempting to Change Constant Value: We attempt to redefine the SITE_NAME constant, which should generate a warning because constants cannot be redefined once they are defined.
Outputting Constant Values Again: We output the value of the SITE_NAME constant again to demonstrate that its value remains unchanged despite the attempt to redefine it.

Save this script as “constants.php” and run it in your PHP environment. Navigate to http://localhost/php-basics/constants.php (adjust the URL based on your project directory name if different). You’ll see the constant values being outputted, and you should observe that attempting to change the value of a constant generates a warning, and the constant retains its original value. This demonstrates the immutability of constants in PHP.

3. Data Types, Variables and Constants.