beginning php and mysql - springer
TRANSCRIPT
Beginning PHP and MySQL: From Novice to Professional
ISBN-13 (pbk): 978-1-4302-6043-1 ISBN-13 (electronic): 978-1-4302-6044-8https://doi.org/10.1007/978-1-4302-6044-8
Library of Congress Control Number: 2018964569
Copyright © 2018 by Frank M. Kromann
This work is subject to copyright. All rights are reserved by the Publisher, whether the whole or part of the material is concerned, specifically the rights of translation, reprinting, reuse of illustrations, recitation, broadcasting, reproduction on microfilms or in any other physical way, and transmission or information storage and retrieval, electronic adaptation, computer software, or by similar or dissimilar methodology now known or hereafter developed.
Trademarked names, logos, and images may appear in this book. Rather than use a trademark symbol with every occurrence of a trademarked name, logo, or image we use the names, logos, and images only in an editorial fashion and to the benefit of the trademark owner, with no intention of infringement of the trademark.
The use in this publication of trade names, trademarks, service marks, and similar terms, even if they are not identified as such, is not to be taken as an expression of opinion as to whether or not they are subject to proprietary rights.
While the advice and information in this book are believed to be true and accurate at the date of publication, neither the authors nor the editors nor the publisher can accept any legal responsibility for any errors or omissions that may be made. The publisher makes no warranty, express or implied, with respect to the material contained herein.
Managing Director, Apress Media LLC: Welmoed SpahrAcquisitions Editor: Steve AnglinDevelopment Editor: Matthew MoodieCoordinating Editor: Mark Powers
Cover designed by eStudioCalamar
Cover image designed by Freepik (www.freepik.com)
Distributed to the book trade worldwide by Springer Science+Business Media New York, 233 Spring Street, 6th Floor, New York, NY 10013. Phone 1-800-SPRINGER, fax (201) 348-4505, e-mail [email protected], or visit www.springeronline.com. Apress Media, LLC is a California LLC and the sole member (owner) is Springer Science + Business Media Finance Inc (SSBM Finance Inc). SSBM Finance Inc is a Delaware corporation.
For information on translations, please e-mail [email protected]; for reprint, paperback, or audio rights, please email [email protected].
Apress titles may be purchased in bulk for academic, corporate, or promotional use. eBook versions and licenses are also available for most titles. For more information, reference our Print and eBook Bulk Sales web page at http://www.apress.com/bulk-sales.
Any source code or other supplementary material referenced by the author in this book is available to readers on GitHub via the book's product page, located at www.apress.com/9781430260431. For more detailed information, please visit http://www.apress.com/source-code.
Printed on acid-free paper
Frank M. KromannAliso Viejo, CA, USA
iii
Chapter 1: Introducing PHP �������������������������������������������������������������������������������������� 1
Key PHP Features �������������������������������������������������������������������������������������������������������������������������� 2
Practicality ������������������������������������������������������������������������������������������������������������������������������� 2
Power �������������������������������������������������������������������������������������������������������������������������������������� 5
Possibility �������������������������������������������������������������������������������������������������������������������������������� 6
Price ���������������������������������������������������������������������������������������������������������������������������������������� 6
The Current State of PHP �������������������������������������������������������������������������������������������������������������� 7
The PHP Ecosystem �������������������������������������������������������������������������������������������������������������������� 11
Drupal ������������������������������������������������������������������������������������������������������������������������������������ 11
WordPress ����������������������������������������������������������������������������������������������������������������������������� 12
Magento �������������������������������������������������������������������������������������������������������������������������������� 12
MediaWiki ������������������������������������������������������������������������������������������������������������������������������ 13
SugarCRM ������������������������������������������������������������������������������������������������������������������������������ 13
Zend Framework ������������������������������������������������������������������������������������������������������������������� 13
Summary������������������������������������������������������������������������������������������������������������������������������������� 14
Chapter 2: Configuring Your Environment �������������������������������������������������������������� 15
Choosing a Hosting Environment ������������������������������������������������������������������������������������������������ 17
Virtual Servers ����������������������������������������������������������������������������������������������������������������������� 17
Platform as a Service (PaaS) ������������������������������������������������������������������������������������������������� 17
Installation Prerequisites ������������������������������������������������������������������������������������������������������������ 18
Windows �������������������������������������������������������������������������������������������������������������������������������� 18
macOS ����������������������������������������������������������������������������������������������������������������������������������� 27
Linux �������������������������������������������������������������������������������������������������������������������������������������� 29
From Source �������������������������������������������������������������������������������������������������������������������������� 30
Table of Contents
About the Author ��������������������������������������������������������������������������������������������������xxiii
Introduction �����������������������������������������������������������������������������������������������������������xxv
iv
Configure PHP ����������������������������������������������������������������������������������������������������������������������������� 30
The Apache httpd�conf and �htaccess Files ��������������������������������������������������������������������������� 32
Within the Executing Script ��������������������������������������������������������������������������������������������������� 33
PHP’s Configuration Directives ���������������������������������������������������������������������������������������������� 33
Choosing an Editor ���������������������������������������������������������������������������������������������������������������������� 44
PHPStorm ������������������������������������������������������������������������������������������������������������������������������ 44
Atom �������������������������������������������������������������������������������������������������������������������������������������� 45
Sublime Text �������������������������������������������������������������������������������������������������������������������������� 45
Visual Studio Code ����������������������������������������������������������������������������������������������������������������� 45
PDT (PHP Development Tools) ����������������������������������������������������������������������������������������������� 45
Zend Studio ��������������������������������������������������������������������������������������������������������������������������� 46
Summary������������������������������������������������������������������������������������������������������������������������������������� 46
Chapter 3: PHP Basics �������������������������������������������������������������������������������������������� 47
Embedding PHP Code in Your Web Pages ����������������������������������������������������������������������������������� 48
Default Syntax ����������������������������������������������������������������������������������������������������������������������� 48
ShortTags ������������������������������������������������������������������������������������������������������������������������������� 49
Embedding Multiple Code Blocks ������������������������������������������������������������������������������������������ 50
Commenting Your Code ��������������������������������������������������������������������������������������������������������������� 50
Single-Line C++ Syntax �������������������������������������������������������������������������������������������������������� 51
Multiple-Line Comments ������������������������������������������������������������������������������������������������������� 52
Outputting Data to the Client ������������������������������������������������������������������������������������������������������� 53
Complex Output Using the printf() Statement ������������������������������������������������������������������������ 54
The sprintf() Statement ���������������������������������������������������������������������������������������������������������� 55
PHP’s Data Types ������������������������������������������������������������������������������������������������������������������������� 56
Scalar Data Types ������������������������������������������������������������������������������������������������������������������ 56
Compound Data Types ����������������������������������������������������������������������������������������������������������� 58
Converting Between Data Types Using Type Casting ������������������������������������������������������������� 60
Adapting Data Types with Type Juggling ������������������������������������������������������������������������������� 62
Type Identifier Functions ������������������������������������������������������������������������������������������������������� 63
Table of ConTenTs
v
Manipulating Dynamic Data Using Variables ������������������������������������������������������������������������������ 64
Variable Declaration �������������������������������������������������������������������������������������������������������������� 64
PHP’s Superglobal Variables �������������������������������������������������������������������������������������������������� 66
Managing Constant Data with Constants ������������������������������������������������������������������������������������ 70
Defining a Constant ��������������������������������������������������������������������������������������������������������������� 71
Taking Action with Expressions��������������������������������������������������������������������������������������������������� 72
Defining Inputs with Operands ���������������������������������������������������������������������������������������������� 72
Defining Actions with Operators �������������������������������������������������������������������������������������������� 72
String Interpolation ��������������������������������������������������������������������������������������������������������������������� 81
Double Quotes ����������������������������������������������������������������������������������������������������������������������� 81
Escape Sequences ���������������������������������������������������������������������������������������������������������������� 81
Single Quotes ������������������������������������������������������������������������������������������������������������������������ 82
Curly Braces �������������������������������������������������������������������������������������������������������������������������� 83
Heredoc ��������������������������������������������������������������������������������������������������������������������������������� 83
Nowdoc���������������������������������������������������������������������������������������������������������������������������������� 84
Taking Control with Control Structures ��������������������������������������������������������������������������������������� 85
Making Decisions with Conditional Statements �������������������������������������������������������������������� 85
Iterating Repeatedly with Looping Statements ��������������������������������������������������������������������� 88
File-Inclusion Statements ������������������������������������������������������������������������������������������������������ 94
Summary������������������������������������������������������������������������������������������������������������������������������������� 96
Chapter 4: Functions ���������������������������������������������������������������������������������������������� 97
Invoking a Function ��������������������������������������������������������������������������������������������������������������������� 98
Creating a Function ������������������������������������������������������������������������������������������������������������������� 100
Returning Multiple Values ���������������������������������������������������������������������������������������������������� 101
Passing Arguments by Value ����������������������������������������������������������������������������������������������� 102
Default Argument Values ����������������������������������������������������������������������������������������������������� 103
Using Type Declarations ������������������������������������������������������������������������������������������������������ 104
Recursive Functions ������������������������������������������������������������������������������������������������������������ 105
Anonymous Functions ��������������������������������������������������������������������������������������������������������� 109
Function Libraries ���������������������������������������������������������������������������������������������������������������� 110
Summary����������������������������������������������������������������������������������������������������������������������������������� 112
Table of ConTenTs
vi
Chapter 5: Arrays �������������������������������������������������������������������������������������������������� 113
What Is an Array? ���������������������������������������������������������������������������������������������������������������������� 114
Creating an Array ���������������������������������������������������������������������������������������������������������������������� 115
Creating Arrays with array() ������������������������������������������������������������������������������������������������� 117
Extracting Arrays with list() ������������������������������������������������������������������������������������������������� 117
Populating Arrays with a Predefined Value Range ��������������������������������������������������������������� 119
Testing for an Array ������������������������������������������������������������������������������������������������������������� 119
Outputting an Array ������������������������������������������������������������������������������������������������������������������� 120
Printing Arrays for Testing Purposes ����������������������������������������������������������������������������������� 121
Adding and Removing Array Elements �������������������������������������������������������������������������������������� 122
Adding a Value to the Front of an Array ������������������������������������������������������������������������������� 123
Adding a Value to the End of an Array ��������������������������������������������������������������������������������� 123
Removing a Value from the Front of an Array ���������������������������������������������������������������������� 124
Removing a Value from the End of an Array ������������������������������������������������������������������������ 124
Locating Array Elements ����������������������������������������������������������������������������������������������������������� 124
Searching an Array �������������������������������������������������������������������������������������������������������������� 125
Retrieving Array Keys ���������������������������������������������������������������������������������������������������������� 126
Retrieving Array Values �������������������������������������������������������������������������������������������������������� 127
Extracting Columns ������������������������������������������������������������������������������������������������������������������� 127
Traversing Arrays ���������������������������������������������������������������������������������������������������������������������� 128
Retrieving the Current Array Key ����������������������������������������������������������������������������������������� 128
Retrieving the Current Array Value �������������������������������������������������������������������������������������� 129
Moving the Array Pointer ����������������������������������������������������������������������������������������������������� 129
Passing Array Values to a Function ������������������������������������������������������������������������������������� 131
Determining Array Size and Uniqueness ����������������������������������������������������������������������������������� 133
Determining the Size of an Array ����������������������������������������������������������������������������������������� 133
Counting Array Value Frequency ������������������������������������������������������������������������������������������ 134
Determining Unique Array Values ���������������������������������������������������������������������������������������� 134
Sorting Arrays ��������������������������������������������������������������������������������������������������������������������������� 135
Reversing Array Element Order ������������������������������������������������������������������������������������������� 135
Flipping Array Keys and Values ������������������������������������������������������������������������������������������� 136
Sorting an Array ������������������������������������������������������������������������������������������������������������������� 136
Table of ConTenTs
vii
Merging, Slicing, Splicing, and Dissecting Arrays ��������������������������������������������������������������������� 142
Merging Arrays �������������������������������������������������������������������������������������������������������������������� 143
Recursively Appending Arrays ��������������������������������������������������������������������������������������������� 143
Combining Two Arrays ��������������������������������������������������������������������������������������������������������� 144
Slicing an Array ������������������������������������������������������������������������������������������������������������������� 145
Splicing an Array ����������������������������������������������������������������������������������������������������������������� 146
Calculating an Array Intersection ���������������������������������������������������������������������������������������� 147
Calculating Associative Array Intersections ������������������������������������������������������������������������� 148
Calculating Array Differences ���������������������������������������������������������������������������������������������� 148
Calculating Associative Array Differences ��������������������������������������������������������������������������� 149
Other Useful Array Functions ���������������������������������������������������������������������������������������������������� 150
Returning a Random Set of Keys ����������������������������������������������������������������������������������������� 150
Shuffling Array Elements ����������������������������������������������������������������������������������������������������� 150
Summary����������������������������������������������������������������������������������������������������������������������������������� 152
Chapter 6: Object-Oriented PHP���������������������������������������������������������������������������� 153
The Benefits of OOP ������������������������������������������������������������������������������������������������������������������ 153
Encapsulation ���������������������������������������������������������������������������������������������������������������������� 154
Inheritance �������������������������������������������������������������������������������������������������������������������������� 155
Polymorphism ���������������������������������������������������������������������������������������������������������������������� 156
Key OOP Concepts ��������������������������������������������������������������������������������������������������������������������� 156
Classes �������������������������������������������������������������������������������������������������������������������������������� 156
Objects �������������������������������������������������������������������������������������������������������������������������������� 158
Properties ���������������������������������������������������������������������������������������������������������������������������� 158
Constants ����������������������������������������������������������������������������������������������������������������������������� 167
Methods ������������������������������������������������������������������������������������������������������������������������������� 167
Constructors and Destructors ��������������������������������������������������������������������������������������������������� 173
Constructors ������������������������������������������������������������������������������������������������������������������������ 173
Destructors �������������������������������������������������������������������������������������������������������������������������� 176
Static Class Members ��������������������������������������������������������������������������������������������������������������� 178
The instanceof Keyword ����������������������������������������������������������������������������������������������������������� 179
Table of ConTenTs
viii
Helper Functions ����������������������������������������������������������������������������������������������������������������������� 180
Determining Whether a Class Exists ������������������������������������������������������������������������������������ 180
Determining Object Context������������������������������������������������������������������������������������������������� 180
Learning About Class Methods �������������������������������������������������������������������������������������������� 180
Learning About Class Properties ����������������������������������������������������������������������������������������� 181
Learning About Declared Classes ���������������������������������������������������������������������������������������� 181
Learning About Object Properties ���������������������������������������������������������������������������������������� 181
Determining an Object’s Parent Class ��������������������������������������������������������������������������������� 181
Determining Object Type ����������������������������������������������������������������������������������������������������� 182
Determining Object Subclass Type �������������������������������������������������������������������������������������� 182
Determining Method Existence ������������������������������������������������������������������������������������������� 182
Autoloading Objects ������������������������������������������������������������������������������������������������������������������ 182
Traits ����������������������������������������������������������������������������������������������������������������������������������������� 183
Summary����������������������������������������������������������������������������������������������������������������������������������� 184
Chapter 7: Advanced OOP Features ���������������������������������������������������������������������� 185
Advanced OOP Features Not Supported by PHP ����������������������������������������������������������������������� 186
Object Cloning ��������������������������������������������������������������������������������������������������������������������������� 187
Cloning Example ������������������������������������������������������������������������������������������������������������������ 188
The __clone() Method ���������������������������������������������������������������������������������������������������������� 190
Inheritance �������������������������������������������������������������������������������������������������������������������������������� 191
Class Inheritance ����������������������������������������������������������������������������������������������������������������� 192
Inheritance and Constructors ���������������������������������������������������������������������������������������������� 195
Inheritance and Late Static Binding ������������������������������������������������������������������������������������ 197
Interfaces ���������������������������������������������������������������������������������������������������������������������������������� 198
Implementing a Single Interface ����������������������������������������������������������������������������������������� 200
Implementing Multiple Interfaces ���������������������������������������������������������������������������������������� 201
Abstract Classes ����������������������������������������������������������������������������������������������������������������������� 202
Introducing Namespaces ���������������������������������������������������������������������������������������������������������� 204
Summary����������������������������������������������������������������������������������������������������������������������������������� 208
Table of ConTenTs
ix
Chapter 8: Error and Exception Handling ������������������������������������������������������������� 209
All Your Bugs Belong to You ������������������������������������������������������������������������������������������������������ 210
Configuring PHP’s Error Reporting Behavior ����������������������������������������������������������������������������� 211
Setting the Desired Error Sensitivity Level �������������������������������������������������������������������������� 211
Displaying Errors Within the Browser ���������������������������������������������������������������������������������� 213
Logging Errors ��������������������������������������������������������������������������������������������������������������������� 214
Creating and Logging Custom Messages ���������������������������������������������������������������������������� 215
Exception Handling ������������������������������������������������������������������������������������������������������������������� 216
Why Exception Handling Is Handy ��������������������������������������������������������������������������������������� 216
PHP’s Exception-Handling Capabilities ������������������������������������������������������������������������������������� 218
Extending the Base Exception Class������������������������������������������������������������������������������������ 218
The Default Constructor ������������������������������������������������������������������������������������������������������� 219
Introducing the Finally Block ����������������������������������������������������������������������������������������������� 220
Extending the Exception Class �������������������������������������������������������������������������������������������� 221
Catching Multiple Exceptions ���������������������������������������������������������������������������������������������� 222
Standard PHP Library Exceptions ���������������������������������������������������������������������������������������� 224
Error Handling in PHP 7 ������������������������������������������������������������������������������������������������������������� 226
Summary����������������������������������������������������������������������������������������������������������������������������������� 227
Chapter 9: Strings and Regular Expressions �������������������������������������������������������� 229
Regular Expressions ����������������������������������������������������������������������������������������������������������������� 230
Regular Expression Syntax (Perl) ���������������������������������������������������������������������������������������� 230
Other String-Specific Functions ������������������������������������������������������������������������������������������������ 241
Determining the Length of a String ������������������������������������������������������������������������������������� 242
Comparing Two Strings�������������������������������������������������������������������������������������������������������� 243
Manipulating String Case ���������������������������������������������������������������������������������������������������� 246
Converting Strings to and from HTML ��������������������������������������������������������������������������������� 248
Alternatives for Regular Expression Functions ������������������������������������������������������������������������� 255
Tokenizing a String Based on Predefined Characters ���������������������������������������������������������� 255
Exploding a String Based on a Predefined Delimiter ����������������������������������������������������������� 256
Converting an Array into a String ���������������������������������������������������������������������������������������� 257
Table of ConTenTs
x
Performing Complex String Parsing ������������������������������������������������������������������������������������ 257
Finding the Last Occurrence of a String ������������������������������������������������������������������������������ 258
Replacing All Instances of a String with Another String ������������������������������������������������������ 259
Retrieving Part of a String ��������������������������������������������������������������������������������������������������� 260
Returning Part of a String Based on Predefined Offsets ����������������������������������������������������� 261
Determining the Frequency of a String’s Appearance ��������������������������������������������������������� 262
Replacing a Portion of a String with Another String ������������������������������������������������������������ 263
Padding and Stripping a String �������������������������������������������������������������������������������������������� 264
Counting Characters and Words ������������������������������������������������������������������������������������������ 266
Summary����������������������������������������������������������������������������������������������������������������������������������� 269
Chapter 10: Working with the File and Operating System ������������������������������������ 271
Learning About Files and Directories ���������������������������������������������������������������������������������������� 272
Directory Separators ����������������������������������������������������������������������������������������������������������� 272
Parsing Directory Paths ������������������������������������������������������������������������������������������������������� 272
Calculating File, Directory, and Disk Sizes ��������������������������������������������������������������������������� 275
Determining Access and Modification Times����������������������������������������������������������������������� 280
Working with Files �������������������������������������������������������������������������������������������������������������������� 282
The Concept of a Resource �������������������������������������������������������������������������������������������������� 282
Recognizing Newline Characters ����������������������������������������������������������������������������������������� 282
Recognizing the End-of-File Character �������������������������������������������������������������������������������� 282
Opening and Closing a File �������������������������������������������������������������������������������������������������� 283
Reading from a File ������������������������������������������������������������������������������������������������������������� 286
Writing a String to a File ������������������������������������������������������������������������������������������������������ 296
Tip Moving the File Pointer �������������������������������������������������������������������������������������������������� 296
Reading Directory Contents ������������������������������������������������������������������������������������������������� 297
Executing Shell Commands ������������������������������������������������������������������������������������������������������ 299
Removing a Directory ���������������������������������������������������������������������������������������������������������� 299
Renaming a File ������������������������������������������������������������������������������������������������������������������� 301
Touching a File �������������������������������������������������������������������������������������������������������������������� 301
Table of ConTenTs
xi
System-Level Program Execution ��������������������������������������������������������������������������������������������� 301
Sanitizing the Input�������������������������������������������������������������������������������������������������������������� 302
PHP’s Program Execution Functions������������������������������������������������������������������������������������ 304
Summary����������������������������������������������������������������������������������������������������������������������������������� 307
Chapter 11: Third-Party Libraries ������������������������������������������������������������������������� 309
Introducing PEAR ���������������������������������������������������������������������������������������������������������������������� 310
Installing PEAR �������������������������������������������������������������������������������������������������������������������� 310
Updating PEAR ��������������������������������������������������������������������������������������������������������������������� 311
Using the PEAR Package Manager �������������������������������������������������������������������������������������������� 311
Installing a PEAR Package ��������������������������������������������������������������������������������������������������� 311
Automatically Installing All Dependencies ��������������������������������������������������������������������������� 312
Viewing Installed PEAR Packages ��������������������������������������������������������������������������������������� 313
Introducing Composer ��������������������������������������������������������������������������������������������������������������� 313
Installing Composer ������������������������������������������������������������������������������������������������������������� 313
Using Composer ������������������������������������������������������������������������������������������������������������������ 315
Extending PHP with C Libraries ������������������������������������������������������������������������������������������������� 317
Summary����������������������������������������������������������������������������������������������������������������������������������� 318
Chapter 12: Date and Time ����������������������������������������������������������������������������������� 319
The Unix Timestamp ������������������������������������������������������������������������������������������������������������������ 319
PHP’s Date and Time Library ����������������������������������������������������������������������������������������������������� 320
Validating Dates ������������������������������������������������������������������������������������������������������������������� 321
Formatting Dates and Times������������������������������������������������������������������������������������������������ 322
Converting a Timestamp to User-Friendly Values ���������������������������������������������������������������� 327
Working with Timestamps ��������������������������������������������������������������������������������������������������� 328
Date Fu �������������������������������������������������������������������������������������������������������������������������������������� 330
Displaying the Localized Date and Time ������������������������������������������������������������������������������ 330
Displaying the Web Page’s Most Recent Modification Date ������������������������������������������������ 335
Determining the Number of Days in the Current Month ������������������������������������������������������ 336
Determining the Number of Days in Any Given Month �������������������������������������������������������� 336
Calculating the Date X Days from the Present Date ������������������������������������������������������������ 337
Table of ConTenTs
xii
Date and Time Classes �������������������������������������������������������������������������������������������������������������� 338
Introducing the DateTime Constructor��������������������������������������������������������������������������������� 338
Formatting Dates ����������������������������������������������������������������������������������������������������������������� 339
Setting the Date After Instantiation ������������������������������������������������������������������������������������� 339
Setting the Time After Instantiation ������������������������������������������������������������������������������������� 340
Modifying Dates and Times ������������������������������������������������������������������������������������������������� 340
Calculating the Difference Between Two Dates ������������������������������������������������������������������� 341
Summary����������������������������������������������������������������������������������������������������������������������������������� 341
Chapter 13: Forms ������������������������������������������������������������������������������������������������ 343PHP and Web Forms ������������������������������������������������������������������������������������������������������������������ 343
A Simple Example ���������������������������������������������������������������������������������������������������������������� 345
Validating Form Data ����������������������������������������������������������������������������������������������������������������� 346
File Deletion ������������������������������������������������������������������������������������������������������������������������� 347
Cross-Site Scripting������������������������������������������������������������������������������������������������������������� 348
Sanitizing User Input ����������������������������������������������������������������������������������������������������������� 350
Validating and Sanitizing Data with the Filter Extension ����������������������������������������������������� 354
Working with Multivalued Form Components ���������������������������������������������������������������������� 357
Summary����������������������������������������������������������������������������������������������������������������������������������� 359
Chapter 14: Authenticating Your Users����������������������������������������������������������������� 361HTTP Authentication Concepts �������������������������������������������������������������������������������������������������� 362
Using Apache’s �htaccess Feature ��������������������������������������������������������������������������������������� 363
Authenticating Your Users with PHP ����������������������������������������������������������������������������������������� 364
PHP’s Authentication Variables �������������������������������������������������������������������������������������������� 365
Useful Functions ������������������������������������������������������������������������������������������������������������������ 365
Hard-Coded Authentication ������������������������������������������������������������������������������������������������� 367
File-Based Authentication ��������������������������������������������������������������������������������������������������� 368
Database-Based Authentication ������������������������������������������������������������������������������������������ 370
User Login Administration ��������������������������������������������������������������������������������������������������������� 372
Password Hashing �������������������������������������������������������������������������������������������������������������������� 372
One-Time URLs and Password Recovery ���������������������������������������������������������������������������� 374
Using OAuth 2�0 ������������������������������������������������������������������������������������������������������������������������ 377
Summary����������������������������������������������������������������������������������������������������������������������������������� 380
Table of ConTenTs
xiii
Chapter 15: Handling File Uploads ����������������������������������������������������������������������� 381
Uploading Files via HTTP ����������������������������������������������������������������������������������������������������������� 381
Uploading Files with PHP ���������������������������������������������������������������������������������������������������������� 383
PHP’s File Upload/Resource Directives �������������������������������������������������������������������������������� 383
The $_FILES Array ��������������������������������������������������������������������������������������������������������������� 385
PHP’s File-Upload Functions ������������������������������������������������������������������������������������������������ 386
Upload Error Messages ������������������������������������������������������������������������������������������������������� 388
A Simple Example ���������������������������������������������������������������������������������������������������������������� 389
Summary����������������������������������������������������������������������������������������������������������������������������������� 390
Chapter 16: Networking ���������������������������������������������������������������������������������������� 391
DNS, Services, and Servers ������������������������������������������������������������������������������������������������������� 392
DNS �������������������������������������������������������������������������������������������������������������������������������������� 392
Services ������������������������������������������������������������������������������������������������������������������������������� 400
Establishing Socket Connections ���������������������������������������������������������������������������������������� 401
Mail ������������������������������������������������������������������������������������������������������������������������������������������� 405
Configuration Directives ������������������������������������������������������������������������������������������������������ 405
Sending E-mail Using a PHP Script ������������������������������������������������������������������������������������� 407
Common Networking Tasks ������������������������������������������������������������������������������������������������������ 411
Pinging a Server ������������������������������������������������������������������������������������������������������������������ 412
Creating a Port Scanner ������������������������������������������������������������������������������������������������������ 413
Creating a Subnet Converter ����������������������������������������������������������������������������������������������� 414
Summary����������������������������������������������������������������������������������������������������������������������������������� 416
Chapter 17: Session Handlers ������������������������������������������������������������������������������ 417
What Is Session Handling?�������������������������������������������������������������������������������������������������������� 417
The Session-Handling Process �������������������������������������������������������������������������������������������� 418
Configuration Directives ������������������������������������������������������������������������������������������������������������ 418
Managing the Session Storage Media ��������������������������������������������������������������������������������� 418
Setting the Session Files Path ��������������������������������������������������������������������������������������������� 419
Automatically Enabling Sessions ����������������������������������������������������������������������������������������� 420
Setting the Session Name ��������������������������������������������������������������������������������������������������� 420
Choosing Cookies or URL Rewriting ������������������������������������������������������������������������������������ 420
Table of ConTenTs
xiv
Setting the Session Cookie Lifetime ������������������������������������������������������������������������������������ 421
Setting the Session Cookie’s Valid URL Path ����������������������������������������������������������������������� 422
Setting Caching Directions �������������������������������������������������������������������������������������������������� 422
Working with Sessions �������������������������������������������������������������������������������������������������������������� 424
Starting a Session ��������������������������������������������������������������������������������������������������������������� 424
Destroying a Session ����������������������������������������������������������������������������������������������������������� 425
Setting and Retrieving the Session ID ��������������������������������������������������������������������������������� 426
Creating and Deleting Session Variables ����������������������������������������������������������������������������� 426
Encoding and Decoding Session Data ��������������������������������������������������������������������������������� 427
Practical Session-Handling Examples �������������������������������������������������������������������������������������� 430
Automatically Logging In Returning Users �������������������������������������������������������������������������� 431
Generating a Recently Viewed Document Index ������������������������������������������������������������������ 433
Creating Custom Session Handlers ������������������������������������������������������������������������������������������� 435
Tying Custom Session Functions into PHP’s Logic �������������������������������������������������������������� 436
Using Custom MySQL-Based Session Handlers ������������������������������������������������������������������ 437
Summary����������������������������������������������������������������������������������������������������������������������������������� 441
Chapter 18: Web Services ������������������������������������������������������������������������������������� 443
Why Web Services? ������������������������������������������������������������������������������������������������������������������� 444
Getting Started with APIs ���������������������������������������������������������������������������������������������������������� 444
API Security ������������������������������������������������������������������������������������������������������������������������������� 450
Create an API ����������������������������������������������������������������������������������������������������������������������������� 453
Summary����������������������������������������������������������������������������������������������������������������������������������� 460
Chapter 19: Secure PHP Programming ����������������������������������������������������������������� 461
Configuring PHP Securely ��������������������������������������������������������������������������������������������������������� 462
Security-Related Configuration Parameters ������������������������������������������������������������������������ 463
Hiding Configuration Details ����������������������������������������������������������������������������������������������������� 465
Hiding Apache ���������������������������������������������������������������������������������������������������������������������� 465
Hiding PHP ��������������������������������������������������������������������������������������������������������������������������� 466
Hiding Sensitive Data ���������������������������������������������������������������������������������������������������������������� 468
Hiding the Document Root ��������������������������������������������������������������������������������������������������� 469
Denying Access to Certain File Extensions �������������������������������������������������������������������������� 469
Table of ConTenTs
xv
Data Encryption ������������������������������������������������������������������������������������������������������������������������� 470
PHP’s Encryption Functions ������������������������������������������������������������������������������������������������� 470
Encrypting Data Using OpenSSL ������������������������������������������������������������������������������������������ 475
Summary����������������������������������������������������������������������������������������������������������������������������������� 478
Chapter 20: Integrating jQuery and PHP ��������������������������������������������������������������� 479
Introducing Ajax ������������������������������������������������������������������������������������������������������������������������ 480
Introducing jQuery �������������������������������������������������������������������������������������������������������������������� 481
Installing jQuery������������������������������������������������������������������������������������������������������������������� 482
A Simple Example ���������������������������������������������������������������������������������������������������������������� 482
Responding to Events ���������������������������������������������������������������������������������������������������������� 483
jQuery and the DOM ������������������������������������������������������������������������������������������������������������ 485
Creating a Username Existence Validator ��������������������������������������������������������������������������������� 488
Determining If a Username Exists ��������������������������������������������������������������������������������������� 490
Summary����������������������������������������������������������������������������������������������������������������������������������� 494
Chapter 21: MVC and Frameworks ����������������������������������������������������������������������� 495
Introducing MVC ������������������������������������������������������������������������������������������������������������������������ 495
PHP’s Framework Solutions ������������������������������������������������������������������������������������������������������ 499
The CakePHP Framework ���������������������������������������������������������������������������������������������������� 499
The Symfony Framework����������������������������������������������������������������������������������������������������� 499
The Zend Framework ����������������������������������������������������������������������������������������������������������� 500
The Phalcon Framework ������������������������������������������������������������������������������������������������������ 500
The Laravel Framework ������������������������������������������������������������������������������������������������������� 501
The PHP Framework Interoperability Group (PHP-FIG) �������������������������������������������������������� 508
PSR-1 and PSR-2 Coding Standards ����������������������������������������������������������������������������������� 509
PSR-4 Autoloading ��������������������������������������������������������������������������������������������������������������� 510
Summary����������������������������������������������������������������������������������������������������������������������������������� 512
Chapter 22: Introducing MySQL ���������������������������������������������������������������������������� 513
What Makes MySQL So Popular? ���������������������������������������������������������������������������������������������� 514
Flexibility ����������������������������������������������������������������������������������������������������������������������������� 514
Power ���������������������������������������������������������������������������������������������������������������������������������� 514
Flexible Licensing Options ��������������������������������������������������������������������������������������������������� 517
Table of ConTenTs
xvi
Prominent MySQL Users ����������������������������������������������������������������������������������������������������������� 518
Craigslist ������������������������������������������������������������������������������������������������������������������������������ 518
Twitter ��������������������������������������������������������������������������������������������������������������������������������� 518
GitHub ���������������������������������������������������������������������������������������������������������������������������������� 519
Other Prominent Users �������������������������������������������������������������������������������������������������������� 519
MariaDB: An Alternative to MySQL �������������������������������������������������������������������������������������������� 519
Summary����������������������������������������������������������������������������������������������������������������������������������� 519
Chapter 23: Installing and Configuring MySQL ����������������������������������������������������� 521
Downloading MySQL ����������������������������������������������������������������������������������������������������������������� 521
Installing MySQL ����������������������������������������������������������������������������������������������������������������������� 522
Installing MySQL on Linux ��������������������������������������������������������������������������������������������������� 523
Installing and Configuring MySQL on Windows ������������������������������������������������������������������� 528
Starting and Stopping MySQL ��������������������������������������������������������������������������������������������������� 528
Controlling the Daemon Manually ��������������������������������������������������������������������������������������� 529
Configuring and Optimizing MySQL ������������������������������������������������������������������������������������������ 530
The mysqld_safe Wrapper ��������������������������������������������������������������������������������������������������� 531
MySQL’s Configuration and Optimization Parameters ��������������������������������������������������������� 532
The my�cnf File �������������������������������������������������������������������������������������������������������������������� 536
Configuring PHP to Work with MySQL ��������������������������������������������������������������������������������������� 540
Reconfiguring PHP on Linux ������������������������������������������������������������������������������������������������ 540
Reconfiguring PHP on Windows ������������������������������������������������������������������������������������������ 540
Summary����������������������������������������������������������������������������������������������������������������������������������� 541
Chapter 24: The Many MySQL Clients ������������������������������������������������������������������� 543
Introducing the Command-Line Clients ������������������������������������������������������������������������������������ 543
The mysql Client ������������������������������������������������������������������������������������������������������������������ 544
The mysqladmin Client �������������������������������������������������������������������������������������������������������� 557
Other Useful Clients ������������������������������������������������������������������������������������������������������������� 560
Useful GUI Client Programs ������������������������������������������������������������������������������������������������������� 562
phpMyAdmin ����������������������������������������������������������������������������������������������������������������������������� 563
Summary����������������������������������������������������������������������������������������������������������������������������������� 565
Table of ConTenTs
xvii
Chapter 25: MySQL Storage Engines and Data Types ������������������������������������������� 567
Storage Engines ������������������������������������������������������������������������������������������������������������������������ 567
InnoDB ��������������������������������������������������������������������������������������������������������������������������������� 569
MyISAM ������������������������������������������������������������������������������������������������������������������������������� 570
MEMORY ������������������������������������������������������������������������������������������������������������������������������ 572
MERGE ��������������������������������������������������������������������������������������������������������������������������������� 574
FEDERATED �������������������������������������������������������������������������������������������������������������������������� 574
ARCHIVE ������������������������������������������������������������������������������������������������������������������������������� 576
CSV �������������������������������������������������������������������������������������������������������������������������������������� 576
EXAMPLE ����������������������������������������������������������������������������������������������������������������������������� 577
BLACKHOLE ������������������������������������������������������������������������������������������������������������������������� 577
Storage Engine FAQ ������������������������������������������������������������������������������������������������������������� 577
Data Types and Attributes ��������������������������������������������������������������������������������������������������������� 579
Data Types ��������������������������������������������������������������������������������������������������������������������������� 580
Data Type Attributes������������������������������������������������������������������������������������������������������������� 587
Working with Databases and Tables ����������������������������������������������������������������������������������������� 592
Working with Databases ������������������������������������������������������������������������������������������������������ 592
Working with Tables ������������������������������������������������������������������������������������������������������������ 594
Altering a Table Structure ���������������������������������������������������������������������������������������������������� 598
The INFORMATION_SCHEMA ����������������������������������������������������������������������������������������������� 599
Summary����������������������������������������������������������������������������������������������������������������������������������� 603
Chapter 26: Securing MySQL �������������������������������������������������������������������������������� 605
What You Should Do First ���������������������������������������������������������������������������������������������������������� 606
Securing the mysqld Daemon ��������������������������������������������������������������������������������������������������� 608
The MySQL Access Privilege System ���������������������������������������������������������������������������������������� 609
How the Privilege System Works ����������������������������������������������������������������������������������������� 610
Where Is Access Information Stored?���������������������������������������������������������������������������������� 612
User and Privilege Management ����������������������������������������������������������������������������������������������� 620
Creating Users ��������������������������������������������������������������������������������������������������������������������� 621
Deleting Users ��������������������������������������������������������������������������������������������������������������������� 621
Table of ConTenTs
xviii
Renaming Users ������������������������������������������������������������������������������������������������������������������ 622
The Grant and Revoke Commands �������������������������������������������������������������������������������������� 622
Reviewing Privileges ����������������������������������������������������������������������������������������������������������� 629
Limiting User Resources ����������������������������������������������������������������������������������������������������������� 630
Secure MySQL Connections ������������������������������������������������������������������������������������������������������ 631
Grant Options ����������������������������������������������������������������������������������������������������������������������� 632
SSL Options ������������������������������������������������������������������������������������������������������������������������� 634
Starting the SSL-Enabled MySQL Server ����������������������������������������������������������������������������� 635
Connecting Using an SSL-Enabled Client ���������������������������������������������������������������������������� 635
Storing SSL Options in the my�cnf File �������������������������������������������������������������������������������� 636
Summary����������������������������������������������������������������������������������������������������������������������������������� 636
Chapter 27: Using PHP with MySQL ���������������������������������������������������������������������� 637
Installation Prerequisites ���������������������������������������������������������������������������������������������������������� 639
Enabling the mysqli Extension on Linux/Unix ���������������������������������������������������������������������� 639
Enabling the mysqli Extension on Windows ������������������������������������������������������������������������ 639
Using the MySQL Native Driver �������������������������������������������������������������������������������������������� 640
Managing User Privileges ���������������������������������������������������������������������������������������������������� 640
Working with Sample Data �������������������������������������������������������������������������������������������������� 641
Using the mysqli Extension ������������������������������������������������������������������������������������������������������� 641
Setting Up and Tearing Down the Connection ��������������������������������������������������������������������� 642
Handling Connection Errors ������������������������������������������������������������������������������������������������� 643
Retrieving Error Information ������������������������������������������������������������������������������������������������ 643
Storing Connection Information in a Separate File �������������������������������������������������������������� 645
Securing Your Connection Information �������������������������������������������������������������������������������� 646
Interacting with the Database ��������������������������������������������������������������������������������������������������� 647
Sending a Query to the Database ���������������������������������������������������������������������������������������� 647
Parsing Query Results ��������������������������������������������������������������������������������������������������������� 650
Determining the Rows Selected and Rows Affected ����������������������������������������������������������� 653
Working with Prepared Statements ������������������������������������������������������������������������������������� 654
Table of ConTenTs
xix
Executing Database Transactions ��������������������������������������������������������������������������������������������� 661
Enabling Autocommit Mode ������������������������������������������������������������������������������������������������� 662
Committing a Transaction ���������������������������������������������������������������������������������������������������� 662
Rolling Back a Transaction �������������������������������������������������������������������������������������������������� 662
Summary����������������������������������������������������������������������������������������������������������������������������������� 662
Chapter 28: Introducing PDO �������������������������������������������������������������������������������� 663
Another Database Abstraction Layer? ��������������������������������������������������������������������������������������� 665
PDO’s Database Options ������������������������������������������������������������������������������������������������������ 666
Using PDO ��������������������������������������������������������������������������������������������������������������������������������� 666
Installing PDO ���������������������������������������������������������������������������������������������������������������������� 667
Connecting to a Database Server and Selecting a Database ���������������������������������������������� 668
Handling Errors �������������������������������������������������������������������������������������������������������������������� 672
Getting and Setting Attributes ��������������������������������������������������������������������������������������������� 674
Executing Queries ���������������������������������������������������������������������������������������������������������������� 675
Introducing Prepared Statements ���������������������������������������������������������������������������������������� 677
Retrieving Data �������������������������������������������������������������������������������������������������������������������� 682
Setting Bound Columns ������������������������������������������������������������������������������������������������������� 686
Working with Transactions �������������������������������������������������������������������������������������������������� 688
Summary����������������������������������������������������������������������������������������������������������������������������������� 688
Chapter 29: Stored Routines ��������������������������������������������������������������������������������� 689
Should You Use Stored Routines? ��������������������������������������������������������������������������������������������� 690
Stored Routine Advantages ������������������������������������������������������������������������������������������������� 690
Stored Routine Disadvantages �������������������������������������������������������������������������������������������� 691
How MySQL Implements Stored Routines��������������������������������������������������������������������������������� 691
Creating a Stored Routine ��������������������������������������������������������������������������������������������������� 692
Declaring and Setting Variables ������������������������������������������������������������������������������������������ 696
Executing a Stored Routine ������������������������������������������������������������������������������������������������� 698
Creating and Using Multistatement Stored Routines ����������������������������������������������������������� 698
Calling a Routine from Within Another Routine ������������������������������������������������������������������� 708
Modifying a Stored Routine ������������������������������������������������������������������������������������������������� 709
Deleting a Stored Routine ���������������������������������������������������������������������������������������������������� 710
Table of ConTenTs
xx
Viewing a Routine’s Status �������������������������������������������������������������������������������������������������� 710
Viewing a Routine’s Creation Syntax ����������������������������������������������������������������������������������� 712
Handling Conditions������������������������������������������������������������������������������������������������������������� 713
Integrating Routines into Web Applications ������������������������������������������������������������������������������ 713
Creating the Employee Bonus Interface ������������������������������������������������������������������������������ 713
Retrieving Multiple Rows ����������������������������������������������������������������������������������������������������� 715
Summary����������������������������������������������������������������������������������������������������������������������������������� 716
Chapter 30: MySQL Triggers ��������������������������������������������������������������������������������� 717
Introducing Triggers ������������������������������������������������������������������������������������������������������������������ 717
Why Use Triggers? ��������������������������������������������������������������������������������������������������������������� 718
Taking Action Before an Event ��������������������������������������������������������������������������������������������� 719
Taking Action After an Event ������������������������������������������������������������������������������������������������ 719
Before Triggers vs� After Triggers ���������������������������������������������������������������������������������������� 720
MySQL’s Trigger Support ����������������������������������������������������������������������������������������������������������� 721
Creating a Trigger ���������������������������������������������������������������������������������������������������������������� 722
Viewing Existing Triggers����������������������������������������������������������������������������������������������������� 724
Modifying a Trigger �������������������������������������������������������������������������������������������������������������� 727
Deleting a Trigger ���������������������������������������������������������������������������������������������������������������� 728
Integrating Triggers into Web Applications �������������������������������������������������������������������������������� 729
Summary����������������������������������������������������������������������������������������������������������������������������������� 731
Chapter 31: MySQL Views ������������������������������������������������������������������������������������� 733
Introducing Views ��������������������������������������������������������������������������������������������������������������������� 734
MySQL’s View Support��������������������������������������������������������������������������������������������������������������� 735
Creating and Executing Views ��������������������������������������������������������������������������������������������� 735
Viewing View Information ���������������������������������������������������������������������������������������������������� 743
Modifying a View ����������������������������������������������������������������������������������������������������������������� 746
Deleting a View �������������������������������������������������������������������������������������������������������������������� 746
Updating Views �������������������������������������������������������������������������������������������������������������������� 747
Incorporating Views into Web Applications ������������������������������������������������������������������������������� 748
Summary����������������������������������������������������������������������������������������������������������������������������������� 750
Table of ConTenTs
xxi
Chapter 32: Practical Database Queries ��������������������������������������������������������������� 751
Sample Data ������������������������������������������������������������������������������������������������������������������������������ 752
Creating Tabular Output ������������������������������������������������������������������������������������������������������������ 752
Installing HTML_Table ��������������������������������������������������������������������������������������������������������� 753
Creating a Simple Table ������������������������������������������������������������������������������������������������������� 754
Creating More Readable Row Output ���������������������������������������������������������������������������������� 756
Creating a Table from Database Data ���������������������������������������������������������������������������������� 756
Sorting Output ��������������������������������������������������������������������������������������������������������������������������� 758
Creating Paged Output �������������������������������������������������������������������������������������������������������������� 760
Listing Page Numbers ��������������������������������������������������������������������������������������������������������������� 763
Querying Multiple Tables with Subqueries �������������������������������������������������������������������������������� 765
Performing Comparisons with Subqueries �������������������������������������������������������������������������� 767
Determining Existence with Subqueries ����������������������������������������������������������������������������� 767
Performing Database Maintenance with Subqueries ���������������������������������������������������������� 769
Using Subqueries with PHP ������������������������������������������������������������������������������������������������� 770
Iterating Result Sets with Cursors �������������������������������������������������������������������������������������������� 770
Cursor Basics ���������������������������������������������������������������������������������������������������������������������� 771
Creating a Cursor ����������������������������������������������������������������������������������������������������������������� 772
Opening a Cursor ����������������������������������������������������������������������������������������������������������������� 772
Using a Cursor ��������������������������������������������������������������������������������������������������������������������� 772
Closing a Cursor ������������������������������������������������������������������������������������������������������������������ 774
Using Cursors with PHP ������������������������������������������������������������������������������������������������������� 774
Summary����������������������������������������������������������������������������������������������������������������������������������� 775
Chapter 33: Indexes and Searching ���������������������������������������������������������������������� 777
Database Indexing �������������������������������������������������������������������������������������������������������������������� 777
Primary Key Indexes ������������������������������������������������������������������������������������������������������������ 778
Unique Indexes �������������������������������������������������������������������������������������������������������������������� 780
Normal Indexes�������������������������������������������������������������������������������������������������������������������� 781
Full-Text Indexes ����������������������������������������������������������������������������������������������������������������� 784
Indexing Best Practices ������������������������������������������������������������������������������������������������������� 790
Table of ConTenTs
xxii
Forms-Based Searches ������������������������������������������������������������������������������������������������������������� 791
Performing a Simple Search ������������������������������������������������������������������������������������������������ 791
Extending Search Capabilities ��������������������������������������������������������������������������������������������� 793
Performing a Full-Text Search ��������������������������������������������������������������������������������������������� 795
Summary����������������������������������������������������������������������������������������������������������������������������������� 796
Chapter 34: Transactions �������������������������������������������������������������������������������������� 797
What’s a Transaction? ��������������������������������������������������������������������������������������������������������������� 797
MySQL’s Transactional Capabilities ������������������������������������������������������������������������������������������� 798
System Requirements ��������������������������������������������������������������������������������������������������������� 799
Table Creation ���������������������������������������������������������������������������������������������������������������������� 799
A Sample Project ����������������������������������������������������������������������������������������������������������������������� 800
Creating Tables and Adding Sample Data ���������������������������������������������������������������������������� 801
Executing an Example Transaction �������������������������������������������������������������������������������������� 802
Usage Tips ��������������������������������������������������������������������������������������������������������������������������� 804
Building Transactional Applications with PHP ��������������������������������������������������������������������������� 805
The Swap Meet Revisited ���������������������������������������������������������������������������������������������������� 805
Summary����������������������������������������������������������������������������������������������������������������������������������� 808
Chapter 35: Importing and Exporting Data ����������������������������������������������������������� 809
Sample Table ����������������������������������������������������������������������������������������������������������������������������� 810
Using Data Delimitation ������������������������������������������������������������������������������������������������������������ 810
Importing Data �������������������������������������������������������������������������������������������������������������������������� 811
Importing Data with LOAD DATA INFILE ������������������������������������������������������������������������������� 811
Importing Data with mysqlimport ���������������������������������������������������������������������������������������� 816
Loading Table Data with PHP ����������������������������������������������������������������������������������������������� 821
Exporting Data �������������������������������������������������������������������������������������������������������������������������� 822
SELECT INTO OUTFILE ���������������������������������������������������������������������������������������������������������� 822
Summary����������������������������������������������������������������������������������������������������������������������������������� 825
Index ��������������������������������������������������������������������������������������������������������������������� 827
Table of ConTenTs
xxiii
Frank M. Kromann has spent more than 30 years solving
business problems using software and technology. Since
the introduction of the first web browser, he has developed
systems with web technology on Unix, Linux, Windows, and
Mac platforms, with the primary focus on PHP, JavaScript,
C/C++, and other languages. He has contributed several
PHP extensions over the years and has been a member of the
PHP development team since 1997. Previous publications
have included several articles in PHP Magazine, and
he was the co-author of PHP 5 Recipes (Apress, 2005).
Frank M. Kromann has held managing positions for more than 20 years, leading both
smaller and larger teams in development and implementation of business systems and
processes utilizing databases and programming. Currently he is a Software Development
Manager at Amazon and the CEO and co-founder of Web by Pixel, LLC. Kromann holds
a Master of Science degree in Electrical Engineering from the Technical University of
Denmark.
About the Author
xxv
Introduction
This marks the fifth edition of Beginning PHP and MySQL. This revision focuses on the
new additions to PHP and new versions of MySQL. Since the last revision, PHP released
version 7 with many language enhancements and improvements to performance, in
some cases more than twice as fast and using less than half the memory compared
to PHP 5.6. During the writing of this book, version 7.0, 7.1, and 7.2 was released; and
before the ink on this book is dry, PHP 7.3 will be released.
The MySQL database has also seen many changes. First of all, the acquisition by
Oracle and subsequent release of Maria DB, a fork of the MySQL version with both
performance and feature improvements and a fast-growing community, has taken
the new version to heart. It is, in fact, the standard MySQL database on many Linux
distributions today.
This book will teach you to install and configure PHP and MySQL with both
performance and security in mind and highlight some of the new functionality available
in PHP 7 as well as new data types supported by the current version of MySQL.