Script execution and memory reset in PHP - Deep Dive

Overview - Script execution and memory reset

What is it?

Script execution in PHP means running the code from start to finish each time a request is made. Memory reset means that after the script finishes, all variables and data stored in memory are cleared. This happens because PHP is designed to run scripts fresh for every request, not keep data between runs.

Why it matters

Without script execution and memory reset, PHP would keep old data from previous users or requests, causing errors and security risks. This reset ensures each user gets a clean start, making web applications reliable and safe. It also means PHP scripts are simple and stateless, which fits the web's request-response nature.

Where it fits

Before learning this, you should understand basic PHP syntax and how to write simple scripts. After this, you can learn about sessions and databases, which help keep data between requests since PHP itself resets memory every time.

Mental Model

Core Idea

Each time a PHP script runs, it starts fresh with empty memory and ends by clearing everything, so no data sticks around between runs.

Think of it like...

Imagine a whiteboard that you write on during a meeting. When the meeting ends, you erase everything so the next meeting starts with a clean board.

┌───────────────┐
│ Start Script  │
├───────────────┤
│ Run Code      │
│ (variables,   │
│  calculations)│
├───────────────┤
│ End Script    │
├───────────────┤
│ Clear Memory  │
└───────────────┘

Build-Up - 6 Steps

1

Foundation

What is script execution in PHP

Concept: Understanding that PHP runs code from top to bottom each time a page loads.

When you visit a PHP page, the server reads the PHP file and runs the code inside it from the first line to the last. This process is called script execution. After the script finishes, the server sends the result (usually HTML) back to your browser.

Result

The PHP code runs once per request, producing output for that request only.

Knowing that PHP scripts run fully each time helps you understand why variables don't keep their values between page loads.

2

Foundation

What happens to memory after script ends

Concept: Learning that all variables and data in memory are erased after the script finishes.

PHP uses memory to store variables and data while the script runs. When the script ends, PHP automatically frees this memory, so nothing remains stored. This means each new request starts with empty memory.

Result

Memory is reset after every script execution, so no data persists automatically.

Understanding memory reset explains why you can't rely on variables to keep data between page visits.

3

Intermediate

Why PHP resets memory every run

🤔Before reading on: Do you think PHP keeps variables from one request to the next or resets them? Commit to your answer.

Concept: PHP resets memory to keep each request independent and secure.

PHP is designed for the web, where each user request is separate. Resetting memory after each script run prevents data leaks between users and avoids confusion from leftover data. This stateless design fits the web's request-response model.

Result

Each request is isolated, improving security and reliability.

Knowing PHP's stateless nature helps you design web apps that handle data explicitly between requests.

4

Intermediate

How to keep data between script runs

🤔Before reading on: Can you guess how PHP remembers user data across pages if memory resets? Commit to your answer.

Concept: Introducing sessions and databases as ways to store data beyond one script execution.

Since PHP clears memory after each run, it uses special tools like sessions (which store data on the server linked to a user) and databases (which save data permanently). These let you keep user info or app state across multiple page visits.

Result

Data can persist across requests using sessions or databases, despite memory reset.

Understanding external storage methods is key to building interactive, stateful web applications.

5

Advanced

Memory management during script execution

🤔Before reading on: Do you think PHP frees memory immediately after each variable is unused or only at script end? Commit to your answer.

Concept: PHP allocates and frees memory dynamically during script run but resets all at the end.

While running, PHP manages memory by allocating space for variables and freeing it when no longer needed. However, the full memory reset happens only after the script finishes. This means temporary data is cleaned up automatically, preventing leaks during execution.

Result

Efficient memory use during script run and complete cleanup after.

Knowing PHP's memory lifecycle helps optimize scripts and avoid memory-related bugs.

6

Expert

Surprises in persistent memory with PHP extensions

🤔Before reading on: Do you think PHP extensions can keep data between requests despite memory reset? Commit to your answer.

Concept: Some PHP extensions or configurations can hold data beyond script execution, breaking the usual reset behavior.

While PHP core resets memory each run, extensions like OPcache or shared memory tools can store data persistently for performance. This can cause unexpected behavior if you assume memory always resets. Understanding this helps debug tricky issues.

Result

Memory reset is not absolute; some tools keep data across requests.

Recognizing exceptions to memory reset prevents confusion and bugs in advanced PHP setups.

Under the Hood

PHP runs scripts inside a process that starts fresh for each request. It loads the script, parses it, executes instructions, and allocates memory for variables. When the script ends, PHP's engine frees all allocated memory and closes the process. This cycle repeats for every request, ensuring no leftover data remains.

Why designed this way?

PHP was created for the web, where each user request is independent. Resetting memory after each script run avoids data leaks, security risks, and complexity of managing persistent state. Alternatives like long-running processes were avoided to keep PHP simple and fast for web hosting.

┌───────────────┐
│ New Request   │
├───────────────┤
│ Load Script   │
├───────────────┤
│ Execute Code  │
├───────────────┤
│ Allocate Mem  │
├───────────────┤
│ Send Output   │
├───────────────┤
│ Free Memory   │
├───────────────┤
│ End Request   │
└───────────────┘

Myth Busters - 3 Common Misconceptions

Quick: Does PHP keep variable values between page loads automatically? Commit yes or no.

Common Belief: PHP variables keep their values between page loads like in desktop programs.

Reality: PHP clears all variables and memory after each script finishes, so variables do not persist between requests.

Why it matters: Assuming variables persist causes bugs where data disappears unexpectedly, confusing beginners.

Quick: Can you store user data just by assigning variables in PHP? Commit yes or no.

Common Belief: Assigning a variable once is enough to remember user data across pages.

Reality: Variables exist only during one script run; to keep data, you must use sessions, cookies, or databases.

Why it matters: Not using proper storage leads to lost user data and broken web app behavior.

Quick: Does PHP memory reset mean all extensions also clear their data? Commit yes or no.

Common Belief: All PHP memory and data, including extensions, reset after each script.

Reality: Some extensions like OPcache or shared memory can keep data between requests, which can surprise developers.

Why it matters: Ignoring this can cause unexpected bugs or security issues in advanced PHP environments.

Expert Zone

1

PHP's memory reset applies only to the script's runtime memory, not to external caches or persistent storage.

2

OPcache improves performance by caching compiled scripts but can cause stale code if not managed properly.

3

Session data is stored outside script memory, often in files or databases, to survive memory resets.

When NOT to use

Relying on PHP's memory for persistent data is wrong; use sessions, databases, or caching systems instead. For long-running processes or real-time apps, consider other technologies like Node.js or PHP's CLI with daemon scripts.

Production Patterns

In production, PHP scripts are short-lived and stateless. Developers use sessions for user login, databases for data storage, and caching layers like Redis or Memcached to improve performance while respecting memory reset.

Connections

HTTP Request-Response Cycle

Builds-on

Understanding PHP's memory reset fits perfectly with the stateless nature of HTTP, where each request is independent.

Session Management

Builds-on

Knowing memory resets clarifies why sessions are needed to keep user data across multiple requests.

Operating System Process Lifecycle

Same pattern

PHP script execution mimics a process lifecycle where memory is allocated during execution and freed at process end, similar to how OS manages programs.

Common Pitfalls

#1 Expecting variables to keep values between page loads.

Wrong approach:

Correct approach:

Root cause:

Misunderstanding that PHP variables reset after each script run, so data must be stored externally to persist.

#2 Trying to share data between users by global variables.

Wrong approach:

Correct approach:

Root cause:

Believing PHP memory is shared across requests and users, ignoring the isolated execution model.

Key Takeaways

PHP runs scripts fresh for every request, starting with empty memory each time.

All variables and data in memory are cleared after the script finishes, so nothing persists automatically.

To keep data between requests, you must use sessions, cookies, databases, or caching systems.

This design ensures security, simplicity, and fits the stateless web model.

Advanced tools like OPcache can cache data beyond script runs, which can surprise developers if not understood.

Practice

1. What happens to variables in a PHP script after the script finishes running?

easy

A. Variables are saved permanently in the script file

B. Variables keep their values until the server restarts

C. All variables and memory are reset and cleared

D. Variables are shared with other scripts automatically

Solution

1. Step 1: Understand PHP script execution

   PHP runs scripts from top to bottom each time the page loads.

2. Step 2: Memory and variable reset after execution

   After the script finishes, all variables and memory used are cleared to keep the environment clean.

3. Final Answer:

   All variables and memory are reset and cleared -> Option C

4. Quick Check:

   PHP resets variables after script ends = C [OK]

Hint: Remember PHP resets memory after each script run [OK]

Common Mistakes:

• Thinking variables keep values between page loads
• Assuming variables save to the script file
• Believing variables are shared across scripts automatically

2. Which of the following is the correct way to start a PHP script that resets variables each time it runs?

easy

A.

B.

C.

D. // PHP code here

Solution

1. Step 1: Identify correct PHP tags

   PHP scripts start with to run properly.

2. Step 2: Understand script resets

   Each time the script runs, variables reset automatically without extra commands.

3. Final Answer:

   -> Option A

4. Quick Check:

   Correct PHP tags = A [OK]

Hint: Use tags to start PHP scripts [OK]

Common Mistakes:

• Using <script> tags which are for JavaScript
• Trying to call reset() function which doesn't reset variables
• Using incorrect <php> tags

3. Consider this PHP code run twice in a row (two separate page loads):

<?php
$counter = 0;
$counter++;
echo $counter;
?>

What will be the output each time the script runs?

medium

A. 1 then 1

B. 0 then 1

C. 1 then 2

D. 0 then 0

Solution

1. Step 1: Analyze variable initialization

   Each time the script runs, $counter is set to 0 at the start.

2. Step 2: Increment and output

   $counter++ increases $counter to 1, then echo prints 1 each time.

3. Final Answer:

   1 then 1 -> Option A

4. Quick Check:

   Variables reset each run, so output is 1 each time [OK]

Hint: Variables reset each run, so counter restarts at 0 [OK]

Common Mistakes:

• Assuming $counter keeps incrementing across runs
• Confusing pre-increment and post-increment
• Thinking echo prints 0 first

4. You wrote this PHP code:

<?php
$sum = 10;
$sum += 5;
?>

But after refreshing the page, $sum is always 15. You want $sum to keep increasing by 5 each time the page loads. What is the problem?

medium

A. You need to use a loop to increase $sum

B. The += operator does not add values correctly

C. You forgot to declare $sum as global

D. PHP resets variables after each script run, so $sum starts at 10 every time

Solution

1. Step 1: Understand variable reset behavior

   PHP clears all variables after each script finishes, so $sum resets to 10 every time.

2. Step 2: Why $sum does not keep increasing

   Because $sum is reinitialized to 10 on each page load, adding 5 results in 15 always.

3. Final Answer:

   PHP resets variables after each script run, so $sum starts at 10 every time -> Option D

4. Quick Check:

   Variables reset each run = D [OK]

Hint: Variables reset each run; use sessions or files to keep values [OK]

Common Mistakes:

• Thinking += operator is faulty
• Assuming global declaration keeps value between runs
• Believing loops affect variable persistence

5. You want to count how many times a PHP page has been loaded by visitors. Since PHP resets variables each run, which method should you use to keep the count across page loads?

hard

A. Declare the count variable as global inside the script

B. Store the count in a session or a file/database to persist data

C. Use a loop to increment the count variable inside the script

D. Reset the count variable to zero at the start of the script

Solution

1. Step 1: Recognize PHP variable reset limitation

   PHP variables reset after each script run, so count cannot persist in normal variables.

2. Step 2: Use persistent storage

   Sessions, files, or databases store data between page loads to keep count.

3. Final Answer:

   Store the count in a session or a file/database to persist data -> Option B

4. Quick Check:

   Persistent storage needed for count across runs = B [OK]

Hint: Use sessions or files to save data between page loads [OK]

Common Mistakes:

• Thinking global variables keep values between runs
• Trying to use loops for persistence
• Resetting variables each time defeats counting