PHP

Introducing PHP                                                                                                      

Configuring Your Environment                                                                 

Installation Prerequisites,Downloading Apache,  Downloading PHP, Downloading the Documentation                                                                                                                 

Installing Apache and PHP on Linux / Installing Apache and PHP on Windows/Installing IIS and

PHP on Windows                                                                                       

Testing Your Installation                                                                                                       

Configuring PHP                                                                                                                   

Configuring PHP at Build Time on Linux, Customizing the Windows Build                                                                                                                   

Run-Time Configuration                                                                                                       

Managing PHP’s Configuration Directives, PHP’s Configuration Directives, Choosing a Code Editor, Adobe Dreamweaver CS, Notepad++                                                                                                                                                   

PDT (PHP Development Tools), Zend Studio                                                                                                                                                  

Choosing a Web Hosting Provider                                                                                        

Seven Questions for Any Prospective Hosting Provider                                                                               

                                                                                                                                

PHP Basics                                                                                               

Embedding PHP Code in Your Web Pages                                                                            

Default Syntax, Short-Tags, Script, ASP Style, Embedding Multiple Code Blocks                                                                                                                

Commenting Your Code                                                                                                        

Single-Line C++ Syntax, Shell Syntax, Multiple-Line C Syntax    

Outputting Data to the Browser                                                                                            

The print() Statement, The echo() Statement, The printf() Statement, The sprintf() Statement                                                                                                                                

PHP’s Supported Data Types                                                                                                

Scalar Data Types, Compound Data Types, Converting Between Data Types Using Type Casting, Adapting Data Types with Type Juggling, Type-Related Functions, Type Identifier Functions                                                                                                                              

Identifiers                                                                                                                             

Variables                                                                                                                              

Variable Declaration                                                                                                                                     

Variable Scope                                                                                                                                             

PHP’s Superglobal Variables                                                                                                                        

Variable Variables                                                                                                                                        

Constants                                                                                                                             

Expressions                                                                                                                          

Operands                                                                                                                                                      

Operators                                                                                                                                                     

String Interpolation                                                                                                              

Double Quotes                                                                                                                                              

Escape Sequences                                                                                                                                       

Single Quotes                                                                                                                                               

Curly Braces                                                                                                                                                 

Heredoc                                                                                                                                                        

Control Structures                                                                                                                

Conditional Statements                                                                                                                                

Looping Statements                                                                                                                                     

File-Inclusion Statements                                                                                                                  

Functions                                                                                                 

Invoking a Function                                                                                                              

Creating a Function                                                                                                          

Passing Arguments by Value                                                                                                                        

Passing Arguments by Reference                                                                                                            

Default Argument Values                                                                                                                             

Using Type Hinting                                                                                                                                       

Returning Values from a Function                                                                                                                

Recursive Functions                                                                                                                                     

Function Libraries                                                                                                                

                                                                                                                                

Arrays                                                                                                      

What Is an Array?                                                                                                                 

Creating an Array                                                                                                             

Creating Arrays with array()                                                                                                                         

Extracting Arrays with list()                                                                                                                          

Populating Arrays with a Predefined Value Range                                                                                       

Testing for an Array                                                                                                                                     

Outputting an Array                                                                                                          

Printing Arrays for Testing Purposes        

 

                                                                                                  

Adding and Removing Array Elements                                                                                 

Adding a Value to the Front of an Array        

Adding a Value to the End of an Array                                                                                                         

Removing a Value from the Front of an Array                                                                                              

Removing a Value from the End of an Array                                                                                                

Locating Array Elements                                                                                                      

Searching an Array                                                                                                                                  

Retrieving Array Keys                                                                                                                                   

Retrieving Array Values                                                                                                                                

Traversing Arrays                                                                                                                 

Retrieving the Current Array Key                                                                                                                 

Retrieving the Current Array Value                                                                                                               

Retrieving the Current Array Key and Value                                                                                                 

Moving the Array Pointer                                                                                                                         

Passing Array Values to a Function                                                                                                              

Determining Array Size and Uniqueness                                                                              

Determining the Size of an Array                                                                                                                 

Counting Array Value Frequency                                                                                                                  

Determining Unique Array Values                                                                                                            

Sorting Arrays                                                                                                                      

Reversing Array Element Order                                                                                                                    

Flipping Array Keys and Values                                                                                                                    

Sorting an Array                                                                                                                                           

Merging, Slicing, Splicing, and Dissecting Arrays                                                                

Merging Arrays                                                                                                                                             

Recursively Appending Arrays                                                                                                                     

Combining Two Arrays                                                                                                                                 

Slicing an Array                                                                                                                                            

Splicing an Array                                                                                                                                          

Calculating an Array Intersection                                                                                                                 

Calculating Associative Array Intersections                                                                                                   

Calculating Array Differences                                                                                                                      

Calculating Associative Array Differences                                                                                               

Other Useful Array Functions                                                                                               

Returning a Random Set of Keys                                                                                                                 

Shuffling Array Elements                                                                                                                             

                                                                                                                                

Object-Oriented PHP                                                                                

The Benefits of OOP                                                                                                             

Encapsulation                                                                                                                                               

Inheritance                                                                                                                                                   

Polymorphism                                                                                                                                              

Key OOP Concepts                                                                                                                

Classes                                                                                                                                                         

Objects                                                                                                                                                         

Properties                                                                                                                                                     

Constants                                                                                                                                                     

Methods                                                                                                                                                       

Constructors and Destructors                                                                                              

Constructors                                                                                                                                                 

Destructors                                                                                                                                                  

Static Class Members                                                                                                      

The instanceof Keyword                                                                                                       

Helper Functions                                                                                                                  

Autoloading Objects                                                                                                             

                                                                                                                                

Advanced OOP Features                                                                           

Advanced OOP Features Not Supported by PHP                                                                   

Object Cloning                                                                                                                      

Cloning Example                                                                                                                                      

The __clone() Method                                                                                                                                  

Inheritance                                                                                                                       

Class Inheritance                                                                                                                                         

Inheritance and Constructors                                                                                                                       

Inheritance and Late Static Binding                                                                                                             

Interfaces                                                                                                                             

Implementing a Single Interface                                                                                                                  

Implementing Multiple Interfaces                                                                                                                

Abstract Classes                                                                                                                   

Introducing Namespaces                                                                                                     

Error and Exception Handling                                                                  

Configuration Directives                                                                                                       

Error Logging                                                                                                                        

Exception Handling                                                                                                              

Why Exception Handling Is Handy                                                                                                                

PHP’s Exception-Handling Implementation                                                                                                  

SPL’s Exceptions                                                                                                                                          

                                                                                                                                

Strings and Regular Expressions                                                            

Regular Expressions                                                                                                             

Regular Expression Syntax (POSIX)                                                                                                              

PHP’s Regular Expression Functions (POSIX Extended)                                                                               

Regular Expression Syntax (Perl)                                                                                                                 

Other String-Specific Functions  

Determining the Length of a String                                                                                                              

Comparing Two Strings                                                                                                                                

Manipulating String Case                                                                                                                             

Converting Strings to and from HTML                                                                                                          

Alternatives for Regular Expression Functions                                                                    

Padding and Stripping a String                                                                                                                    

Counting Characters and Words                                                                                                                  

Taking Advantage of PEAR: Validate_US                                                                              

Installing Validate_US                                                                                                                                  

Using Validate_US                                                                                                                                        

                                                                                                                                

Working with the File and Operating System                                    

Learning About Files and Directories                                                                                   

Parsing Directory Paths                                                                                                                               

Calculating File, Directory, and Disk Sizes                                                                                                   

Determining Access and Modification Times                                                                                               

Working with Files                                                                                                                

The Concept of a Resource                                                                                                                      

Recognizing Newline Characters                                                                                                                 

Recognizing the End-of-File Character                                                                                                        

Opening and Closing a File                                                                                                                           

Reading from a File                                                                                                                                      

Writing a String to a File                                                                                                                              

Moving the File Pointer                                                                                                                                

Reading Directory Contents                                                                                                                         

Executing Shell Commands                                                                                                  

System-Level Program Execution                                                                                    

Sanitizing the Input                                                                                                                                       

PHP’s Program Execution Functions                                                                                                            

                                                                                                                                

Date and Time                                                                                        

The Unix Timestamp                                                                                                             

PHP’s Date and Time Library                                                                                                

Validating Dates                                                                                                                                           

Formatting Dates and Times                                                                                                                        

Converting a Timestamp to User-Friendly Values                                                                                        

Working with Timestamps                                                                                                                           

Displaying the Localized Date and Time    

Displaying the Web Page’s Most Recent Modification Date                                                                         

Determining the Number of Days in the Current Month                                                                               

Determining the Number of Days in Any Given Month                                                                                 

Calculating the Date X Days from the Present Date                                                                                     

Date and Time Enhancements for PHP      + Users                                                              

Introducing the DateTime Constructor                                                                                                         

Formatting Dates                                                                                                                                     

Setting the Date After Instantiation                                                                                                              

Setting the Time After Instantiation                                                                                                         

Modifying Dates and Times                                                                                                                          

Calculating the Difference between Two Dates                                                                                           

Working with HTML Forms                                                                     

PHP and Web Forms                                                                                                             

A Simple Example                                                                                                                                        

Validating Form Data                                                                                                            

File Deletion                                                                                                                                                 

Cross-Site Scripting                                                                                                                                     

Sanitizing User Input                                                                                                                                    

Validating and Sanitizing Data with the Filter Extension                                                                             

Working with Multivalued Form Components                                                                                              

Taking Advantage of PEAR: HTML_QuickForm                                                                     

Installing HTML_QuickForm                                                                                                                         

Creating and Validating a Simple Form                                                                        

Authenticating Your Users                                                                     

HTTP Authentication Concepts                                                                                             

Using Apache’s  htaccess Feature                                                                                                               

Authenticating Your Users with PHP                                                                                    

PHP’s Authentication Variables                                                                                                                    

Useful Functions                                                                                                                                          

Hard-Coded Authentication                                                                                                                          

File-Based Authentication                                                                                                                            

Database-Based Authentication                                                                                                                        

User Login Administration                                                                                                    

Testing Password Guessability with the CrackLib Library                                                                       

One-Time URLs and Password Recovery                                                                                                     

                                                                                                                                

Handling File Uploads                                                                            

Uploading Files via HTTP                                                                                                      

Uploading Files with PHP                                                                                                     

PHP’s File Upload/Resource Directives                                                                                                        

The $_FILES Array                                                                                                                                        

PHP’s File-Upload Functions                                                                                                                        

Upload Error Messages                                                                                                                                

A Simple Example                                                                                                                                    

                                                                                      

Session Handlers                                                                                   

What Is Session Handling?                                                                                                   

The Session-Handling Process                                                                                                                    

Configuration Directives      

Managing the Session Storage Media                                                                                                         

Setting the Session Files Path                                                                                                                     

Automatically Enabling Sessions                                                                                                                 

Setting the Session Name                                                                                                                            

Choosing Cookies or URL Rewriting                                                                                                             

Automating URL Rewriting                                                                                                                           

Setting the Session Cookie Lifetime                                                                                                            

Setting the Session Cookie’s Valid URL Path                                                                                               

Setting Caching Directions for Session-Enabled Pages                                                                               

Working with Sessions                                                                                                         

Starting a Session                                                                                                                                        

Destroying a Session                                                                                                                                   

Setting and Retrieving the Session ID                                                                                                          

Creating and Deleting Session Variables                                                                                                 

Encoding and Decoding Session Data                                                                                                          

Practical Session-Handling Examples                                                                                  

Automatically Logging In Returning Users                                                                                                   

Generating a Recently Viewed Document Index                                                                                          

Creating Custom Session Handlers                                                                                      

Tying Custom Session Functions into PHP’s Logic                                                                                  

Using Custom MySQL-Based Session Handlers                                                                                           

                                                                                                                                

                                                                                                                               

                                                     

Creating Ajax-enhanced Features with jQuery and PHP                        

Introducing Ajax                                                                                                                   

Introducing jQuery                                                                                                                

Installing jQuery                                                                                                                                       

A Simple Example                                                                                                                                        

Responding to Events                                                                                                                             

jQuery and the DOM                                                                                                                                     

Creating a Username Existence Validator                                                                            

Determining If a Username Exists                                                                                                                

                                                                        

              

                                                                                                                 

Introducing MySQL                                                                                

What Makes MySQL So Popular?                                                                                         

Flexibility                                                                                                                                                      

Power                                                                                                                                                           

Flexible Licensing Options                                                                                                                           

A (Hyper)Active User Community                                                                                                                 

The Evolution of MySQL                                  

Installing and Configuring MySQL                                                         

Downloading MySQL                                                                                                            

Installing MySQL                                                                                                                  

Installing MySQL on Linux                                                                                                                            

Installing and Configuring MySQL on Windows                                                                                           

Setting the MySQL Administrator Password                                                                        

Starting and Stopping MySQL                                                                                              

Controlling the Daemon Manually                                                                                    

Configuring PHP to Work with MySQL                                                                                  

Reconfiguring PHP on Linux                                                                                                                         

Reconfiguring PHP on Windows                                                                

The Many MySQL Clients                                                                        

Introducing the Command-Line Clients                                                                                

The mysql Client                                                                                                                                          

The mysqladmin Client                                                                                                                                 

Other Useful Clients                                                                                                                                     

Client Options                                                                                                                                               

MySQL’s GUI Client Programs                                                                                              

phpMyAdmin                                                                                                                        

                                                                 

                                                                                                               

Using PHP with MySQL                                                                          

Installation Prerequisites                                                                                                      

Enabling the mysqli Extension on Linux/Unix                                                                                          

Enabling the mysqli Extension on Windows                                                                                                 

Using the MySQL Native Driver                                                                                                                    

Managing User Privileges                                                                                                                            

Working with Sample Data                                                                                                                          

Using the mysqli Extension                                                                                                  

Setting Up and Tearing Down the Connection                                                                                             

Handling Connection Errors                                                                                                                         

Retrieving Error Information                                                                                                                         

Storing Connection Information in a Separate File                                                                                      

Securing Your Connection Information                                                                                                    

Interacting with the Database                                                                                              

Sending a Query to the Database                                                                                                                 

Parsing Query Results                                                                                                                                  

Determining the Rows Selected and Rows Affected                                                                                    

Working with Prepared Statements                                                                                                             

Executing Database Transactions                                                                                        

Enabling Autocommit Mode                                                                                                                         

Committing a Transaction                                                                                                                            

Rolling Back a Transaction                                                                                                                          

                                                                                                                                

Introducing PDO                                                                                     

Another Database Abstraction Layer?                                                                                  

Using PDO                                                                                                                             

Installing PDO                                                                                                                                               

PDO’s Database Options                                                                                                                              

Connecting to a Database Server and Selecting a Database                                                                       

Handling Errors                                                                                                                                            

Getting and Setting Attributes                                                                                                                      

Executing Queries                                                                                                                                        

Introducing Prepared Statements                                                                                                                

Retrieving Data                                                                                                                                            

Setting Bound Columns                                                                                                                                

Working with Transactions   

Importing and Exporting Data    

Sample Table                                                                                                                       

Using Data Delimitation                                                                                                        

Importing Data                                                                                                                     

Importing Data with LOAD DATA INFILE                                                                                                       

Importing Data with mysqlimport                                                                                                                

Loading Table Data with PHP                                                                                                                       

Exporting Data                                                                                                                      

SELECT INTO OUTFILE                                                                                         

 

Web Services                                                                                         

Why Web Services?                                                                                                                                                                                                                                              

SimpleXML                                                                                                                           

Loading XML                                                                                                                                                

Parsing XML                                                                                                              

JSON                                   

AJAX

Handling Ajax calls

Responding Ajax Requests

Create a RESTful Services API in PHP

Build a RESTful Webservice

URI patterns

requests for formats

HTTP Status code

Request headers.

Test the RESTful

Training Details

  • Course Duration: PHP training course duration is of 45 days. Training + Assignments + Actual Project Based Case Studies
  • Training Materials:
    All attendees will receive,
    Assignment after each module, Video recording of every session
    Notes and study material for examples covered.
    Access to the Training Blog & Repository of Materials

Course Inquiry – PHP