class design - variables in array instead of distinct variables?

[Bjom]

Hi,

I'd like some suggestions/critique/opinions on the following setup of class "bar".

Both classes "bar" and "foo" hold the same data and do the same stuff, the difference being that in one case data is held in an array whereas in the other there are distinct variables.

Is there anything fundamentally wrong with that approach that would make you say "I would never do that"?

Obviously it's not easily possible to convert the variables in the array to "public" - but I do not intend to do so - I prefer using accessors and mutators for exposing class variables.

The advantage that I see is that I can build a "lazy" constructor where I can simply fill the whole class-data in one swoop - for example from an array that I got through a datareader class that retrieves them for me from a DB.

class bar
{
	private $_data = array (
                             'myVar1'=>'',
                             'myVar2'=>0,
                             'myVar3'=>null
                              );
	public function __construct($array)
	{
		$this->_data = $array;
	}
	/**
	 * mutators like this would provide public access to variables
	 * @param $string
	 * @return void
	 */
	public function setMyVar1($string)
	{
		$this->_data['myVar1'] = $string;
	}
	/**
	 * accessors like this would provide public access to variables
	 * 
	 * @return $string
	 */
	public function getMyVar1()
	{
		return $this->_data['myVar1'];
	}
	/**
	 * some function that does something
	 * @return void
	 */
	public function doSomethingUseful()
	{
	}						   	
}

class foo
{
	private $_myVar1 = '';
	private $_myVar2 = 0;
	private $_myVar3 = null;

public function __construct($string, $int, $obj)
{
	$this->_myVar1 = $string;
	$this->_myVar2 = $int;
	$this->_myVar3 = $obj;
}
/**
 * mutators like this would provide public access to variables
 * @param $string
 * @return void
 */
public function setMyVar1($string)
{
	$this->_myVar1 = $string;
}
/**
 * accessors like this would provide public access to variables
 * 
 * @return $string
 */
public function getMyVar1()
{
	return $this->_myVar1;
}
/**
 * some function that does something
 * @return void
 */
public function doSomethingUseful()
{
}	
}

[halojoy]

I see no difference that would be of any great importance.

Even when using the second variant,
you can use one array for argument in constructor:

class foo
{
    private $_myVar1 = '';
    private $_myVar2 = 0;
    private $_myVar3 = null;

public function __construct($array)
{
    $this->_myVar1 = $array['myVar1'];
    $this->_myVar2 = $array['myVar2'];
    $this->_myVar3 = $array['myVar3'];
} 

[Bjom]

True. The difference being, that assigning the variables takes three steps, instead of just one. With three variables that doesn't really matter, with maybe 100 it might make a difference (maybe I should test this actually...)

• ty for taking a look.

[Bjom]

Some research made me come up with this third approach. Actually the idea of having just an array for the data doesn't seem so terrible. (I'm still not sure if I like it tho 😉)

class bar2
{
	protected $_data = array	(
					 		'myVar1'=>'',
							'myVar2'=>0,
							'myVar3'=>null
						   	);
	public function __construct()
	{
		//$this->_data = $array;
	}
	/**
	 * magic mutator ftw
	 * 
	 * @param $property
	 * @param $value
	 * @return void
	 */
	public function __set($property, $value)
	{
		if (array_key_exists($property,$this->_data)) {
			$this->_data[$property] = $value;
		} else {
			throw new Exception ('Property does not exist.');
		}

}
/**
 * magic accessor ftw
 * 
 * @param $property
 * @return unknown_type
 */
public function __get($property)
{
	if (array_key_exists($property,$this->_data)) {
			return $this->_data[$property];
	} else {
		throw new Exception ('Property does not exist.');
	}
}
/**
 * some function that does something
 * @return void
 */
public function doSomethingUseful()
{
}						   	
}

[NogDog]

The last technique is a bit odd when you consider that the set() and get() have essentially turned what you've initially defined as a private(protected) property into a public one. Not necessarily an issue, but worth considering whether or not you want that data encapsulated from the client code or not.

Personally, I probably would only want to go the array route if the elements of the array were in some way specifically related to each other, such that it makes logical sense to group them into an array. If it does make sense to do so, then that suggests to me that it would make sense to make them their own object (which could then either be passed to the containing class via the constructor's args, or created via new by the constructor).

PS: One other possible issue with putting class variables into an array is that it woul make it harder to have them documented automatically by PHPDocumenter. 😉