Standard Coding, OOP Techniques and Code Reuse

phpXperts 2010 Md. Rayhan Chowdhury | [email protected] 2

Standard Coding


What isWhat is Standard CodingStandard Coding??

● Clean, smart and readable code● Follows a coding standard● Streamlined to the purpose

“Code is Art”


Why Standard Coding?

● Code Quality● Less buggy● Maintainability● Scalability● Collaboration

(Readability)


Coding Standards

● Zend Coding Standard

- The most advanced coding standard in PHP

● PEAR Coding Standards- Base for most of the coding standards in PHP

● CakePHP Coding Standard

● CodeIgniter Coding Standard

Note: There are tons of bad & inconsistent coding standards in PHP

http://framework.zend.com/manual/en/coding-standard.html


http://book.cakephp.org/view/509/Coding-Standards

http://codeigniter.com/user_guide/general/styleguide.html



Code Commenting

● Remember! Doc-block is must for File, Class and Method

● Always in phpDocumentor format, don't put your own tag

● Latest PHP IDE like NetBeans, Zend Studio, Eclipse PDT can help you generating doc-block easily

● Benefit

● Documentation is done as you go with coding

● Doxygen can build your API documentation in chm format instantly from your code

● IDE like netbeans shows code hints, code completion along with popup documentation on the fly


See, netbeans can show documentation on the fly

for you


Standard Coding - Tips

● Say no to short tags <? ?>, always long tags (<?php ?>)

● Use foreach instead of for loop for array iteration

● Ensure variable is not empty before any iteration

● Use null as default function parameter if possible

● Avoid nested conditions, return as early as possible

● Use alternative syntax for control structures when mixing with HTML

if ():

else:

endif;

foreach ():

endforeach;

for ():

endfor;

while ():

endwhile;


Standard Coding – empty

● empty() is a magic in php, learn how to use it, at the end you will love it

● Use !empty() instead of isset() when working with non-empty or non-zero value

● Use !empty($array) instead of count($array) when checking if array has value

● Always check your variable before going further with it


array functions = green power

● Learn them all, specially: in_array, array_merge, array_map, array_values, array_keys, join, explode!

● They can save your time!


Clean and Smart

Clean and Smart


OOP Techniques


Static Method & Variables

● Ever used Configure::read() in CakePHP.

● Remember! Public static method can be accessed from any part of your application

● No more global function, move them to a wrapper class with static method

● All methods in Sanitize, Set and String among other classes in CakePHP are static

● Extensively used in Zend Framework too


One-time/Magic Configuration

● Tired of multiple setters! Or you can't remember the order of parameters

● $options array as function parameter instead of multiple parameters or multiple setters

● setConfig() method, in constructor call setConfig(), do not bypass.

● Ensure configure and reconfigure ability

● Chain your method if possible


Design PatternsDesign Patterns● Solve common design problems not coding problems

● Singleton, Factory and MVC patterns are common

● Worth learning: Registry, Adapter, Decorator, Observer and Strategy patterns

● Same task can be done using different patterns, so choose wisely!

● Reminder! Patterns are not perfect, they have week points too


Singleton - Design Pattern

● Ensure a class has only one instance● Provide a global point of access to it

● Mostly used in application level Configuration, Logging, Database etc

● CakePHP uses extensive number of singleton classes like Configure, Router, App with static method etc

● Lazy initialization


class Logger {

protected static $_instance;

private function __construct($options = null) {}

public static function &getInstance($options = null) {

If (is_null(self::$_instance)) {self::$_instance = new self($options);

}

return self::$_instance;}

public function write($message, $type = null) {}}

Logger::getInstance()->write('My log message');

// Or $Logger = Logger::getInstance();$Logger->write('My log message!');


class Logger {

protected static $_instance;

private function __construct($options = null) {}

public static function &getInstance($options = null) {if (is_null(self::$_instance)) {

self::$_instance = new self($options);}

return self::$_instance;}

protected function _write($message, $type = null) {}

public static function write($message, $type = null) {$_this = self::getInstance();$_this->_write($message, $type = null);

}}

Logger::write('My log message!');


Order the factory to get

your favorite jeans

Factory MethodFactory Method


Factory Method - Design Pattern

● Single interface for creating instance from a family of classes that can do the same task in multiple ways

● Reduce platform dependency

● Example:

● Database Driver– mysqli, sqlite, oracle, postgres, odbc, mssql

● Authentication– Database, LDAP, OpenID etc


class DatabaseDriver {

static function &factory($driver = null, $options = null) {

switch ($driver) {case 'postgres':

return PostgresDriver($options);

case 'sqlite':return SQLiteDriver($options);

default:return MySQLiDriver($options);

}}

}

$DbDriver = DatabaseDriver::factory('mysqli');


MVC - Design Patterns

● Separate presentation, decision making and data layer

● Web is MVC

● So, your web application should be

● Zend Framework, CakePHP, CodeIgniter all are MVC

StorageClient Server


ORM – Object Relational Mapping

● Raw SQL? No more!

● ORM is more flexible, efficient and maintainable

● CakePHP has built-in ORM through association

● Zend has Relationships using Zend_Db_Table

● Doctrine and Propel are most popular ORM in PHP

● Doctrine can be used with both Zend Framework & CodeIgniter


Abstract Class

● Incomplete implementation of some concept

● You can implement multiple Interfaces but extend from only one abstract class

● You can't create instance of an Abstract Class

● Type hinting, enforce object type


Code Reuse


Code Reuse – when and how?

● Don't Re-Invent the Wheel

● But, you can always Improve the Wheel

● Decide when to Reuse● Got a peace of code that can perform a specific task

individually

● No copy & paste of the same code, put them inside a wrapper class and call whenever you need.


Wrap your code● Say you have got a

piece of code for updating Twitter Status

● First, separate configuration variable like apiUrl, username and password

● Separate variables that are specific to call, like message

● Write your update method

class Twitter {

protected $_configs = array('apiUrl' => '_api_url_','username' => '','password' => ''

);

function __construct($options) {

$this->_configs = $options; }

function setConfig($options);

function update($message);

}


Avoid DependencyAvoid Dependency

● My belief “Always keep the door open”

● Loosely coupled classes are reusable

● Make your class independent and flexible as much as you can

● Avoid dependency on global variables, constants, files, paths, system parameters

● Use dependency injection if necessary


Share Your Code

● Your Blog

● PHPClasses.org

● Google Code

● Github.com


Question and Answer

?


Source

● All images are taken from flickr.com

Standard Coding, OOP Techniques and Code Reuse

Technology

Transcript of Standard Coding, OOP Techniques and Code Reuse