دانلود کتاب PHP 8 Objects, Patterns, and Practice: Mastering OO Enhancements, Design Patterns, and Essential Development Tools

فهرست مطالب :

Table of Contents About the Author About the Technical Reviewer Acknowledgments Introduction Part I: Objects Chapter 1: PHP: Design and Management The Problem PHP and Other Languages About This Book Objects Patterns Practice What’s New in the Sixth Edition Summary Chapter 2: PHP and Objects The Accidental Success of PHP Objects In the Beginning: PHP/FI Syntactic Sugar: PHP 3 PHP 4 and the Quiet Revolution Change Embraced: PHP 5 PHP 7: Closing the Gap PHP 8: The Consolidation Continues Advocacy and Agnosticism: The Object Debate Summary Chapter 3: Object Basics Classes and Objects A First Class A First Object (or Two) Setting Properties in a Class Working with Methods Creating a Constructor Method Constructor Property Promotion Default Arguments and Named Arguments Arguments and Types Primitive Types Primitive Types: An Example Some Other Type-Checking Functions Type Declarations: Object Types Type Declarations: Primitive Types mixed Types Union Types Nullable Types Return Type Declarations Inheritance The Inheritance Problem Working with Inheritance Constructors and Inheritance Invoking an Overridden Method Public, Private, and Protected: Managing Access to Your Classes Accessor Methods Typed Properties The ShopProduct Classes Summary Chapter 4: Advanced Features Static Methods and Properties Constant Properties Abstract Classes Interfaces Traits A Problem for Traits to Solve Defining and Using a Trait Using More Than One Trait Combining Traits and Interfaces Managing Method Name Conflicts with insteadof Aliasing Overridden Trait Methods Using Static Methods in Traits Accessing Host Class Properties Defining Abstract Methods in Traits Changing Access Rights to Trait Methods Late Static Bindings: The static Keyword Handling Errors Exceptions Throwing an Exception Subclassing Exception Cleaning Up After try/catch Blocks with finally Final Classes and Methods The Internal Error Class Working with Interceptors Defining Destructor Methods Copying Objects with __clone() Defining String Values for Your Objects Callbacks, Anonymous Functions, and Closures Anonymous Classes Summary Chapter 5: Object Tools PHP and Packages PHP Packages and Namespaces Namespaces to the Rescue Using the File System to Simulate Packages Naming the PEAR Way Include Paths Autoload The Class and Object Functions Looking for Classes Learning About an Object or Class Getting a Fully Qualified String Reference to a Class Learning About Methods Learning About Properties Learning About Inheritance Method Invocation The Reflection API Getting Started Time to Roll Up Your Sleeves Examining a Class Examining Methods Examining Method Arguments Using the Reflection API Attributes Summary Chapter 6: Objects and Design Defining Code Design Object-Oriented and Procedural Programming Responsibility Cohesion Coupling Orthogonality Choosing Your Classes Polymorphism Encapsulation Forget How to Do It Four Signposts Code Duplication The Class Who Knew Too Much The Jack of All Trades Conditional Statements The UML Class Diagrams Representing Classes Attributes Operations Describing Inheritance and Implementation Associations Aggregation and Composition Describing Use Using Notes Sequence Diagrams Summary Part II: Patterns Chapter 7: What Are Design Patterns? Why Use Them? What Are Design Patterns? A Design Pattern Overview Name The Problem The Solution Consequences The Gang of Four Format Why Use Design Patterns? A Design Pattern Defines a Problem A Design Pattern Defines a Solution Design Patterns Are Language Independent Patterns Define a Vocabulary Patterns Are Tried and Tested Patterns Are Designed for Collaboration Design Patterns Promote Good Design Design Patterns Are Used by Popular Frameworks PHP and Design Patterns Summary Chapter 8: Some Pattern Principles The Pattern Revelation Composition and Inheritance The Problem Using Composition Decoupling The Problem Loosening Your Coupling Code to an Interface, Not to an Implementation The Concept That Varies Patternitis The Patterns Patterns for Generating Objects Patterns for Organizing Objects and Classes Task-Oriented Patterns Enterprise Patterns Database Patterns Summary Chapter 9: Generating Objects Problems and Solutions in Generating Objects The Singleton Pattern The Problem Implementation Consequences Factory Method Pattern The Problem Implementation Consequences Abstract Factory Pattern The Problem Implementation Consequences Prototype The Problem Implementation Pushing to the Edge: Service Locator Splendid Isolation: Dependency Injection The Problem Implementation Dependency Injection with Attributes Consequences Summary Chapter 10: Patterns for Flexible Object Programming Structuring Classes to Allow Flexible Objects The Composite Pattern The Problem Implementation Consequences Composite in Summary The Decorator Pattern The Problem Implementation Consequences The Facade Pattern The Problem Implementation Consequences Summary Chapter 11: Performing and Representing Tasks The Interpreter Pattern The Problem Implementation Interpreter Issues The Strategy Pattern The Problem Implementation The Observer Pattern Implementation The Visitor Pattern The Problem Implementation Visitor Issues The Command Pattern The Problem Implementation The Null Object Pattern The Problem Implementation Summary Chapter 12: Enterprise Patterns Architecture Overview The Patterns Applications and Layers Cheating Before We Start Registry The Problem Implementation Registry, Scope, and PHP Consequences The Presentation Layer Front Controller The Problem Implementation ApplicationHelper CommandResolver Request A Command Overview Consequences Application Controller The Problem Implementation The Front Controller Implementation Overview The Configuration File Parsing the Configuration File Managing the Component Data The Command Class A Concrete Command Consequences Page Controller The Problem Implementation Consequences Template View and View Helper The Problem Implementation Consequences The Business Logic Layer Transaction Script The Problem Implementation Consequences Domain Model The Problem Implementation Consequences Summary Chapter 13: Database Patterns The Data Layer Data Mapper The Problem Implementation Handling Multiple Rows Using a Generator in Place of the Iterator Interface Acquiring Collection Objects Consequences Identity Map The Problem Implementation Consequences Unit of Work The Problem Implementation Consequences Lazy Load The Problem Implementation Consequences Domain Object Factory The Problem Implementation Consequences The Identity Object The Problem Implementation Consequences The Selection Factory and Update Factory Patterns The Problem Implementation Consequences What’s Left of Data Mapper Now? Summary Part III: Practice Chapter 14: Good (and Bad) Practice Beyond Code Borrowing a Wheel Playing Nice Giving Your Code Wings Standards Vagrant Testing Continuous Integration Summary Chapter 15: PHP Standards Why Standards? What Are PHP Standards Recommendations? Why PSR in Particular? Who Are PSRs for? Coding with Style PSR-1 Basic Coding Standard Opening and Closing Tags Side Effects Naming More Rules and an Example PSR-12 Extended Coding Style Starting and Ending a PHP Document Starting and Ending a Class Working with Traits Declaring Properties and Constants Starting and Ending a Method Single-Line Declarations Multiline Declarations Return Types Lines and Indentation Calling Methods and Functions Flow of Control Checking and Fixing Your Code PSR-4 Autoloading The Rules That Matter to Us Summary Chapter 16: PHP Using and Creating Components with Composer What Is Composer? Installing Composer Installing a (Set of) Package(s) Installing a Package from the Command Line Versions require-dev Composer and Autoload Creating Your Own Package Adding Package Information Platform Packages Distribution Through Packagist Keeping It Private Summary Chapter 17: Version Control with Git Why Use Version Control? Getting Git Using an Online Git Repository Configuring a Git Server Creating the Remote Repository Preparing the Repository for Local Users Providing Access to Users Closing Down Shell Access for the git User Beginning a Project Cloning the Repository Updating and Committing Adding and Removing Files and Directories Adding a File Removing a File Adding a Directory Removing Directories Tagging a Release Branching a Project Summary Chapter 18: Testing with PHPUnit Functional Tests and Unit Tests Testing by Hand Introducing PHPUnit Creating a Test Case Assertion Methods Testing Exceptions Running Test Suites Constraints Mocks and Stubs Tests Succeed When They Fail Writing Web Tests Refactoring a Web Application for Testing Simple Web Testing Introducing Selenium Getting Selenium PHPUnit and Selenium Introducing php-webdriver Creating the Test Skeleton Connecting to Selenium Writing the Test A Note of Caution Summary Chapter 19: Automated Build with Phing What Is Phing? Getting and Installing Phing Composing the Build Document Targets Properties Conditionally Setting Property Values with the Condition Task Types FileSet PatternSet FilterChain Tasks Echo Copy Input Delete Summary Chapter 20: Vagrant The Problem A Little Setup Choosing and Installing a Vagrant Box Mounting Local Directories on the Vagrant Box Provisioning Setting Up the Web Server Setting Up MariaDB Configuring a Hostname Wrapping It Up Summary Chapter 21: Continuous Integration What Is Continuous Integration? Preparing a Project for CI CI and Version Control Phing Unit Tests Documentation Code Coverage Coding Standards Installing Jenkins Installing Jenkins Plug-ins Setting Up the Git Public Key Installing a Project Running the First Build Configuring the Reports Triggering Builds Test Failures Summary Chapter 22: Objects, Patterns, Practice Objects Choice Encapsulation and Delegation Decoupling Reusability Aesthetics Patterns What Patterns Buy Us Tried and Tested Patterns Suggest Other Patterns A Common Vocabulary Patterns Promote Design Patterns and Principles of Design Favor Composition over Inheritance Avoid Tight Coupling Code to an Interface, Not an Implementation Encapsulate the Concept That Varies Practice Testing Standards Version Control Automated Build Continuous Integration What I Missed Summary Appendix A: Bibliography Books Articles Sites Appendix B: A Simple Parser The Scanner The Parser Index