Why global state is dangerous in PHP - See It in Action

Why Global State is Dangerous in PHP

📖 Scenario: Imagine you are building a simple PHP application that tracks user visits. You want to understand how using global variables can cause problems when multiple parts of your program change the same data unexpectedly.

🎯 Goal: You will create a PHP script that uses a global variable to count visits, then see how changing it in different functions can lead to confusing results. This will help you learn why global state is dangerous and how to avoid it.

📋 What You'll Learn

Create a global variable called $visitCount initialized to 0

Write a function incrementVisit() that increases $visitCount by 1 using the global keyword

Write a function resetVisit() that sets $visitCount to 0 using the global keyword

Call incrementVisit() twice, then resetVisit(), then incrementVisit() once

Print the final value of $visitCount

💡 Why This Matters

🌍 Real World

Many PHP applications use global variables to share data, but this can cause bugs when different parts of the code change the same data unexpectedly.

💼 Career

Understanding why global state is dangerous helps developers write cleaner, more reliable PHP code, which is important for maintaining and scaling web applications.

1

Create the global variable $visitCount

Create a global variable called $visitCount and set it to 0.

PHP

# Create a global variable called $visitCount and set it to 0
# Your code here

Hint

Use $visitCount = 0; outside any function to create a global variable.

2

Write the functions incrementVisit() and resetVisit()

Write a function called incrementVisit() that uses the global keyword to access $visitCount and adds 1 to it. Also write a function called resetVisit() that uses the global keyword to set $visitCount back to 0.

PHP

<?php
$visitCount = 0;

# Write function incrementVisit() that uses global $visitCount and adds 1
# Write function resetVisit() that uses global $visitCount and sets it to 0
# Your code here

Hint

Inside each function, use global $visitCount; to access the global variable.

3

Call the functions in order

Call incrementVisit() twice, then call resetVisit(), then call incrementVisit() once.

PHP

<?php
$visitCount = 0;

function incrementVisit() {
    global $visitCount;
    $visitCount += 1;
}

function resetVisit() {
    global $visitCount;
    $visitCount = 0;
}

# Call incrementVisit() twice
# Call resetVisit()
# Call incrementVisit() once
# Your code here

Hint

Call the functions exactly in this order: incrementVisit(), incrementVisit(), resetVisit(), incrementVisit().

4

Print the final value of $visitCount

Print the value of the global variable $visitCount using echo.

PHP

<?php
$visitCount = 0;

function incrementVisit() {
    global $visitCount;
    $visitCount += 1;
}

function resetVisit() {
    global $visitCount;
    $visitCount = 0;
}

incrementVisit();
incrementVisit();
resetVisit();
incrementVisit();

# Print the value of $visitCount
# Your code here

Hint

Use echo $visitCount; to show the final count.

Practice

1. Why is using global variables considered dangerous in PHP?

easy

A. Because they can be changed anywhere, causing unexpected bugs

B. Because they make the code run faster

C. Because they prevent the use of functions

D. Because they automatically encrypt data

Solution

1. Step 1: Understand what global variables do

   Global variables can be accessed and modified from any part of the program.

2. Step 2: Identify the risk of global variables

   Since they can be changed anywhere, it is easy to accidentally overwrite or misuse them, leading to bugs that are hard to find.

3. Final Answer:

   Because they can be changed anywhere, causing unexpected bugs -> Option A

4. Quick Check:

   Global variables cause unexpected bugs [OK]

Hint: Global variables can be changed anywhere, causing bugs [OK]

Common Mistakes:

• Thinking global variables improve performance
• Believing global variables prevent function use
• Assuming global variables encrypt data automatically

2. Which of the following is the correct way to access a global variable inside a PHP function?

easy

A. Declare the variable again inside the function

B. Use the global keyword inside the function

C. Use static keyword inside the function

D. Use const keyword inside the function

Solution

1. Step 1: Recall PHP syntax for accessing global variables

   In PHP, to access a global variable inside a function, you must declare it with the global keyword.

2. Step 2: Understand why other options are incorrect

   Declaring the variable again inside the function creates a new local variable. static keeps value between calls but does not access global. const defines constants, not variables.

3. Final Answer:

   Use the global keyword inside the function -> Option B

4. Quick Check:

   Access global variable in function = global keyword [OK]

Hint: Use 'global' keyword inside function to access globals [OK]

Common Mistakes:

• Redeclaring variable inside function thinking it accesses global
• Using static or const keywords incorrectly
• Forgetting to declare global keyword inside function

3. What will be the output of this PHP code?

$count = 5;
function increment() {
  global $count;
  $count++;
}
increment();
echo $count;

medium

A. 5

B. Nothing is printed

C. Error: Undefined variable

D. 6

Solution

1. Step 1: Understand the global keyword usage

   The function declares global $count; which means it uses the global variable $count defined outside.

2. Step 2: Trace the code execution

   The global $count starts at 5, the function increments it by 1, so $count becomes 6. Then echo $count; prints 6.

3. Final Answer:

   6 -> Option D

4. Quick Check:

   Global increment changes $count to 6 [OK]

Hint: Global keyword lets function modify external variable [OK]

Common Mistakes:

• Thinking $count inside function is local without global keyword
• Expecting output 5 because of misunderstanding scope
• Assuming code causes error due to variable scope

4. Identify the problem in this PHP code related to global state:

$value = 10;
function changeValue() {
  $value = 20;
}
changeValue();
echo $value;

medium

A. The function changes the global variable correctly

B. The code will cause a syntax error

C. The function does not change the global variable because it lacks the global keyword

D. The variable $value is undefined

Solution

1. Step 1: Analyze variable scope in the function

   Inside the function, $value = 20; creates a new local variable, not affecting the global $value.

2. Step 2: Understand why global keyword is needed

   Without declaring global $value; inside the function, the global variable remains unchanged.

3. Final Answer:

   The function does not change the global variable because it lacks the global keyword -> Option C

4. Quick Check:

   Missing global keyword means global variable unchanged [OK]

Hint: Without 'global', function changes local variable only [OK]

Common Mistakes:

• Assuming function changes global variable without global keyword
• Expecting syntax error when none occurs
• Thinking $value is undefined outside function

5. You have a PHP script that uses a global variable $config to store settings. Why is this approach risky, and what is a better alternative?

hard

A. Global $config can be changed anywhere causing bugs; better to pass it as a function parameter

B. Global variables are faster; no alternative needed

C. Global $config encrypts data automatically; better to use global for security

D. Global variables prevent code reuse; better to use global constants instead

Solution

1. Step 1: Understand risks of global variables for configuration

   Global $config can be modified anywhere, leading to unexpected changes and bugs.

2. Step 2: Identify better practice

   Passing $config explicitly as a function parameter keeps control clear and avoids accidental changes.

3. Final Answer:

   Global $config can be changed anywhere causing bugs; better to pass it as a function parameter -> Option A

4. Quick Check:

   Pass config as parameter to avoid global bugs [OK]

Hint: Pass config as parameter instead of using global variable [OK]

Common Mistakes:

• Believing global variables improve speed or security
• Thinking global constants solve all global state issues
• Ignoring risks of accidental global variable changes