03. Basics of PHP

1) PHP Syntax

The syntax of PHP (Hypertext Preprocessor) is similar to C, C++, and other programming languages. Here are some key syntax elements in PHP:

Tags:
- PHP code is typically enclosed within <?php and ?> tags.
- Alternatively, you can use short tags <? and ?>, but they are not recommended for portability reasons.

Example:

    <?php
    // PHP code goes here
    ?>

Statements:
- PHP statements end with a semicolon ;.
- Statements can span multiple lines or be written on a single line.

Example:

    $name = "John"; // Single-line statement
    $age = 25;      // Single-line statement

    $greeting = "Hello, ";
    $greeting .= $name; // Multi-line statement

2. Comments

In PHP, you can use comments to add explanatory notes or disable certain parts of the code. There are two types of comments:

Single-Line Comments:
- Single-line comments begin with // and continue until the end of the line.
- They are used to add comments on a single line.

Example:

    // This is a single-line comment
    $name = "John"; // Assigning a value to the variable

Multi-Line Comments:
- Multi-line comments start with /* and end with */.
- They are used for adding comments that span multiple lines.

Example:

    /*
    This is a multi-line comment.
    It can span multiple lines.
    */
    $age = 25; // Assigning a value to the variable

Comments are ignored by the PHP interpreter and are not executed as part of the program. They are useful for documenting code, providing explanations, or temporarily disabling specific lines of code without deleting them. Comments also help improve code readability and make it easier for other developers to understand your code.

3. Variables

In PHP, variables are used to store and manipulate data. Here are some key points about variables in PHP:

Variable Naming Rules:
- Variable names in PHP must start with a dollar sign $, followed by a valid name.
- Names can only contain letters, numbers, and underscores (_).
- Variable names are case-sensitive.

Example:

    $name = "John";
    $age = 25;
    $isStudent = true;

Variable Assignment:
- Variables are assigned values using the assignment operator =.
- The value on the right side of the = sign is assigned to the variable on the left side.

Example:

    $name = "John";
    $age = 25;

Data Types:
- PHP is a dynamically typed language, meaning you don't need to explicitly declare the data type of a variable.
- Variables in PHP can hold various types of data, such as strings, numbers, booleans, arrays, objects, etc.
- The data type of a variable is determined by the value assigned to it.

Example:

    $name = "John";        // String
    $age = 25;             // Integer
    $isStudent = true;     // Boolean
    $grades = [90, 85, 95]; // Array

Variable Scope:
- The scope of a variable defines its visibility and accessibility within the program.
- PHP supports various scopes, including global, local, function, and class scopes.

Example:

    $globalVar = "Global"; // Global scope

    function myFunction() {
        $localVar = "Local"; // Local scope
    }

Variable Interpolation:
- In PHP, variables can be included within double-quoted strings to interpolate their values.
- This allows you to directly include variable values within the string without concatenation.

Example:

    $name = "John";
    echo "My name is $name"; // Output: My name is John

Variables in PHP are flexible and can hold different types of data. They allow you to store and manipulate values throughout your program, making it dynamic and adaptable to different scenarios.

4. Echo and Print

In PHP, both echo and print statements are used to output data to the browser or the command line. Here are the details of each:

echo Statement:
- The echo statement is the most commonly used for outputting data in PHP.
- It can output one or more values separated by commas.
- The echo statement has no return value and can be used as a language construct.

Example:

    $name = "John";
    echo "Hello, " . $name; // Output: Hello, John

print Statement:
- The print statement is another way to output data in PHP.
- It can only output a single value.
- The print statement returns a value of 1, which can be useful in certain scenarios.

Example:

    $name = "John";
    print "Hello, " . $name; // Output: Hello, John

Both echo and print statements are used for similar purposes, but there are a few differences between them:

echo is slightly faster than print because it does not return a value.
echo can output multiple values separated by commas, while print can only output a single value.
echo can be used as a language construct without parentheses, while print is a function and requires parentheses.

In most cases, you can choose either echo or print based on personal preference. However, echo is more commonly used in PHP code.

5. Data Types

In PHP, variables can hold different data types. Here are some commonly used data types in PHP:

Strings:
- Strings represent sequences of characters.
- They can be enclosed in single quotes (') or double quotes (").
- You can concatenate strings using the dot (.) operator.

Example:

    $name = "John";
    $message = 'Hello, ' . $name;

Integers:
- Integers represent whole numbers without decimal points.
- They can be positive or negative.

Example:

    $age = 25;
    $count = -10;

Floating-Point Numbers:
- Floating-point numbers represent decimal numbers.
- They can be specified using the decimal point.

Example:

    $pi = 3.14;
    $price = 9.99;

Booleans:
- Booleans represent the truth values true and false.
- They are used for logical comparisons and conditions.

Example:

    $isStudent = true;
    $isEmployee = false;

Arrays:
- Arrays are used to store multiple values in a single variable.
- They can hold values of different data types.
- Arrays can be indexed or associative.

Example:

    $numbers = [1, 2, 3, 4, 5];
    $person = ['name' => 'John', 'age' => 25];

Objects:
- Objects represent instances of classes.
- They have properties (variables) and methods (functions) associated with them.

Example:

    class Person {
        public $name;
        public function sayHello() {
            echo "Hello, " . $this->name;
        }
    }

    $person = new Person();
    $person->name = "John";
    $person->sayHello();

These are some of the basic data types in PHP. Additionally, PHP also supports data types such as null, resources, and callable. Understanding data types is crucial for effectively storing and manipulating data in PHP.

6. String Functions

PHP provides a wide range of built-in string functions that allow you to manipulate and process strings. Here are some commonly used string functions in PHP:

strlen($string):
- Returns the length (number of characters) of a string.

Example:

    $str = "Hello, World!";
    echo strlen($str); // Output: 13

strtolower($string):
- Converts a string to lowercase.

Example:

    $str = "Hello, World!";
    echo strtolower($str); // Output: hello, world!

strtoupper($string):
- Converts a string to uppercase.

Example:

    $str = "Hello, World!";
    echo strtoupper($str); // Output: HELLO, WORLD!

substr($string, $start, $length):
- Extracts a substring from a given string.
- The $start parameter specifies the starting position, and $length (optional) determines the number of characters to extract.

Example:

    $str = "Hello, World!";
    echo substr($str, 7, 5); // Output: World

str_replace($search, $replace, $string):
- Replaces all occurrences of a substring with another substring within a string.

Example:

    $str = "Hello, World!";
    echo str_replace("World", "PHP", $str); // Output: Hello, PHP!

strpos($haystack, $needle):
- Finds the position of the first occurrence of a substring within a string.
- Returns the position as an integer, or false if the substring is not found.

Example:

    $str = "Hello, World!";
    echo strpos($str, "World"); // Output: 7

trim($string):
- Removes whitespace or other specified characters from the beginning and end of a string.

Example:

    $str = "   Hello, World!   ";
    echo trim($str); // Output: Hello, World!

These are just a few examples of the string functions available in PHP. There are many more string functions that you can explore in the PHP documentation. These functions provide powerful tools for manipulating and working with strings in PHP.

7. Mathematical Functions

PHP provides a variety of mathematical functions that allow you to perform mathematical operations and calculations. Here are some commonly used mathematical functions in PHP:

abs($number):
- Returns the absolute value of a number.

Example:

    $number = -5;
    echo abs($number); // Output: 5

sqrt($number):
- Returns the square root of a number.

Example:

    $number = 16;
    echo sqrt($number); // Output: 4

pow($base, $exponent):
- Raises a number to a given power.

Example:

    $base = 2;
    $exponent = 3;
    echo pow($base, $exponent); // Output: 8

round($number, $precision):
- Rounds a number to the nearest integer or to a specified number of decimal places.
- The $precision parameter is optional and determines the number of decimal places.

Example:

    $number = 3.14159;
    echo round($number);        // Output: 3
    echo round($number, 2);     // Output: 3.14

rand($min, $max):
- Generates a random number between a minimum and maximum value (inclusive).

Example:

    $randomNumber = rand(1, 10);
    echo $randomNumber; // Output: Random number between 1 and 10

min($value1, $value2, ...):
- Returns the minimum value among the given arguments.

Example:

    $minValue = min(5, 3, 8);
    echo $minValue; // Output: 3

max($value1, $value2, ...):
- Returns the maximum value among the given arguments.

Example:

    $maxValue = max(5, 3, 8);
    echo $maxValue; // Output: 8

These are just a few examples of the mathematical functions available in PHP. PHP provides many more mathematical functions, including trigonometric functions, logarithmic functions, and more. You can refer to the PHP documentation for a complete list of mathematical functions and their usage.

8. Constants

In PHP, constants are named values that cannot be changed once they are defined. They provide a way to store values that remain constant throughout the execution of a script. Here's how constants are defined and used in PHP:

Defining Constants:
- Constants are defined using the define() function or the const keyword.
- The naming convention for constants is to use uppercase letters and underscores for word separation.

Example using define() function:

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

Example using const keyword (PHP 5.3 or later):

    const PI = 3.14;
    const SITE_NAME = "My Website";

Accessing Constants:
- Constants can be accessed without using the dollar sign ($).
- To access a constant, simply use its name.

Example:

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

Using Constants in Expressions:
- Constants can be used in mathematical expressions, function calls, and string concatenation.

Example:

    $radius = 5;
    $area = PI * pow($radius, 2);
    echo "The area of the circle is: " . $area;  // Output: The area of the circle is: 78.5

Predefined Constants:
- PHP also provides a set of predefined constants that are available for use without the need for defining them.
- These constants represent information about the PHP environment, server settings, and more.
- Predefined constants are written in uppercase.

Example:

    echo PHP_VERSION;   // Output: 8.0.11
    echo PHP_OS;        // Output: Linux

Constants in PHP are useful for storing values that remain constant throughout the execution of a script, such as configuration settings, mathematical constants, or commonly used values. They provide a way to ensure that certain values are not accidentally modified during runtime.

9. Super Global Variables

In PHP, there are several predefined global variables that provide access to important information and functionalities. Here are some commonly used global variables:

$_SESSION:
- The $_SESSION variable is used to store session data across multiple requests for a specific user.
- It allows you to store and retrieve data that remains accessible as long as the user's session is active.

Example:

    // Starting a session
    session_start();

    // Storing data in the session
    $_SESSION['username'] = 'John';

    // Retrieving data from the session
    echo $_SESSION['username'];  // Output: John

$_COOKIE:
- The $_COOKIE variable is an associative array that contains cookies sent by the client.
- Cookies are small pieces of data stored on the client's computer and can be used to remember user preferences or track user activity.

Example:

    // Retrieving a cookie
    echo $_COOKIE['username'];  // Output: John

    // Setting a cookie
    setcookie('username', 'John', time() + 3600);  // Expires in 1 hour

$_SERVER:
- The $_SERVER variable contains information about the server and the current request.
- It provides details such as server paths, request headers, and client information.

Example:

    // Retrieving the current URL
    echo $_SERVER['HTTP_HOST'] . $_SERVER['REQUEST_URI'];

    // Getting the client IP address
    echo $_SERVER['REMOTE_ADDR'];

$_GET and $_POST:
- The $_GET and $_POST variables are used to retrieve data sent via HTTP GET and POST methods, respectively.
- They contain key-value pairs of the form data submitted by the client.

Example:

    // Retrieving data from a form submitted via GET
    echo $_GET['name'];

    // Retrieving data from a form submitted via POST
    echo $_POST['name'];

These global variables provide access to essential information and functionality in PHP applications. They allow you to interact with session data, cookies, server details, and client request data. Proper usage of these global variables is important for building dynamic and interactive web applications.

10. Operators

In PHP, operators are used to perform various operations on variables, values, and expressions. PHP supports a wide range of operators that can be categorized into different types. Here are some of the most commonly used operators in PHP:

Arithmetic Operators:
- Addition: +
- Subtraction: -
- Multiplication: *
- Division: /
- Modulus (remainder): %
- Increment: ++
- Decrement: --
Assignment Operators:
- Assignment: =
- Addition assignment: +=
- Subtraction assignment: -=
- Multiplication assignment: *=
- Division assignment: /=
- Modulus assignment: %=
Comparison Operators:
- Equal to: ==
- Not equal to: != or <>
- Identical to: ===
- Not identical to: !==
- Greater than: >
- Less than: <
- Greater than or equal to: >=
- Less than or equal to: <=
Logical Operators:
- Logical AND: && or and
- Logical OR: || or or
- Logical NOT: ! or not
String Operators:
- Concatenation: .
Array Operators:
- Union: +
- Equality: ==
- Identity: ===
Ternary Operator:
- The ternary operator is a shorthand way of writing conditional statements.
- Syntax: $variable = (condition) ? value_if_true : value_if_false;

Example:

    $age = 18;
    $isAdult = ($age >= 18) ? true : false;

These are just some of the operators available in PHP. There are also bitwise operators, increment/decrement operators, type operators, and more. Understanding and using these operators effectively is essential for performing calculations, comparisons, and logical operations in PHP.