PHP (Hypertext Preprocessor) is a server-side scripting language for web development, embedded in HTML.

    echo "Hello, World!";
?>

Practice outputting a message:

    echo "Welcome to PHP!";
?>

Variables in PHP start with a dollar sign ($), and code runs within tags.

    $name = "Alice";
    echo "Hello, $name!";
?>

Practice a variable:

    $greeting = "Hi!";
    echo $greeting;
?>

PHP supports multiple data types without explicit declaration.

    $string = "Text";
    $number = 42;
    $array = ["item"];
    var_dump($string);
?>

Practice a data type:

    $num = 10;
    echo $num;
?>

Conditionals control program flow.

    $age = 20;
    if ($age >= 18) {
        echo "Adult";
    } else {
        echo "Minor";
    }
?>

Practice a conditional:

    $score = 85;
    if ($score > 80) {
        echo "Pass";
    }
?>

Loops repeat code execution.

    for ($i = 1; $i <= 3; $i++) {
        echo $i;
    }
?>

Practice a loop:

    $count = 0;
    while ($count < 2) {
        echo "Loop";
        $count++;
    }
?>

Functions encapsulate reusable logic.

    function greet($name) {
        return "Hello, $name!";
    }
    echo greet("Bob");
?>

Practice a function:

    function sayHi() {
        echo "Hi!";
    }
    sayHi();
?>

Arrays store multiple values, indexed or associative.

    $colors = ["red", "blue"];
    echo $colors[0];
?>

Practice an array:

    $items = ["item1"];
    echo $items[0];
?>

PHP provides functions for array manipulation.

    $nums = [3, 1];
    sort($nums);
    print_r($nums);
?>

Practice an array function:

    $arr = [1, 2];
    array_push($arr, 3);
    echo count($arr);
?>

Manipulate strings with built-in functions.

    $str = "Hello";
    echo strlen($str);
?>

Practice string manipulation:

    $text = "Hi";
    echo strtoupper($text);
?>

Use $_POST or $_GET to process form data.

    if (isset($_POST["name"])) {
        echo $_POST["name"];
    }
?>

Practice form handling:

    $input = $_POST["input"] ?? "";
    echo $input;
?>

Validate inputs to ensure data integrity.

    $email = $_POST["email"] ?? "";
    if (filter_var($email, FILTER_VALIDATE_EMAIL)) {
        echo "Valid";
    }
?>

Practice validation:

    $data = $_POST["data"] ?? "";
    echo htmlspecialchars($data);
?>

Handle file uploads with $_FILES.

    if ($_FILES["file"]["size"] < 10000) {
        move_uploaded_file($_FILES["file"]["tmp_name"], "upload.txt");
    }
?>

Practice file uploads:

    if (isset($_FILES["file"])) {
        echo "File received";
    }
?>

Connect to MySQL using MySQLi or PDO.

    $conn = new mysqli("localhost", "user", "pass", "db");
    $result = $conn->query("SELECT * FROM users");
?>

Practice a query:

    $conn = new mysqli("localhost", "user", "pass", "db");
    $conn->query("SELECT 1");
?>

Perform Create, Read, Update, Delete operations.

    $pdo = new PDO("mysql:host=localhost;dbname=db", "user", "pass");
    $stmt = $pdo->prepare("INSERT INTO users (name) VALUES (?)");
    $stmt->execute(["Alice"]);
?>

Practice a CRUD operation:

    $pdo = new PDO("mysql:host=localhost;dbname=db", "user", "pass");
    $pdo->query("SELECT * FROM users");
?>

Prepared statements secure queries.

    $pdo = new PDO("mysql:host=localhost;dbname=db", "user", "pass");
    $stmt = $pdo->prepare("SELECT * FROM users WHERE id = ?");
    $stmt->execute([1]);
?>

Practice a prepared statement:

    $pdo = new PDO("mysql:host=localhost;dbname=db", "user", "pass");
    $stmt = $pdo->prepare("SELECT * FROM test WHERE id = ?");
    $stmt->execute([1]);
?>

Create classes for object-oriented programming.

    class User {
        public $name;
        public function __construct($name) {
            $this->name = $name;
        }
    }
    $user = new User("Bob");
?>

Practice a class:

    class Test {
        public $val = 1;
    }
    $obj = new Test();
    echo $obj->val;
?>

Use inheritance and interfaces for code reuse.

    class Person {
        public $name;
    }
    class Student extends Person {}
?>

Practice inheritance:

    class Base {}
    class Derived extends Base {}
    $obj = new Derived();
?>

Traits and abstract classes enhance flexibility.

    trait Log {
        public function log() {
            echo "Log";
        }
    }
    class App {
        use Log;
    }
?>

Practice a trait:

    trait Test {
        public function test() {
            echo "Test";
        }
    }
    class MyClass {
        use Test;
    }
    $obj = new MyClass();
    $obj->test();
?>

Handle errors with try-catch blocks.

    try {
        throw new Exception("Error");
    } catch (Exception $e) {
        echo $e->getMessage();
    }
?>

Practice error handling:

    try {
        echo 1 / 0;
    } catch (Exception $e) {
        echo "Caught";
    }
?>

Secure applications against vulnerabilities.

    $input = htmlspecialchars($_POST["data"] ?? "");
    echo $input;
?>

Practice security:

    $pass = password_hash("test", PASSWORD_DEFAULT);
    echo $pass;
?>

Manage user sessions with $_SESSION.

    session_start();
    $_SESSION["user"] = "Alice";
    echo $_SESSION["user"];
?>

Practice sessions:

    session_start();
    $_SESSION["id"] = 1;
    echo $_SESSION["id"];
?>

Use cURL or HTTP functions to consume APIs.

    $data = file_get_contents("https://api.example.com");
    echo $data;
?>

Practice API consumption:

    $json = json_decode('{"key":"value"}', true);
    echo $json["key"];
?>

Create RESTful APIs with PHP.

    header("Content-Type: application/json");
    echo json_encode(["data" => "test"]);
?>

Practice building an API:

    header("Content-Type: application/json");
    http_response_code(200);
    echo json_encode(["ok" => true]);
?>

Secure APIs with JWT or other methods.

    $token = $_SERVER["HTTP_AUTHORIZATION"] ?? "";
    if ($token) {
        echo "Authenticated";
    }
?>

Practice authentication:

    http_response_code(401);
    echo "Unauthorized";
?>

Frameworks like Laravel simplify development.

    // Laravel route example
    Route::get("/", function() {
        return "Hello, Laravel!";
    });
?>

Practice a framework concept:

    echo "Framework test";
?>

Use Laravel’s MVC architecture.

    Route::get("/users", function() {
        return view("users");
    });
?>

Practice a route:

    Route::get("/test", function() {
        return "Test";
    });
?>

Composer manages dependencies.

    require "vendor/autoload.php";
    use Monolog\Logger;
    $log = new Logger("app");
?>

Practice Composer:

    require "vendor/autoload.php";
?>

Test code with PHPUnit.

    use PHPUnit\Framework\TestCase;
    class Test extends TestCase {
        public function testAdd() {
            $this->assertEquals(2, 1 + 1);
        }
    }
?>

Practice a test:

    use PHPUnit\Framework\TestCase;
    class MyTest extends TestCase {
        public function testTrue() {
            $this->assertTrue(true);
        }
    }
?>

Automate deployments with CI/CD.

name: CI
on: [push]
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v3
    - name: Run tests
      run: vendor/bin/phpunit

Practice a deployment config:

name: Test
on: [push]
jobs:
  build:
    runs-on: ubuntu-latest

Explore PHP career opportunities.

    echo "Backend, Full-Stack, WordPress";
?>

Practice a career-related output:

    echo "PHP Developer";
?>