1. Printing output:
```php
echo "Hello, world!";
```
2. Variables:
```php
$name = "John";
$age = 30;
```
3. Concatenation:
```php
$greeting = "Hello, " . $name;
```
4. Conditional statements:
```php
if ($age >= 18) {
echo "You are an adult.";
} else {
echo "You are a minor.";
}
```
5. Loops:
- For loop:
```php
for ($i = 0; $i < 5; $i++) {
echo $i;
}
```
- While loop:
```php
$num = 0;
while ($num < 5) {
echo $num;
$num++;
}
```
6. Arrays:
```php
$fruits = array("apple", "banana", "orange");
echo $fruits[0]; // Output: apple
```
7. Functions:
```php
function add($a, $b) {
return $a + $b;
}
$result = add(5, 3); // Output: 8
```
8. Superglobals:
```php
echo $_SERVER['PHP_SELF']; // Current file path
echo $_GET['param']; // Accessing URL parameters
```
Remember, these are just basic examples. PHP is a versatile language used for web development and has many more features and functions to explore.
9. Including files:
```php
// Include another PHP file
include 'header.php';
```
10. Classes and objects:
```php
class Car {
public $brand;
public $model;
function __construct($brand, $model) {
$this->brand = $brand;
$this->model = $model;
}
function displayInfo() {
echo "Brand: " . $this->brand . ", Model: " . $this->model;
}
}
$car1 = new Car("Toyota", "Camry");
$car1->displayInfo(); // Output: Brand: Toyota, Model: Camry
```
11. File handling:
```php
// Read from a file
$filename = "data.txt";
$file_content = file_get_contents($filename);
echo $file_content;
// Write to a file
$filename = "output.txt";
$data = "This is some data to be written to the file.";
file_put_contents($filename, $data);
```
12. MySQL database connection and query execution:
```php
// Connect to MySQL database
$servername = "localhost";
$username = "username";
$password = "password";
$dbname = "database_name";
$conn = new mysqli($servername, $username, $password, $dbname);
// Execute a query
$sql = "SELECT * FROM users";
$result = $conn->query($sql);
// Loop through the query result
while ($row = $result->fetch_assoc()) {
echo "Name: " . $row['name'] . ", Email: " . $row['email'];
}
```
13. Handling form data:
```php
if ($_SERVER["REQUEST_METHOD"] == "POST") {
$name = $_POST["name"];
$email = $_POST["email"];
// Process the form data
}
```
These examples cover various aspects of PHP, such as working with files, databases, and HTML form data. Remember to use these examples as a starting point and refer to the PHP documentation for more in-depth information and best practices. PHP is widely used for web development and can handle a wide range of tasks, making it a powerful language to learn.
14. Error handling with try-catch blocks:
```php
try {
// Code that may throw an exception
$result = 10 / 0;
} catch (Exception $e) {
echo "An error occurred: " . $e->getMessage();
}
```
15. String manipulation:
```php
$str = "Hello, World!";
// Getting the length of the string
$length = strlen($str); // Output: 13
// Converting to uppercase and lowercase
$uppercase_str = strtoupper($str); // Output: HELLO, WORLD!
$lowercase_str = strtolower($str); // Output: hello, world!
// Replacing a substring
$new_str = str_replace("Hello", "Hi", $str); // Output: Hi, World!
// Splitting a string into an array
$words = explode(" ", $str); // Output: ['Hello,', 'World!']
```
16. Date and time manipulation:
```php
// Get the current date and time
$current_datetime = date("Y-m-d H:i:s");
// Format a given timestamp
$timestamp = strtotime("2023-08-01 12:30:00");
$formatted_date = date("F j, Y, g:i a", $timestamp); // Output: August 1, 2023, 12:30 pm
```
17. Sessions and cookies:
```php
// Start a session
session_start();
// Store data in a session variable
$_SESSION['user_id'] = 123;
// Set a cookie
setcookie("username", "JohnDoe", time() + (86400 * 30), "/"); // Cookie valid for 30 days
```
18. Sending email:
```php
$to = "recipient@example.com";
$subject = "Test Email";
$message = "This is a test email.";
$headers = "From: sender@example.com";
// Send the email
mail($to, $subject, $message, $headers);
```
19. JSON handling:
```php
// Convert an array to JSON
$data = array("name" => "John", "age" => 30);
$json_data = json_encode($data); // Output: {"name":"John","age":30}
// Convert JSON to an array
$json_str = '{"name":"Jane","age":25}';
$array_data = json_decode($json_str, true);
```
These additional examples cover various aspects of PHP, including error handling, string manipulation, date and time handling, sessions, cookies, sending emails, and JSON data handling. PHP's versatility allows it to handle a wide range of tasks in web development and beyond. Feel free to explore and experiment with these examples to deepen your understanding of PHP programming.
20. Regular expressions:
```php
// Match a pattern in a string
$string = "The quick brown fox jumps over the lazy dog.";
if (preg_match("/fox/i", $string)) {
echo "Found a fox!";
}
```
21. File upload handling:
```php
if ($_FILES['file']['error'] === UPLOAD_ERR_OK) {
$temp_file = $_FILES['file']['tmp_name'];
$target_path = "uploads/" . $_FILES['file']['name'];
move_uploaded_file($temp_file, $target_path);
echo "File uploaded successfully.";
}
```
22. Working with cookies:
```php
// Access a cookie value
if (isset($_COOKIE['username'])) {
$username = $_COOKIE['username'];
echo "Welcome back, $username!";
}
```
23. Handling form data with GET method:
```php
if (isset($_GET['name'])) {
$name = $_GET['name'];
echo "Hello, $name!";
}
```
24. Redirecting to another page:
```php
// Redirect to another page
header("Location: new_page.php");
exit; // Ensure no further code is executed after the redirect
```
25. Handling multiple form submissions with CSRF tokens:
```php
// Generate and store CSRF token in session
session_start();
$csrf_token = bin2hex(random_bytes(32));
$_SESSION['csrf_token'] = $csrf_token;
// Include the CSRF token in the form
echo '<input type="hidden" name="csrf_token" value="' . $csrf_token . '">';
// Validate the CSRF token on form submission
if ($_POST['csrf_token'] !== $_SESSION['csrf_token']) {
die("CSRF token validation failed.");
}
```
26. Sending JSON response:
```php
// Set response header and encode data as JSON
header('Content-Type: application/json');
$data = array("name" => "John", "age" => 30);
echo json_encode($data);
```
27. Working with cookies and expiration time:
```php
// Set a cookie with an expiration time
setcookie("username", "JohnDoe", time() + (86400 * 30), "/"); // Cookie valid for 30 days
```
These additional examples cover regular expressions, file uploads, handling form data with the GET method, redirecting to other pages, handling CSRF tokens for form submissions, sending JSON responses, and working with cookies with expiration times. PHP provides powerful tools to handle various aspects of web development, making it a popular choice for server-side scripting. Feel free to explore and experiment with these examples to deepen your understanding of PHP programming.
28. Working with sessions and session variables:
```php
// Starting a session
session_start();
// Storing data in session variables
$_SESSION['user_id'] = 123;
$_SESSION['username'] = 'john_doe';
// Accessing session variables
$user_id = $_SESSION['user_id'];
$username = $_SESSION['username'];
// Destroying a session
session_destroy();
```
29. Handling file downloads:
```php
// Set appropriate headers for a file download
$file_name = "example.pdf";
$file_path = "files/" . $file_name;
header("Content-type: application/pdf");
header("Content-Disposition: attachment; filename=" . $file_name);
header("Content-Length: " . filesize($file_path));
// Output the file content
readfile($file_path);
```
30. Using namespaces:
```php
// Creating a namespace
namespace MyNamespace;
// Defining a class within the namespace
class MyClass {
public function doSomething() {
// Code here
}
}
// Using the class from another file
use MyNamespace\MyClass;
$obj = new MyClass();
$obj->doSomething();
```
31. Working with JSON data from an API:
```php
// Fetching JSON data from an API
$json_data = file_get_contents("https://api.example.com/data");
$data = json_decode($json_data, true);
// Processing the JSON data
foreach ($data as $item) {
echo "Name: " . $item['name'] . ", Age: " . $item['age'] . "<br>";
}
```
32. Handling exceptions with custom error handling:
```php
// Custom error handler function
function customErrorHandler($errno, $errstr, $errfile, $errline) {
echo "Error: $errstr in $errfile on line $errline";
}
// Set the custom error handler
set_error_handler("customErrorHandler");
// Generate an error
echo $undefined_variable;
```
33. Using the ternary operator for shorthand conditionals:
```php
// Ternary operator
$age = 25;
$is_adult = ($age >= 18) ? "Yes" : "No";
echo "Is adult? $is_adult";
```
These additional examples cover working with sessions and session variables, handling file downloads, using namespaces, fetching and processing JSON data from APIs, custom error handling, and shorthand conditionals with the ternary operator. PHP's rich set of features allows you to perform various tasks efficiently in web development and beyond. Feel free to explore and experiment with these examples to further enhance your PHP programming skills.
34. Utilizing the null coalescing operator for default values:
```php
// Null coalescing operator
$username = $_GET['user'] ?? "Guest";
echo "Welcome, $username!";
```
35. Working with switch statements for multiple condition checks:
```php
// Switch statement
$day = "Wednesday";
switch ($day) {
case "Monday":
echo "It's the start of the week.";
break;
case "Wednesday":
echo "It's the middle of the week.";
break;
case "Friday":
echo "It's almost the weekend!";
break;
default:
echo "Enjoy your day!";
}
```
36. Using the `foreach` loop to iterate through arrays:
```php
// Foreach loop
$colors = ["red", "green", "blue"];
foreach ($colors as $color) {
echo "$color ";
}
```
37. Employing the `while` loop for repeated execution based on a condition:
```php
// While loop
$count = 0;
while ($count < 5) {
echo "$count ";
$count++;
}
```
38. Taking advantage of the `do-while` loop for executing code at least once:
```php
// Do-while loop
$num = 10;
do {
echo "$num ";
$num--;
} while ($num > 0);
```
39. Defining and using functions for reusable code blocks:
```php
// Function definition
function greet($name) {
return "Hello, $name!";
}
// Function usage
$message = greet("Alice");
echo $message;
```
40. Including external files with `include` and `require` for modularity:
```php
// Include and require
// include 'header.php'; // Include the file (non-fatal if not found)
// require 'footer.php'; // Require the file (fatal if not found)
```
41. Using the `class` keyword to define a class:
```php
// Class definition
class Car {
public $brand;
public function honk() {
return "Honk! Honk!";
}
}
// Creating an object
$myCar = new Car();
$myCar->brand = "Toyota";
echo $myCar->brand; // Outputs: Toyota
echo $myCar->honk(); // Outputs: Honk! Honk!
```
42. Defining constructors and destructors within a class:
```php
class Person {
public $name;
// Constructor
public function __construct($name) {
$this->name = $name;
echo "Hello, $name!";
}
// Destructor
public function __destruct() {
echo "Goodbye, {$this->name}!";
}
}
$person = new Person("John");
// Outputs: Hello, John!
// (other code execution)
// Outputs: Goodbye, John!
```
43. Working with visibility modifiers (`public`, `protected`, and `private`) within classes:
```php
class BankAccount {
private $balance = 1000;
protected $accountNumber = "1234567890";
public $owner;
public function getBalance() {
return $this->balance;
}
}
$account = new BankAccount();
echo $account->owner; // Accessible
echo $account->balance; // Error (private)
echo $account->accountNumber; // Error (protected)
```
44. Creating static methods and properties within a class:
```php
class MathUtils {
public static $pi = 3.14159;
public static function double($number) {
return $number * 2;
}
}
echo MathUtils::$pi; // Outputs: 3.14159
echo MathUtils::double(5); // Outputs: 10
```
45. Implementing interfaces and using `implements` to ensure method implementation:
```php
interface Shape {
public function getArea();
}
class Circle implements Shape {
private $radius;
public function __construct($radius) {
$this->radius = $radius;
}
public function getArea() {
return pi() * $this->radius * $this->radius;
}
}
```
46. Handling exceptions with `try`, `catch`, and `finally` blocks:
```php
try {
$result = 10 / 0;
} catch (DivisionByZeroError $e) {
echo "Division by zero error: " . $e->getMessage();
} finally {
echo "Cleanup or finalization code.";
}
```
47. Using the `namespace` keyword for better organization and avoiding naming conflicts:
```php
namespace MyProject;
class MyClass {
// class implementation
}
```
48. Utilizing traits to share methods among different classes:
```php
trait Logger {
public function log($message) {
echo "Logging: $message";
}
}
class Product {
use Logger;
// class implementation
}
$product = new Product();
$product->log("Product created.");
```
49. Understanding type hints for function parameters and return values:
```php
function add(int $a, int $b): int {
return $a + $b;
}
$result = add(5, 7); // Result: 12
```
50. Interacting with databases using PDO (PHP Data Objects):
```php
$dsn = "mysql:host=localhost;dbname=mydb";
$user = "username";
$pass = "password";
try {
$pdo = new PDO($dsn, $user, $pass);
$stmt = $pdo->prepare("SELECT * FROM users WHERE id = ?");
$stmt->execute([1]);
$user = $stmt->fetch(PDO::FETCH_ASSOC);
print_r($user);
} catch (PDOException $e) {
echo "Database error: " . $e->getMessage();
}
```
51. Using anonymous functions (also known as closures) for inline functionality:
```php
$greeting = function($name) {
return "Hello, $name!";
};
echo $greeting("Alice"); // Outputs: Hello, Alice!
```
52. Working with arrow functions introduced in PHP 7.4 for concise closures:
```php
$double = fn($x) => $x * 2;
echo $double(4); // Outputs: 8
```
53. Employing the `yield` keyword for creating generators to efficiently iterate large datasets:
```php
function countUpTo($max) {
for ($i = 1; $i <= $max; $i++) {
yield $i;
}
}
foreach (countUpTo(5) as $number) {
echo "$number ";
}
// Outputs: 1 2 3 4 5
```
54. Using the `list()` construct to assign variables from an array:
```php
$info = ["John", "Doe", 30];
list($first, $last, $age) = $info;
echo "$first $last is $age years old.";
```
55. Implementing the `__toString()` magic method to define a custom string representation for objects:
```php
class Book {
public $title;
public function __construct($title) {
$this->title = $title;
}
public function __toString() {
return "Book title: " . $this->title;
}
}
$book = new Book("The Great Gatsby");
echo $book; // Outputs: Book title: The Great Gatsby
```
56. Uploading files from forms and handling them on the server:
```php
if ($_FILES['file']['error'] === UPLOAD_ERR_OK) {
$tempPath = $_FILES['file']['tmp_name'];
$targetPath = 'uploads/' . $_FILES['file']['name'];
move_uploaded_file($tempPath, $targetPath);
echo "File uploaded successfully!";
} else {
echo "File upload failed.";
}
```
57. Using the `glob()` function to retrieve a list of files matching a pattern:
```php
$files = glob('images/*.jpg');
foreach ($files as $file) {
echo "$file ";
}
```
58. Reading and writing files using file handles and the `fopen()`, `fwrite()`, and `fclose()` functions:
```php
$filename = 'data.txt';
$file = fopen($filename, 'r');
$data = fread($file, filesize($filename));
fclose($file);
// Writing to a file
$file = fopen('output.txt', 'w');
fwrite($file, "Hello, world!");
fclose($file);
```
59. Manipulating dates and times with the `DateTime` class:
```php
$now = new DateTime();
echo $now->format('Y-m-d H:i:s');
$future = new DateTime('+1 week');
$interval = $now->diff($future);
echo "Difference: " . $interval->format('%a days');
```
60. Using sessions to store user-specific data across requests:
```php
session_start();
$_SESSION['username'] = 'alice';
if (isset($_SESSION['username'])) {
echo "Welcome, " . $_SESSION['username'];
} else {
echo "Please log in.";
}
```
61. Handling JSON data using `json_encode()` and `json_decode()` functions:
```php
$data = [
'name' => 'Alice',
'age' => 25,
'city' => 'New York'
];
$jsonString = json_encode($data);
echo $jsonString;
$decodedData = json_decode($jsonString, true);
echo $decodedData['name']; // Outputs: Alice
```
62. Sending HTTP headers to control response content and behavior:
```php
header('Content-Type: application/json');
$data = ['message' => 'Success'];
echo json_encode($data);
```
63. Using the `filter_var()` function to validate and sanitize user input:
```php
$email = $_POST['email'];
if (filter_var($email, FILTER_VALIDATE_EMAIL)) {
echo "Valid email address.";
} else {
echo "Invalid email address.";
}
```
64. Working with cookies to store small amounts of user data:
```php
setcookie('username', 'alice', time() + 3600, '/');
echo "Cookie set.";
if (isset($_COOKIE['username'])) {
echo "Welcome, " . $_COOKIE['username'];
}
```
65. Interacting with APIs using the `curl` library for making HTTP requests:
```php
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, 'https://api.example.com/data');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$response = curl_exec($ch);
curl_close($ch);
$data = json_decode($response, true);
```
66. Implementing basic object-oriented design patterns, like the Singleton pattern:
```php
class Singleton {
private static $instance;
private function __construct() {
// private constructor to prevent direct instantiation
}
public static function getInstance() {
if (!self::$instance) {
self::$instance = new self();
}
return self::$instance;
}
}
$instance = Singleton::getInstance();
```
67. Using the `header()` function for redirecting users to different pages:
```php
header('Location: new_page.php');
exit;
```
68. Handling user authentication and sessions for secure access control:
```php
session_start();
if ($_SESSION['authenticated']) {
echo "Welcome, " . $_SESSION['username'];
} else {
header('Location: login.php');
exit;
}
```
69. Working with regular expressions using the `preg_match()` function:
```php
if (preg_match('/[0-9]{3}-[0-9]{2}-[0-9]{4}/', $_POST['ssn'])) {
echo "Valid Social Security Number.";
} else {
echo "Invalid Social Security Number.";
}
```
70. Using Composer to manage third-party libraries and dependencies in your project:
```php
// Install Composer globally
// Create a composer.json file in your project directory
{
"require": {
"monolog/monolog": "^2.0"
}
}
// Run `composer install` to install the specified library
```