1.
Advanced PHP Simplified
Mark Niebergall
https://joind.in/talk/e328e

2.
Thank You Sponsors

3.
About Mark Niebergall
● PHP since 2005
● Masters degree in MIS
● Senior Software Engineer
● Drug screening project
● UPHPU President
● SSCP, CSSLP Certified and SME
● Drones, fishing, skiing, father, husband

4.
Advanced PHP Simplified

5.
Disclaimer
● Breadth not depth
● Think about your current coding style and
architecture
● Leverage topics covered

6.
Topics to Cover
● Abstract
● Interface
● Trait
● Namespace
● Dependency Injection

7.
Abstract

8.
Abstract
● Abstract Art
● Abstract of text
● Abstract thought or idea

9.
Abstract Class
● abstract class X {...}
● class Y extends X {...}
● Cannot instantiate an abstract class

10.
Abstract Class
● abstract public function doSomething($a);
● protected function somethingElse() {...}
● Abstract method signatures must match

11.
Abstract Class
● Can have methods with functionality
● Can have class properties
● Can extend another abstract class
○ Classes can extend concrete classes

12.
Abstract Uses
● X "is a" Y (NOT "has a")

13.
Abstract Uses
● Represents an idea or base concept
● Composition over Inheritance
● Centralizing logic
● Reducing duplicate code
● Avoid a maze - keep code readable

14.
Abstract Examples
● Truck extends Vehicle
● Laptop extends Computer
● Email extends Communication

15.
Abstract Examples
● abstract Animal
● abstract Mammal extends Animal
● abstract Canine extends Mammal
● abstract Dog extends Canine
● class GermanSheperd extends Dog

16.
abstract class Pen
{
protected $length;
abstract public function usePen();
abstract public function refuel();
protected function setLength($length)
{
$this->length = (float) $length;
return $this;
}
public function getLength()
{
return $this->length;
}
}

17.
abstract class Bird
{
protected $beak;
abstract public function walk();
abstract private function eat();
protected function fly(Wings $wings)
{
$wings->flap();
}
}

18.
Abstract

19.
Interface

20.
Interface
● User Interface
● System Interface
● Provides a way for communication or
control
● Connect two things together

21.
Interface
● interface X {
public function doStuff(Thing $thing);
protected function other();
}
● class Y implements X {...}
● abstract Z implements V, W, X {...}

22.
Interface
● Methods must be implemented
● Method signatures must match
● Methods are left empty in the interface

23.
Interface Uses
● When no logic is required but methods
signatures can be reused
● Contract between concept and
implementation

24.
Interface Uses
● Class can implement multiple interfaces
● Polymorphism

25.
Interface Examples
● Auditing
● Underwater Creatures
● USB

26.
Interface Examples
● Authentication methods
● Responses to a request
● Orders from vendors and customers

27.
interface Light
{
public function shine();
public function travel($x, $y, $z);
}

28.
interface ProcessSomething
{
public function process(Something $something);
}

29.
Interface

30.
Traits

31.
Traits
● Characteristics of something
● Attributes possessed

32.
Trait
● trait X {
public $property;
protected function doStuff() {...}
}
● class Something {
use X;
}

33.
Trait
● PHP 5.4+
● Can have methods and properties
● "Looks" like a concrete class
● Horizontal Inheritance
● Cannot be instantiated

34.
Trait Usage
● Common attributes and functionality
● Consider: required for functionality within
this class?

35.
Trait Usage
● Keep vertical inheritance in mind,
especially when making changes
● Reduces some limitations of single
inheritance

36.
Trait Examples
● Car tire
● Underwater creature

37.
trait Circular
{
protected $radius;
public function getDiameter()
{
return bcmul($this->radius, 2);
}
public function getArea()
{
return bcmul(pi(), bcpow($this->radius, 2));
}
}

38.
trait Wave
{
protected $length;
protected $amplitude;
protected $frequency;
public function setLength($length)
{
$this->length = (float) $length;
return $this;
}
public function getLength()
{
return $this->length;
}
public function setAmplitude($amplitude)
{
$this->amplitude = (float) $amplitude;
return $this;
}
public function getAmplitude()
{
return $this->amplitude;
}
}

39.
Trait

40.
Namespaces

41.
Namespaces
● Container for identification
● Encapsulate items

42.
Namespace
● namespace DomainTopicSubgroup;
use OtherAreaZ;
class A {
protected function doStuff() {
$z = new Z;
}
}

43.
Namespace
● PHP 5.3+
● Grouping related classes together

44.
Namespace Uses
● Shorten_Up_Really_Long_Class_Names_
In_Your_Application
● Avoid naming collisions

45.
Namespace Uses
● Autoloader with file structure built around
namespaces
● Can have multiple
● Often one for composer, one for project

46.
Namespace Uses
class Autoloader
{
public static function registerAutoloader()
{
spl_autoload_register(array('self', 'loader'), false);
}
public static function loader($className)
{
require __DIR__ . ‘/../../’ . $className . ‘.php’;
}
}
require_once __DIR__ . ‘/../vendor/autoload.php’;
Autoloader::registerAutoloader();

47.
Namespace Uses
● Must be first code in file
● Aliasing: use WidgetXyz as X;
● Watch out for keywords
○ Trait
○ Case
○ Switch

48.
Namespace Uses
● Avoid collisions
○ use BobCat as BobCat;
○ use JaneCat as JaneCat;

49.
Namespace Examples
● Last name
○ namespace Smith;
○ class John {...}

50.
Namespace Examples
● Just_About_Any_Long_Name
○ namespace JustAboutAnyLong;
○ class Name {...}

51.
Namespace Examples
Domain/Subject/Science.php:
<?php
namespace DomainSubject;
use OtherDomainSubjectThing;
use OtherDomainArea;
class Science {
protected function doSomething(Thing $thing)
{
$thing->doWhatItDoes();
}
public function otherStuff(AreaNorth $north)
{
$north->head(AreaSouth::getPole());
}
}

52.
Namespace

53.
Dependency Injection
● Send object dependencies into an object
from outside
● Pass class as parameter into a method
rather than method building the class

54.
Dependency Injection Uses
● Constructor: __construct(X $x, ...)
● Setter: setX(X $x) { $this->x = $x; }
● Interface: setX(X $x);
● Method: doSomething(Thing $thing) {...}

55.
Dependency Injection
● Big help for unit tests
● Allows for use of mock objects
● See PHPUnit documentation for
getMockBuilder,
getMockForAbstractClass, and other
PHPUnit methods

56.
Dependency Injection
● Does add more lines of code
● Composition over Inheritance

57.
Dependency Injection Uses
● Service locator
● Factories

58.
Dependency Injection Examples
● Desktop computer parts from different
manufacturers
● Lamp light bulbs: colors, types

59.
namespace Pen;
use LightLight as LightLaser;
require_once __DIR__ . '/../Autoloader.php';
Autoloader::registerAutoloader();
class Laser extends Pen
{
protected $lightLaser;
public function __construct(LightLaser $lightLaser = null)
{
$this->lightLaser = $lightLaser;
}
protected function getLightLaser()
{
if (is_null($this->lightLaser)) {
$this->lightLaser = new LightLaser;
}
return $this->lightLaser;
}
public function usePen()
{
$this->getLightLaser()->shine();
}
public function refuel()
{
$this->getLightLaser()->replaceBatteries();
}
}

60.
Dependency Injection

61.
Things to Consider
● Why need for abstract vs interface vs
trait?
● Benefits of vertical vs horizontal
inheritance?

62.
Things to Consider
● Traits vs dependency injection?
● Tradeoffs of complexity vs code reuse
(think of database normalization)

63.
Conclusion
● Goals for using concepts
● Evaluate current architectural approach
● Just scratched the surface on topics
covered
● Consider how concepts all come together
for solution

64.
Questions?
● https://joind.in/talk/e328e