Would using an array to create objects be wise?

[Zoruglu]

Hi everybody! :p

I am in the process of making a project, trying out some code and mainly planning it at this stage.

I have a question that I believe will greatly influence the way the code will be designed...

I would like to create objects in an array instead of vars like this:

$ZAPI = array();

$ZAPI['core']    = new core;
$ZAPI['output'] = new output;

So that I can call them like this:

$ZAPI['core']->load_skin();

$ZAPI['output']->render_page();

Basicaly, I would like to have just one global array so that I only need to do this in every function where I need to access it:

function my_func()
{
    global $ZAPI;

// do something here...
}

Just for the sake of making everything global nicely transportable over the entire script which will be composed of several modules who all need to access shared (=global $ZAPI) data...

What do you think of this method? Would there be any significant disadvantages (or hopefully advantages) on doing it like this?

[paulnaj]

Hi Zoruglu,

In general, the rule seems to be 'If it works, it works'. And your way will work, but it does defeat somewhat the point of using objects in the first place. Using lots of globals generally means that the 'action' is happening outside of the objects you are creating ... so their usefulness becomes questionable.

I generally find that I always need a few globals in any application, but as a rule, I try and keep them to a minimum.

Some things to think about ...

1) Portability ... for example, if the server hosting the site changes it's configuration or the client moves to a different host, how much code will you have to re-write? (More globals => more re-writing)

2) Re-use ... your scripts work for this client .... how much of it do you need to change for it to be usable for a different client? (More globals => more re-writing)

3) Ease of use/Debug-ability ... if some of your logic breaks down (not a typo or a compile error), how hard is it to find the problem.
(More objects with their own error-processing => less debugging)

4) Er ... there are others

The downsides of OOP include the amount of planning that needs to go into it ... especially choosing the 'right' classes to code and (sometimes) the amount of overhead.

Hope that helps!

Paul 🙂

[Zoruglu]

Thx for the reply.

Yes, what you're saying is also what I read in OOP literature and it makes much sense indeed.

However, I do need a way for making some objects transportable:

this is what I have so far:

A mysql class: handles the connection and mysql operations

a core class: contains all "low level" functions and does the basic init of the script environment (like loading config, load skin, load words, etc...) and loads a module specified in the url (eg: http://www.mydomain.com/index.php?module=news )

a display class: loads a specified template and replaces the custom tags with html from the skin templates and prints to the browser.

a session class: does the user authentication and session creation.

a skin class: loads the html template bits specific for a module.

A goup of modules that use all of the above classes, specified by module=news in the url...

Inside a module, this would result in code like this:

function my_function()
{
    global $input, $core, $sess, $conf, $db;

$db->query( 'SELECT * FROM tablename where id='.$input['topic_id'] );

// do somthing with it...
}

The exemple above illustrates why I was thinking about an array so that I only need to say "global $ZAPI", or am I approaching it totaly wrong and is there a better way for this? 🙂

My goal is to make a script that serves as an API and a "plugin system" which does all the universal things a php script needs to do.

The modules would be the "plugins" that expand the script's abilities so that it can be a blog, gallery, board, or anything you plug in it.

[paulnaj]

Hey Zoruglu,

Sounds like you've got things pretty sorted out!!

But, you might want to consider that, in effect, you could still achieve exactly the same results with an 'application' class that just does what your modules are doing.

<?php  

class App {
	var $input;
	var $db;

// Constructor, etc ...


function my_function(){
	$this->db->query( 'SELECT * FROM tablename where id='.$this->input['topic_id'] );
	// do somthing with it...
}
}
?>

Paul.

[Zoruglu]

Thx Paul! I've already been giving it a lot of thought. 🙂

I'm not shure I understood what you mean with "application class" from the exemple you posted.