As a part of his "Advancing PHP Developer" series, Eran Galperin has posted part five, a look at design patterns and what they can do for you and your application.

A design pattern is a general reusable solution to a recurring design problem in object-oriented systems. Design patterns are essentially blueprints that suggest how to solve a particular set of OO design problems while adhering to OO best good-practices (which I've recounted in my Object Oriented part of this series).

He talks about one of the most popular examples - the Model/View/Controller design pattern that is used in many rapid development frameworks for PHP (including CodeIgniter and the Zend Framework). He also briefly mentions a few others like the composite, singleton and decorator patterns.

Other parts of this series include looks at testing, refactoring and coding standards.

The IBM developerWorks site has a new article posted that talks about design patterns, five of them in particular, that can help to "accelerate your PHP development" and make your code more maintainable down the line.

As an application developer, you can have a lifelong career without ever knowing what any of the patterns are called or how or when they're used. However, I've found that a good working knowledge of these patterns, as well as those introduced in the developerWorks article "Five common PHP design patterns" (see Resources), allows you to do two things: Enable high-bandwidth conversations and reduce painful lessons.

The patterns they talk about in this "five more" article of the series are:

• Adapter Pattern
• Iterator Pattern
• Decorator Pattern
• Delegate Pattern
• State Pattern

Diagrams are provided for each of them, showing how they flow along with brief code examples (structures really) to show how that transitions over to actual use.

Rob Allen has posted an example - a "super simple, complete example" of how to use the Zend_Form component of the Zend Framework to create a basic contact form.

Following on from the Simple Zend_Layout Example, Zend_Form is now in the trunk, so here's a super simple, complete example that shows it in action.

He includes screenshots of the different steps along the way - the form that will be generated, the structure of the directories and, of course, the contents of the PHP files to make things happen. He also mentions the use of Decorators (the design pattern) to assign the various attributes of the form element object.

On the Zend Developer Zone, there's a new post pointing to the second part of their look at the Manning Publishing book "PHP in Action".

If you've been anxiously awaiting part two of this series then your wait is over. Here's a short introduction to the section part of this series written by the author of the book, Dagfinn Reiersol. I had the privilege of meeting Dagfinn at phpuk last week. Below the introduction is the link I know you've been waiting for.

The new PDF they link to focus on two different patterns - the Decorator (a wrapper class) pattern and the Null Object (an object that works like the others but does nothing behind the scenes) pattern.

On the Zend Developer Zone today, there's this new tutorial that looks at making the move from PHP4's object-oriented programming up to the "more complete obejct model of PHP5" - specifically with the Decorator design pattern.

While working on a project I realized one particular solution was a pretty good way to demonstrate the decorator design pattern together with some of PHP5's features, including abstract classes, interfaces, type hinting, the final keyword and the visibility of properties and methods. This article is intended for those of you who, like myself, are moving from object-oriented programming, including some use of design patterns, in PHP4, to the more complete object model of PHP5.

He sets up a scenario about the development of an online pizza ordering system to show how to "decorate" a pizza with each of the toppings on a list (instead of having to list out every pizza in every possible topping combination). Of course, all of the code is included and explained so you understand exactly what's happening. Finally, there's a demonstration of its usage - a simple call that grabs the stock level/name/cost of each of the items in stock (pizza combinations).

DevShed continues its look at the Decorator pattern with this new article today talking about working with MySQL result sets inside of the structure of the Decorator pattern.

Definitely, the pattern in question can be used for generating different types of outputs (or views) based on a returned result set, by using a few decorator classes that I'll define in the course of this tutorial. Hopefully, when you finish reading these lines, you should have a clear idea of how to include decorator classes in your object-based PHP applications.

They start off by showing how they're going to handle the MySQL result sets normally with a class and how to use that class in an example. Finally, they tie all of that in with the Decorator pattern, creating multiple Decorator classes to handle the various MySQL result set types.

In yet another of their looks at using patterns in PHP, DevShed has posted the first part of a new three-part series today covering the Decorator patten, useful for adding new or other functionality to prexisting objects.

Due to the wide range of web applications where the decorator pattern can be successfully applied, over the course of this series, I'll show you some useful pointers to demonstrate how this pattern works, and how it can be introduced in your own PHP applications with only minor hassles. Before you start reading the rest of this article, make sure that you have a pretty good understanding of object-based programming with PHP, since you'll see an abundance of material related to this topic.

To help you get started, they start at ground level with a basic class, one to save a string to a file. They then, in a different class, build the Decorator object, adding the ability to reset and display the string. To help out, they also make two other classes to make the string either all uppercase or all lowercase. Finally, they tie them all together, amking an application that adds its functionality on the fly.

Robert Peake has a new note today about how Part Two of his Design Patterns series has been published in the latest PHP Magazine.

The latest issue of PHP Magazine is now available. In it you will find part two of my series on design patterns in PHP, along with a host of other great articles. Check it out!

In this part of the series, he covers the decorator, strategy, and observer patterns...

On Mike's blog today, he has a quick post with his take on the "fluent interfaces" topic that's been floating around the community lately.

I've read some posts about "fluent interfaces" and I have to agree that it's a bad idea to sacrifice a reasonable API to be able to write english code.

It's anyway possible to accomplish that to some extent on a need-by-need basis with a class of only 20 lines of code.

0 comments voice your opinion now!
php fluent interface decorator pattern php fluent interface decorator pattern