class Item {
 
     private $_quantity = 100;
     private $_item_price = 29;
 
     public function get_price() {
 
          $base_price = $this->_quantity * $this->_item_price;
          $discount_factor = 0;
 
          if($base_price > 1000) {
               $discount_factor = 0.95;
          } else {
               $discount_factor = 0.98;
          }
 
          return ($base_price * $discount_factor);
     }
 
}
 
$item = new Item();
echo $item->get_price();

Now all we have to do is convert the temp variables right side expression into methods and use the same in get_price. To avoid introducing errors during refactoring we convert one temp variable at a time and test it before proceeding further. First we convert $base_price temp variable to a function.

 
class Item {
 
     private $_quantity = 100;
     private $_item_price = 29;
 
     private function base_price() {
          return ($this->_quantity * $this->_item_price);
     }
 
     public function get_price() {
          $base_price = $this->base_price();
          $discount_factor = 0;
 
          if($base_price > 1000) {
               $discount_factor = 0.95;
          } else {
               $discount_factor = 0.98;
          }
 
          return ($base_price * $discount_factor);
     }
 
}

Next we convert the $discount_factor variable expression to a function.

 
class Item {
 
     private $_quantity = 100;
     private $_item_price = 29;
 
     private function base_price() {
          return ($this->_quantity * $this->_item_price);
     }
 
     private function discount_factor() {
          if($this->base_price() > 1000)
               return 0.95;
          else
               return 0.98;
     }
 
     public function get_price() {
          $base_price = $this->base_price();
          $discount_factor = $this->discount_factor();
 
          return ($base_price * $discount_factor);
     }
 
}

Finally we eliminate the temp variables in the get_price function.

 
public function get_price() {
          return ($this->base_price() * $this->discount_factor());
     }

Using Replace Temp with Query is easier when the temp variables are assigned only once in a block of code, and also if they do not cause any side effects i.e the temp variables statement does not modify any object.
Note that in the above example before refactoring the $base_price and $discount_factor variables were assigned to only once each. Multiple assignments can make it a little trickier to use the current refactoring method.

Conclusion
This seems a long way to go to eliminate temporary variables, but besides clean code the other main advantage of using the above method is that now the base_price and the discount_factor methods are available to other members of the class to use.

What this method basically does is to take a group of related code and convert it to a function with a appropriate name that easily explains the purpose of the code. You can also use ‘Extract Method’ if one of your methods is too long or requires copious amount of comments to explain its purpose.

Take for example the following code from a recent project. The code converts a hotel room price to points depending on the currency. The code by itself doesn’t do much to explain what it does.

Note: In view of the recent constructive comments given by readers I’ve changed the code to more correctly reflect the concept of the Extract method. Its people like you that always keep me alert. Thanks guys.

<?php
 
function getRoomPoints($roomPrice)
{
    /* $forex is an array containing exchange rates */
    $forex = array("gbp"=>1.2, "eur"=>.75, "usd"=>1);
    $_factor = 0;
    $currency_code = "GBP";
 
    switch($currency_code)
    {
        case "GBP" : $_factor = 1/$forex['gbp'];
                     break;
        case "USD" : $_factor = 1;
                     break;
        case "EUR" : $_factor = 1/$forex['eur'];
                     break;
        default : $_factor = 1;
                     break;
    }
 
    return $roomPrice * $_factor;
}
 
$room_points = getRoomPoints($_service_hotel['AvailableRoom']['Price']);
 
?>

The block of code that does the actual conversion can be extracted and converted into a function with an appropriate name as given below which now makes the intention of the code clear.

<?php
 
function getRoomPoints($roomPrice)
{
    $currency = $_service_hotel['Currency']['code'];
    $_factor =  getConversionRateFactor($currency);
    return $roomPrice * $_factor;
}
 
function getConversionRateFactor($currency_code)
{
    $_factor = 0;
    $forex = array("gbp"=>1.2, "eur"=>.75, "usd"=>1);
 
    switch($currency_code)
    {
        case "GBP" : $_factor = 1/$forex['gbp'];
                     break;
        case "USD" : $_factor = 1;
                     break;
        case "EUR" : $_factor = 1/$forex['eur'];
                     break;
        default : $_factor = 1;
                     break;
    }
 
    return $_factor;
}
 
 
$room_points = getRoomPoints($_service_hotel['AvailableRoom']['Price']);
 
?>

Consolidate Conditional Expressions
Many times you see a group of conditionals where the returned values are the same. To make the code cleaner you can group the conditionals together using the ‘&&’ or the ‘||’ operators and then extract the code into a separate function. This also has the added benefit that you can reuse the extracted method in other places where the required conditional goes. Before using this pattern make sure that the grouped conditionals do not have any side-effects; i.e they do not change any variables.

A simple example is shown below:

Before refactoring:

class Security {
 
	private $_isHttps = true;
	private $_isAdmin = true;
	private $_totalLoginsPerDay = 19;
	.
	.
	.
 
	public function can_upload_file()
	{
		if($this->_isHttps == false) return 0;
		if($this->_isAdmin == false) return 0;
		if($this->_totalLoginsPerDay > 100) return 0;
 
		return 1;	
	}
}
 
$login = new Security();
echo $login->can_upload_file();

After refactoring:

class Security {
 
	private $_isHttps = true;
	private $_isAdmin = true;
	private $_totalLoginsPerDay = 199;
	.
	.
	.
 
	public function can_upload_file()
	{
		return $this->check_security_status();
	}
 
	private function check_security_status()
	{
		if($this->_isHttps == false || 
		   $this->_isAdmin == false || 
		   $this->_totalLoginsPerDay > 100)
			return 0;
		else
			return 1;
	}
}
 
$login = new Security();
echo $login->can_upload_file();

Refactoring is a process of changing code to make it more understandable and structured without changing the code functionality or introducing additional bugs. Informally it is known as ‘cleaning up code’. Refactoring is based on the tenet that the written code is more important to the human reader than it is to the machine. Many programmers write code with the idea that once the program is complete and working the code will not be touched again. But this seldom happens. Features need to be added, bug issues need to be fixed. This may happen tomorrow or months from now; wherein you need to really remember what a particular function did. Comments in the code may be useful, but not much if the code written is not differentiable from the half eaten spaghetti bowl sitting beside.

Code refactoring is not to be confused with code optimization. Code optimization is a completely different ball game, where the goal is to run the program as fast as possible by using as few CPU cycles as you can. The focus during optimization is to speed up the program, if it impedes code understandability then so be it. On the contrary refactoring may at times make your program slower, albeit most of the times by a small factor. A sample code adapted from the wonderful book is shown below:

// Before refactoring 
if($receiptDate < SUMMER_START || $receiptDate > SUMMER_END)
    $charge = $quantity * $winter_rate + $winter_service_charge;
else
    $charge = $quantity * $summer_rate;

/* After refactoring. The statements in the conditionals   
    have been refactored to functions. */ 
if(notSummer($receiptDate))
    $charge = winterCharge($quantity);
else
    $charge = summerCharge($quantity);

Many people refactor the code after the programming part is complete, many refactor as they go along. The important part is to test your code after refactoring. Unit tests are an indispensable part of this. Keep this maxim in mind – Always Test After Refactoring.

I’m planning to post one refactoring pattern every week or two. Although I could condense all the patterns in a lengthy post and be done with, I will resist that temptation. I want you to savour each pattern slowly so that you could remember and understand each of them like the back of your hand. There are more than fifty patterns catalogued by Fowler and others so it will help if we take it slowly. Most people after seeing the complete list of patterns become overwhelmed and confused and only remember a small percentage of them. Many patterns I’ll be posting will be self explanatory so I’ll do away with elaborate explanation. Refactoring is a habit and like all good programming habits it transcends the shifting landscape of technologies and languages.