Better way to initialize a class variable - php

Question

I have been searching for a while but I could not find the answer, what are the differences between these two ways of inicialize a variable class in PHP?:(if there are)
class MyClass
{
private $myVariable='something';
public function __construct()
{
}
}
class MyClass
{
private $myVariable;
public function __construct()
{
$this->myVariable='something';
}
}

Answer 1

If you want to initialize the variable with a default value inside the class, choose method 1.
If you want to initialize the variable with a outside value, pass the variable through the constructor and choose method 2.

Answer 2

See this scenario:
class Parent {
protected $property1; // Not set
protected $property2 = '2'; // Set to 2
public function __construct(){
$this->property1 = '1'; // Set to 1
}
} // class Parent;
class Child extends Parent {
public function __construct(){
// Child CHOOSES to call parent constructor
parent::__construct(); // optional call (what if skipped)
// but if he does not, ->property1 remains unset!
}
} // class Child;
This is a difference between the two calls. parent::__construct() is optional for child classes that inherit from a parent. So:
if you have scalar (as in is_scalar()) properties that need to be preset, do it in the class definition to be sure that they exist in child classes too.
if you properties that depend on arguments or are optional, put them in the constructor.
It all depends on how you design your code's functionality.
There's no right of wrong here, it's only what's right for you.

Answer 3

I like to do it somewhat like the second way to facilitate lazy-loading. Simple values I will set when declaring the member variable.
class WidgetCategory
{
/** #var array */
private $items;
/**
*
* #return array
*/
public function getItems()
{
if (is_null($this->items)) {
$this->items = array();
/* build item array */
}
return $this->items;
}
}

Answer 4

You can only use constant values if you don't choose to initialize the variable in the constructor. Here a little example:
define('MY_CONSTANT', 'value');
class MyClass
{
// these will work
private $myVariable = 'constant value';
private $constant = MY_CONSTANT;
private $array = Array('value1', 'value2');
// the following won't work
private $myOtherVariable = new stdClass();
private $number = 1 + 2;
private $static_method = self::someStaticMethod();
public function __construct($param1 = '')
{
$this->myVariable = $param1;
// in here you're not limited
$this->myOtherVariable = new stdClass();
$this->number = 1 + 2;
$this->static_method = self::someStaticMethod();
}
}
Take a look at this Manual Page to see what values are allowed to be directly assinged to properties: http://php.net/manual/en/language.oop5.properties.php
There may be more differences ...