Sign up ×
WordPress Development Stack Exchange is a question and answer site for WordPress developers and administrators. It's 100% free, no registration required.

I need to create a variable that can be accessed throughout my WordPress Theme template files (index.php, header.php etc..). I know function definitions go inside the functions.php template file (in your theme path), but there's no such thing for variables.

For example I constantly need to retrieve Categories in my Theme, so I would like to have this accessible from anywhere in my theme:

$categories = get_categories(); /* get_categories() is a wordpress function */

This way I can simply access to allocated data, without having to re-allocate it every time I need to get my categories.

Unfortunately adding that piece of code in my functions.php file, doesn't work, neither does making the variable global.

share|improve this question

migrated from Feb 20 '12 at 21:49

This question came from our site for professional and enthusiast programmers.

4 Answers 4

up vote 4 down vote accepted

Apparently global does the trick. The problem was that my variable $categories should have been redefined with a global in front of it, in each template I needed to use it.

share|improve this answer
Does anyone else know of a more intuitive solution than having to redefine it as global in every template file? I use this method in developing my theme and it looks... out of place. – Eddie Ringle Nov 9 '09 at 23:04
Awesome dude, thanks! For anyone ready this who's a bit thick like me: In your functions.php file: <?php $test = "I'm a test!"; ?> In your, I don't know, header.php: <?php global $test; echo $test; ?> and you're golden! – Dominic Nov 30 '10 at 12:04
If this helps to clarify: all of the template files in WordPress are called by require() statements which are wrapped in functions: get_header(), get_footer(), etc; which themselves are wrappers around the function get_template_part(). Since functions in PHP only have access to the variables defined within them or passed by reference to them, if you want to use a variable from the global scope (or define a variable and make it accessible in the global scope) you have to announce it with the global keyword first. – goldenapples Feb 20 '12 at 21:57

Dominic (don't know how to add a note to his answer):

define only accepts scalars, so you couldn't do define( CATS, get_categories() ); and not even

$categories = get_categories();
define( CATS, $categories );

Otherwise define works fine, and it is in fact safer for scalars (as you can be sure the constants cannot be overwritten)

share|improve this answer

This also works:

in functions.php add define('TEST', 'this is a test');
and in your header.php or whatever echo TEST;

Is there any perfomance advantage to one method over another?

share|improve this answer

I know this one is really old, but there is a room for improvement.

You should consider using $GLOBALS['categories'] instead of just global.

There are two reasons for this:

  1. We don't have to write global $categories; everytime.
  2. It's crystal clear then we are using global and then not.

Consider this code:

global $categories;

// a lot of PHP code here

<?php print_r ($categories) ?>

Only if we initialize global state right before using variable, it's pretty hard to tell, if it's global or not. And don't forget to repeat it in any of template files you have.

It's possible to use naming conventions for that, but there is a better way, in my opinion.

Consider using $GLOBALS['categories'].

We only have to initialize our variable one time in functions.php without having to think about global $categories again. And we can see it's a global one.

print_r ($GLOBALS['categories']);

Performance issue is not a an issue at all in this situation. I'll quote Sara Golemon (link):

What does that mean for your use of the $GLOBALS array? That's right, the global keyword is technically faster. Now, I want to be really clear about one thing here. The minor speed affordance given by using your globals as localized [compiled variables] needs to be seriously weighed against the maintainability of looking at your code in five years and knowing that $foo came from the global scope. something_using($GLOBALS['foo']); will ALWAYS be clearer to you down the line than global $foo; /* buncha code */ something_using($foo); Don't be penny-wise and pound foolish..

share|improve this answer

Your Answer


By posting your answer, you agree to the privacy policy and terms of service.