Classes vs. Functions

raidon

I just recently learned how to code classes and I was wondering what is the benefit of using classes over functions. None of the books or articles will give me a clear explanation. Thanks!

MrAlaska

Classes are objects with properties and actions available, functions are a set of actions or instructions. That's how I think of them anyway. Related functions can be grouped together in a class, forming a sensible object that takes care of one area of your application. I kind of consider classes as nouns and functions as verbs but it can get confusing because some classes only exist to take action while some functions only exist to create something.

It really is up to you how you percieve it an whether your objects are understandable and portable. A lot of it is a conceptual matter of perception. I can't explain it well, but when it is done right I recognize it (sometimes). The only thing I can tell you for sure is classes are the ones that use that funny arrow in PHP 😃

raidon

Thanks I got it now😃

dmayo2

Sorry guys, but I still don't understand the finer points of the differences of when to use one over the other. I can write functions that are completely independant of any code and totally portable, i.e. OO.

Are there performance benefits? Based on the above statement, I can't envision any coding benefits. Sure, I read that you can easily extend classes, but I can do that just as easily (for me) with functions.

I've been searching for a really good explaination for over a year now, to no avail.

Thanks:

spaddict

I think part of the idea with classes is just to have one completely independent object. With functions you can have all of them and copy/paste them into your application, but with classes you just include them and off you go. Classes are especially important when it comes to adding modules - PHP, for example, has a ton of modules (Win based .dlls) that add extra functionality to PHP without having to recompile or redistribute.

Also, with classes, its a lot easier to change the actual code inside the class. You can say you have class version 1 or class version 2 - it doesn't make sense to say that you have function version 1 or function version 2. Its quite a bit easier to keep track of one version number for a class than for each function as well.

All in all, classes are mostly organizational things with data members thrown in as an extra bonus. And better organization = better code.

And one more thing - since everything in the world can basically be described as an object - an apple, a computer, a whatever - with properties and actions, it makes sense to build our programming languages around the same way that we interact with our world. This way we enable ourselves to get more understandable code because we describe things in ways we are already accustomed to. For me, its a lot easier to look at a function and see what is happening with classes than to look at functions and try to figure out what each and every function does and how exactly it interacts with things.

MrAlaska

Originally posted by dmayo2
....Are there performance benefits? ...

There aren't any performance benefits, there is actually a slight performance loss. There can be a performance loss using functions, too, for that matter. As far as code functionality goes, functions will give you all the functionality you will need (which is, I suppose, why they are called functions 😃 )

As Spaddict explained classes keep things organized, and in doing so can greatly speed up development time especially when teams are involved. If I build a bunch of classes it is easier to share (or re-use) them with a bit of documentation then it is to share a bunch of functions and explain and document which functions need to be used for what purposes.

It is pretty intuitive if I build a session object then all I need to know later is anything to do with a session is done through the $session object, such as $session->start, $session->purge, $session->destroy, $session->log etc. If a co-developer has a problem with using the $session object, I do not need to check whether this particular function or that one was included or understood, all that is needed is the $session class and a level of troubleshooting is reduced.

junkie_doodle

I think the variable scope of PHP makes things harder to clearify. Because the use of properties

class myNewClass{
// declared variables.. (properties)
var $property;

// declared functions.. (methods)
function method()
    {
        //code
     }

}

sometimes makes it easier for developers to develop and designers to design software.

I think choosing OO coding or not is something depended to the project requirements. And ofcourse the coding habits of the designers and/or developers.

It's not possible to say that, recent version(s) of PHP support(~s) a full OO style developing. So my personel choice to code OO is only about having abstract and easy-to-understand (so easy-to-maintain) PHP code.

I agree with the above posts saying that it's a personal choice to use classes, functions or none of them.

But i strongly recommend you to try using OO features of PHP too. Who knows? Maybe you might like 😉

matto

I use classes more and more often because:

you don't get so confused in complex projects
you can dereference classes from each other, varying them without fuss
you can store complex objects in arrays, loop through them in order to do the same with all of them
you don't have to work with functions that take lots of parameters which you don't overlook

now I will describe an example, perhaps it's interesting to someone 😉 sorry, it got quite long ...

I have created a set of classes which represent HTML inputs.

class Input has two dereferenced classes:
HiddenInput and VisibleInput.
and VisibleInput has
TextInput, Checkable (-> Checkbox, RadioButton)
and so on.

this far it seems more complicated than just writing a html form.

now every VisibleInput has a Label (for example: "Enter your name:").

you can create a textinput like this:
$t = new Textinput();
$t->setName('username');
$t->setLabel('Enter your name:');

once you have all the inputs you want to be included in your form, create a Form object an add the inputs to it.

$f = new Form();
$f->setAction('post.php');
$f->addItem($t);
...

you can add multiple inputs in a loop.

now, if you want to display the Form as an HTML table, do the following:

$f->setStyle('table');

or, if you want each input line by line:

$f->setStyle('normal');

if you want the labels on the right of each item, you can adjust it easily:

$f->setLabelAlign('right');

finally, produce the whole HTML code:

echo $f->getHTML();

for me, the best idea I had when designing this, is a SQLSelectbox. it's basically a normal selectbox (from which it is dereferenced) but you can set an sql statement as an attribute:

$s = new SQLSelectbox()
$s->setName('id_customer');
$s->setSQL("select id,name from customer");
echo $s->getHTML();

voilà - that's really fun to use.
if I had used functions, I would have had to copy the selectbox() function, rename and modify the copy.
a bug in the original function? -> correct both functions. (bah!)

with object orientation, I just have to debug the superclass (Selectbox).

the point is, using this programming style reduces the complexity of your scripts drastically (not of your project library, but of the scripts which make use of it). imagine you designing a site that has 50 form pages in it.

now, the code needed for producing a medium-complex form is free of plain HTML, thus far better maintainable. you can turn switches by calling a method such as $f->setLabelAlign('bottom');

I have tried this with functions before, and I got lost in my 15 parameters for some inputs and functions calling sub-functions and so on.

but class hierarchies have to be designed well, so if you already hate designing databases, this will be no fun for you.

_SuperString

I have to agree that using OO in PHP has its definite advantages over functions. I think its harder to get the concept of OO over functions if you havnt came from an OO background, and I must admit there are very little, good examples, of OO with PHP around.
I would also like to see more up-to-date PHP Class documenting rules available. Has anyone got any good links ?

daveyboy

It's a really nice way to organize things.
The advantages aren't so apparent in PHP, which is not particularly OO. If you look at something like Ruby it's more obvious: instead of foreach( $arr as $v ), you do $arr.each. In Python, trim( $text ) becomes text.strip(), array_pop( $arr ) => arr.pop().

It's a really logical metaphor - objects do things to themselves, rather than you doing things to them, and you don't have to remember all the really long names of functions typical in a language like PHP or C.

Furthermore, inheritance is the lazy man's dream. As much as functions promote code reuse, I think OO inheritance does it better. What do you guys think?