访问非公共成员

Question

I am creating domain objects. I want these objects to have setters that will check the validity of the value to be assign to each property, but I also want to be able to set this property without performing the check if the data is assumed correct.

I could do the following :

class DO_Group
{
    protected $_name = null;

    public function getName()
    {
        return $this->_name;
    }

    public function setName( $name )
    {
        $length = strlen( $name );

        if( 4 <= $length && $length <= 16 && preg_match( '^[A-Z]*(_[A-Z]*)*$', $name ) == 1 )
            $this->_name = $name;
        else
            throw new Exception( '::DO_Group::setName() - Invalid name.' );
    }
}

But in a case where the $name passed to setName() is known to be valid, I would have to call setName, and thus perform an unneeded check, to set that property.

I could use the reflection API or the debug trace hack, but I want to use none of these two ways because they are bad performance wise when used many times (and are dirty, IMO).

I thought about adding a method that doesn't check the value :

public function setNameNoCheck( $name )
{
    $this->_name = $name;
}

But in this case, making the property non-public doesn't make sense. And if I chose to make it public, a code user might forget to check it when needed.

Could I do :

abstract class BaseClass
{
    public function setProperty( $name, $value )
    {
        $this->$name = $value;
    }
}

And make my domain objects extends this class ? It is correct PHP to refer undeclared properties ? (since they doesn't exist in the base class)

Answer 1

I guess my suggestion would be to just use the method you have now for both instances:

public function setName( $name )
{
        $length = strlen( $name );

        if( 4 <= $length && $length <= 16 && preg_match( '^[A-Z]*(_[A-Z]*)*$', $name ) == 1 )
            $this->_name = $name;
        else
            throw new Exception( '::DO_Group::setName() - Invalid name.' );
}

In this case, you can be certain your database will always retain its integrity. And even there are a few instances where you are POSITIVE the value is valid, the overhead would be minimal. It just seems to be a clean solution that is guaranteed to work.

EDIT :

If the object already exists in the database, why not just create a class method to handle that? Then call it when you are pulling values directly out of the database..

public function populateFields( $row )
{
    $this->_name = $row['name'];
    // ... populate other fields here
}

This would populate all of the fields at once instead of having to write and call individual functions for each property.

Answer 2

If you use PHP 5.4+ then here is a good pice of code for you. I came up with this a couple of months back. If you're on PHP 5.3 or less, you can still make it work using call_user_func . However with the help of anonymous functions it is much more clean, and verbose.

The idea is to make a kind of a friend object. Similar to friend classes in C++, but operating on specific objects instead of classes.

So let's get started. First we need to prepare your class a bit:

class DoGroup
{
    protected $_name = null;

    public function makeFriend(IDoGroupFriend $newFriend)
    {
        $newFriend->plugNameSetter(function($name){
            $this->_doSetName($name);
        });
    }

    public function setName( $name )
    {
        // do the costly checking here...
        /// and set the variable:
        $this->_doSetName($name);
    }

    protected function _doSetName($name)
    {
        $this->_name = $name;
    }
}

Next, we would define that friend interface:

interface IDoGroupFriend
{
    public function plugNameSetter(callable $nameSetterFn);
}

And now we can create friends:

class ExampleFriend implements IDoGroupFriend
{
    private $_nameSetterFn = null;

    public function plugNameSetter(callable $nameSetterFn)
    {
        $this->_nameSetterFn = $nameSetterFn;
    }

    public function setTheNameFromFriend($name)
    {
        $nameSetterFn = $this->_nameSetterFn;
        $nameSetterFn($name);
    }
}

Finally, we can use the friends as follows:

$Main = new DoGroup();
$Friend = new ExampleFriend();

$Main->makeFriend($Friend);

// tadam!
$Friend->setTheNameViaFriend('name via friend');

Ofcourse your real implementation could be much more sophisticated then just blindly passing the name. If the source of the $name (the ExampleFriend object in this case) is trusted then I'm assuming it comes from a different trusted source. In such case you would implement the setTheNameFromFriend differently - for example as an databese fetch method.

Also you'd probably don't want to have the DoGroup::makeFriend() method public. I usually invoke this method only from constructor of the DoGroup class, so I like to meke it private.

Answer 3

Create safe mode ($this->safeMode = false) and

       public function setName( $name )
    {
if ($this->safeMode===true){ $this->_name = $name; return;}

            $length = strlen( $name );

            if( 4 <= $length && $length <= 16 && preg_match( '^[A-Z]*(_[A-Z]*)*$', $name ) == 1 )
                $this->_name = $name;
            else
                throw new Exception( '::DO_Group::setName() - Invalid name.' );
    }

set safeMode to true if data is from database or other "safe" source (or class extends database class)