CODEWITHSUNDEEP
phpoop
JohnnyC
JohnnyC

Reputation: 1435

Why declare class' properties when constructor initialize this properties

Write what is best and why?

class Chat
{
    private $_couleur;
    private $_race;

    function __construct($couleur, $race)
    {
        $this->_couleur = $couleur;
        $this->_race = "$race";
    }

    public function getCouleur() {
        return $this->_couleur;
    }
}

Or

class Chat
{
    function __construct($couleur, $race)
    {
        $this->_couleur = $couleur;
        $this->_race = "$race";
    }

    public function getCouleur() {
        return $this->_couleur;
    }
}

Because $this->_couleur is initialized when the class is instancied, so declare the property directly in the class is useless, isn't ?

Upvotes: 4

Views: 4590

Answers (4)

Niki van Stein
Niki van Stein

Reputation: 10734

Declaring the variables at the top of your class is a very good practice, because it makes it clear to anyone that reads your code which properties the class has private and which properties the class has public.

In the second example your variables will be public because they're dynamically generated.

When your constructor would be much bigger it is a pain in the ass as developer to find out where your variables are introduced.
It is also good to set default values (if they are always the same) to the variables in the class as opposed to the constructor. It makes your code more readable and understandable.

Upvotes: 9

Cave Johnson
Cave Johnson

Reputation: 6778

Just wanted to add one simple benefit of declaring class properties: Any good IDE will parse and build a symbol table out of your declared class properties. So if you are writing a class and start typing $this->, a list of your declared properties will show up so you can easily select the one you want to use. If you create variables in your constructor without declaring them, your IDE won't be able to see them.

Upvotes: 0

Murad Hasan
Murad Hasan

Reputation: 9583

First block of code is better from the second, But one thing in first block.

Objects of the same type will have access to each others private and protected members even though they are not the same instances. This is because the implementation specific details are already known when inside those objects.

This code collected from php.net

<?php
class Test
{
    private $foo;

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

    private function bar()
    {
        echo 'Accessed the private method.';
    }

    public function baz(Test $other)
    {
        // We can change the private property:
        $other->foo = 'hello';
        var_dump($other->foo);

        // We can also call the private method:
        $other->bar();
    }
}

$test = new Test('test');

$test->baz(new Test('other'));
?>

Output:

string(5) "hello"
Accessed the private method.

Upvotes: 1

SubliemeSiem
SubliemeSiem

Reputation: 1159

The first one is better. You are actually declaring your variables as private, giving them a meaningful scope. The second version is more error-prone.

Upvotes: 0

Related Questions