Why global state is dangerous in PHP - Performance Analysis

Time Complexity: Why global state is dangerous in PHP

O(n)

Understanding Time Complexity

When using global state in PHP, it's important to see how it affects the program's behavior as it grows.

We want to understand how accessing and changing global variables impacts the program's speed and complexity.

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

<?php
$globalArray = [];

function addItem($item) {
    global $globalArray;
    $globalArray[] = $item;
}

for ($i = 0; $i < $n; $i++) {
    addItem($i);
}

This code adds items to a global array inside a loop.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Adding an item to the global array inside the loop.
• How many times: The loop runs n times, so the add operation repeats n times.

How Execution Grows With Input

Each new item is added one by one, so the total work grows as we add more items.

Input Size (n)	Approx. Operations
10	10 additions to the global array
100	100 additions to the global array
1000	1000 additions to the global array

Pattern observation: The number of operations grows directly with the input size.

Final Time Complexity

Time Complexity: O(n)

This means the time to complete the task grows in a straight line as the input size increases.

Common Mistake

[X] Wrong: "Using global variables makes the code faster because data is always available."

[OK] Correct: Accessing and modifying global state can cause hidden delays and bugs, especially as the program grows, making it harder to predict performance.

Interview Connect

Understanding how global state affects program growth helps you write clearer, more predictable code, a skill valued in many coding challenges and real projects.

Self-Check

"What if we replaced the global array with a local array passed as a function argument? How would the time complexity change?"

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