PHP functions - system functions, recursive functions, reused functions, constructor usage_PHP tutorial

​

php tutorial function-system function, recursive function, reused function, constructor usage

/*
* 1. Internal functions: PHP can declare functions inside the function
* The purpose is to call
inside the function * Used to help external functions complete some sub-functions
*
* 2. Recursive function: 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 included once
* include_once: used for dynamic inclusion, only included once
*
* 4. Use of some system functions
* Resource=opendir("directory name")
* readdir(resource)
*
*
*/
//Internal function
function score($php,$java,$dotnet)
{
function php($php)
{
if($php>60)
Return "pass";
else
Return "failed";
}
function java($java)
{
If($java>60)
Return "pass";
else
Return "failed";
}
function dotnet($dotnet)
{
if($dotnet>60)
Return "pass";
else
Return "failed";
}

$total=$php+$java+$dotnet;
$agv=$total/3;
echo "Your php score is {$php} points, ".php($php)."
";
echo "Your java score is {$java} points,".java($java)."
";
echo "Your dotnet score is {$dotnet} points,".dotnet($dotnet)."
";
echo "Your total score is: {$total}
";
echo "Your average score is: {$agv}
";
}
score(50,90,70);

//Recursive function
function demo($num)
{
echo $num."
";
if($num>0)
demo($num-1);
else
echo "--------------------------------
";
echo $num."
";
}
demo(10);

function total($dirname,&$dirnum,&$filename)
{
$dir=opendir($dirname);
readdir($dir)."
";
readdir($dir)."
";
while($filename=readdir($dir))
{
$newfile=$dirname."/".$filename;
echo $filename."
";
If(is_dir($filename
}

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

Constructor and destructor
Constructor
void __construct ([ mixed $args [, $... ]] )
PHP 5 allows developers to define a method as a constructor in a class. Classes with a constructor will call this method every time an object is created, so it is very suitable for doing some initialization work before using the object.

Note: If a constructor is defined in a subclass, the constructor of its parent class will not be called implicitly. To execute the parent class's constructor, you need to call parent::__construct() in the child class's constructor.

Example #1 Using the new standard constructor

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();
?>

For backward compatibility, if PHP 5 cannot find a __construct() function in a class, it will try to find an old-style constructor, which is a function with the same name as the class. Therefore, the only situation where compatibility issues will arise is if the class already has a method named __construct(), but it is not a constructor.

Destructor
void __destruct (void)
PHP 5 introduced the concept of destructors, similar to other object-oriented languages ​​such as C++. A destructor is executed when all references to an object are removed or when the object is explicitly destroyed.

Example #2 Destructor example

class MyDestructableClass {
function __construct() {
          print "In constructorn";
         $this->name = "MyDestructableClass";
}

function __destruct() {
            print "Destroying " . $this->name . "n";
}
}

$obj = new MyDestructableClass();
?>

Like constructors, parent class destructors are not implicitly called by the engine. To execute the parent class's destructor, parent::__destruct() must be explicitly called in the child class's destructor body.

Note:

The destructor is called when the script is closed, after all header information has been emitted.

Note:

Attempting to throw an exception in the destructor will result in a fatal error.

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
# Some function that throws an exception
function fail($foobar) {
Throw new Exception("Exception A!");
}

$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
?>

http://www.bkjia.com/PHPjc/445341.htmlwww.bkjia.comtruehttp: //www.bkjia.com/PHPjc/445341.htmlTechArticlephp tutorial function - system function recursive function reuse function constructor usage /* * 1. Internal functions: PHP can be used in The purpose of declaring the function * inside the function is to call * inside the function to help...