Scoping – Who Can Communicate With Whom

Let’s talk about scoping, i.e. who can communicate with whom in your program. If you are going to write code, then you must understand scope. It defines the rules to define what code can talk with other code. This is a technical discussion which includes how memory is used and allocated.

Your key takeaways are:

• Local scope means the variables are only accessible within the code block
• Global scope means the variables are accessible everywhere
• Unexpected behavior can happen with global variables
• Do not use global variables in your code
• Garbage collection helps prevent memory leaks

Study Notes

Let’s define scoping:

• It’s a set of rules to define what code can talk with other code
• Variables have scope
  • Global scope – everyone can read and write to the variable. WordPress uses a lot of global variables. Yes, this means that some piece of code or plugin could overwrite your global variable, causing unexpected results and faults.
    Do not use global variables in your code.
  • Local scope – access is limited to within the code block where the variable is declared. This is the variable scope you should be using when writing code.

Declare a Variable

Remember that a variable represents an actual value of data. To declare a variable, you first give it a user-defined name and then you assign it a value. The assignment is called initializing the variable. We call it initializing because we’re setting an initial state for the variable.
pageName = 'FAQ'

What happens when you declare a variable?

1. you’re giving it a name
2. you’re making an assignment, or initializing the variable

In memory, the user-defined variable is stored in memory or symbols table and then points to the memory location of the data it represents.

Variable Scope

Variables have scope, which is assigned to the code block it resides within. Variables in one scope are not accessible to another scope unless they are global and specifically declared as global within the local scope.

For variables specified within a function call, such as displayPage(pageName), the data’s memory location is passed to the function (subroutine) and not the variable itself. When given this code:

the variables pageName and isPageLoaded on lines 1 and 2 are not the same variables as in the function displayPage.

Why? They are in different scopes.

When the function is called in the code above, the location of the data represented by pageName on line 2 is copied and stored in a new memory location for the local scope of the function.

Calling User-defined Functions

In programs, you have the name of the function (or subroutine) and you can pass it a series of arguments.
What are we doing in the global scope of the following code?

1. we initialize the isPageLoaded variable by
2. calling the displayPage function and
3. passing displayPage the memory location of the pageName variable
4. the result of that function is then assigned to the ispageLoaded variable.

In Step 3 above, since we are only passing the memory location, and not the actual variable, the following code would work too. Do you notice the different variable name used in the function’s arguments?

More on Local vs. Global Scope

Any variable used inside a function is, by default, in the local scope of that function. Neither other functions nor the main program can access these local variables. They are hidden away inside the function. When that function ends, or when you leave the function by getting to the return statement, the local variable loses scope. At that point, garbage collection frees up that memory location. If that function is called again, new memory will be allocated to hold the value of the local variable.

This means that a global variable can exist in the global scope, and a variable with the same name can be declared within the local scope of a function or subroutine. The global variable and local variable are not the same variable. They do not point to the same memory location.

The function lives in its own little world. It can only “see” the things inside itself, so it is not aware of any global variables. You can, however, make the function aware of the global variables. You do this by explicitly declaring inside that function that the function’s variable is pointing to the global variable.

Episode #13
08:34 Runtime

What's the deal with scope?free

Lab: PHP 101: Gentle Introduction to WordPress Programming

What is the deal with scope? If you are working on a theme or some code, you’ll hear about scope. Or maybe you’ve tried to access a variable that’s in another function and you don’t understand why you can’t access it. Why? How about the global variables? Let’s talk about scope. Scope defines what parts of your code can access other code. In this episode, we’ll talk specifically about variables and their scope. Variables have scope. They belong to some access level. Variables within a function belong to that function. The function can use them, but code outside of that […]

Learn more

Episode #3
08:24 Runtime

Variable Scope

Lab: PHP Variables Bootcamp

Let's talk about variable scope. Scope defines how and where you can access and use variables. It relates to memory. A variable within a function belongs to that function. Scoping is like a gatekeeper. It protects our code from other functions and code, to ensure we have control. It protects our variable naming to avoid naming conflicts.

Learn more

Other Resources

• WordPress-specific global variables
• Variable scope in PHP