Home arrow PHP arrow Page 3 - Executing Destructors Manually in PHP 5

Calling multiple destructors manually - PHP

Welcome to the final chapter of the series “Understanding Destructors in PHP 5.” In consonance with this article’s title, this series walks you through the basics of utilizing class destructors in object-based applications and also provides you with a decent number of hands-on examples, so you can start incorporating these useful methods into your PHP 5 classes with minor efforts.

TABLE OF CONTENTS:
  1. Executing Destructors Manually in PHP 5
  2. Triggering a destructor manually
  3. Calling multiple destructors manually
  4. Emulating destructors in PHP 4
By: Alejandro Gervasio
Rating: starstarstarstarstar / 6
February 13, 2008

print this article
SEARCH DEV SHED

TOOLS YOU CAN USE

advertisement

During the prior section, you learned how to manually trigger the destructor of a trivial user handling object without having to abruptly stop the execution of a script. As you may have guessed, this approach can be easily extended to work with multiple objects and destructors.

Basically the logic behind this idea remains the same: once these objects are spawned, they’re purposely deleted via the pertinent “unset()” PHP function, as I did earlier.

Having explained how to execute different destructors manually, I’m going to list again the definition of the previous “User” class, so you can recall more easily how it functions:


// define 'User' class

class User{

private $firstName;

private $lastName;

private $email;

public function __construct($firstName,$lastName,$email){

if(!$firstName||strlen($firstName)>32){

throw new Exception('Invalid First Name parameter!');

}

if(!$lastName||strlen($lastName)>32){

throw new Exception('Invalid Last Name parameter!');

}

if(!$email||!preg_match("/^.+@.+..+$/",$email)){

throw new Exception('Invalid Email parameter!');

}

$this->firstName=$firstName;

$this->lastName=$lastName;

$this->email=$email;

}

// get user's first name

public function getFirstName(){

return $this->firstName;

}

// get user's last name

public function getLastName(){

return $this->lastName;

}

// get user's email

public function getEmail(){

return $this->email;

}

// get all user data

public function getAll(){

return 'First Name: '.$this->firstName.' Last Name: '.$this->lastName.' Email Address: '.$this->email;

}

// implement a __destruct()' method

public function __destruct(){

// display object properties

echo '<h2>Properties of object being destroyed</h2>';

foreach(get_object_vars($this) as $prop=>$val) {

 echo '<p>'.$prop.'='.$val.'</p>';

 }

// display object methods

echo '<h2>Methods of object being destroyed</h2>';

$methods=get_class_methods(get_class($this));

foreach($methods as $method) {

echo '<p> Method Name: '.$method.'()</p>';

}

}

}


Having listed the signature corresponding to the sample “User” class, now it’s time to demonstrate how to manually trigger the respective destructors of a few user handling objects when they’re removed by way of the “unset()” PHP function.

This process is performed neatly by the  hands-on example below, thus I recommend that you have a close look at it:


try{

// create first user

$user1=new User('John','Doe','john@domain.com');

// display separately user data

echo 'First Name: '.$user1->getFirstName().'<br />';

echo 'Last Name: '.$user1->getLastName().'<br />';

echo 'Email: '.$user1->getEmail().'<br />';

// display all user information

echo 'Complete user information: '.$user1->getAll();

 

// delete object, this triggers its '__destruct()' method

echo '<h2>Calling destructor method of first user object!</h2>';

unset($user1);

// create second user

$user2=new User('Mary','Smith','mary@domain.com');

// display separately user data

echo 'First Name: '.$user2->getFirstName().'<br />';

echo 'Last Name: '.$user2->getLastName().'<br />';

echo 'Email: '.$user2->getEmail().'<br />';

// display all user information

echo 'Complete user information: '.$user2->getAll();

 

// delete object, this triggers its '__destruct()' method

echo '<h2>Calling destructor method of second user object!</h2>';

unset($user2);

// create third user

$user3=new User('Susan','Norton','susan@domain.com');

// display separately user data

echo 'First Name: '.$user3->getFirstName().'<br />';

echo 'Last Name: '.$user3->getLastName().'<br />';

echo 'Email: '.$user3->getEmail().'<br />';

// display all user information

echo 'Complete user information: '.$user3->getAll();

 

/* displays the following

 

First Name: John

Last Name: Doe

Email: john@domain.com

Complete user information: First Name: John Last Name: Doe Email Address: john@domain.com

 

Calling destructor method of first user object!

Properties of object being destroyed

firstName=John

lastName=Doe

email=john@domain.com

 

Methods of object being destroyed

Method Name: __construct()

Method Name: getFirstName()

Method Name: getLastName()

Method Name: getEmail()

Method Name: getAll()

Method Name: __destruct()

 

First Name: Mary

Last Name: Smith

Email: mary@domain.com

Complete user information: First Name: Mary Last Name: Smith Email Address: mary@domain.com


Calling destructor method of second user object!

Properties of object being destroyed

firstName=Mary

lastName=Smith

email=mary@domain.com

 

Methods of object being destroyed

Method Name: __construct()

Method Name: getFirstName()

Method Name: getLastName()

Method Name: getEmail()

Method Name: getAll()

Method Name: __destruct()


First Name: Susan

Last Name: Norton

Email: susan@domain.com

Complete user information: First Name: Susan Last Name: Norton Email Address: susan@domain.com

Properties of object being destroyed


firstName=Susan

lastName=Norton

email=susan@domain.com

 

Methods of object being destroyed

Method Name: __construct()

Method Name: getFirstName()

Method Name: getLastName()

Method Name: getEmail()

Method Name: getAll()

Method Name: __destruct()


*/

}

catch(Exception $e){

echo $e->getMessage();

exit();

}


That wasn’t rocket science, was it? As you can see by the above example, three different user handling objects are first spawned, and then deleted with the “unset()” PHP function. Obviously, the consequences of doing this are that the respective constructors are called according to the order in which these objects are removed.

Quite possibly at this very moment you’re wondering if it’s really useful to trigger destructors manually. Well, in certain conditions you might want to trigger these methods “behind the scenes” without having to terminate the execution of a specific PHP script. However, this depends completely on the application you’re working with and it’s up to you to decide when (if ever) to use this approach.

So far, so good. At this stage, I’m reasonably sure that you learned an alternative approach to call destructors manually. Nonetheless, it’s fair to mention that all the code samples that I built worked with PHP 5. So, there’s a question that remains unanswered: is it possible to emulate the behavior of destructors in PHP 4? Of course it is! And the last section will be entirely focused on discussing this process in detail.

Go ahead and read the next few lines. We’re almost finished!



 
 
>>> More PHP Articles          >>> More By Alejandro Gervasio
 

blog comments powered by Disqus
escort Bursa Bursa escort Antalya eskort
   

PHP ARTICLES

- Hackers Compromise PHP Sites to Launch Attac...
- Red Hat, Zend Form OpenShift PaaS Alliance
- PHP IDE News
- BCD, Zend Extend PHP Partnership
- PHP FAQ Highlight
- PHP Creator Didn't Set Out to Create a Langu...
- PHP Trends Revealed in Zend Study
- PHP: Best Methods for Running Scheduled Jobs
- PHP Array Functions: array_change_key_case
- PHP array_combine Function
- PHP array_chunk Function
- PHP Closures as View Helpers: Lazy-Loading F...
- Using PHP Closures as View Helpers
- PHP File and Operating System Program Execut...
- PHP: Effects of Wrapping Code in Class Const...

Developer Shed Affiliates

 


Dev Shed Tutorial Topics: