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

WBOY
Release: 2016-07-20 11:02:37
Original
816 people have browsed it

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<5.3.6:
# 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
?>


www.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...
source:php.cn
Statement of this Website
The content of this article is voluntarily contributed by netizens, and the copyright belongs to the original author. This site does not assume corresponding legal responsibility. If you find any content suspected of plagiarism or infringement, please contact admin@php.cn
Popular Tutorials
More>
Latest Downloads
More>
Web Effects
Website Source Code
Website Materials
Front End Template
About us Disclaimer Sitemap
php.cn:Public welfare online PHP training,Help PHP learners grow quickly!