Learning PHP, MySQL &

JavaScript PDF
Robin Nixon
Learning PHP, MySQL & JavaScript
Create Engaging Websites Using PHP, MySQL, and
JavaScript Essentials
Written by Bookey
Check more about Learning PHP, MySQL & JavaScript
Summary
Listen Learning PHP, MySQL & JavaScript Audiobook
About the book
Embark on a journey to create dynamic, interactive websites
using essential open-source technologies, even with just a
fundamental grasp of HTML. This comprehensive guide
introduces you to the latest versions of core web technologies,
including PHP, MySQL, JavaScript, CSS, HTML5, and the
powerful React and React Native libraries. Through engaging
hands-on projects, you’ll learn to seamlessly integrate these
tools while mastering best practices for web programming,
such as optimizing sites for mobile devices. By the end of the
book, you’ll have the skills to develop a fully functional social
networking site that performs beautifully across both desktop
and mobile platforms, along with proficiency in database
management, security, and modern web development
techniques.
About the author
Robin Nixon is a seasoned software developer with over 30
years of experience in creating websites and applications. An
accomplished author, he has penned nearly 30 books and over
500 magazine articles on technology and computing, with
many of his works translated into various languages. In
addition to his writing, he is a highly regarded instructor of
online video courses. Robin's eclectic interests extend beyond
IT to include motivational psychology, artificial intelligence
research, music—both performing and enjoying—board game
design, and culinary experiences. Residing on the south-east
coast of England, he writes full-time while supporting his
wife, Julie, a university lecturer and trained nurse, and raising
their five children alongside three fostered children with
disabilities.
Summary Content List
Chapter 1 : Learning PHP, MySQL JavaScript

Chapter 2 : 1. Introduction to Dynamic Web Content

Chapter 3 : 2. Setting Up a Development Server

Chapter 4 : 3. Introduction to PHP

Chapter 5 : 4. Expressions and Control Flow in PHP

Chapter 6 : 5. PHP Functions and Objects

Chapter 7 : 6. PHP Arrays

Chapter 8 : 7. Practical PHP

Chapter 9 : 8. Introduction to MySQL

Chapter 10 : 9. Mastering MySQL

Chapter 11 : 10. What’s new in PHP 8 and MySQL 8

Chapter 12 : A. Solutions to the Chapter Questions

Chapter 1 Summary : Learning PHP,
MySQL JavaScript

Book Information

- Title: Learning PHP, MySQL & JavaScript

- Author: Robin Nixon
- Copyright: 2021
- Publisher: O’Reilly Media, Inc.
- ISBN: 978-1-492-09381-7

Preface

The book addresses dynamic web design using PHP and

MySQL, emphasizing their popularity due to open-source
advantages. It is suitable for developers on different
platforms, teaching them to create advanced websites using
technologies like JavaScript, React, CSS, and HTML5.

Target Audience

The book is intended for individuals looking to learn web

development, including webmasters, graphic designers,
students, and self-learners aiming to enhance their skills in
responsive web design.

Assumptions

Readers are assumed to have a basic understanding of HTML

but do not need prior knowledge of PHP, MySQL,
JavaScript, CSS, or HTML5 to benefit from the content.

Book Organization

The book systematically covers:

1. Core languages: PHP basics, MySQL structure and
queries, integrating PHP and MySQL for dynamic web
pages.
2. JavaScript fundamentals: Functions, event handling, and
DOM manipulation including a primer on React.
3. Styling web pages using CSS.
4. Interactive HTML5 features.
5. A final project creating a fully functional social
networking website.

Supporting Books

Recommended additional readings post-completion include

titles on Dynamic HTML, PHP, MySQL, JavaScript, and
CSS.

Conventions Used

The book utilizes various typographical conventions:

- Plain text for menu items.
- Italic for new terms and file names.
- Constant width for code elements.
- NOTE for tips; WARNING for cautions.

Code Examples

Supplemental materials are available online, and readers can

freely use example code with some restrictions on
reproduction. Attribution is appreciated but not required.

O’Reilly Online Learning

Provides access to a wealth of training resources and learning

paths for continued development.

Contact Information

Readers can contact O’Reilly Media for inquiries, further

resources, or to report errors through various platforms
including email and social media.

Acknowledgments

Thanks various contributors and editors who played pivotal

roles in the creation and publication of the book.
Critical Thinking
Key Point:Emphasis on Open-Source Technologies
Critical Interpretation:The chapter highlights the
author's belief in the advantages of open-source
technologies, specifically PHP and MySQL, as essential
tools for dynamic web design. However, readers should
consider that while Nixon’s perspective aligns with
popular trends in web development, it may overlook
significant considerations such as security
vulnerabilities and scalability issues inherent in
open-source software. Various studies indicate that
proprietary solutions can sometimes offer better support
and performance, suggesting that developers should
evaluate the merits of both open-source and commercial
solutions based on their specific project requirements
(see 'Web Development with Node and Express' by
Ethan Brown for a contrasting viewpoint). Ultimately,
while open-source frameworks are undeniably
influential, they are not universally applicable or
superior in all contexts.
Chapter 2 Summary : 1. Introduction to
Dynamic Web Content

Chapter 1: Introduction to Dynamic Web Content

Overview of the Evolution of the Web

The World Wide Web has transformed since its inception in

the early 1990s, originally designed to facilitate data sharing
among global scientists. Tim Berners-Lee invented HTTP
and HTML, creating the first web browser and server, which
revolutionized internet navigation.

The Request/Response Procedure

The interaction between a client (browser) and server
involves a request/response cycle:
1. User enters a web address.
2. Browser resolves the domain to an IP address.
3. A request is sent to the web server.
4. The server retrieves the requested page and returns it.
5. The browser displays the web page.
Dynamic pages use PHP and MySQL, incorporating database
interactions into the process to deliver personalized content.

Technologies Behind Dynamic Web Pages

Key technologies include:

-
PHP
: A server-side scripting language allowing dynamic content
generation.
-
MySQL
: A relational database management system that efficiently
manages data.
-
JavaScript
: A client-side scripting language enabling interactivity and
asynchronous communication.
-
CSS
: Stylesheets that control the presentation of HTML elements.
-
HTML5
: The latest markup language version supporting multimedia
and improved functionality.

MariaDB: The MySQL Alternative

MariaDB, a fork of MySQL, was developed to ensure

open-source continuity after Oracle's acquisition of Sun
Microsystems. It offers compatibility with MySQL and can
be used interchangeably.

Using PHP, MySQL, and JavaScript

PHP allows embedding dynamic scripts in HTML. MySQL

handles data storage and retrieval through simple SQL
commands. JavaScript enhances user interaction and supports
asynchronous communication, making web applications feel
more responsive.
CSS for Styling

CSS styles HTML elements. With CSS3, developers can

create animations and responsive designs, enhancing user
experience across different devices.

Introduction to HTML5

HTML5 improves upon its predecessors, offering new

features like audio, video, and graphical elements without
third-party plugins, while evolving continuously to
incorporate new functionalities.

Apache Web Server

The book uses the Apache web server, which supports

various file types and enables dynamic content generation
with PHP.

Developing for Mobile Devices

Modern web development focuses on responsive design to

cater to diverse device types, utilizing technologies covered
in the book along with the jQuery Mobile library.

Open Source Advantages

The open-source nature of PHP, MySQL, JavaScript, and

Apache fosters community-driven development, allowing for
free usage and rapid bug fixes.

Conclusion

The harmonious integration of PHP, MySQL, JavaScript,

CSS, and HTML5 creates dynamic web content.
Understanding these technologies paves the way for further
exploration and practical application in web development.

Key Technology Questions

1. What four components are necessary for dynamic web

pages?
2. What does HTML stand for?
3. Why is SQL included in the name MySQL?
4. How do PHP and JavaScript differ, and why are both
used?
5. What does CSS represent?
6. Name three new features in HTML5.
7. How can you address bugs in open-source tools?
8. Why are frameworks like jQuery or React vital for modern
web development?
Refer to "Chapter 1 Answers" in Appendix A for responses.
Example
Key Point:The Importance of the Client-Server
Interaction
Example:Understanding the request/response cycle is
crucial as it shapes how users interact with web
applications, enabling you to create seamless and
responsive experiences.
 Chapter 3 Summary : 2. Setting Up a
Development Server
Section Summary

Introduction to Early This chapter allows Early Release readers to test new technologies while providing feedback to
Release Readers the author.

Importance of a Local development servers allow instant testing without uploading to remote servers, saving
Development Server time and enhancing security.

Web Browser It's essential to install multiple web browsers and access various mobile devices for optimal
Compatibility testing.

Understanding WAMP, WAMP, MAMP, and LAMP are packages that facilitate local web server setup, ideal for
MAMP, and LAMP development but not for production.

Installing AMPPS on Steps include downloading the installer, agreeing to terms, choosing an install location, and
Windows installing Microsoft Visual C++ Redistributable if needed.

Post-Installation Setup Familiarize with AMPPS documentation, and test the server by accessing localhost or [Link]
for configuration.

Document Root Access The document root is the directory for web documents, defaulting to C:\Program
Files\Ampps\www; verify by creating a "Hello World" file.

Conclusion AMPPS provides a robust platform for efficiently and securely developing and testing web
applications with easy access to tools.

Chapter 2: Setting Up a Development Server

Introduction to Early Release Readers

This chapter is part of an Early Release version of the book,

which includes unedited content to enable readers to
implement new technologies promptly. Feedback is
encouraged by contacting the author.
Importance of a Development Server

A local development server streamlines internet application

development by allowing instant testing of modifications
without the need to upload files to a remote server. This not
only saves time but also mitigates security risks associated
with testing on a public site. Setting up your own
development server is straightforward and beneficial for
writing and testing applications.

Web Browser Compatibility

For optimal testing, it’s essential to have multiple web

browsers (e.g., Microsoft Edge, Mozilla Firefox, Opera,
Safari, Google Chrome) installed. Access to various iOS and
Android devices is also recommended for mobile site testing.

Understanding WAMP, MAMP, and LAMP

WAMP (Windows), MAMP (Mac), and LAMP (Linux) are

Install
packages Bookey
that App toMySQL,
bundle Apache, UnlockandFull
PHPText andfor
together
Audio
easy installation of a web development server. These setups
are not suited for production environments but are effective
 Chapter 4 Summary : 3. Introduction to
PHP
Section Content

Overview Introduction to PHP as a server-side scripting language for dynamic web pages; guidance on embedding
PHP in HTML.

Setting Up PHP files use `.php` extension; PHP statements start with ``; can output HTML.
PHP

Using PHP PHP code snippets available for practice; involves comments, syntax rules, and variable declarations.

Comments Single line comments use `//`, multi-line comments use `/*` and `*/`.

Basic Syntax Commands end with a semicolon; variables start with a '$', can include letters, numbers, and underscores.
Rules

Variable Types Variables hold strings, numbers, or arrays; arrays can be one-dimensional or multi-dimensional.

Operators Includes arithmetic, assignment, comparison, and logical operations; arithmetic operators perform
calculations.

Variable Variables are denoted with `$`; loosely typed; constants defined with `define()` function.
Handling

Output `echo` and `print` are used to output to browser; strings concatenated with `.` operator.
Commands

Functions Encapsulate code for reuse; can accept parameters and return values.

Variable Scope Local variables confined to functions; global variables accessible throughout the script; static variables
retain values between calls.

Superglobals Accessible everywhere; includes `$_GET`, `$_POST`, and `$_SERVER` with environment info.

Best Practices Sanitize user input from superglobals; use comments and whitespace for readability.

Conclusion Chapter summary and questions to reinforce material; aims to provide a solid foundation in PHP.

Chapter 4 Summary: Introduction to PHP

Overview
This chapter introduces the fundamentals of PHP, a
server-side scripting language used to create dynamic web
pages. It emphasizes understanding the PHP code's output
and provides guidance on how to embed PHP within HTML
files.

Setting Up PHP

- PHP files should have a `.php` extension to be processed by

the PHP engine.
- A basic PHP statement starts with `<?php` and ends with
`?>`.
- Simple PHP code can output HTML and can be integrated
seamlessly with HTML documents.

Using PHP

- Example PHP code snippets are provided for practice and

downloading from a GitHub repository for ease of access.
- PHP code follows a specific structure, including comments,
syntax rules, and variable declarations.

Comments
- Single line comments use `//`.
- Multi-line comments are surrounded by `/*` and `*/`.

Basic Syntax Rules

- Each PHP command should end with a semicolon (`;`).

- Variables need to start with a `$` and can include letters,
numbers, and underscores, but no spaces.

Variable Types

- Variables can hold different types of values such as strings,

numbers, or arrays.
- Arrays can be one-dimensional or multi-dimensional,
allowing for the organization of data collections.

Operators

- PHP includes various operators for arithmetic, assignment,

comparison, and logical operations.
- Arithmetic operators (+, -, *, /) perform standard
calculations.
Variable Handling

- The `$` prefix denotes variables.

- Variables are loosely typed, meaning their type is
determined by context.
- Constants are defined using the `define()` function and
remain unchanged once set.

Output Commands

- The `echo` function outputs to the browser; `print` can also

be used with a return value.
- Strings are concatenated using the `.` operator.

Functions

- Functions encapsulate code for reuse and improve

readability.
- They can accept parameters and return values.

Variable Scope

- Local variables are confined to their function, whereas

global variables can be accessed throughout the script using
the `global` keyword.
- Static variables retain their value between function calls.

Superglobals

- Superglobals (such as `$_GET`, `$_POST`, and

`$_SERVER`) are accessible everywhere within the script
and contain information about the environment.

Best Practices

- Always sanitize user input from superglobals to prevent

security vulnerabilities.
- Use comments and whitespace effectively for code
readability.

Conclusion

The chapter concludes with a summary and questions to help

reinforce the material covered, setting the stage for more
advanced PHP programming topics. The main goal is to
provide learners with a solid foundation in PHP syntax,
usage, and principles for developing web applications.
Example
Key Point:Understanding the PHP code structure is
essential for creating dynamic web pages.
Example:Imagine you're building a dynamic web
application. As you integrate PHP into your HTML
files, you start each PHP code snippet with `<?php`, like
opening a door to a new realm of possibilities. There,
you declare your variables with a `$`, such as
`$username = 'John';`, which can hold data like names
or numbers. You swiftly output your results using
`echo`, combining it with HTML to display a greeting:
`echo 'Hello, ' . $username;`. This magical blend allows
users to interact with your site in real time, showcasing
the power of PHP that transforms static pages into an
engaging user experience.
Critical Thinking
Key Point:Understanding PHP Syntax and Structure
Critical Interpretation:The author emphasizes the
importance of grasping the foundational syntax and
structure of PHP as vital for developing dynamic web
applications. However, readers might consider
questioning whether focusing primarily on syntax can
overshadow deeper programming principles or best
practices that enhance efficiency and maintainability in
real-world projects. Research shows that while syntax is
essential, concepts like design patterns and code
optimization can greatly impact programming outcomes
(Source: "Clean Code" by Robert C. Martin).
Chapter 5 Summary : 4. Expressions and
Control Flow in PHP

Chapter 5: Expressions and Control Flow in PHP

Overview

This chapter delves into expressions, control flow, and how

to effectively utilize these concepts in PHP programming.

Expressions

-
Definition
: An expression is a combination of values, variables,
operators, and functions that results in a value.
-
Boolean Values
: PHP recognizes two Boolean constants: TRUE and FALSE.
TRUE is represented as 1, while FALSE is defined as NULL.
-
Examples
:
- Simple expressions like `20 > 9` yield TRUE, while `5 ==
6` yields FALSE.
- Literals and variables are fundamental in expressions,
where literals evaluate to themselves, and variables hold
values assigned to them.

Operators

-
Types of Operators
: PHP has various types of operators, including arithmetic,
string, logical, relational, and assignment operators.
-
Operator Precedence
: Operators have different precedence levels affecting how
expressions are evaluated. For instance, multiplication and
division are evaluated before addition and subtraction.
-
Associativity
: This dictates the order operators of the same precedence are
processed, primarily left-to-right.
Relational Operators

-
Equality and Comparison
: The equality operator `==` compares values and converts
types if necessary, while the identity operator `===` checks
for both value and type equality.
-
Logical Operators
: PHP supports AND, OR, XOR, and NOT operations to
generate Boolean outcomes in conditions.

Conditionals

-
If Statement
: This structure allows the code to execute based on whether
a condition is TRUE. Braces `{}` are advised for clarity.
-
Else Statement
: Provides an alternative action if the if condition evaluates to
FALSE.
-
Elseif Statement
: Allows for multiple conditions to be checked sequentially,
enabling more complex decision trees.
-
Switch Statement
: Offers a cleaner alternative for evaluating a single variable
against multiple possible values, using cases.

Looping

-
While Loops
: Execute a block of code while the specified condition holds
TRUE.
-
Do...While Loops
: Ensure the block of code runs at least once before checking
the condition.
-
For Loops
: More powerful, enabling initialization, condition checking,
and modification in a single line, making them useful for
iteration over a known range.
-
Breaking Out of Loops
: The `break` statement exits a loop, while the `continue`
statement skips to the next iteration.

Casting

-
Implicit vs. Explicit Casting
: PHP can automatically convert types (implicit), but
developers can also use explicit casting to enforce type
conversions. Common cast types include (int), (bool), and
(string).

Dynamic Linking

- PHP allows modular web development, splitting functions

into separate files for maintainability. This structure
enhances teamwork and individual module management.

Conclusion

The chapter provides foundational knowledge essential for

creating dynamic web applications with PHP, introducing
expressions, control structures, and best practices for robust
coding.
Example
Key Point:Understanding control flow is key to
dynamic programming.
Example:Imagine you are building an online quiz
application. As users select answers, the control flow in
your PHP code determines which feedback or next
question to show based on their choices. By mastering
`if`, `else`, and `switch` statements, you can create a
seamless user experience that responds intelligently to
user inputs. This not only enhances engagement but also
ensures that your application behaves logically, guiding
users through the quiz effectively.
Chapter 6 Summary : 5. PHP Functions
and Objects

Chapter 6 Summary: PHP Functions and Objects

Overview of PHP Functions

- PHP supports built-in functions that help manage data

storage, program flow, and expression evaluation.
- Functions allow for the reduction of repetitive code,
decrease syntax errors, and improve program efficiency.
- Functions are defined using the `function` keyword and can
accept parameters to enhance versatility.

Defining Functions

- The general syntax for defining a function includes the

`function` keyword, the name of the function, and optional
parameters.
- Function names are case-insensitive, and curly braces
define the block of code to execute.
Returning Values

- Functions can return single or multiple values, with the

latter achieved by returning an array.
- The concept of nesting functions is introduced to process
data sequentially.

Passing Arguments

- Arguments can be passed by value or by reference, with the

latter allowing a function to modify the original variable.
- The `global` keyword allows functions to access variables
defined in the broader scope.

Including Files

- The `include` and `require` statements allow for modular

code by including external files without copying code.
- `include_once` and `require_once` are safer alternatives to
prevent multiple inclusions of the same file.
Install Bookey App to Unlock Full Text and
Audio
Understanding PHP Objects
Chapter 7 Summary : 6. PHP Arrays

Chapter 6: PHP Arrays

Introduction to PHP Arrays

- Arrays are a fundamental feature of PHP, enabling the

management of complex data structures efficiently. They
allow access via numeric indexes or alphanumeric identifiers
and facilitate operations like sorting and modifying data.

Basic Access

- Arrays can be visualized as strings of beads, where each

bead represents a variable (number, string, or other arrays).
You can create single-dimensional or multi-dimensional
arrays.

Numerically Indexed Arrays

- PHP allows easy insertion of items into numeric arrays

using brackets. Example:
```php
$paper[] = "Copier";
```
- Code samples illustrate how items can be added and
retrieved using a loop for display.

Associative Arrays

- Associative arrays let you reference items by names rather

than numbers. This improves code readability and
maintainability. Example:
```php
$paper['copier'] = "Copier & Multipurpose";
```

Assignment Using the Array Keyword

- The `array` keyword enables compact assignment of

multiple items into arrays. Example:
```php
$p1 = array("Copier", "Inkjet");
```

The foreach...as Loop

- This loop simplifies iterating through array items without
needing to check array lengths or manage indexes, making it
user-friendly.

Multidimensional Arrays

- PHP supports creating arrays within arrays, allowing for

multidimensional data structures. Example:
```php
$products = array('paper' => array(...));
```

Using Array Functions

- Various built-in functions enhance array handling, such as:

- `is_array`: Check if a variable is an array.
- `count`: Count elements in an array.
- `sort`: Sort array elements.
- `explode`: Split a string into an array using a delimiter.
- `extract`: Turn array key/value pairs into variables, with
precautions against overwriting existing variables.
- `compact`: Create an array from variables.
- `reset` and `end`: Manage the position of the internal
pointer of arrays.

Conclusion

- By mastering PHP arrays, including different types and

associated functions, developers can significantly enhance
the complexity and efficiency of their applications.

Review Questions

1. Differentiate between numeric and associative arrays.

2. Explain the benefits of using the array keyword in PHP.
3. Compare foreach and each functions.
4. Describe how to create a multidimensional array.
5. Outline methods to determine the number of elements in
an array.
6. What is the function of explode in PHP?
7. How do you reset PHP’s internal pointer in an array?
This summary provides essential insights into the content of
Chapter 6 on PHP arrays as presented in Robin Nixon’s
book, encapsulating key learning outcomes and concepts for
readers.
Chapter 8 Summary : 7. Practical PHP

Chapter 8 Summary: Practical PHP

Overview

Chapter 8 builds upon previously discussed PHP concepts by

demonstrating practical applications important for web
development. This chapter focuses on handling strings,
formatting output, managing files, and working with date and
time in PHP.

Using `printf` for Output Formatting

- The `printf` function allows formatted output, supporting

various specifiers for displaying different data types (e.g.,
`%d` for decimal, `%f` for floating point).
- Customizing output precision and padding with spaces or
zeros is detailed, enabling tailored presentation.

String Padding
- Strings can be padded for alignment using various
formatting options. Justification (left/right) and custom
padding characters (like '#') are explored.

Storing Output with `sprintf`

- The `sprintf` function stores formatted data in a variable,

useful for later use in programs rather than immediate output.

Date and Time Functions

- PHP tracks time using Unix timestamps. Functions like

`time()` and `mktime()` allow for timestamp retrieval and
generation.
- The `date()` function formats timestamps into
human-readable dates, with a comprehensive set of format
specifiers provided.

File Handling in PHP

- File operations include checking existence, creating files,

writing, copying, moving, deleting, and updating files.
- Error handling is crucial; using functions like `file_exists()`
prevents issues when files are not found.
- The chapter covers various modes for file operations (e.g.,
reading, writing, appending) and emphasizes proper file
closure.

Reading and Updating Files

- Functions like `fgets` and `fread` are employed for reading

files, while `fwrite` is used for appending and modifying
content.
- File pointers can be manipulated with `fseek`, aiding in
precise file access.

File Locking

- Using `flock` ensures safe concurrent access by multiple

users, preventing data corruption during simultaneous write
operations.

Reading Entire Files

- The `file_get_contents()` function facilitates reading entire

files easily and is capable of retrieving content from remote
URLs.
File Uploading

- The chapter ends by explaining how to set up file uploads

through HTML forms, utilizing `multipart/form-data`
encoding to transfer files successfully to a server.
This chapter effectively emphasizes practical skills necessary
for proficient PHP use, providing numerous code examples
and explanations to facilitate understanding.
 Chapter 9 Summary : 8. Introduction to
MySQL
Section Content

Overview of MySQL MySQL is an open-source database management system known for its speed, efficiency, and free
availability, with over 10 million installations.

MySQL Basics

Database: Container for storing data.

Table: Structured sub-container with rows and columns.
Row: A single record in a table.
Column: A field within a row that holds data.

Accessing MySQL via

Command Line
Command Line Interface: Varies across OS.
Web Interface (phpMyAdmin): GUI for database management.

Basic Commands in
MySQL
Commands end with a semicolon.
Common commands: SHOW, CREATE, INSERT, DELETE, ALTER.

Creating and Modifying

Databases
Creating Users: Create users with limited privileges.
Creating Tables: Specify data types (e.g., VARCHAR, CHAR).
Indexes: Improve query performance.

Data Types

Character Types: VARCHAR, CHAR

Numeric Types: INT, FLOAT
Date and Time Types: DATETIME, DATE
BLOB Types: For binary data.

Adding Data Use the INSERT command, ensuring column names and data match.

Querying a MySQL
Database
SELECT Command: Retrieves data with filters (DISTINCT, WHERE).
LIKE Operator: For pattern matching.
LIMIT Clause: Restricts result count.
Section Content

Joining Tables Link multiple tables using JOIN operations for combined queries.

MySQL Functions Built-in functions enable calculations or alterations within SQL queries.

Using phpMyAdmin Graphical interface for easier database and table management.

Conclusion Covers fundamental MySQL topics; next chapter will focus on database design and advanced
SQL techniques.

Chapter 9: Introduction to MySQL

Overview of MySQL

MySQL is a widely used open-source database management

system. Its popularity, with over 10 million installations,
stems from its speed, efficiency, and free availability. It
supports structured data collection, allowing users to quickly
retrieve information.

MySQL Basics

-
Database:
A container for storing data.
-
Table:
 A structured sub-container within a database containing
rows and columns.
-
Row:
A single record in a table.
-
Column:
A field within a row that holds data.

Accessing MySQL via Command Line

Users can interact with MySQL through various methods,

including:
1.
Command Line Interface:
Instructions for access differ between Windows, macOS, and
Linux.
2.
Web Interface (phpMyAdmin):
A GUI for managing MySQL databases.

Install
Basic Bookey
Commands App to
in MySQL Unlock Full Text and
Audio
- MySQL commands conclude with a semicolon.
Chapter 10 Summary : 9. Mastering
MySQL

Chapter 10: Mastering MySQL

Introduction

This chapter emphasizes the importance of database design

for optimal MySQL performance, building on foundational
knowledge of relational databases and SQL from previous
chapters.

Database Design

-
Importance of Planning:
Proper design is crucial before creating a database. A good
starting point is listing potential queries you might run.
-
Guidelines for Table Structure:
Group tightly linked data, like books and their ISBNs in one
table, while separating loosely related categories, like books
and customers.

Primary Keys

- Utilize unique identifiers (primary keys) for authors, books,

and customers, ensuring each table focuses on a main object
of interest.

Normalization

- Normalization is the process of organizing data to minimize

redundancy, implemented through several forms:
-
First Normal Form (1NF):
Eliminate repeating columns and ensure all data is atomic
with a primary key.
-
Second Normal Form (2NF):
Remove redundancy by splitting tables further if columns
have repeating data across rows.
-
Third Normal Form (3NF):
Organize non-key dependent columns into separate tables.
Relationships in MySQL

-
Types of Relationships:

-
One-to-One:
Rare, typically in specific data associations (e.g., each state
has a unique abbreviation).
-
One-to-Many:
Common structure where one record in one table relates to
multiple records in another (e.g., customers to their
purchases).
-
Many-to-Many:
Requires a third table to link two other tables, allowing
multiple associations.

Database Transactions

- MySQL supports transactions to ensure data integrity,

allowing multiple queries to execute successfully in sequence
or rollback if an error occurs.
- Use `BEGIN`, `COMMIT`, and `ROLLBACK` commands
to manage transactions effectively.

Using EXPLAIN

- The `EXPLAIN` command in MySQL provides insights

into query performance and optimization opportunities.

Backing Up and Restoring Data

- Regular backups are essential, employing `mysqldump` for

database backup. Supports various formats including CSV.
- Restoring databases can be done using commands that call
backup files.

Conclusion

By mastering these principles—database design,

normalization, handling relationships, supporting
transactions, and managing backups—users will be
well-prepared to efficiently utilize PHP with MySQL in
future applications.
Critical Thinking
Key Point:Database Design and Normalization are
Crucial for MySQL Performance.
Critical Interpretation:The chapter highlights the
essential role of database design and normalization
techniques in optimizing MySQL performance, aiming
to reduce redundancy and enhance query efficiency.
However, it is critical to challenge the prescriptive
nature of these guidelines, as some assert that
over-normalization can lead to complex queries and
hinder performance (Hernandez, 1997). The author's
insistence on strict adherence to normalization standards
may not universally apply; different applications may
require tailored approaches for optimal outcomes.
Therefore, while the chapter offers valuable insights,
readers should remain open to alternative database
design philosophies that may better suit their unique
requirements.
Chapter 11 Summary : 10. What’s new
in PHP 8 and MySQL 8

Chapter 11 Summary: What’s New in PHP 8 and

MySQL 8

Overview

PHP and MySQL have reached their 8th versions,

establishing themselves as mature technologies. PHP
dominates with 79% of websites using it, while MySQL
remains the leading database with 52% market share. This
chapter highlights new features and improvements
introduced in PHP 8 and MySQL 8.

PHP 8 Features

-
Named Parameters
: Allow specifying parameter names in functions, enhancing
code clarity.
-
Attributes
: Enable inclusion of metadata in classes without impacting
runtime performance.
-
Constructor Properties
: Permit property declaration in class constructors, reducing
boilerplate code.
-
Just-In-Time (JIT) Compilation
: Boosts performance for CPU-intensive applications, though
it's disabled by default.
-
Union Types
: Allow specifying multiple types for function parameters.
-
Null-safe Operator
: Avoids errors when accessing properties of potentially null
objects.
-
Match Expressions
: Simplified alternative to switch statements, supporting
type-safe comparisons and implicit returns.
New Functions

-
str_contains
: Checks if one string is contained within another, improving
clarity over strpos.
-
str_starts_with
and
str_ends_with
: Functions to check string beginnings and endings,
respectively.
-
fdiv
: Handles division safely, avoiding division by zero errors.
-
get_resource_id
: Retrieves resource IDs safely with type checking.
-
get_debug_type
and
preg_last_error_msg
: Provide detailed information on variable types and friendly
error messaging for preg_ functions.

MySQL 8 Features

-
SQL Enhancements
: Introduces window functions and recursive Common Table
Expressions, among others.
-
JSON Handling
: Improved JSON functions and sorting for better data
manipulation.
-
Geography Support
: Enhanced GIS functions for spatial calculations.
-
Reliability Improvements
: Streams metadata through InnoDB engine, ensuring
transactional consistency.
-
Performance Enhancements
: Substantial speed improvements and better scalability for
heavy workloads.
-
Management Interface
: New commands for index visibility and remote server
administration.
-
Security Upgrades
: Enhanced authentication plugins, encrypted logs, and a
password policy for better security.

Conclusion

The updates in PHP 8 and MySQL 8 offer significant

advancements that enhance functionality, performance, and
ease of use for modern web development. The chapter serves
as an introduction to these exciting features, encouraging
further exploration.
Critical Thinking
Key Point:The advancements in PHP 8 and MySQL
8.
Critical Interpretation:While the author argues that
features like JIT compilation and improved JSON
handling enhance web development, it’s essential to
critically evaluate whether these features translate to
real-world productivity gains. Not every developer may
benefit from these enhancements, particularly in smaller
projects or legacy systems, where the transition costs
and potential compatibility issues with new
functionalities could outweigh the benefits. Research,
such as findings presented in 'The Pragmatic
Programmer' by Hunt and Thomas and various
performance comparison studies, may illustrate that the
real impact of these updates can significantly vary
depending on specific use cases and coding practices.
Chapter 12 Summary : A. Solutions to
the Chapter Questions

Appendix A: Solutions to the Chapter Questions

Chapter 1 Answers

1. Components of a web stack: web server (Apache),

server-side scripting language (PHP), database (MySQL),
client-side scripting language (JavaScript).
2. HTML: structure of web pages including text and markup.
3. MySQL uses SQL for commands, the standard
communication language.
4. PHP runs server-side; JavaScript runs client-side, each
with its specific capabilities.
5. CSS: layout and styling rules for HTML elements.
6. Interesting HTML5 elements include <audio>, <video>,
and <canvas>.
7. Debugging for open-source software relies on community
contributions.
8. Frameworks help developers focus on core functionality,
ensuring compatibility across platforms and devices.

Chapter 2 Answers

1. WAMP (Windows, Apache, MySQL, PHP), MAMP

(Mac), LAMP (Linux) describe environments for hosting
web pages.
2. [Link] and [Link] refer to the local server.
3. FTP (File Transfer Protocol) transfers files between client
and server.
4. Frequent updates via FTP can extend development time.
5. Specialized editors can detect code issues early.

Chapter 3 Answers

1. PHP code is enclosed in `<?php...?>`.

2. Comments can be single-line (`//`) or multi-line (`/*...*/`).
3. Statements end with a semicolon.
4. Variables start with `$`, except constants.
5. Variables hold various data types.
6. `$variable = 1` sets a variable, `$variable == 1` checks its
Install Bookey App to Unlock Full Text and
value.
7. Hyphens are not allowedAudio
in variable names.
8. Variable names are case-sensitive.
Best Quotes from Learning PHP,
MySQL & JavaScript by Robin Nixon
with Page Numbers
View on Bookey Website and Generate Beautiful Quote Images

Chapter 1 | Quotes From Pages 3-11

[Link] PHP, MySQL & JavaScript is an
essential step for anyone looking to create effective
and dynamic websites.
[Link] combination of PHP and MySQL is the most
convenient approach to dynamic, database-driven web
design.
[Link] ready to learn the fundamentals behind responsive
web design will obtain a thorough grounding in the core
technologies of PHP, MySQL, JavaScript, CSS, and
HTML5.
[Link] an understanding of all three of these core
technologies, you will then learn how to make
behind-the-scenes Ajax calls and turn your websites into
highly dynamic environments.
Chapter 2 | Quotes From Pages 12-34
[Link] real beauty of PHP, MySQL, JavaScript
(sometimes aided by React or other frameworks),
CSS, and HTML5 is the wonderful way in which
they all work together to produce dynamic web
content.
[Link]’s a never-ending cycle of development, though, and more
functionality is sure to be built into it over time.
[Link] you need to modify HTML on the fly, process a
credit card, add user details to a database, or fetch
information from a third-party website, you can do it all
from within the same PHP files in which the HTML itself
resides.
[Link] source means that they have been developed in the
community by teams of programmers writing the features
they themselves want and need, with the original code
available for all to see and change.
[Link] asynchronous communication, the entire form
would have to be submitted to the server, which would then
 send back HTML, highlighting any mistakes.
Chapter 3 | Quotes From Pages 35-60
[Link] you have your own development server,
you’ll wonder how you ever managed without one.
[Link] if you already have all the components installed and
integrated with one another, they should work with the
examples in this book.
[Link], for developing and testing websites and
applications, one of these installations should be entirely
sufficient.
[Link] you choose not to go the WAMP/MAMP/LAMP route
for building your own development system, you should
know that downloading and integrating the various parts
yourself can be very time-consuming and may require a lot
of research.
[Link] proceeding, I recommend you acquaint yourself
with the AMPPS documentation.
Chapter 4 | Quotes From Pages 61-102
[Link] PHP program is responsible for passing back
a clean file suitable for display in a web browser.
[Link]’s not too difficult, but I recommend that you work your
way through it carefully, as it sets the foundation for
everything else in this book.
3.A common error is to use /* and */ to comment out a large
section of code that already contains a commented-out
section that uses those characters.
[Link] are little (or big) matchboxes!
[Link] is a very loosely typed language.
[Link] use of whitespace is generally encouraged (along
with comprehensive commenting) to help you understand
your code when you come back to it.
[Link]'s essential to sanitize superglobals before using them.
[Link] not only shorten your program and make it more
readable, but also add extra functionality.
[Link] create a multiline echo or assignment?
[Link] only place for the semicolon is after the terminating
 _END tag, although it is safe to use semicolons within the
block as normal text characters.
Chapter 5 | Quotes From Pages -147
[Link] expression is a combination of values,
variables, operators, and functions that results in a
value.
2.A basic Boolean value can be either TRUE or FALSE.
[Link] in doubt, place braces around your if statements.
[Link] alter program flow. They enable you to ask
questions about certain things and respond to the answers
you get in different ways.
[Link] can override the default operator precedence by
inserting your own parentheses and forcing whatever order
you want.
[Link] of the more popular PHP-driven applications on the
web today is the blogging platform WordPress.
Chapter 6 | Quotes From Pages 148-184
1.A function is a set of statements that performs a
particular function and—optionally—returns a
 value.
[Link] have many advantages over contiguous, inline
code.
[Link] object incorporates one or more functions, and the data
they use, into a single structure called a class.
[Link], or writing a class in such a way that only its
methods can be used to manipulate its properties, makes
debugging easy.
[Link] original class is now called the superclass, and the new
one is the subclass (or derived class).
[Link] can use the parent operator to access the parent’s
method if you write a method in a subclass with the same
name as one in its parent class.
Chapter 7 | Quotes From Pages -205
[Link] are an example of what has made PHP so
popular.
[Link] them, you can reference the items in an array by
name rather than by number.
[Link] foreach...as loop allows you to step through all the
items in an array, one at a time, and do something with
them.
[Link] can create arrays of more than one dimension.
5....PHP offers many more [functions], which I’ll get to
shortly.
6....you can have PHP do the job automatically:
extract($_GET);
Chapter 8 | Quotes From Pages -241
1.A more practical example of printf sets colors in
HTML using decimal values.
[Link] the second parameter to the fopen call. It is simply
the character w, which tells the function to open the file for
writing.
[Link] you want your programs to be both efficient and to avoid
corrupting files, you must also use the file-locking flock
function.
[Link] introduced the DateTime class in version 5.2 to
overcome this issue, but it will work only on 64-bit
architecture.
[Link] you wish to create a timestamp for a given date, you can
use the mktime function.
Chapter 9 | Quotes From Pages -302
[Link] is probably the most popular database
management system for web servers... it’s also
extremely powerful and exceptionally fast—it can
run on even the most basic of hardware, and it
hardly puts a dent in system resources.
2.A database is a structured collection of records or data
stored in a computer system and organized in such a way
that it can be quickly searched and information can be
rapidly retrieved.
[Link] commands and keywords are case-insensitive.
 CREATE, create, and CrEaTe all mean the same thing.
[Link] can get more complicated too, because you can
combine multiple columns in one index. And even when
you’ve decided that, you still have the option of reducing
index size by limiting the amount of each column to be
indexed.
[Link] MATCH...AGAINST construct can be used on
columns that have been given a FULLTEXT index...
FULLTEXT indexes are case-insensitive, so it makes no
difference what case is used in your queries.
Chapter 10 | Quotes From Pages -338
[Link]’s very important that you design a database
correctly before you start to create it; otherwise,
you are almost certainly going to have to go back
and change it by splitting up some tables, merging
others, and moving various columns about in
order to achieve sensible relationships.
[Link] into account those simple rules of thumb, we can
guess we’ll need at least three tables to accommodate all
these queries: Authors, Books, Customers.
[Link] process of separating your data into tables and creating
primary keys is called normalization.
4.A unique key is often used as a primary key in one table,
and as a foreign key to link rows in that table to rows in
another table.
[Link] you have a database that complies with both the First
and Second Normal Forms, it is in pretty good shape and
you might not have to modify it any further.
[Link] you are absolutely certain that the name and address of a
 customer is all that you will ever require, you probably will
want to leave out this final normalization stage.
[Link] you wish to know the authors of these books, you
could also use the ISBNs you just looked up on Table 9-3,
the Authors table, and you would see that ISBN
0596527403, Dynamic HTML, was written by Danny
Goodman...
[Link] golden rule to backing up is to do so as often as you
find practical.
Chapter 11 | Quotes From Pages 339-353
[Link] 8 marks a major update and a huge
milestone, bringing a number of new features to
type, system, syntax, error handling, strings,
object-oriented programming, and more.
[Link] parameters... substantially increase code clarity.
[Link] PHP 8 you can now declare class properties right
from the class constructor, saving a great deal of boilerplate
coding.
[Link]-In-Time (JIT) Compilation... provides a performance
 boost to CPU-heavy applications.
[Link] 8 also brings GIS or Geography Support... can
now calculate the distance between two points on the
Earth’s surface.
[Link] MySQL 8 there is now only a single data dictionary,
guaranteeing that any DDL statement will either be
executed fully, or not at all.
Chapter 12 | Quotes From Pages -412
[Link] associative arrays used to pass submitted form
data to PHP are $_GET for the GET method and
$_POST for the POST method.
[Link] can encapsulate a form element and supporting text or
graphics, making the entire unit selectable with a mouse
click, by using the <label> and </label> tags.
[Link] ensure that a form is not submitted with missing data,
you can apply the required attribute to essential inputs.
[Link] can help users complete fields with data they may have
submitted elsewhere by using the autocomplete attribute,
which prompts the user with possible values.
Learning PHP, MySQL & JavaScript
Questions
View on Bookey Website

Chapter 1 | Learning PHP, MySQL JavaScript|

Q&A
[Link]
What makes PHP and MySQL a preferred choice for web
development?
Answer:PHP and MySQL offer a convenient and
accessible approach to dynamic, database-driven
web design. They are open-source, making them free
to implement, which has contributed to their
popularity over integrated frameworks that can be
more complex to learn. These technologies are
essential for any developer working on Unix/Linux
or Windows/Apache platforms.

[Link]
Who is the target audience for 'Learning PHP, MySQL,
and JavaScript'?
Answer:The book is aimed at a wide range of learners,
including webmasters, graphic designers seeking to enhance
their skills, high school and college students, recent
graduates, and self-taught individuals eager to understand the
fundamentals of responsive web design using core
technologies like PHP, MySQL, JavaScript, CSS, and
HTML5.

[Link]
What prior knowledge is assumed for readers of this
book?
Answer:The book assumes that readers have a basic
understanding of HTML and can create simple static
websites. However, no prior knowledge of PHP, MySQL,
JavaScript, CSS, or HTML5 is required, although having
some familiarity will allow for quicker progress.

[Link]
How is the book organized to facilitate learning?
Answer:The book begins by introducing all core technologies
and guides readers through their installation on a web
development server. It sequentially covers PHP first, then
progresses to MySQL, followed by a combination of PHP
and MySQL for dynamic web pages. Subsequently,
JavaScript is explored, along with frameworks like React,
CSS for styling, and HTML5 for interactivity, culminating in
creating a fully functional social networking website.

[Link]
What resources does the book suggest for further
learning after mastering the basics?
Answer:After learning PHP, MySQL, JavaScript, CSS, and
HTML5, readers are encouraged to explore other O'Reilly
reference books such as 'Dynamic HTML: The Definitive
Reference', 'PHP in a Nutshell', 'MySQL in a Nutshell',
'JavaScript: The Definitive Guide', 'CSS: The Definitive
Guide', and 'HTML5: The Missing Manual' to further
enhance their skills.

[Link]
What typographical conventions are used in this book?
Answer:Different typographical conventions indicate specific
types of content: plain text for menu titles and options, italic
for terms and URLs, constant width for commands and code
elements, and constant width bold for program output.

[Link]
What should readers know about using code examples
from the book?
Answer:Readers can use available example code in their
programs and documentation without needing permission
unless they plan to reproduce significant portions. Citing the
book does not require permission, but permission is
necessary for distributing examples.

[Link]
How can readers contact O'Reilly Media with comments
or questions concerning the book?
Answer:Comments and questions can be addressed to
O'Reilly Media via their physical address in Sebastopol,
California, or through their customer service phone numbers.
Additionally, readers can reach out via email at specified
addresses for technical inquiries or concerns.

[Link]
What unique learning opportunities does O'Reilly Online
Learning provide?
Answer:O'Reilly Online Learning offers on-demand access
to live training courses, in-depth learning paths, interactive
coding environments, and a vast collection of text and video
resources from O'Reilly and over 200 other publishers.

[Link]
What acknowledgment does the author make in the
introduction?
Answer:The author expresses gratitude to various editorial
and production staff as well as individuals who contributed
through technical reviews, production oversight, and
suggestions that helped shape the new edition of the book.
Chapter 2 | 1. Introduction to Dynamic Web
Content| Q&A
[Link]
What four components (at the minimum) are needed to
create a fully dynamic web page?
Answer:The four essential components for creating
a fully dynamic web page are PHP (for server-side
scripting), MySQL (for managing the database),
JavaScript (for client-side interactivity), and HTML
(for the structure of the web page). Together, they
allow for generating dynamic content by processing
user data, retrieving information from databases,
and presenting it in a user-friendly format.

[Link]
What does HTML stand for?
Answer:HTML stands for Hypertext Markup Language.

[Link]
Why does the name MySQL contain the letters SQL?
Answer:The name MySQL contains the letters SQL because
it stands for Structured Query Language, which is the
language used to interact with the MySQL database. The
inclusion signifies its primary function of managing data
through SQL.

[Link]
PHP and JavaScript are both programming languages
that generate dynamic results for web pages. What is
their main difference, and why would you use both of
them?
Answer:The main difference between PHP and JavaScript is
that PHP is a server-side scripting language while JavaScript
is a client-side scripting language. PHP processes data on the
server before sending HTML to the user's browser, while
JavaScript runs in the user's browser, enabling real-time
interaction with the web page. Using both allows developers
to handle tasks efficiently - PHP for data management and
processing, and JavaScript for user interaction and dynamic
content updates.

[Link]
What does CSS stand for?
Answer:CSS stands for Cascading Style Sheets.

[Link]
List three major new elements introduced in HTML5.
Answer:Three major new elements introduced in HTML5 are
`<audio>` for embedding sound, `<video>` for embedding
video, and `<canvas>` for creating dynamic graphics directly
in the web page.

[Link]
If you encounter a bug (which is rare) in one of the open
source tools, how do you think you could get it fixed?
Answer:If you encounter a bug in an open-source tool, you
could report it to the community through their issue tracker
or forums. Depending on your skills, you might also
contribute to fixing it by reviewing the code, suggesting a
solution, or even submitting a pull request with your fix.

[Link]
Why is a framework such as jQuery or React so
important for developing modern websites and web apps?
Answer:Frameworks like jQuery and React are important for
developing modern websites and web apps because they
provide pre-built functions and libraries that simplify
complex tasks, improve cross-browser compatibility, and
enhance performance. They also support asynchronous
communication, allowing developers to create fast,
responsive applications without needing to reload the entire
page or script from scratch.
Chapter 3 | 2. Setting Up a Development Server|
Q&A
[Link]
Why is it important to have a development server for web
development?
Answer:Having a development server allows for
immediate testing and iteration of changes made to
your web applications without the need to upload
modifications to a remote server, which can
significantly slow down the development process.
Additionally, it provides a safe environment to
troubleshoot errors and security concerns before
making an application public.

[Link]
What are WAMP, MAMP, and LAMP, and why are they
useful?
Answer:WAMP, MAMP, and LAMP are packages designed
to install and configure the required software for web
development quickly and easily. They each correspond to
different operating systems (Windows, Mac, and Linux)
along with Apache (web server), MySQL (database), and
PHP (programming language). These packages simplify the
setup process, allowing developers to focus on building their
applications rather than dealing with complex installations.

[Link]
What should I check after installing AMPPS to ensure
everything is working correctly?
Answer:After installing AMPPS, verify that it is set up
correctly by entering 'localhost' or '[Link]' into your
browser. You should see the introduction screen of AMPPS.
Then, check the document root by going to the same address
and ensuring you can access it without any issues.

[Link]
How can I create a simple test file to check my AMPPS
installation?
Answer:To create a test file, open a text editor (like Notepad)
and input the following HTML code:
<!DOCTYPE html>
<html lang='en'>
<head>
<title>A quick test</title>
</head>
<body>
Hello World!
</body>
</html>
Save the file in the document root directory of AMPPS,
typically found at 'C:\Program Files\Ampps\www'. Then,
access it via your browser to ensure it displays as expected.

[Link]
What is the document root and why is it significant?
Answer:The document root is the directory from which the
web server serves files. It is where web documents—such as
HTML files—are stored and accessed through a browser.
Understanding the document root is crucial for organizing
your web files and ensuring they are correctly served by the
web server.

[Link]
What precautions should be taken when using a local
development server?
Answer:While local development servers like AMPPS
provide convenience, they lack the security configurations of
production servers. Therefore, it's important not to expose
sensitive data or unfinished applications publicly until they
are properly secured.

[Link]
How does having multiple browsers and devices affect
web development?
Answer:Testing across multiple web browsers and devices is
essential to ensure that your web applications are functional
and visually appealing across various platforms. Each
browser may render content differently, and optimizing for
mobile devices ensures a broader audience engagement.

[Link]
Why is it recommended to download the latest stable
release of software like AMPPS?
Answer:Downloading the latest stable release ensures you
have the most updated features, security vulnerabilities
resolved, and bug fixes, which are essential for a smooth
development experience.

[Link]
What should I do if I encounter an issue with AMPPS
installation?
Answer:If you face issues with your AMPPS installation,
consult the documentation provided with AMPPS, and if
necessary, use the Support link available in the AMPPS
control window to open a trouble ticket for further assistance.
Chapter 4 | 3. Introduction to PHP| Q&A
[Link]
What tag is used to invoke PHP to start interpreting
program code? And what is the short form of the tag?
Answer:The tag used to invoke PHP is <?php and
the short form of the tag is <?.

[Link]
What are the two types of comment tags?
Answer:The two types of comment tags are single-line
comments (// comment) and multi-line comments (/*
comment */).

[Link]
Which character must be placed at the end of every PHP
statement?
Answer:A semicolon (;) must be placed at the end of every
PHP statement.

[Link]
Which symbol is used to preface all PHP variables?
Answer:The dollar sign ($) is used to preface all PHP
variables.
[Link]
What can a variable store?
Answer:A variable can store different types of data,
including strings, numbers, and arrays.

[Link]
What is the difference between $variable = 1 and
$variable == 1?
Answer:$variable = 1 assigns the value 1 to the variable,
while $variable == 1 checks if the value of $variable is equal
to 1.

[Link]
Why do you suppose that an underscore is allowed in
variable names ($current_user), whereas hyphens are not
($current-user)?
Answer:An underscore is allowed in variable names because
it is recognized as a valid character in variable naming, while
a hyphen is interpreted as a minus sign and cannot be used.

[Link]
Are variable names case-sensitive?
Answer:Yes, variable names in PHP are case-sensitive.
[Link]
Can you use spaces in variable names?
Answer:No, spaces cannot be used in variable names.

[Link]
How do you convert one variable type to another (say, a
string to a number)?
Answer:PHP automatically converts variable types based on
context, but explicit type casting can be done using functions
like (int)$variable to convert to an integer.

[Link]
What is the difference between ++$j and $j++?
Answer:++$j increments the value of $j before it is used,
while $j++ increments it after its current value has been used.

[Link]
Are the operators && and and interchangeable?
Answer:Yes, && and and are interchangeable, but && has
higher precedence than and.

[Link]
How can you create a multiline echo or assignment?
Answer:A multiline echo can be created by enclosing the text
within double quotes or by using heredoc syntax (<<<).

[Link]
Can you redefine a constant?
Answer:No, a constant cannot be redefined once it is set.

[Link]
How do you escape a quotation mark?
Answer:A quotation mark can be escaped by placing a
backslash (") before it.

[Link]
What is the difference between the echo and print
commands?
Answer:echo is a language construct and does not return a
value, while print is a function that returns 1.

[Link]
What is the purpose of functions?
Answer:Functions are used to encapsulate code for specific
tasks, enabling code reuse and organization.

[Link]
How can you make a variable accessible to all parts of a
PHP program?
Answer:By declaring the variable as global using the global
keyword.

[Link]
If you generate data within a function, what are a couple
of ways to convey the data to the rest of the program?
Answer:You can return the data from the function or pass it
as an argument to another function.

[Link]
What is the result of combining a string with a number?
Answer:PHP will automatically convert the number to a
string and concatenate them.
Chapter 5 | 4. Expressions and Control Flow in
PHP| Q&A
[Link]
What actual underlying values are represented by TRUE
and FALSE?
Answer:In PHP, TRUE is represented as '1', while
FALSE is represented as NULL. This means that
any condition evaluating to TRUE results in a
numerical output of 1, whereas FALSE outputs
nothing as it equates to NULL.

[Link]
What are the simplest two forms of expressions?
Answer:The simplest two forms of expressions are literals
and variables. A literal represents a fixed value such as a
number (e.g., 73) or a string (e.g., 'Hello'), while a variable
evaluates to the value assigned to it (e.g., $myname =
'Brian').

[Link]
What is the difference between unary, binary, and
ternary operators?
Answer:Unary operators require one operand, such as
increment (++) or logical NOT (!). Binary operators, which
are the most common, involve two operands like addition (+)
or comparison (>). Ternary operators take three operands,
allowing for a shorthand conditional operation in the form of
'condition ? trueValue : falseValue'.

[Link]
What is the best way to force your own operator
precedence?
Answer:To force your own operator precedence, it is best to
use parentheses in your expressions. This method ensures
that certain operations are calculated first, regardless of the
built-in precedence.

[Link]
What is meant by operator associativity?
Answer:Operator associativity determines the order in which
operators of the same precedence are processed in an
expression. For example, left-associative operators are
evaluated from left to right, while right-associative operators
are evaluated from right to left.

[Link]
When would you use the === (identity) operator?
Answer:You would use the === (identity) operator when you
want to compare two values and ensure that they are both
equal in value and type, preventing PHP from performing
type juggling that might occur with the == operator.

[Link]
Name the three conditional statement types.
Answer:The three conditional statement types are the 'if'
statement, the 'switch' statement, and the ternary operator
(?:). Each serves to determine the flow of execution based on
specified conditions.

[Link]
What command can you use to skip the current iteration
of a loop and move on to the next one?
Answer:The 'continue' command can be used to skip the
remainder of the current iteration in a loop and proceed
directly to the next iteration.

[Link]
Why is a for loop more powerful than a while loop?
Answer:A for loop is more powerful than a while loop
because it combines initialization, conditional checking, and
incrementing all in one statement, making the code cleaner
and more succinct, especially for iterating over a sequence.

[Link]
How do if and while statements interpret conditional
expressions of different data types?
Answer:If and while statements in PHP interpret conditional
expressions by evaluating the truthiness of the expression
based on its type. Non-zero numbers, non-empty strings, and
TRUE evaluate to TRUE, while zero, empty strings, NULL,
and FALSE evaluate to FALSE.
Chapter 6 | 5. PHP Functions and Objects| Q&A
[Link]
What is the main benefit of using a function?
Answer:The main benefit of using a function is code
reusability. Instead of rewriting the same block of
code multiple times, you can define it once as a
function and call it whenever needed, which reduces
errors and makes the code cleaner and easier to
maintain.

[Link]
How many values can a function return?
Answer:A function can return a single value, but it can also
return multiple values packaged in an array, allowing for
flexibility in data handling.

[Link]
What is the difference between accessing a variable by
name and by reference?
Answer:Accessing a variable by name means using its direct
value, whereas accessing by reference allows a function to
modify the variable's value directly in the calling scope, as if
the function is working with the original variable itself.

[Link]
What is the meaning of scope in PHP?
Answer:Scope in PHP refers to the visibility and lifetime of
variables within different parts of your code. Variables can
have global scope (accessible anywhere), local scope
(restricted to the function they are defined in), or static scope
(retains value across function calls but only accessible within
the function).

[Link]
How can you incorporate one PHP file within another?
Answer:You can incorporate one PHP file within another
using the 'include' or 'require' statements. 'include' will
include the file but continue executing even if the file is not
found, whereas 'require' stops script execution if the file is
not available. Use 'include_once' or 'require_once' to avoid
inclusion of the same file multiple times.

[Link]
How is an object different from a function?
Answer:An object is an instance of a class that encapsulates
data (properties) and behavior (methods) into a single
structure, whereas a function is a block of code designed to
perform a specific task and can return a value. Objects
represent entities with state and behavior, while functions
represent reusable actions.

[Link]
How do you create a new object in PHP?
Answer:To create a new object in PHP, you use the 'new'
keyword followed by the class name, like this: $object = new
ClassName;.

[Link]
What syntax would you use to create a subclass from an
existing one?
Answer:To create a subclass from an existing class in PHP,
you use the 'extends' keyword, like this: class SubclassName
extends ParentClassName {}.

[Link]
How can you cause an object to be initialized when you
create it?
Answer:To initialize an object during creation, you define a
special method named '__construct' within the class, which
will be automatically called when an object is instantiated.

[Link]
Why is it a good idea to explicitly declare properties
within a class?
Answer:Explicitly declaring properties within a class
enhances code readability and maintainability. It helps avoid
bugs that can arise from implicitly declared properties,
ensuring that other developers (or yourself in the future) can
easily understand the intended structure and components of
the class.
Chapter 7 | 6. PHP Arrays| Q&A
[Link]
What is the distinction between numeric and associative
arrays in PHP?
Answer:Numeric arrays use numeric indices to
access their elements, while associative arrays use
named keys (strings) as indices. For example, in an
associative array, an item can be accessed by a
descriptive name like 'inkjet' instead of a number.

[Link]
What are the advantages of using the array keyword for
array assignment?
Answer:Using the array keyword allows for more concise
and readable code when initializing an array. It enables you
to assign multiple items at once, making the array creation
quicker and easier to maintain.

[Link]
What differentiates the foreach loop from the deprecated
each function in PHP?
Answer:The foreach loop is designed specifically for
iterating over arrays and handles the array elements in a
simple, readable manner without needing to manage a
separate internal pointer, while the each function, which has
been deprecated, required manual handling of the internal
array position.

[Link]
How can you construct a multidimensional array in PHP?
Answer:A multidimensional array can be created by nesting
arrays within another array. For example, you can create an
associative array where each entry itself contains other
arrays, allowing for multiple dimensions to be represented,
like storing various product categories.

[Link]
What method can be employed to determine the number
of elements in a specific array?
Answer:You can use the count() function to determine the
number of elements in an array. For multidimensional arrays,
you can pass a second parameter to count all elements
recursively.
[Link]
What is the usage of the explode function in PHP?
Answer:The explode function is utilized to split a string into
an array based on a specified delimiter. This can be useful for
breaking down sentences or structured text into manageable
pieces.

[Link]
How can you reset PHP’s internal pointer back to the
first element of an array?
Answer:You can reset PHP's internal pointer to the first
element of an array by using the reset() function. This is
particularly useful when you need to iterate through the array
again from the start.
Chapter 8 | 7. Practical PHP| Q&A
[Link]
What is the significance of using the `printf` function in
PHP?
Answer:The `printf` function in PHP allows for
advanced formatting of output, enabling developers
to control how data is presented in a concise and
clear manner. For example, you can format numbers
in different bases (like binary or hexadecimal) or
control the number of decimal places displayed for
currency. This level of control ensures that data
appears exactly as intended in web applications,
improving user experience.

[Link]
How does one handle date and time in PHP?
Answer:PHP manages date and time using Unix timestamps,
which represent the number of seconds since January 1,
1970. Functions like `time()` provide the current timestamp,
while `mktime()` can create a timestamp for specific date and
time values. The `date()` function is then used to format these
timestamps in various human-readable forms, allowing for
flexible date and time manipulation in applications.

[Link]
What are the key steps involved in handling files with
PHP?
Answer:Handling files in PHP involves several key steps: 1)
Open the file using `fopen()`, ensuring the correct mode
(read/write) is specified. 2) Perform operations like reading
or writing using `fread()` or `fwrite()`. 3) Close the file with
`fclose()` to free system resources. Safeguarding applications
against issues like file corruption with file locking using
`flock()` is also essential.

[Link]
Why is it important to check if a file exists before
performing operations on it?
Answer:Checking if a file exists using `file_exists()` prevents
errors that could arise when trying to read from or write to a
non-existent file. It helps program stability, ensuring that
operations are correctly performed and that users won’t
encounter confusing error messages.

[Link]
Can you explain how file uploading works in PHP?
Answer:File uploading in PHP is facilitated by using forms
with an encoding type of `multipart/form-data`. When users
select a file to upload and submit the form, PHP handles the
file transfer automatically. The uploaded file's details can be
accessed with the `$_FILES` superglobal, and you can move
the file to a designated directory using
`move_uploaded_file()`. This process simplifies handling
user-uploaded content on a server.

[Link]
How can date validation be performed in PHP?
Answer:To validate user-submitted dates in PHP, the
`checkdate()` function can be employed. This function
checks if the month, day, and year provided correspond to a
valid date (for instance, it correctly identifies that September
31 is invalid). This is crucial for maintaining data integrity
and avoiding errors in applications that rely on accurate date
data.

[Link]
What is the purpose of file locking in PHP?
Answer:File locking in PHP using `flock()` is essential for
managing concurrent access to files. When multiple users or
processes might attempt to read from or write to the same file
simultaneously, implementing a lock prevents data
corruption. It ensures that files are accessed one at a time,
thus preserving the integrity of the data being handled.

[Link]
How does one format output with precision using
`printf`?
Answer:Using `printf`, you can specify precision for
floating-point numbers by inserting a period followed by the
number of decimal places before the conversion specifier.
For example, `printf('%.2f', $value)` would format the value
to two decimal places, which is particularly useful for
displaying currency values.

[Link]
What advantages do the `sprintf` and `printf` functions
provide in PHP?
Answer:Both `sprintf` and `printf` functions offer great
flexibility in formatting strings and numbers. `sprintf` stores
the formatted output in a variable rather than printing it
directly, which is beneficial when you need to manipulate the
formatted string later in the code. `printf`, on the other hand,
outputs the formatted string directly, making it useful for
immediate display. Together, they enable precise control over
how data is presented in PHP applications.
Chapter 9 | 8. Introduction to MySQL| Q&A
[Link]
What is the purpose of the semicolon in MySQL queries?
Answer:The semicolon in MySQL queries is used to
separate or end commands, indicating that a
command has been completely entered. It allows the
execution of multiple lines of commands or queries
as a batch.

[Link]
Which command would you use to view the available
databases or tables?
Answer:You would use the SHOW DATABASES; command
to view available databases and SHOW TABLES; to view
tables within the selected database.

[Link]
How would you create a new MySQL user on the local
host called newuser with a password of newpass and with
access to everything in the database newdatabase?
Answer:You would execute the following commands:
1. CREATE USER 'newuser'@'localhost' IDENTIFIED BY
'newpass';
2. GRANT ALL ON newdatabase.* TO
'newuser'@'localhost';

[Link]
How can you view the structure of a table?
Answer:To view the structure of a table, you use the
DESCRIBE table_name; command. For example,
DESCRIBE classics;.

[Link]
What is the purpose of a MySQL index?
Answer:A MySQL index improves the speed of data retrieval
operations on a database table, allowing for faster searches
and efficient data management.

[Link]
What benefit does a FULLTEXT index provide?
Answer:A FULLTEXT index allows for super-fast searches
of entire columns of text, enabling natural language searches
similar to a web search engine.

[Link]
What is a stopword?
Answer:A stopword is a common word that is ignored in
searches because it doesn't add significant meaning, such as
'the' or 'is' in full-text searches.

[Link]
Both SELECT DISTINCT and GROUP BY cause the
display to show only one output row for each value in a
column, even if multiple rows contain that value. What
are the main differences between SELECT DISTINCT
and GROUP BY?
Answer:SELECT DISTINCT is used to filter out duplicate
entries from the result set based on selected columns, while
GROUP BY organizes result rows into groups based on the
values in one or more columns and often requires aggregate
functions to summarize data.

[Link]
Using the SELECT...WHERE construct, how would you
return only rows containing the word Langhorne
somewhere in the author column of the classics table used
in this chapter?
Answer:You would use the query: SELECT * FROM classics
WHERE author LIKE '%Langhorne%';.

[Link]
What needs to be defined in two tables to make it possible
for you to join them together?
Answer:To join two tables, you need to have at least one
common column defined in both tables, usually with the
same or compatible data types, which allows for relational
linking.
Chapter 10 | 9. Mastering MySQL| Q&A
[Link]
What does the word relationship mean in reference to a
relational database?
Answer:In a relational database, a relationship
refers to how data in one table relates to data in
another table. This can include one-to-one,
one-to-many, and many-to-many relationships,
enabling the organization and retrieval of
interconnected data efficiently.

[Link]
What is the term for the process of removing duplicate
data and optimizing tables?
Answer:The term is normalization. It involves structuring a
database in such a way as to minimize redundancy and
dependency by organizing fields and table relationships.

[Link]
What are the three rules of the First Normal Form?
Answer:1. There should be no repeating groups or columns
containing the same kind of data. 2. All columns must
contain a single value. 3. There should be a primary key to
uniquely identify each row in the table.

[Link]
How can you make a table satisfy the Second Normal
Form?
Answer:To satisfy the Second Normal Form, a table must be
in First Normal Form and must have all non-key columns
fully functionally dependent on the primary key, requiring
the removal of any columns that do not meet this
dependency.

[Link]
What do you put in a column to tie together two tables
that contain items having a one-to-many relationship?
Answer:You place a foreign key in the 'many' table that
references the primary key of the 'one' table, establishing the
linkage between the two tables.

[Link]
How can you create a database with a many-to-many
relationship?
Answer:To create a many-to-many relationship, you need to
add an intermediary or junction table that contains foreign
keys referencing the primary keys of the two tables you want
to relate. This allows many entries from one table to be
associated with many entries in another.

[Link]
What commands initiate and end a MySQL transaction?
Answer:To initiate a transaction, you use the command
BEGIN or START TRANSACTION. To end a transaction
successfully, you use COMMIT, and to cancel it, you use
ROLLBACK.

[Link]
What feature does MySQL provide to enable you to
examine how a query will work in detail?
Answer:MySQL provides the EXPLAIN command, which
gives insight into how MySQL interprets a given query,
including details about how indexes are used and the number
of rows processed.

[Link]
What command would you use to back up the database
publications to a file called [Link]?
Answer:You would use the command: mysqldump -u user
-ppassword publications > [Link]. This command
exports the 'publications' database into a file named
'[Link]'.
Chapter 11 | 10. What’s new in PHP 8 and MySQL
8| Q&A
[Link]
What does PHP 8 now allow you to do when declaring
class properties?
Answer:PHP 8 allows you to declare class properties
directly within the constructor, significantly
reducing boilerplate code. For example, instead of
defining properties and assigning them in a separate
constructor block, you can now do it all in one line:
`public function __construct(public string
$username, public string $email) {}`.

[Link]
What is the Null-safe operator, and what is it for?
Answer:The Null-safe operator (?.) allows you to safely
access properties or methods on an object that might be null.
If any part of the chain evaluates to null, it short-circuits and
returns null immediately instead of throwing an error. This
improves code safety by preventing runtime exceptions due
to null dereferencing.

[Link]
How would you use a match expression in PHP 8, and
why can it be better than the alternative?
Answer:A match expression can be used like this: `$lang =
match($country) { "UK", "USA", "Australia" => "English",
"Spain" => "Spanish", "Germany", "Austria" => "German",
};`. It provides type-safe comparisons, reduces boilerplate
code, eliminates the need for 'break' statements, and is
cleaner than switch-case blocks.

[Link]
What easy to use new function can you now use in PHP 8
to determine if one string exists within another?
Answer:You can use the new `str_contains()` function to
check if one string exists within another. For example, `if
(str_contains('Once upon a time', 'Once')) echo 'Found';` This
is much clearer and less error-prone compared to older
methods.

[Link]
In PHP 8, what is the best new way to make a floating
point division calculation without causing a Division by
Zero error?
Answer:You can use the new `fdiv()` function, which allows
division by zero without throwing an error. For example,
`fdiv(1, 0)` returns `INF`, making your code more robust
against division errors.

[Link]
What is a polyfill?
Answer:A polyfill is code that replicates features that are
expected to be available in the environment but may not be.
It allows developers to use newer functions or features in
older versions of a language or library by providing a
fallback implementation.

[Link]
What is a simple new way in PHP 8 to see in plain English
the most recent error generated by a call to one of the
preg_ functions?
Answer:In PHP 8, you can use the `preg_last_error_msg()`
function to retrieve a readable error message after a `preg_`
function fails, making debugging much more
straightforward.

[Link]
By default, what does MySQL 8 now use as its
transactional storage engine?
Answer:MySQL 8 uses the InnoDB transactional storage
engine as the default, ensuring improved reliability and
performance.

[Link]
In MySQL 8, what can you use instead of an ALTER
TABLE ... CHANGE TABLE command to change the
name of a column?
Answer:In MySQL 8, you can use the new `RENAME
COLUMN` command as a simpler alternative to rename
columns in your tables.

[Link]
What is the default authentication plugin in MySQL 8?
Answer:The default authentication plugin in MySQL 8 is
`caching_sha2_password`, which offers enhanced security
features compared to the previous default.
Chapter 12 | A. Solutions to the Chapter Questions|
Q&A
[Link]
What are the main components necessary for hosting
dynamic web pages?
Answer:The main components include a web server
(like Apache), a server-side scripting language (such
as PHP), a database (like MySQL), and a client-side
scripting language (JavaScript).

[Link]
How does PHP differ from JavaScript in terms of
execution environment?
Answer:PHP runs on the server side and can interact directly
with a database to process data, while JavaScript runs on the
client side, allowing for dynamic changes to the web page
without refreshing.

[Link]
What are the benefits of using frameworks in web
development?
Answer:Frameworks streamline the development process by
handling cross-platform compatibility, styling consistency,
and core functionalities, allowing developers to focus on
building unique features of their web applications.

[Link]
How can you ensure that users have a smooth experience
when filling out forms on a website?
Answer:To enhance user experience, you can use features
like the required attribute for essential inputs, the
autocomplete attribute to prompt users with previously
entered values, and the label tag to make form elements more
accessible.

[Link]
What is the purpose of the PHP htmlentities function?
Answer:The htmlentities function converts HTML characters
to their corresponding HTML entities, which prevents the
browser from interpreting those characters as HTML code,
thus allowing for safe display.

[Link]
What are cookies and why are they important in web
development?
Answer:Cookies are small files stored on the user's browser
that help retain user preferences and session information
across different pages. They are important for maintaining
state and personalization in web applications.

[Link]
How do you manage user sessions in a PHP application?
Answer:User sessions in PHP can be managed by initiating a
session with the session_start function, and storing
user-specific data in the $_SESSION superglobal array,
ensuring data is retained across different pages.

[Link]
What is the difference between GET and POST methods
in forms?
Answer:The GET method appends data to the URL allowing
it to be bookmarked, while POST sends data in the body of
the request, which is more secure and suitable for larger
amounts of data.

[Link]
What is the role of the try...catch construct in JavaScript?
Answer:The try...catch construct is used to handle exceptions
and errors gracefully, allowing developers to define a block
of code that will be tested for errors and a corresponding
block to be executed if an error occurs.

[Link]
What are some features introduced in PHP 8 that
improve coding functionality?
Answer:PHP 8 introduces named parameters for clearer
function calls, a Null-safe operator to prevent errors when
dealing with null values, and the match expression for easier
conditional logic.
Learning PHP, MySQL & JavaScript
Quiz and Test
Check the Correct Answer on Bookey Website

Chapter 1 | Learning PHP, MySQL JavaScript| Quiz

and Test
[Link] book 'Learning PHP, MySQL & JavaScript' is
suitable for developers on different platforms.
[Link] book requires readers to have prior knowledge of PHP
and MySQL before starting.
[Link] final project in the book involves creating a fully
functional e-commerce website.
Chapter 2 | 1. Introduction to Dynamic Web
Content| Quiz and Test
[Link] is a client-side scripting language that
generates dynamic web pages.
2.HTML5 allows embedding of audio and video elements
without third-party plugins.
[Link] is a direct competitor to MySQL and cannot be
used interchangeably.
Chapter 3 | 2. Setting Up a Development Server|
Quiz and Test
[Link] up a development server allows for instant
testing of modifications without uploading files to
a remote server.
[Link], MAMP, and LAMP are production-ready server
configurations suitable for deployment in live
environments.
[Link] default document root for AMPPS is located at
C:\Program Files\Ampps\www.
Chapter 4 | 3. Introduction to PHP| Quiz and Test
[Link] files should have a `.php` extension to be
processed by the PHP engine.
[Link] PHP command should end with a period (`.`).
[Link] such as `$_GET` and `$_POST` are only
accessible within the function they are defined in.
Chapter 5 | 4. Expressions and Control Flow in
PHP| Quiz and Test
[Link] recognizes TRUE as 1.
[Link] PHP, the FALSE constant is represented as 0.
3.A Do...While loop in PHP ensures the code block runs
before checking the condition.
Chapter 6 | 5. PHP Functions and Objects| Quiz and
Test
[Link] supports built-in functions that help manage
data storage, program flow, and expression
evaluation.
[Link] in PHP can return multiple values without using
arrays to bundle them.
[Link] `global` keyword in PHP allows functions to access
local variables defined within their own scope.
Chapter 7 | 6. PHP Arrays| Quiz and Test
[Link] arrays can only be accessed using numeric
indexes.
[Link] foreach...as loop in PHP requires a check on array
lengths before use.
[Link] the array keyword allows for compact assignment of
multiple items into an array.
Chapter 8 | 7. Practical PHP| Quiz and Test
[Link] `printf` function in PHP allows for formatted
output with various specifiers for different data
types.
[Link] `file_get_contents()` function in PHP can only read
files located on the local server.
[Link] file closure is not important in PHP file handling
operations.
Chapter 9 | 8. Introduction to MySQL| Quiz and
Test
[Link] is a widely used open-source database
management system known for its speed and
 efficiency.
[Link] MySQL, the ALTER command is used to add data to
tables.
[Link] is a command-line tool used for managing
MySQL databases.
Chapter 10 | 9. Mastering MySQL| Quiz and Test
[Link] design is crucial before creating a database
in MySQL.
[Link] in database design is unnecessary for
minimizing redundancy.
[Link] supports transactions to ensure data integrity and
allows commands like BEGIN and COMMIT.
Chapter 11 | 10. What’s new in PHP 8 and MySQL
8| Quiz and Test
[Link] 8 introduces Named Parameters, which
enhance code clarity by allowing the specification
of parameter names in functions.
[Link] 8 does not include any improvements for JSON
handling and sorting.
[Link]-In-Time (JIT) Compilation in PHP 8 is enabled by
default, boosting performance for CPU-intensive
applications.
Chapter 12 | A. Solutions to the Chapter Questions|
Quiz and Test
[Link] runs server-side while JavaScript runs
 client-side.
[Link] allows for commands with arbitrary text and lays
no requirement for a specific language.
[Link] in PHP can return multiple values using arrays or
references.