Examples of forward declarations (of functions) in PHP? - php

Question

I'm posting this because it wasn't readily apparent on Google or php.net
==> Please demonstrate several examples of the syntax for forward declaring functions, in the PHP language.
For example (in C++):
int foo(); // forward declaration
int x = foo(); // calling the function.
int foo() // the actual implementation
{
return 5;
}
How would this look in PHP? How about with multiple arguments? How about with default arguments? What are the best practices and why?

Answer 1

You don't need to do forward declaration in PHP, instead you need to have the function declared, in current script (even if it's after the invocation), or in any included/required script, givent that the include/require statement is executed before you call the function.
There's no forward declaration.
If on the current script, even at the end, after the invocation: it' ok
If it's on a script INCLUDEd/REQUIREd by the current script, the INCLUDE/REQUIRE statement should have been executed BEFORE invocation of the function.
If it's on a script that INCLUDE/REQUIRE the current script: it's ok (even if declared AFTER the INCLUDE/REQUIRE statement)

Answer 2

I'd say the requested example is not the best for demonstrating the need of forward declarations. Say, we need the following instead:
function foo($n) {
echo 'Foo';
if($n>0) bar($n-1);
}
function bar($n) {
echo 'Bar';
if($n>0) foo($n-1);
}
foo(200);
The code above works perfectly in PHP despite of "undefined" function bar inside foo. It appears that PHP checks function definition when it is called.
So the answer is:
PHP doesn't have forward declarations.
The function doesn't have to
be defined before it appears in the text, but it must be defined
before it is called.

Answer 3

Would it not just be...
$x = foo();
function foo() {
return 5;
}
echo $x; //echos "5"
?

Answer 4

PHP does not do forward function declarations (or "function prototyping*). The closest thing we have is Object Interfaces and Abstract Methods. These are called "method prototypes" or "method declarations" (declaration as opposed to definition, which carries a c-style semantic)
Interface MyWidgetInterface {
function calculateThings(SomeClass $foo);
}
Abstract Class MyAbsClass {
public abstract function sayHello();
}
Class MyObj Extends MyAbsClass Implements MyWidgetInterface {
public function calculateThings(SomeClass $foo) {
}
public function sayHello() {
echo "Hi!\n";
}
}
$thing = new MyObj();
$thing->sayHello();
One of the reasons we don't have/need forward declared functions is that php parses your script before it compiles it, every time. It finds your functions before it starts executing the file, so it knows they are there. In fact, I can't remember how far back you'd have to go to even have to have defined the function before calling it. I've been doing PHP for 9 years and it's never needed that :-)

Answer 5

If you want that a function to return a certain type value in PHP, you can use something like this.
function foo($param) {
// code
return (int) $param; // or (string), (float)
}
Or, when you access the function:
$x = (int) foo($param);

Answer 6

Referring to the default argument you can do like this
function foo( $param1="value1" , $param2="value2" ){
echo $param1." ".$param2;
}
foo();
foo("not default","not default");
foo(NULL,"not default");