Sign In Start Free Trial

Mastering PHP 7

By : Branko Ajzele

4.7 (7)

Mastering PHP 7

4.7 (7)

By: Branko Ajzele

Overview of this book

PHP is a server-side scripting language that is widely used for web development. With this book, you will get a deep understanding of the advanced programming concepts in PHP and how to apply it practically The book starts by unveiling the new features of PHP 7 and walks you through several important standards set by PHP Framework Interop Group (PHP-FIG). You’ll see, in detail, the working of all magic methods, and the importance of effective PHP OOP concepts, which will enable you to write effective PHP code. You will find out how to implement design patterns and resolve dependencies to make your code base more elegant and readable. You will also build web services alongside microservices architecture, interact with databases, and work around third-party packages to enrich applications. This book delves into the details of PHP performance optimization. You will learn about serverless architecture and the reactive programming paradigm that found its way in the PHP ecosystem. The book also explores the best ways of testing your code, debugging, tracing, profiling, and deploying your PHP application. By the end of the book, you will be able to create readable, reliable, and robust applications in PHP to meet modern day requirements in the software industry.

Preface

Preface

What this book covers

What you need for this book

Who this book is for

Conventions

Reader feedback

Customer support

Free Chapter

The All New PHP

The All New PHP

Scalar type hints

Return type hints

Anonymous classes

Generator delegation

Generator return expressions

The null coalesce operator

The spaceship operator

Constant arrays

Uniform variable syntax

Throwables

Group use declarations

Catching multiple exceptions types

Class constant visibility modifiers

Iterable pseudo-type

Nullable types

Void return types

Summary

Embracing Standards

Embracing Standards

PSR-1 - basic coding standard

PSR-2 - coding style guide

PSR-3 - logger interface

PSR-4 - autoloading standard

PSR-6 - caching interface

PSR-7 - HTTP message interface

PSR-13 - hypermedia links

Summary

Error Handling and Logging

Error Handling and Logging

Error handling

Logging

Summary

Magic Behind Magic Methods

Magic Behind Magic Methods

Using __construct()

Using __destruct()

Using __call()

Using __callStatic()

Using __set()

Using __get()

Using __isset()

Using __unset()

Using __sleep()

Using __wakeup()

Using __toString()

Using __invoke()

Using __set_state()

Using __clone()

Using __debugInfo()

Usage statistics across popular platforms

Summary

The Realm of CLI

The Realm of CLI

Understanding PHP CLI

The Console component

Input/output streams

Process control

Summary

Prominent OOP Features

Prominent OOP Features

Object inheritance

Objects and references

Object iteration

Object comparison

Traits

Reflection

Summary

Optimizing for High Performance

Optimizing for High Performance

Max execution time

Memory management

File uploads

Session handling

Output buffering

Disabling debug messages

Zend OPcache

Concurrency

Summary

Going Serverless

Going Serverless

Using the serverless framework

Using Iron.io IronWorker

Summary

Reactive Programming

Reactive Programming

Similarities with event-driven programming

Using RxPHP

Non-blocking IO

Using React

Summary

Common Design Patterns

Common Design Patterns

Base patterns

Creational patterns

Behavioral patterns

Structural patterns

Summary

Building Services

Building Services

Understanding the client-server relationship

Working with SOAP

Working with REST

Working with Apache Thrift (RPC)

Understanding microservices

Summary

Working with Databases

Working with Databases

Working with MySQL

Working with MongoDB

Working with Redis

Summary

Resolving Dependencies

Resolving Dependencies

Mitigating the common problem

Understanding dependency injection

Understanding dependency injection container

Summary

Working with Packages

Working with Packages

Understanding Composer

Understanding Packagist

Using third-party packages

Creating your own package

Distributing your package

Summary

Testing the Important Bits

Testing the Important Bits

PHPUnit

Behat

phpspec

jMeter

Summary

Debugging, Tracing, and Profiling

Debugging, Tracing, and Profiling

Xdebug

Zend Z-Ray

Summary

Hosting, Provisioning, and Deployment

Hosting, Provisioning, and Deployment

Choosing the right hosting plan

Automating provisioning

Automating the deployment

Continuous integration

Summary

Customer Reviews

4.7 (7)

5 star

85.7%

4 star

0

3 star

14.3%

2 star

0

1 star

0

Understanding dependency injection container

A dependency injection container is an object that knows how to auto-wire classes together. The auto-wire term implies both instantiating and properly configuring objects. This is by no means an easy task, which is why there are several libraries addressing this functionality.

The DependencyInjection component provided by the Symfony framework is a neat dependency injection container that can be easily installed by Composer.
Moving forward, let's go ahead and create a di-container directory where we will execute these commands and set up our project:

composer require symfony/dependency-injection

The resulting output suggests we should install some additional packages:

We need to make sure we add the symfony/yaml and symfony/config packages by running the following console...

Search

Your notes and bookmarks