PHP Tutorial: Programming Usage of PHP Design Pattern_PHP Tutorial

Please read the previous article first

Refactor

Even the most thoughtful and skilled programmer cannot foresee any of the subtleties in a software project. Problems always arise unexpectedly, requirements may change, and the result is that code is optimized, shared, and replaced.

Refactoring is a common method: check all your code and find common or similar things that can be unified and simplified, making your code easier to maintain and extend. Refactoring also involves exploring whether a design pattern can be applied to the specific problem - which can also simplify the solution.

Refactoring, to put it simply, is to rename a property or method, to be more complex, to compress an existing class. Changing your code so that it conforms to one or more design patterns is another type of refactoring—one that you may be able to implement after reading this book.

Nothing explains refactoring better than examples!

Let us consider two simple classes: CartLine and Cart. CartLine records the unit price and quantity of each item in the shopping cart. For example, CartLine may record "four red polo shirts, 19.99$ each". Cart is a container used to load one or more CartLine objects and perform some related calculations, such as the total cost of all items in the shopping cart.

The following is a simple implementation of CartLine and Cart:

// PHP5
class CartLine {
public $price = 0;
public $qty = 0;
}
class Cart {
protected $lines = array() ;
public function addLine($line) {
$this->lines[] = $line;
}
public function calcTotal() {
$total = 0;
// add totals for each line
foreach($this->lines as $line) {
$total += $line->price * $line->qty;
}
// add sales tax
$total *= 1.07;
return $total;
}
}

The first step in refactoring must be to have enough tests to cover all your code. This will ensure that the code you modify cannot produce different results from your original code. By the way, your test code cannot be changed unless you change the requirements (the expected results of your code) or find a bug in the test instance.

The following is an example of testing CartLine and Cart, which will not change during the reconstruction process.

function TestCart() {
$line1 = new CartLine;
$line1->price = 12; $line1->qty = 2;
$line2 = new CartLine;
$line2->price = 7.5; $line2->qty = 3;
$line3 = new CartLine;
$line3->price = 8.25; $line3->qty = 1;
$cart = new Cart;
$cart->addLine($line1);
$cart->addLine($line2);
$cart->addLine($line3);
$this->assertEqual(
(12*2 + 7.5*3 + 8.25) * 1.07,
$cart->calcTotal());
}

Look Looking at the code above, you may notice that it has some "code smells" - code that has an odd appearance and seems to be problematic - which are candidates for refactoring. (For more information about code smells, please see http://c2.com/cgi/wiki?codesmell). The two most immediate candidates for refactoring are Annotations and Calculations (calculations related to sales tax, etc.). A form of refactoring: the Extract Method will extract this ugly code from cart::calcTotal() and replace it with a suitable method, making the code more concise.

For example, you can add two calculation methods: lineTotal() and calcSalesTax():

protected function lineTotal($line) {
return $line->price * $line->qty;
}
protected function calcSalesTax($amount) {
return $amount * 0.07;
}

Now you can override the calcTotal() function:

public function calcTotal() {
$total = 0;
foreach($this->lines as $line) {
$total += $this->lineTotal( $line);
}
$total += $this->calcSalesTax($total);
return $total;
}

The changes so far are Making sense (at least in the context of this example), it would be helpful to pause and run the code again to verify that the results are still correct. Remember, a green success bar is displayed! (Translator's note: At the beginning of this chapter, the author mentioned: Green bars mean that the tests have passed.)

However, the current code still has some flaws. One of them is accessing public properties in the new method lineTotal(). It is obvious that the responsibility for calculating the sum of each row should not belong to the Cart class, but should be implemented in the CartLine class.

Refactor again and add a new method total() to CartLine to calculate the long-term price of each item in the order.

public function total() {
return $this->price * $this->qty;
}

Then remove the method lineTotal() from class Cart, and Change the calcTotal() method to use the new cartLine::Total() method. Rerun the test and you'll still see the result is a green bar.

The newly refactored code looks like this:

class CartLine {
public $price = 0;
public $qty = 0;
public function total() {
return $this->price * $this->qty ;
}
}
class Cart {
protected $lines = array();
public function addLine($line) {
$this->lines[] = $ line;
}
public function calcTotal() {
$total = 0;
foreach($this->lines as $line) {
$total += $line-> ;total();
}
$total += $this->calcSalesTax($total);
return $total;
}
protected function calcSalesTax($amount) {
return $amount * 0.07;
}
}

Now this code no longer needs comments for each line, because the code itself better explains the function of each line. These new methods better encapsulate the computing function and make it easier to adapt to future changes. (For example, consider different sales tax rates). In addition, these classes are also more balanced and easier to maintain.

This example is obviously trivial, but hopefully you can extrapolate from it and envision how to refactor your own code.

When coding, you should be in one of two modes: add new features or refactor the code. When adding features, you write tests and add code. When refactoring, you change your original code and make sure that all related tests still run correctly.
The main reference material on refactoring is "Refactoring: Improving the Design of Existing Code" by Martin Fowler. To summarize Fowler's book with some concise points, the steps for reconstruction are as follows:

Define the code that needs to be refactored
Have tests that cover all the code
Work in small steps
Run your tests after each step. Coding and testing are both quite repetitive - much easier with interpreted languages ​​like PHP than with compiled languages.
Use refactoring to make your code more readable and modifiable.​

• Total 2 pages:
• Previous page
• 1
• 2
• Next page

http://www.bkjia.com/PHPjc/363970.htmlwww.bkjia.comtruehttp: //www.bkjia.com/PHPjc/363970.htmlTechArticlePlease read the previous article first Refactoring Even the most thoughtful and skilled programmer cannot foresee a software Any detail in the project. Problems always arise unexpectedly, and needs...