PHP Object-Oriented Solutions Book

About the Author     xi
About the Technical Reviewer     xiii
Acknowledgments     xv
Introduction     xvii
Why Object-Oriented PHP?     3
Understanding basic OOP concepts     4
How OOP evolved     5
Using classes and objects     6
Protecting data integrity with encapsulation     8
Polymorphism is the name of the game     10
Extending classes through inheritance     10
Deciding on a class hierarchy     11
Using best practice     12
How OOP has evolved in PHP     13
OOP since PHP 5     13
Preparing for PHP 6     14
Choosing the right tools to work with PHP classes     16
Using a specialized script editor     16
Chapter review     19
Writing PHP Classes     23
Formatting code for readability     25
Using the Zend Framework PHP Coding Standard     25
Choosing descriptive names for clarity     26
Creating classes and objects     26
Defining a class     27
Controlling access to properties and methods     27
Quick review     32
Setting default valueswith a constructor method     33
Using inheritance to extend a class     36
Defining a child class     37
Accessing a parent class's methods and properties     39
Using the scope resolution operator     39
Controlling changes to methods and properties     44
Preventing a class or method from being overridden     44
Using class constants for properties     46
Creating static properties and methods     47
Quick review     49
Loading classes automatically     50
Exploring advanced OOP features     51
Creating abstract classes and methods     52
Simulating multiple inheritance with interfaces     54
Understanding which class an object is an instance of     55
Restricting acceptable data with type hinting     56
Using magic methods     59
Converting an object to a string     60
Cloning an object     60
Accessing properties automatically     64
Accessing methods automatically     65
Cleaning up with a destructor method     66
Handling errors with exceptions     67
Throwing an exception     67
Catching an exception      67
Extracting information from an exception     68
Extending the Exception class     72
Using comments to generate code hints     73
Writing PHPDoc comments     74
Chapter review     75
Taking the Pain Out of Working with Dates     77
Designing the class     78
Examining the built-in date-related classes     79
Using the DateTime class     81
Setting the default time zone in PHP     83
Examining the DateTimeZone class     85
Using the DateTimeZone class     87
Deciding how to extend the existing classes     89
Building the class     91
Creating the class file and constructor     91
Resetting the time and date     95
Accepting dates in common formats     98
Accepting a date in MM/DD/YYYY format     98
Accepting a date in DD/MM/YYYY format     99
Accepting a date in MySQL format     99
Outputting dates in common formats     100
Outputting date parts     101
Performing date-related calculations     103
Adding and subtracting days or weeks     105
Adding months     106
Subtracting months      110
Adding and subtracting years     112
Calculating the number of days between two dates     113
Creating a default date format     114
Creating read-only properties     115
Organizing and commenting the class file     117
Chapter review     118
Using PHP Filters to Validate User Input     121
Validating input with the filter functions     122
Understanding how the filter functions work     123
filter_has_var()     125
filter_list()     126
filter_id()     126
Setting filter options     127
Filtering single variables     130
Setting flags and options when filtering a single variable     134
Filtering multiple variables     136
Setting a default filter     137
Building the validation class     138
Deciding what the class will do     138
Planning how the class will work     139
Coding the validation class properties and methods     140
Naming properties and defining the constructor     140
Setting the input type and checking required fields     142
Preventing duplicate filters from being applied to a field     147
Creating the validation methods     147
Creating the methods to process the tests and get the results     157
Using the validation class     159
Sticking to your design decisions     165
Chapter review     166
Building a Versatile Remote File Connector     169
Designing the class     171
Building the class     172
Defining the constructor     172
Checking the URL     174
Retrieving the remote file     180
Defining the accessDirect() method     180
Using cURL to retrieve the remote file     186
Using a socket connection to retrieve the remote file     190
Handling the response headers from a socket connection     196
Generating error messages based on the status code     202
Final testing     204
Ideas for improving the class     204
Chapter review     205
SimpleXML-Couldn't Be Simpler     207
A quick XML primer     208
What is XML?     208
How XML documents are structured     210
The rules of writing XML     212
Using HTML entities in XML     213
Inserting HTML and other code in XML     213
Using SimpleXML     214
Loading an XML document with SimpleXML     217
Loading XML from a file     217
Loading XML from a string     218
Extracting data with SimpleXML     220
Accessing text nodes     221
Accessing attributes     221
Accessing unknown nodes     222
Saving and modifying XML with SimpleXML     228
Outputting and saving SimpleXMLElement objects     228
Modifying SimpleXMLElement objects     231
Changing the values of text and attributes     231
Removing nodes and values     232
Adding attributes     233
Adding new elements     234
Using SimpleXML with namespaces     235
How namespaces are used in XML     236
Handling namespace prefixes in SimpleXML     236
Handling namespaced attributes     241
Finding out which namespaces a document uses     242
Using SimpleXML with XPath     244
A quick introduction to XPath     244
Using XPath to drill down into XML     245
Using XPath expressions for finer control     246
Using XPath with namespaces     247
Registering namespaces to work with XPath      247
Chapter review     248
Supercharged Looping with SPL     251
Introducing iterators     252
Using an array with SPL iterators     253
Limiting the number of loops with the LimitIterator     253
Using SimpleXML with an iterator     255
Filtering     256
Setting options for RegexIterator     259
Looping sequentially through more than one set of data     263
Looking ahead with the CachingIterator     265
Using anonymous iterators as shorthand     268
Examining files and directories     269
Using DirectoryIterator     270
Including subdirectories in a single operation     271
Extracting file information with SplFileInfo     273
Finding files of a particular type     274
Reading and writing files with SplFileObject     275
Extending iterators     281
Understanding the Iterator interface     282
Extending the FilterIterator class     283
Chapter review     285
Generating XML from a Database     289
Designing the application     290
Defining the application's purpose     290
Setting the requirements      292
Building the application     292
Creating the database connection     293
Getting the database result     294
Defining the properties and constructor     295
Implementing the Iterator interface     296
Implementing the Countable interface     298
Generating the XML output     302
Defining the properties and constructor     303
Setting the SQL query     305
Setting the root and top-level node names     305
Obtaining the primary key     306
Setting output file options     307
Using XMLWriter to generate the output     307
Chapter review     317
Case Study: Creating Your Own RSS Feed     321
Understanding the RSS 2.0 format     322
The structure of an RSS 2.0 feed     322
What the [left angle bracket]channel[right angle bracket] element contains     323
What the [left angle bracket]item[right angle bracket] elements contain     325
Deciding what the feed will contain     326
Building the class     327
Populating the elements that describe the feed     328
Populating the [left angle bracket]item[right angle bracket] elements     333
Building the SQL query      334
Creating the [left angle bracket]pubDate[right angle bracket] element     338
Creating the [left angle bracket]link[right angle bracket] elements     340
Creating helper methods to format [left angle bracket]item[right angle bracket] child elements     344
Generating the XML for the [left angle bracket]item[right angle bracket] elements     346
Where to go from here     352
Index     355