Manipulating Strings, OO Style

Intro
Whenever using php to output data on the web, it is common place to have to format
it so that it is visually stimulating, or to add emphasis. Depending on your configuration,
this may require echoing large amounts of html each time you output data. You may be using a template
engine, or a framework that allows view scripts, where the file is primarily html, but you put in place-holders
or echo the data wherever needed, this arguably is the easiest to debug, fastest to change, and the best
configuration.

Sometimes, however, you may not have the ability to use templating engines, or a framework, and may have to rely on
your own functions for manipulating data for output. Having to echo html several times over and over again, to
change simple things like color, or creating elements is a pain, and not friendly. Say you have an error message style, or a header
style, and everytime you use this data, you have to again and again echo html elements. This can lead to several
mistakes in html, and or php code.

What you should always remember when thinking of your code, is DRY, or Don't Repeat Yourself. Whenever
you find you are coding the same thing multiple times, it is time to step aside, think, and refactor.

In Comes OOP. Using the power of OOP in PHP, PHP5 especially, we can create objects that will handle string manipulation.

Creating the Base Class
So now that we know what we want to do, manipulate strings for output, lets create a class that we will expand on
to handle these functions.

NOTE: Remember, longer names do not take longer to execute in php, so make sure you name your methods, objects, and properties
something that is self-explanatory on function and return.

Class StringHelper


Brainstorming
Now that we have our base class, lets figure out what exactly we want to be able to do with it. What common things
do we need to do to strings. Come up with a list of what you need to do to them, in whatever way you like, I prefer mind-mapping.


Lets see, I have come up with this list
Escape - Prevent XSS Attacks by escaping html chars
Caps - Make string capitalize
CamelCase - Make every word capitalized by first letter
Sentence - Add period to end, Capitalize first letter
Color - Change color of data
Div/Span/P - Make html elements with supplied attributes
Is Email? - Check to see if data is a valid email address

Now lets refine that list. Cast out functions that are not related to the overall scheme. Is Email does help manage
strings, however we are wanting to strictly manipulate data for output. So lets eliminate that one, and while we are at it
lets choose a more descriptive class name for our helper.

Instead of StringHelper lets use StringFormatter.
Now lets create empty functions from the list provided.


Simple enough, empty functions, all accept the string that you want to manipulate.

Wrapping!!!!!
No, Not presents. What we do now, is take our functions, and compare them to functions already integrated into the PHP language.
Then we will just make the function a wrapper for the php-integrated function by just funneling our string into it and returning the output.
Like so!

Now, you don't want to reinvent the wheel, so make sure you check around on google, and the php manual at php.net, to make
sure there isn't already a function for what you want to do. There are a lot of hidden gems in php.

OK, so we have knocked out a good bit of our work, now we need to figure out what we want the finished output from each
function to look like, and what arguments to accept to create this.

I will step through one of the functions, as you will get the picture, and I don't want to repeat myself (DRY remember ) when not needed.

We will take our div function.

Creating methods

Ok so we want our div output to look at its most basic form like this <div>string</div>
and at it's most complex form, like this <div class=class id=id style=styles>string</div>
So this should be obvious, our arguments should be function div($string,$class,$id,$style) since all arguments other than the string can be optional, we will make them null by default and then check
in the method to see if they are null, if they are, then do nothing, else if they are not, we will create that part of the element.

So now our method looks like


Well first, we need to open our tag, there is no way around that, it will be static in all formations of output.
Then we will need to close the opening tag, echo our string, and close the div element alltogether, and then
return the formatted string. Now we leave space where
our logic will go, and come back to that later.

Now it looks like this


Easy enough, not too much headache, now lets check to see if each of our attributes are null or not.
Since we are doing nothing if they are null, there is no reason for else statements. Also, we will go ahead
and create our id and class attributes if they are not null, since it is as trivial as adding onto the existing
'$d' string.


Now they will be able to pass multiple style definitions to this function, and whenever your dealing with
multiple named elements in php, or any other programming language, what is the most powerful thing you can rely
on? ARRAYSSSS , So instead of checking if $style is null, lets check to see if it is an array, if it is , lets cycle
through and create a attribute for each definition.

This is made very easy by PHP's handy array iterator, foreach()



It is that simple. We will accept an associative array with style definitions formatted in Key=Value style.
So with this added to our StringFormatter class, lets see an example of use.

Using your new class


Conclusion
Pretty awesome huh! So you see using some simple logic, and not a lot of work, you can create an object
oriented interface for formatting strings and other data. This will make it much easier when outputting data
to the browser, and save you a lot of time in the future. Blah Blah Blah ROI blah blah blah.
Don't stop here either, you can create OO interfaces for handling all types of data.

My Gift To You
I have created a StringFormatter class, that does a lot of what we have covered here, along with a special addition.
I created a method, filter() that accepts the string to be formatted and an array of filters to apply.
This allows you to say, change the color, and make capital the string etc.. without having to do more variable definitions
or function withing function arguments.

The class is below, but here is an example of how to use the new filter method.


Now let me explain how it expects the filters array to be formatted.


You see this is an associative array with each key representing a method inside
our stringFormatter class, OR as you see above it can be a normal php function
(in the example above this was 'strtolower').

The value of each key is an array containing arguments for the function.
NOTE: The script passes the string to the function as the first argument, the array starts with argument2.

Complex example:
If you look here we specify some arguments, and one of which is an array of styles for our span method.

As you can also see, you can pass null arguments to functions.

DO NOT FORGET THAT THE KEY=Function. If the function has no arguments, specify it as
$filters = array('function' => NULL);


Here is the class file.

stringformatter.class.php