beginning php and mysql - springer

24
Beginning PHP and MySQL From Novice to Professional Fifth Edition Frank M. Kromann

Upload: khangminh22

Post on 16-Nov-2023

1 views

Category:

Documents


0 download

TRANSCRIPT

Beginning PHP and MySQL

From Novice to Professional

Fifth Edition

Frank M. Kromann

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.