Why global state is dangerous in PHP - Quick Recap

Recall & Review

beginner

What is global state in PHP?

Global state refers to variables or data that are accessible from anywhere in the program, not limited to a specific function or class.

beginner

Why can global state make debugging harder in PHP?

Because any part of the code can change global variables, it becomes difficult to track where and why a value changed, leading to confusing bugs.

intermediate

How does global state affect code testing in PHP?

Global state makes testing harder because tests can interfere with each other by changing shared data, causing unpredictable results.

beginner

What is a safer alternative to using global state in PHP?

Using local variables, passing data through function parameters, or using objects to encapsulate state helps keep data controlled and predictable.

intermediate

Give an example of a problem caused by global state in PHP.

If two functions change the same global variable, one function might overwrite the other's data unexpectedly, causing errors or wrong results.

What does global state mean in PHP?

A Variables that never change

B Variables accessible everywhere in the program

C Variables only inside a function

D Variables stored in a database

Global state means variables that can be accessed and changed from any part of the program.

Why is global state dangerous for debugging?

A Because it prevents variable changes

B Because it makes code run faster

C Because it hides where variables change

D Because it only works in PHP

Global state hides where variables are changed, making bugs hard to find.

How does global state affect testing?

A Tests can interfere by sharing data

B Tests do not need data

C Tests become faster

D Tests run independently without issues

Global state causes tests to share data, which can make test results unpredictable.

What is a better way than using global state?

A Using global constants only

B Using more global variables

C Avoiding variables completely

D Using local variables and passing data explicitly

Using local variables and passing data clearly keeps code easier to understand and safer.

What problem can happen if two functions change the same global variable?

A One function might overwrite the other's data

B They will never run

C The variable becomes constant

D The program crashes immediately

Shared global variables can be overwritten unexpectedly, causing errors.

Explain why global state can cause bugs in PHP programs.

Think about how many places can change the same data.

Describe how using local variables and passing data can improve PHP code compared to using global state.

Consider how data moves clearly between parts of the program.

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