Complete Modern PHP Developer Course

The PHP Interpreter

Running a PHP Script

PHP Tags

The echo Keyword

Comments

Variables

Assignment Operator

Data Types

The var_dump Function

Null Data Type

Boolean Data Type

Integers and Floats

String Data Type

Arrays

Associative Arrays

Multidimensional Arrays

Type Casting

Type Juggling

Arithmetic Operators

Assignment Operators

Comparison Operators

Error Control Operator

Incrementing and Decrementing Numbers

Logical Operators

Operator Precedence

Constants

String Concatenation

Terminology: Expressions

Control Structures

Switch Statements

Match Expressions

Functions

Function Parameters

Function Return Values

Type Hinting & Union Types

Strict Types

Short-Circuiting

While Loop

For Loop

Foreach Loop

Getting Started with Challenges

Coding Solution: Resistor Colors

Coding Solution: Two Fer

Coding Solution: Leap Year

Predefined Constants

Alternative Syntax for Constants

Unsetting Variables

Reading the PHP Documentation

Rounding Numbers

Alternative if statement syntax

Avoiding Functions in Conditions

Including PHP Files

Variadic Functions

Named Arguments

Global Variables

Static Variables

Anonymous and Arrow Functions

Callable Type

Passing by Reference

Array Functions

Destructuring Arrays

Working with Files

Exploring the Challenges

Coding Solution: Robot Name

Coding Solution: Armstrong Numbers

Coding Solution: Series

What is OOP (Object-Oriented Programming)?

Classes

Properties

Magic Methods

Constructor Property Promotion

Custom Methods

Null-safe Operator

Understanding Namespaces

Creating a Namespace

Working with Namespaces

Autoloading Classes

Using Constants in Classes

Static Properties and Methods

OOP Principle: Encapsulation

OOP Principle: Abstraction

OOP Principle: Inheritance

Protected Modifier

Overriding Methods

Abstract Classes and Methods

Interfaces

OOP Principle: Polymorphism

Anonymous Classes

Docblocks

Throwing Exceptions

Custom Exceptions

Catching Exceptions

The DateTime Class

Iterator and Iterable Type

OOP Challenges Overview

Coding Solution: Nucleotide Count

Coding Solution: Grade School

Project Overview

Text Editors

Understanding the LAMP stack

Exploring XAMPP

The htdocs Folder

Configuring Virtual Hosts in Apache

Configuring PHP

Creating an Application Class

Bootstrapping an Application

The Command Line

Understanding PSR

Installing Composer

JSON Crash Course

Initializing Composer

Generating Autoload Files

Including Autoload Files

What is Git?

Using GitHub

Exploring Git Files

Understanding Routing

Apache Mod Rewrite

The htaccess File

Sugar Functions

Creating a Router Class

Adding Routes

Understanding HTTP Methods

Supporting HTTP Methods in Routes

Normalizing Paths

Exploring Regular Expressions

Regular Expressions in PHP

MVC Design Pattern

Creating a Controller

Registering Controllers

Class Magic Constant

Dispatching a Route

Finding Matches with Regular Expressions

Instantiating Classes with Strings

PSR-12 Auto Formatting

Understanding Template Engines

Creating a Template Engine Class

Setting a Base Path

Rendering a Template

Extracting Arrays

Understanding Output Buffering

Creating an Output Buffer

Loading Assets

Adding Partials

Exercise: Creating an About Page

Escaping Data

Autoloading Functions

Understanding Dependency Injection

Creating a Container

External Definitions File

Factory Design Pattern

Merging Arrays

Reflective Programming

Validating Classes

Validating the Constructor Method

Retrieving the Constructor Parameters

Validating Parameters

Invoking Factory Functions

Instantiating a Class with Dependencies

Understanding Middleware

Supporting Router Middleware

Adding Middleware

Creating Middleware

Interface Contracts

Chaining Callback Functions

Looping through Middleware

Supporting Dependency Injection in Middleware

Global Template Variables

Singleton Pattern

Preparing the Registration Form

Configuring the Form

Handling POST Data

Understanding Services

Creating a Validator Class

Validation Rule Contract

Registering a Rule

Applying Rules to Fields

Storing Validation Errors

Custom Validation Exception

HTTP Status Codes

Custom Middleware

Redirection with Headers

Passing on the Errors

HTTP Referrer

Understanding Sessions

Enabling Sessions

Handling Session Exceptions

Common Session Error

Closing the Session Early

Injecting Errors into a Template

Flashing Errors

Displaying Errors

Validating Emails

Supporting Rule Parameters

Minimum Validation Rule

In Validation Rule

Exercise: URL Validation Rule

Password Matching Rule

Prefilling a Form

Filtering Sensitive Data

Introduction to SQL

Creating a Database

Creating Tables

Inserting Data

Reading Data

Updating Data

Deleting Data

Using PHPMyAdmin

Enabling PDO Extension

Custom Composer Scripts

Understanding DSN

Creating a DSN String

Connecting to a Database

The PDOException Class

Refactoring the Database Connection

Querying the Database

Fetch Modes

SQL Injections

Prepared Statements

Understanding Transactions

Creating Transactions with PDO

Understanding Data Modeling

Designing a User Table

Creating a Table in an SQL File

Loading Files

Conditionally Creating Tables

Refactoring the Query

Database Container Definition

Understanding Environment Variables

Creating Environment Variables

Ignoring Environment Files

Passing on the Container to Definitions

Counting Records with SQL

Supporting Prepared Statements

Validating Duplicate Emails

Exercise: Inserting a User

Understanding Hashing

Hashing a Password

Preparing the Login Page

Exercise: Validating the Login Form

Validating the User’s Credentials

Understanding Session Hijacking

Configuring Session Cookies

Regenerating a Session ID

Protecting Routes

Applying Route Middleware

Logging out of the Application

Authenticating Registered Users

Understanding CSRF

Generating a CSRF Token

Rendering Tokens

Validating CSRF Tokens

Conditionally Rendering Sections

Designing the Transactions Table

Understanding Database Relationships

Adding Foreign Keys

Preparing the Create Transaction Page

Validating Transactions

Validating Maximum Character Length

Validating Numbers

Validating Dates

Creating a Transaction

Retrieving Transactions

Formatting Dates with SQL

Query Parameters

SQL LIKE Clause

Filtering Transactions

Escaping the Search Term

SQL Limit Clause

Limiting Results

Previous Page Link

Next Page Link

Page Number Links

Preparing the Edit Route

Replacing Strings with Regular Expressions

Extracting Route Parameter Values

Edit Transaction Template

Updating a Transaction

Overriding HTTP Methods

Deleting a Transaction

Preparing the Receipt Controller

Encoding File Data

Exercise: Creating a Receipt Service

Validating a File Upload

Validating File Sizes

Validating Filenames

Validating File Mime Types

Generating a Random Filename

Moving Uploaded Files

Designing the Receipts Table

Storing the Receipt

Displaying Receipts

Validating the Download Request

Downloading Files

Deleting a Receipt

Magic Numbers

Destroying Session Cookies

Rendering a 404 Page

Understanding Deployment

Configuring a Server

Configuring an Application

Setting up our Project

Conclusion