PHP Code Sequencing

Rivet

OK, I've figured out a couple of different things empirically:
1. Functions are apparently read before any input, validation, etc. occur so other than logically it should be at the (top?) or (botttom?) of the script. Is TOP the right answer?

Same goes for arrays; it doesn't seem to matter whether I place them before or after the code that uses them; they still work just fine.

Rhetorically, which occurs first when a server reads the code it receives?

More directly, where could I find further information on such workings of PHP? Figuring things out empirically is only reinventing the wheel and prone to lots of error.

Or is it so simple it can be covered in a response here? I tend to doubt that, and I've also been looking for this sort of information for a long, long time now. I'd just like a little detail about what happens, sequentially, when a server receives a script to execute?

TIA for any leads or hints,

Twayne`

bradgrafelman

Rivet;11032569 wrote:
1. Functions are apparently read before any input, validation, etc. occur so other than logically it should be at the (top?) or (botttom?) of the script. Is TOP the right answer?

This quote comes from the PHP manual page [man]functions.user-defined[/man]:

PHP Manual wrote:
Functions need not be defined before they are referenced, except when a function is conditionally defined as shown in the two examples below.

(See that manual page for the examples given.)

Rivet;11032569 wrote:
2. Same goes for arrays; it doesn't seem to matter whether I place them before or after the code that uses them; they still work just fine.

This one is false; arrays are just one type of data that can be stored in a variable, and you must define a variable before you use it.

In other words, this code:

<?php

shuffle($myaray);
echo "The first element of myarray is: $myarray[0]";

$myarray = array( "one", "two", "three" );

will produce output similar to:

Warning: shuffle() expects parameter 1 to be array, null given in <file> on line 3

Notice: Undefined variable: myarray in <file> on line 4
The first element of myarray is:

This is because variable assignments are not like function definitions; the former are evaluated during "run-time" (i.e. when the statements are actually encountered during the course of the script's execution), whereas the latter (minus the exception noted above) are done at "compile-time" (i.e. when the PHP interpreter is converting your script into the executable code that it will then "run").

Rivet;11032569 wrote:
More directly, where could I find further information on such workings of PHP?

Well the manual is obviously the first resource that should be considered.

As for your other questions... it really depends on how in depth you want to get. In a nutshell, when a file is passed into the PHP interpreter, it's going to parse the script into actual machine code that can be executed, and then it... executes that code. PHP, despite being an interpreted language, is very similar to C. The execution starts with the first statement in the script. Where it moves from there would depend on things like control structure ([man]language.control-structures[/man]) that alter the otherwise sequential execution of statements.

The function definition location addressed above is similar to C as well; the C compiler doesn't need to come across a function definition before it can parse a function call. (The one that will have an issue if you never define that function would be the linker... but that's a bit off-topic I think.)

johanafm

PHP Manual wrote:
Functions need not be defined before they are referenced, except when a function is conditionally defined as shown in the two examples below.

How come the third exception isn't listed there: when function is defined in another file? Or does that fall under "conditionally always defined", the same as if it was

if (true)
   require 'stuff.php'

What does actually happen?

bradgrafelman

Think of "require" and "include" as doing nothing but copying-and-pasting a separate file inside of the current one. Thus, yes, if you've got a require/include statement inside of a conditional block, and that included file defines a function, you've essentially duplicated Example #2.

johanafm

bradgrafelman;11032597 wrote:
Think of "require" and "include" as doing nothing but copying-and-pasting a separate file inside of the current one.

Except that my question is about the fact that you cannot at all think about included files as being copy-pasted. Not in this and one other regard anyway.
1. included files can return values - copy-pasted code cannot.
2. Functions can be called before the place where you copy-paste their definition - included files do not allow this.

So to be clear, my question concerns a require/include statement, which includes a file defining a function - after it is first used.
But while I'm at it, I might as well include a clarification of point 1 above as well.

foo();  # fatal error

echo require foo_file.php;   # assuming you comment out the function call above to avoid error - this echos "foo_file included"

foo(); # works

foo_file.php

function foo() {}
return "foo_file included";

and compare the above with

foo(); # works

function foo() {}

foo() # also works

And my question was why included files does not work as if they were copy-pasted.

bradgrafelman

Interesting; guess I should have tried it first. Okay, so then think of it this way... it's not a direct copy and paste, but more like replacing this:

include 'foo_file.php';

with this:

$_INC = function() { function foo() {} 
return "foo_file included"; };
$_INC();

where the contents of the closure correspond to the contents of the include()'ed file.

That would more closely resemble what is apparently done for include/require constructs (since, as you point out, your example behaves more like a conditional or "run time" function definition).

johanafm

Thanks. Put that way the mechanics make sense again.

Weedpacket

bradgrafelman wrote:
your example behaves more like a conditional or "run time" function definition

So file inclusion happens at runtime - after the current script has been compiled.

Read and parse the script file, and generate the bytecode (all three happen at the same time)
Global functions and classes are defined in the runtime environment.
Execution begins with the first bytecode op.
If an include op is encountered,
then carry out the steps in this list on the included file. When that's done,
resume executing the current script.
When the end of the script is reached, return.