Php : what is better for configuration variable ? variable or parameter?

i have an application done in php and all configuration variables are loaded in a big $conf variable at the beginning of the script.

What is the better way to communicate this configuration variable to all other functions ?

make it a parameter of every function ? or use it with开发者_开发问答 "global $conf;" statement in every function ?

is there a better way to do ?

Thanks

Use PHP constants.

For ponies sake, avoid using global variables at all costs :)

EDIT

Some explanations about "avoiding global variables at all costs" and possible alternatives:

• https://stackoverflow.com/questions/357187/when-are-global-variables-acceptable/357361#357361
• http://my.opera.com/zomg/blog/2007/08/30/globals-are-evil
• https://stackoverflow.com/questions/1285700/what-are-some-good-tips-for-a-new-php-developer (especially section Scope of the accepted answer)

Make a configuration class that stores the options. Make it a singleton PHP Manual describes that here. This is just an alternative to global variables. It would allow you to define a method to load options from a file or a php array and store them in the class. Other classes can use the configuration object by getting the single instance and accessing the data.

I think this is better than a global variable as the other answer also says. But it still lets you define options as arrays, or even nested arrays if you want (and set up your class accordingly)

Your use of a single global-scoped variable $conf is perfectly fine. Many PHP applications do that. But there are drawbacks to combat.

In particular it's often more effort to write global $conf in each function where you want to access them. In that case I would recommend a simple global wrapper function instead:

function conf($key, $sub="") {
    global $conf;
    if (defined($key))
        { return constant($key); }
    elseif ($sub)
        { return $conf[$key][$sub]; }
    else
        { return $conf[$key]; }
}

This allows you to write conf("setting1") or conf("main", "opt3") whereever you need it. Still you can access the global $conf where that is more suitable. As extra bonus you can make this wrapper function more intelligent, by allowing it to query alternative settings etc. Also see how easy it is to also sneak in conf("CONSTANT") support.

Keeping this adds some flexibility in defining your configuration settings. Personally I use a similar approach, albeit with defining the array step-wise rather than at once:

$app_config["title"] = ...;
$app_config["editor.btns"] = ...;
define("RESTRICTED_MODE", true);

I'm preferring the array() approach, but transitioning to an ini-file for storage at a later point is not a problem. Also you can still make your config array read-only if the need arises. For that just define an:

class Read_Only_Array extends ArrayObject { function offsetSet() {} }
$conf = new ReadOnlyArray($conf);

So it's still accessible as array, but you easily established what others use cumbersome registries or syntactic workarounds for.

The "globals are evil" meme is completely baloney. It's parrotted on SO by cargo cult programmers with a desire for oversimplification and newcomers who glance over bold headlines without understanding the language semantics.

In your case, you just use a single $conf variable, and do not pollute the shared scope. When it is coherently accessed from the whole application, then it's not an issue. You should however strictly avoid to modify contents at runtime (use Read_Only_Array if need be). Create a secondary $app_var[] aray for that, and keep your config settings static.