Php functions-use of system functions recursive functions to reuse function constructors

Php Tutorial functions-use of system function recursive functions to reuse function constructors

<? Php
/*
* 1. Internal function: PHP can declare the function inside the function.
* The purpose is to call the function internally.
* Used to help external functions complete some sub-functions
 *
* 2. Recursive functions: Call your own function name within yourself.
 *
* 3. Reuse functions
 *
* Require: used for static inclusion
* Include: used for dynamic inclusion
* Require_once: used for static inclusion only once
* Include_once: used for dynamic inclusion, only once
 *
* 4. Use of some system functions
* Resource = opendir ("directory name ")
* Readdir (resource)
 *
 *
*/
// Internal functions
Function score ($ php, $ java, $ dotnet)
 {
Function php ($ php)
  {
If ($ php> 60)
Return "pass ";
Else
Return "fail ";
  }
Function java ($ java)
  {
If ($ java> 60)
Return "pass ";
Else
Return "fail ";
  }
Function dotnet ($ dotnet)
  {
If ($ dotnet> 60)
Return "pass ";
Else
Return "fail ";
  }
  
$ Total = $ php + $ java + $ dotnet;
$ Agv = $ total/3;
Echo "your php score is {$ php},". php ($ php). "<br> ";
Echo "your java score is {$ java},". java ($ java). "<br> ";
Echo "your dotnet score is {$ dotnet},". dotnet ($ dotnet). "<br> ";
Echo "your total score is: {$ total} <br> ";
Echo "your average score is: {$ agv} <br> ";
 }
Score (50, 90, 70 );
 
// Recursive function
Function demo ($ num)
 {
Echo $ num. "<br> ";
If ($ num> 0)
Demo ($ num-1 );
Else
Echo "-------------------------------- <br> ";
Echo $ num. "<br> ";
 }
Demo (10 );
 
Function total ($ dirname, & $ dirnum, & $ filename)
 {
$ Dir = opendir ($ dirname );
Readdir ($ dir). "<br> ";
Readdir ($ dir). "<br> ";
While ($ filename = readdir ($ dir ))
  {
$ Newfile = $ dirname. "/". $ filename;
Echo $ filename. "<br> ";
If (is_dir ($ filename
  }

 }
$ Dirnum = 0;
$ Filenum = 0;
Total ("c:/windows", $ dirnum, $ filenum );
Echo "total number of directories:". $ dirnum. "<br> ";
Echo "total number of files:". $ filenum. "<br> ";
?>

Constructor and Destructor
Constructor
Void _ construct ([mixed $ args [, $...])
PHP 5 allows developers to define a method in a class as a constructor. Classes with constructors call this method each time an object is created, so it is very suitable for initialization before using the object.

Note: If the constructor is defined in the subclass, the constructor of its parent class will not be called secretly. To execute the constructor of the parent class, you must call parent ::__ construct () in the constructor of the subclass ().

Example #1 use the new standard constructor

<? Php
Class BaseClass {
Function _ construct (){
Print "In BaseClass constructorn ";
   }
}

Class SubClass extends BaseClass {
Function _ construct (){
Parent: :__ construct ();
Print "In SubClass constructorn ";
   }
}

$ Obj = new BaseClass ();
$ Obj = new SubClass ();
?>

To achieve backward compatibility, if PHP 5 cannot find the _ construct () function in the class, it will try to find the old constructor, that is, the function with the same name as the class. Therefore, the only situation that causes compatibility problems is that the class already has a method named _ construct (), but it is not a constructor.

Destructor
Void _ destruct (void)
PHP 5 introduces the concept of destructor, which is similar to other object-oriented languages, such as C ++. The Destructor is executed when all references to an object are deleted or when the object is explicitly destroyed.

Example #2 destructor Example

<? Php
Class MyDestructableClass {
Function _ construct (){
Print "In constructorn ";
$ This-> name = "MyDestructableClass ";
   }

Function _ destruct (){
Print "Destroying". $ this-> name. "n ";
   }
}

$ Obj = new MyDestructableClass ();
?>

Like constructors, the parent class's destructor will not be called by the engine. To execute the destructor of the parent class, you must explicitly call parent ::__ destruct () in the destructor of the subclass ().

Note:

The Destructor is called when the script is disabled. All header information is sent.

Note:

Throwing an exception in the destructor will cause a fatal error.

<? Php
Class Foobar {
Public $ baz;
Function _ destruct (){
# Don't do either of these, if $ baz also has a _ destruct ()!
$ This-> baz = null;
Unset ($ this-> baz );
       
# Instead, don't clear it at all, or do this:
$ This-> baz->__ destruct ();
    }
}
?>

If you made this mistake, this might happen in php <5.3.6:
<? Php
# Some function that throws an exception
Function fail ($ foobar ){
Throw new Exception ("Exception! ");
}

$ Foobar = new Foobar ();
$ Foobar-> baz = new Foobar ();

Try {
Fail ($ foobar); // Send foobar to func that throws an Exception
} Catch (Exception $ e ){
Print $ e-> getMessage (); // Exception A will be caught and printed, as expected.
}

$ Foobar = null; // clearing foobar, and its property $ baz

Try {
Print 'exception B: '; // this will be printed
// Output stops tutorial here.
Throw new Exception ("Exception B! ");
} Catch (Exception $ e ){
Print $ e-> getMessage (); // doesn' t happen
}
Print 'end'; // this won't be printed
?>