I learning a bit of OO PHP but the docs I came across showed a couple of methods of the following examples. I am confused as to why both work, and which should be used exclusively.

I know that #1 is not OOP but I was still curious about the second method of echo, and if it should be used or not.

1. Both of the echo's below print "Lansana", but one initializes $name before the echo whereas the other initializes it after (or during) the echo.

   <?php
   
   $name = "Lansana";
   echo $name;
   
   echo $name = "Lansana";
   
   ?>
   

2. Notice how there is a public property $name with no value in the first example, and no public property in the second, yet both still work the same.

   class Pets
   {
       public $name;
   
       public function __construct($name) {
           $this->name = $name;
       }
   }
   
   $dog = new Pets("Buddy");
   echo $dog->name;
   

   ---

   class Pets
   {
       public function __construct($name) {
           $this->name = $name;
       }
   }
   
   $dog = new Pets("Buddy");
   echo $dog->name;
   

What is the preferred method in #1 and #2, and why? I don't know why the docs showed the first class method because I don't see the need for a public property there, but then again what do I know.

Thought I should give a little more context to what I outlined in the comments above.

For the First example try not to mix assignment and output in the same statement. Although it is syntactically correct it doesn't immediately indicate the intent of the statement.

For the second example as I stated in the comments explicitly defining properties is always preferable. The advantages are:

1. Most IDE's will auto-complete defined properties for you minimizing the risk of mistyping a property.
2. It clearly indicates to someone reading the code what properties are available on the object.
3. It allows for you to set the visibility of the property so you can control more how your class is used which promotes encapsulation.

One of the most common bugs that you see with OO PHP is when you silently create a property for example something like:

class A {
    public function setUserId($id){
        $this->userId = $id;
    }

    public function getUserId(){
        return $this->userid;
    }
}

The intent is clear here but you have to be paying pretty close attention to the fact that the referenced properties are cased differently. If becomes much harder if you throw in another 50 lines of code and the two property references aren't on the screen at the same time.

On of the uses for PHP's magic __get and __set method are to help eliminate this problem earlier in development. Example:

class A {
    public $foo;
    public $bar;        

    public function __set($prop, $val){
        throw new Exception ($prop." does not exist on this object");
    }

    public function __get($prop){
        throw new Exception ($prop." does not exist on this object");
    }
}

This makes it where if you attempt to access an undefined property the class will throw an exception letting you know exactly what happened and where.

I think #1 is just a shortcut. #2 is because of overloading, where class variables are created dynamically.

http://www.php.net/manual/en/language.oop5.overloading.php

As for preferred methods, with #1 'echo $name = 'Something'` more of a short cut than a different method. The end outcome is the same in either case.

With #2, dynamically created variables are not usually a good idea as it can generate some unexpected results but they do have their place. Check the link above for some example of code using overloading. The first method is favored.

1

echo $name = "Lansana";

PHP interprets it as

echo ($name = "Lansana");

echo sort of works like a function, because of that php interprets everything on the right side of the echo before sending it to standard out.

2

The first one is definitely the best way. Because PHP is a dynamic language (as opposed to a static language like C# or Java) it allows one to create and set variables without declaring them first. It is the best to always declare class variables--it makes the code easier to read and maintain.