No, it is not possible to "undefine" an existing class.

In your case, you should not have several classes that all have the same name : each class should have a different / distinct name, and you should modify the way you are working with those, so your code deals with classes not named ItemClass.

For instance, you could have :

• ItemClass_Type1 in itemclass_type1.php
• ItemClass_Type2 in itemclass_type2.php

and so on -- and those classes could all extend the same base class, if needed / if it makes sense.

(For a while, I thought maybe runkit could help with the "undefining a class" idea ; but there doesn't seem to be a function to do that -- and that extension is not quite stable and shouldn't be used on a production server)

Take into account that you can't explicitly destroy an object.

The ways to allow PHP Garbage Collector to act upon an object are:

$var = null; // set to null
unset($var); // unset

The object will stay there. However, if you unset the object and your script pushes PHP to the memory limits, the objects not needed will be garbage collected. I would go with unset() as it seams to have better performance (not tested but documented on one of the comments from the PHP official manual).

That said do keep in mind that PHP always destroys the objects as soon as the page is served. So this should only be needed on really long loops and/or heavy intensive pages.

unset($a->new_property);

This works for array elements, variables, and object attributes.

Example:

$a = new stdClass();

$a->new_property = 'foo';
var_export($a);  // -> stdClass::__set_state(array('new_property' => 'foo'))

unset($a->new_property);
var_export($a);  // -> stdClass::__set_state(array())

foreach ($this as &$value) {
    $value = null;
}

See http://www.php.net/manual/en/language.oop5.iterations.php.

You should not unset properties, they're part of the class/object. Set them to null instead to clear their values. But: the object is about the go out of memory anyway, and all properties will go with it. There's no real need to do this.

Automatic cleanup?

No, PHP isn't awared about your architecture. It will not remove objects "cascade", they are independent entities - and, more, can belong to different scopes, for example. Simple code:

class Test
{
   protected $id = null;
   protected $uniqid = null;

   public function __construct($id)
   {
      $this->id = $id;//user-passed variable
      $this->uniqid = uniqid();//internal: to identify instance 
   }

   public function getCopy()
   {
      return new self($this->id);
   }

   public function getIdentity()
   {
      return $this->uniqid;
   }
}

$foo = new Test(3);
$bar = $foo->getCopy();
var_dump($foo->getIdentity());//valid

unset($foo);
//still valid: bar has nothing to do with foo
var_dump($bar->getIdentity());

By the way, for copying you can use clone in PHP (that, however, will result in object cloning, obviously)

Simple way

Most simple way to resolve a matter is to iterate through $GLOBALS, checking it with instanceof. This has serious weakness: inner function/method scopes would not be affected:

//static since doesn't belong to any instance:
public static function cleanup()
{
   foreach($GLOBALS as $name=>$var)
   {
      if($var instanceof self)
      {
         unset($GLOBALS[$name]);
      }
   }
}

-and

$foo = new Test(3);
$bar = $foo->getCopy();
var_dump($foo->getIdentity(), $bar->getIdentity());//valid
Test::cleanup();
//2 x notice:
var_dump($foo, $bar);

Note, that is has nothing to do with "child" mechanics (i.e. it will clean all instances in global scope - no matter which was copied from which).

Common case

Sample above will not do the stuff in common case. Why? Imagine that you'll have holder class:

class Holder
{
   protected $obj = null;

   public function __construct($obj)
   {
      $this->obj = $obj;
   }

   public function getData()
   {
      return $this->obj;
   }
}

and you'll pass instance to it:

$foo = new Test(3);
$bar = $foo->getCopy();
$baz = new Holder($bar);

-so then you'll have no chances to handle even this simple situation in common case. And with more complex situations you will also be stuck.

What to do?

I'd recommend: destroy objects explicitly when you need to do that. Implicit unset is a side-effect, and even if you'll maintain that somehow (I can imagine Observer pattern + some global registry for that) - it will be horrible side-effect, that will kill readability for your code. And same is about code, that uses $GLOBALS I've written above - I do not recommend to act such way in any case.

No, you cannot delete or substantially modify PHP classes (or functions) at runtime.

You need to unset the created object.

Don't do this in your constructor, do it where you're creating the obj.

What you can do to centralize this code is to build a Factory. You could just tell that factory then that you want an obj of the type example with these properties set val1, val2, val3....

Then the factory would run the code below and return the obj if everything is fine, if not you could give out an error message which explains what went wrong, like property wasn't set or something. Then you could react properly to it.

$example = new example('Value 1', 2, false);

foreach (get_object_vars($example) as $propertie => $value) {
    if (empty($value)) {
        unset($exampe);
        break; //This stops the foreach
    }
}