(a)Explain the basic architecture with flow of the zend engine. Explain how PHP scripts are executed.

The Zend Engine is the core of PHP, responsible for interpreting and executing PHP code. Here's an overview of its architecture and flow:

Lexical Analysis:
The PHP code is first broken down into tokens (smallest individual units of the language) by the lexical analyzer (lexer).
Parsing:
The parser takes these tokens and builds an Abstract Syntax Tree (AST), which represents the structure of the code.
Compilation:
The AST is then compiled into opcodes (operation codes), which are low-level instructions that can be executed by the Zend Virtual Machine (VM).
Execution:
The Zend VM executes these opcodes, which perform the actual operations of the PHP script.
Output:
The results of the execution are then sent back to the web server, which forwards them to the client (usually a web browser).

Now, let's look at how PHP scripts are executed:

Request Initiation:
When a PHP script is requested (e.g., through a web server), the PHP interpreter is invoked.
Script Loading:
The PHP script file is loaded into memory.
Parsing and Compilation:
The script goes through the lexical analysis and parsing stages mentioned above, resulting in opcodes.
Execution:
The Zend Engine executes the opcodes.
Interaction with Extensions:
During execution, the script may interact with various PHP extensions (like MySQL, GD, etc.) which are loaded as needed.
Memory Management:
The Zend Engine manages memory allocation and deallocation for variables and objects used in the script.
Output Buffering:
Output from the script is typically buffered before being sent to the client.
Request Shutdown:
After execution, resources are freed, and any shutdown functions are called.
Response Sent:
The final output is sent back to the web server and then to the client.

(b) Explain various types of arrays in PHP with example scripts:
PHP supports three main types of arrays:

Indexed Arrays:
These are arrays with numeric keys.

<?php
$fruits = array("Apple", "Banana", "Cherry");
// or
$fruits = ["Apple", "Banana", "Cherry"];

echo $fruits[1]; // Outputs: Banana
?>

Associative Arrays:
These use named keys instead of numeric indexes.

<?php
$age = array("Peter"=>35, "Ben"=>37, "Joe"=>43);
// or
$age = ["Peter"=>35, "Ben"=>37, "Joe"=>43];

echo $age["Ben"]; // Outputs: 37
?>

Multidimensional Arrays:
These are arrays containing one or more arrays.

<?php
$cars = array (
  array("Volvo",22,18),
  array("BMW",15,13),
  array("Saab",5,2)
);

echo $cars[0][0]; // Outputs: Volvo
?>
(c) Explain different variable scopes in PHP with help of example scripts:
PHP has three main variable scopes:

Local Scope:
Variables declared within a function have local scope.

<?php
function test() {
    $x = 5; // local scope
    echo $x;
}
test(); // Outputs: 5
// echo $x; // This would cause an error
?>

Global Scope:
Variables declared outside a function have global scope.

phpCopy<?php
$x = 5; // global scope

function myTest() {
    global $x; // Use the global keyword to access global variable
    echo $x;
}

myTest(); // Outputs: 5
?>

Static Scope:
Static variables retain their value between function calls.

phpCopy<?php
function counter() {
    static $count = 0;
    echo $count;
    $count++;
}

counter(); // Outputs: 0
counter(); // Outputs: 1
counter(); // Outputs: 2
?>