PHP for Adults: Clean Code and Object Calisthenics

PHP 4 ADULTS
OBJECT CALISTHENICS AND CLEAN CODE

GUILHERMEBLANCO
GUILHERMEBLANCO
Guilherme Blanco

MOTIVATION
▸ Readability
▸ Maintainability
▸ Reusability
▸ Testability

SINGLETON
TIGHT COUPLING
UNTESTABILITY
PREMATURE OPTIMIZATION
INDESCRIPTIVE NAMING
DUPLICATION

SINGLE RESPONSIBILITY
OPEN/CLOSED PRINCIPLE
LISKOV SUBSTITUTION PRINCIPLE
INTERFACE SEGREGATION
DEPENDENCY INVERSION

interface Bird
{
public function setLocation($longitude, $latitude);
public function setHeight($height);
public function draw();
}

class Penguin implements Bird
{
public function setHeight($height)
{
// Do nothing
}
}

interface Bird
{
public function setLocation($longitude, $latitude);
public function draw();
}
interface FlightfulBird extends Bird  
{  
public function setHeight($height);
}

DEPENDENCY
INVERSION PRINCIPLE

namespace DatingUserBundleEntity
{
class User
{
/** @var DatingUserBundleEntityImage */
protected $avatar;
}
}
namespace DatingMediaBundleEntity
{
class Image
{
/** @var DatingUserBundleEntityUser */
protected $owner;
}  
}

namespace DatingUserBundleEntity
{
class User
{
/** @var AvatarInterface */
protected $avatar;
}
interface AvatarInterface
{
// ...
}
}
namespace DatingMediaBundleEntity
{
use DatingUserBundleEntityAvatarInterface;
class Image implements AvatarInterface
{
/** @var DatingUserBundleEntityUser */
protected $owner;
}  
}

RULE #1
ONLY ONE INDENTATION LEVEL PER
METHOD

public function validateForm($filters='', $validators='', $options='')
{
$data = $_POST;
$input = new Zend_Filter_Input($filters, $validators, $data, $options);
$input->setDefaultEscapeFilter(new Zend_Filter_StringTrim());
if ($input->hasInvalid() || $input->hasMissing()) {
foreach ($input->getMessages() as $field => $messageList) {
foreach ($messageList as $message) {
if (strpos($message, "empty")) {
throw new Tss_FormException(
"The field {$field} cannot be empty!",
3,
"javascript:history.back();"
);  
} else {
"{$message}",
3,
);
}
}
}
}
return $input;
}

1
2
3
4
public function validateForm($filters='', $validators='', $options='')
{
$data = $_POST;
if ($input->hasInvalid() || $input->hasMissing()) {
3,
);  
} else {
"{$message}",
3,
);
}
}
}
}
return $input;
}
Class prototype

public function validateForm($filters=array(), $validators=array(), $options=array())
{
$data = $_POST;
if (! ($input->hasInvalid() || $input->hasMissing())) {
return $input;
}
3,
);  
} else {
"{$message}",
3,
);
}
}
}
return $input;
}

1
2
3
{
$data = $_POST;
return $input;
}
3,
);  
} else {
"{$message}",
3,
);
}
}
}
return $input;
}

{
$data = $_POST;
return $input;
}
$errorMessage = (strpos($message, "empty") === false)
? "The field {$field} cannot be empty!"
: $message;
$errorMessage,
3,
);
}
}
return $input;
}

1
2
{
$data = $_POST;
return $input;
}
: $message;
$errorMessage,
3,
);
}
}
return $input;
}

{
$data = $_POST;
return $input;
}
$message = array_shift($messageList);
$jsAction = "javascript:history.back();";
: $message;
throw new Tss_FormException($errorMessage, 3, $jsAction);
}
return $input;
}

{
$data = $_POST;
return $input;
}
: $message;
}
return $input;
}
Logical groups
Variable interpolation

{
$data = $_POST;
return $input;
}
? sprintf("The field %s cannot be empty!", $field)
: $message;
}
return $input;
}

BENEFITS
▸ Single Responsibility Principle ("S" in SOLID)
▸ Reusability

public function createPost($request) {
$entity = new Post();
$form = new MyForm($entity);
$form->bind($request);
if ($form->isValid()){
$repository = $this->getRepository('MyBundle:Post');
if (!$repository->exists($entity)) {
$repository->save($entity);
return $this->redirect('create_ok');
} else {
$error = "Post Title already exists";
return array('form' => $form, 'error' => $error);
}  
} else {
$error = "Invalid fields";
}
}

public function createPost($request) {
if ($form->isValid()){
$repository = $this->getRepository('MyBundle:Post');
if (!$repository->exists($entity)) {
} else {
}  
} else {
}
}
Type-casting
Coding standards
Separate into logical
groups.
Consider as paragraphs!

public function createPost(Request $request)
{
$repository = $this->getRepository(‘MyBundle:Post');
if ($form->isValid()) {
if (! $repository->exists($entity)) {
} else {
}  
} else {
}
}

UML
NORMAL VS. ALTERNATIVE FLOWS

{
if (! $form->isValid()) {
}
if (! $repository->exists($entity)) {
} else {
}
}

{
if (! $form->isValid()) {
}
if ($repository->exists($entity)) {
}
}

BENEFITS
▸ Prevents code duplication
▸ Increases legibility
▸ Reduce cyclomatic complexity

RULE #3
ENCAPSULATE ALL PRIMITIVE TYPES
AND STRINGS

RULE #3
ENCAPSULATE ALL PRIMITIVE TYPES
AND STRINGS
IF THEY HAVE BEHAVIOR

EXCESSIVE USAGE OF OBJECTS IN
PHP (IF PHP <7!) DRASTICALLY
INCREASES MEMORY FOOTPRINT!
Guilherme Blanco

class Item
{
final public static function find($id)
{
if (is_string($id) && trim($id) != '') {
// do find ...
}
throw new InvalidArgumentException('$id must be a non-empty string');
}
final public static function create($id, array $data)
{
if ( ! is_string($id)) {
throw new InvalidArgumentException('$id must be a string');
}
if (empty(trim($id))) {
}
// do create ...
}
}

class Item
{
final public static function find($id)
{
if (! is_string($id) || trim($id) === '') {
}
// do find ...
}
final public static function create($id, array $data)
{
}
// do create ...
}
}

final class Id
{
/** @var string */
public $value;
public function __construct($value)
{
$message = sprintf('%s must be a non-empty string', $value);
throw new InvalidArgumentException($message);
}
$this->value = $value;
}
public function getValue()
{
return $this->value;
}
}

class Item
{
final public static function find(Id $id)
{
// do find ...
}
final public static function create(Id $id, array $data)
{
// do create ...
}
}

BENEFITS
▸ Type hinting
▸ Encapsulation
▸ Prevents code duplication

RULE #4
ONE OBJECT OPERATOR (->) PER LINE

$this->manager->getConfig()->getSegment()->setName("foo");
Properties are hard to mock What if previous call returned NULL?

JUST USE A NULL OBJECT!
Someone watching this talk, one day

final class NullObject
{
public function __get($property)
{
return new self;
}
public function __set($property, $value)
{
return new self;
}
public function __call($method, array $arguments)
{
return new self;
}
public function __callStatic($method, array $arguments)
{
return new self;
}
public function__toString()
{
return 'null';
}
}

WHY IS IT BAD?
▸ Hide encapsulation problem
▸ Hard to debug and handle exceptions
▸ Codebase must be structured to use NullObject
▸ Hard to read and understand

EXCEPTION TO RULE
FLUENT INTERFACE UNDER SAME
METHOD

$filterChain  
->addFilter(new Zend_Filter_Alpha())
->addFilter(new Zend_Filter_StringToLower())
;

BENEFITS
▸ Law of Demeter
▸ Readability
▸ Increases testability (easier to mock)
▸ Simpliﬁes debugging

THERE ARE 2 HARD PROBLEMS IN
COMPUTER SCIENCE: CACHE
INVALIDATION, NAMING THINGS AND
OFF BY 1 ERRORS.
Tim Bray (mentioning Phil Karlton)

CODE DUPLICATION PROBLEM!
WRITE SAME NAME REPEATEDLY

MULTIPLE RESPONSIBILITY
PROBLEM!
LONG NAMES

public function getPage($data) { ... }
"Get" from where?
public function startProcess() { ... }
$trx->process('site.login');
How?
WTF is that?
renderHomePage
forkIntoChildProcess
extendedTranslator

BENEFITS
▸ Readability
▸ Better exposing method’s intent
▸ Improved maintainability
▸ Good indicator of code duplication and encapsulation

RULE #6
KEEP YOUR CLASSES SMALL

OBJECTIVE
▸ Maximum 200 lines per class 
(including docblock/documentation)
▸ 10 methods per class
▸ Up to 20 lines per method
▸ 15 classes/interfaces/traits per namespace

BENEFITS
▸ Single Responsibility Principle
▸ Clear and objective methods
▸ Better code segregation
▸ Cleaner namespaces

RULE #7
LIMIT CLASS INSTANCE VARIABLES IN A
CLASS (BETWEEN 2 TO 5)

class MyRegistrationService
{
protected $userService;
protected $passwordService;
protected $logger;
protected $translator;
protected $entityManager;
protected $imageCropper;
// ...
}
Database interactions
should be on UserService
Rely on an Event system
and move this to a listener
Cross-cutting concerns. Should be auto-
injected by your DI through an interface hint

class MyRegistrationService
implements LoggerAwareInterface, TranslatorAwareInterface
{
use LoggerAwareTrait;
use TranslatorAwareTrait;
protected $userService;
protected $passwordService;
protected $eventDispatcher;
// ...
}

BENEFITS
▸ Loose coupling
▸ Better encapsulation
▸ Testability

RULE #8
USE FIRST CLASS COLLECTIONS

ANY CLASS THAT CONTAINS AN
ARRAY MUST NOT HAVE ANY
OTHER PROPERTY.
Guilherme Blanco
TEXT

class User
{
private $name;
// ...
private $albumList = array();
public function getPublicAlbumList()
{
$filteredAlbumList = array();
foreach ($this->albumList as $album) {
if ($album->getPrivacy() === AlbumPrivacy::PUBLIC) {
$filteredAlbumList[] = $album;
}
}
return $filteredAlbumList;
}
// ...
}
$publicAlbumList = $user->getPublicAlbumList();

class AlbumList extends Collection
{
public function getPublic()
{
$filteredAlbumList = array();
foreach ($this->value as $album) {
if ($album->getPrivacy() === AlbumPrivacy::PUBLIC) {
$filteredAlbumList[] = $album;
}
}
return $filteredAlbumList;
}
}
class User
{
private $name;
private $albumList = new AlbumList();
// ...
}
$publicAlbumList = $user->getAlbumList()->getPublic();

class AlbumList extends Collection
{
public function getPublic()
{
return new ArrayCollection(
array_filter(
$this->value,
function (Album $album) {
return $album->isPublic();
}
)
);
}
}
class User
{
private $name;
private $albumList = new AlbumList();
// ...
}
$publicAlbumList = $user->getAlbumList()->getPublic();

BENEFITS
▸ Collection operations implemented inside of Collection
▸ Usage of SPL classes
▸ Easy to group collections without concerns over their
members’ behavior
▸ Filtering, ordering, mapping, combining are good
example methods

RULE #9
USE GETTERS AND SETTERS

class BankAccount
{
public $balance = 0;
public function deposit($amount)
{
$this->balance += $amount;
}
public function withdraw($amount)
{
$this->balance -= $amount;
}
}
// Example:
$account = new BankAccount();
 
$account->deposit(100.00);
// ...
$account->balance = 0;  
// ...
$account->withdraw(10.00);
Balance can be modiﬁed without class being
notiﬁed, leading to unexpected errors.

BENEFITS
▸ Operations injection
▸ Transformations encapsulation
▸ Promotes Open/Closed Principle ("O" in SOLID)

THANKS! =)
GUILHERMEBLANCO
GUILHERMEBLANCO

PHP for Adults: Clean Code and Object Calisthenics

Recommended

More Related Content

What's hot (20)

Viewers also liked (13)

Similar to PHP for Adults: Clean Code and Object Calisthenics (20)

More from Guilherme Blanco (10)

Recently uploaded (20)

PHP for Adults: Clean Code and Object Calisthenics