PHPNotesForProfessionals.pdf

(3559 KB) Pobierz
Notes for Professionals
PHP
PHP
Notes for Professionals
of professional hints and tricks
400+ pages
GoalKicker.com
Free Programming Books
Disclaimer
This is an unocial free book created for educational purposes and is
not aliated with ocial PHP group(s) or company(s).
All trademarks and registered trademarks are
the property of their respective owners
Contents
About
................................................................................................................................................................................... 1
Chapter 1: Getting started with PHP
................................................................................................................... 2
Section 1.1: HTML output from web server
.................................................................................................................. 2
Section 1.2: Hello, World!
............................................................................................................................................... 3
Section 1.3: Non-HTML output from web server
........................................................................................................ 3
Section 1.4: PHP built-in server
..................................................................................................................................... 5
Section 1.5: PHP CLI
....................................................................................................................................................... 5
Section 1.6: Instruction Separation
............................................................................................................................... 6
Section 1.7: PHP Tags
.................................................................................................................................................... 7
Chapter 2: Variables
.................................................................................................................................................... 9
Section 2.1: Accessing A Variable Dynamically By Name (Variable variables)
...................................................... 9
Section 2.2: Data Types
.............................................................................................................................................. 10
Section 2.3: Global variable best practices
............................................................................................................... 13
Section 2.4: Default values of uninitialized variables
.............................................................................................. 14
Section 2.5: Variable Value Truthiness and Identical Operator
............................................................................. 15
Chapter 3: Variable Scope
..................................................................................................................................... 18
Section 3.1: Superglobal variables
............................................................................................................................. 18
Section 3.2: Static properties and variables
............................................................................................................. 18
Section 3.3: User-defined global variables
............................................................................................................... 19
Chapter 4: Superglobal Variables PHP
........................................................................................................... 21
Section 4.1: Suberglobals explained
.......................................................................................................................... 21
Section 4.2: PHP5 SuperGlobals
................................................................................................................................. 28
Chapter 5: Outputting the Value of a Variable
.......................................................................................... 32
Section 5.1: echo and print
.......................................................................................................................................... 32
Section 5.2: Outputting a structured view of arrays and objects
.......................................................................... 33
Section 5.3: String concatenation with echo
............................................................................................................. 35
Section 5.4: printf vs sprintf
........................................................................................................................................ 36
Section 5.5: Outputting large integers
...................................................................................................................... 36
Section 5.6: Output a Multidimensional Array with index and value and print into the table
............................. 37
Chapter 6: Constants
................................................................................................................................................ 39
Section 6.1: Defining constants
................................................................................................................................... 39
Section 6.2: Class Constants
...................................................................................................................................... 40
Section 6.3: Checking if constant is defined
............................................................................................................. 40
Section 6.4: Using constants
...................................................................................................................................... 42
Section 6.5: Constant arrays
...................................................................................................................................... 42
Chapter 7: Magic Constants
.................................................................................................................................. 43
Section 7.1: Dierence between __FUNCTION__ and __METHOD__
................................................................. 43
Section 7.2: Dierence between __CLASS__, get_class() and get_called_class()
........................................... 43
Section 7.3: File & Directory Constants
..................................................................................................................... 44
Chapter 8: Comments
.............................................................................................................................................. 45
Section 8.1: Single Line Comments
............................................................................................................................ 45
Section 8.2: Multi Line Comments
.............................................................................................................................. 45
Chapter 9: Types
......................................................................................................................................................... 46
Section 9.1: Type Comparison
.................................................................................................................................... 46
Section 9.2: Boolean
.................................................................................................................................................... 46
Section 9.3: Float
......................................................................................................................................................... 47
Section 9.4: Strings
...................................................................................................................................................... 48
Section 9.5: Callable
.................................................................................................................................................... 50
Section 9.6: Resources
................................................................................................................................................ 50
Section 9.7: Type Casting
........................................................................................................................................... 51
Section 9.8: Type Juggling
......................................................................................................................................... 51
Section 9.9: Null
........................................................................................................................................................... 52
Section 9.10: Integers
.................................................................................................................................................. 52
Chapter 10: Operators
.............................................................................................................................................. 54
Section 10.1: Null Coalescing Operator (??)
.............................................................................................................. 54
Section 10.2: Spaceship Operator (<=>)
.................................................................................................................... 55
Section 10.3: Execution Operator (``)
.......................................................................................................................... 55
Section 10.4: Incrementing (++) and Decrementing Operators (--)
....................................................................... 55
Section 10.5: Ternary Operator (?:)
........................................................................................................................... 56
Section 10.6: Logical Operators (&&/AND and ||/OR)
............................................................................................. 57
Section 10.7: String Operators (. and .=)
.................................................................................................................... 57
Section 10.8: Object and Class Operators
................................................................................................................. 57
Section 10.9: Combined Assignment (+= etc)
........................................................................................................... 59
Section 10.10: Altering operator precedence (with parentheses)
........................................................................... 59
Section 10.11: Basic Assignment (=)
............................................................................................................................ 60
Section 10.12: Association
............................................................................................................................................ 60
Section 10.13: Comparison Operators
........................................................................................................................ 60
Section 10.14: Bitwise Operators
................................................................................................................................. 62
Section 10.15: instanceof (type operator)
................................................................................................................. 64
Chapter 11: References
............................................................................................................................................ 67
Section 11.1: Assign by Reference
............................................................................................................................... 67
Section 11.2: Return by Reference
.............................................................................................................................. 67
Section 11.3: Pass by Reference
................................................................................................................................. 68
Chapter 12: Arrays
...................................................................................................................................................... 71
Section 12.1: Initializing an Array
................................................................................................................................ 71
Section 12.2: Check if key exists
................................................................................................................................. 73
Section 12.3: Validating the array type
..................................................................................................................... 74
Section 12.4: Creating an array of variables
............................................................................................................ 74
Section 12.5: Checking if a value exists in array
....................................................................................................... 74
Section 12.6: ArrayAccess and Iterator Interfaces
................................................................................................... 75
Chapter 13: Array iteration
.................................................................................................................................... 79
Section 13.1: Iterating multiple arrays together
........................................................................................................ 79
Section 13.2: Using an incremental index
.................................................................................................................. 80
Section 13.3: Using internal array pointers
............................................................................................................... 80
Section 13.4: Using foreach
......................................................................................................................................... 81
Section 13.5: Using ArrayObject Iterator
................................................................................................................... 83
Chapter 14: Executing Upon an Array
.............................................................................................................. 84
Section 14.1: Applying a function to each element of an array
.............................................................................. 84
Section 14.2: Split array into chunks
.......................................................................................................................... 85
Section 14.3: Imploding an array into string
............................................................................................................. 86
Section 14.4: "Destructuring" arrays using list()
....................................................................................................... 86
Section 14.5: array_reduce
......................................................................................................................................... 86
Section 14.6: Push a Value on an Array
..................................................................................................................... 87
Chapter 15: Manipulating an Array
.................................................................................................................... 89
Section 15.1: Filtering an array
.................................................................................................................................... 89
Section 15.2: Removing elements from an array
..................................................................................................... 90
Section 15.3: Sorting an Array
.................................................................................................................................... 91
Section 15.4: Whitelist only some array keys
........................................................................................................... 96
Section 15.5: Adding element to start of array
......................................................................................................... 96
Section 15.6: Exchange values with keys
................................................................................................................... 97
Section 15.7: Merge two arrays into one array
........................................................................................................ 97
Chapter 16: Processing Multiple Arrays Together
..................................................................................... 99
Section 16.1: Array intersection
................................................................................................................................... 99
Section 16.2: Merge or concatenate arrays
.............................................................................................................. 99
Section 16.3: Changing a multidimensional array to associative array
.............................................................. 100
Section 16.4: Combining two arrays (keys from one, values from another)
...................................................... 100
Chapter 17: Datetime Class
................................................................................................................................. 102
Section 17.1: Create Immutable version of DateTime from Mutable prior PHP 5.6
............................................ 102
Section 17.2: Add or Subtract Date Intervals
.......................................................................................................... 102
Section 17.3: getTimestamp
..................................................................................................................................... 102
Section 17.4: setDate
................................................................................................................................................. 103
Section 17.5: Create DateTime from custom format
............................................................................................. 103
Section 17.6: Printing DateTimes
.............................................................................................................................. 103
Chapter 18: Working with Dates and Time
.................................................................................................. 105
Section 18.1: Getting the dierence between two dates / times
.......................................................................... 105
Section 18.2: Convert a date into another format
................................................................................................. 105
Section 18.3: Parse English date descriptions into a Date format
........................................................................ 107
Section 18.4: Using Predefined Constants for Date Format
................................................................................. 107
Chapter 19: Control Structures
.......................................................................................................................... 109
Section 19.1: if else
..................................................................................................................................................... 109
Section 19.2: Alternative syntax for control structures
.......................................................................................... 109
Section 19.3: while
...................................................................................................................................................... 109
Section 19.4: do-while
................................................................................................................................................ 110
Section 19.5: goto
...................................................................................................................................................... 110
Section 19.6: declare
.................................................................................................................................................. 110
Section 19.7: include & require
................................................................................................................................. 111
Section 19.8: return
.................................................................................................................................................... 112
Section 19.9: for
......................................................................................................................................................... 112
Section 19.10: foreach
................................................................................................................................................ 113
Section 19.11: if elseif else
.......................................................................................................................................... 113
Section 19.12: if
........................................................................................................................................................... 114
Section 19.13: switch
................................................................................................................................................... 114
Chapter 20: Loops
.................................................................................................................................................... 116
Section 20.1: continue
............................................................................................................................................... 116
Section 20.2: break
................................................................................................................................................... 117
Section 20.3: foreach
................................................................................................................................................ 118
Section 20.4: do...while
.............................................................................................................................................. 118
Section 20.5: for
........................................................................................................................................................ 119
Section 20.6: while
..................................................................................................................................................... 120
Chapter 21: Functions
............................................................................................................................................. 121
Section 21.1: Variable-length argument lists
........................................................................................................... 121
Section 21.2: Optional Parameters
.......................................................................................................................... 122
Section 21.3: Passing Arguments by Reference
..................................................................................................... 123
Section 21.4: Basic Function Usage
......................................................................................................................... 124
Section 21.5: Function Scope
.................................................................................................................................... 124
Chapter 22: Functional Programming
............................................................................................................ 125
Section 22.1: Closures
................................................................................................................................................ 125
Section 22.2: Assignment to variables
.................................................................................................................... 126
Section 22.3: Objects as a function
......................................................................................................................... 126
Section 22.4: Using outside variables
..................................................................................................................... 127
Section 22.5: Anonymous function
.......................................................................................................................... 127
Section 22.6: Pure functions
..................................................................................................................................... 128
Section 22.7: Common functional methods in PHP
............................................................................................... 128
Section 22.8: Using built-in functions as callbacks
................................................................................................ 129
Section 22.9: Scope
................................................................................................................................................... 129
Section 22.10: Passing a callback function as a parameter
................................................................................. 129
Chapter 23: Alternative Syntax for Control Structures
........................................................................ 131
Section 23.1: Alternative if/else statement
............................................................................................................. 131
Section 23.2: Alternative for statement
.................................................................................................................. 131
Section 23.3: Alternative while statement
............................................................................................................... 131
Section 23.4: Alternative foreach statement
.......................................................................................................... 131
Section 23.5: Alternative switch statement
............................................................................................................. 132
Chapter 24: String formatting
.......................................................................................................................... 133
Section 24.1: String interpolation
............................................................................................................................. 133
Section 24.2: Extracting/replacing substrings
....................................................................................................... 134
Chapter 25: String Parsing
................................................................................................................................... 136
Section 25.1: Splitting a string by separators
......................................................................................................... 136
Section 25.2: Substring
............................................................................................................................................. 136
Section 25.3: Searching a substring with strpos
.................................................................................................... 138
Section 25.4: Parsing string using regular expressions
......................................................................................... 139
Chapter 26: Classes and Objects
...................................................................................................................... 140
Section 26.1: Class Constants
................................................................................................................................... 140
Section 26.2: Abstract Classes
................................................................................................................................. 142
Section 26.3: Late static binding
.............................................................................................................................. 144
Section 26.4: Namespacing and Autoloading
........................................................................................................ 145
Section 26.5: Method and Property Visibility
.......................................................................................................... 147
Section 26.6: Interfaces
............................................................................................................................................ 149
Section 26.7: Final Keyword
..................................................................................................................................... 152
Section 26.8: Autoloading
......................................................................................................................................... 153
Section 26.9: Calling a parent constructor when instantiating a child
................................................................ 154
Section 26.10: Dynamic Binding
............................................................................................................................... 155
Section 26.11: $this, self and static plus the singleton
............................................................................................ 156
Section 26.12: Defining a Basic Class
...................................................................................................................... 159
Section 26.13: Anonymous Classes
.......................................................................................................................... 160
Chapter 27: Namespaces
..................................................................................................................................... 162
Section 27.1: Declaring namespaces
....................................................................................................................... 162
Section 27.2: Referencing a class or function in a namespace
........................................................................... 162
Section 27.3: Declaring sub-namespaces
............................................................................................................... 163
Section 27.4: What are Namespaces?
.................................................................................................................... 164
Chapter 28: Sessions
............................................................................................................................................... 165
Section 28.1: session_start() Options
...................................................................................................................... 165
Section 28.2: Session Locking
.................................................................................................................................. 165
Section 28.3: Manipulating session data
................................................................................................................. 166
Section 28.4: Destroy an entire session
.................................................................................................................. 166

Plik z chomika:

Inne pliki z tego folderu:

Inne foldery tego chomika:

Zgłoś jeśli naruszono regulamin