When do I use static variables/functions in php?

Question

I am refreshing myself on OOP with PHP and I saw an example of setting functions and/or variables as static. When and why would I set a variable/function to static? I've done other languages and don't really recall ever using static, I never found a real purpose to it. I know what it does but why not just use a variable instead?

Answer 1

Static functions and variable are used to access Variables/functions in a global scope, like this:

echo myClass::myVariable;
echo myClass::myFunction();

When something is static, it can be accessed anywhere, and is very similar to a procedural type function, except it can use self and is contained in the classes scope.

class myClass{
    static $myVariable = "myVar";
    static function myFunction()
    {
       return "myFunc";
    }
}

One of the ways to use this is to keep only one instance of a class, or a Singleton Method.

class myClass
   {
    static $class = false;
    static function get_connection()
    {
     if(self::$class == false)
     {
      self::$class = new myClass;
     }
     else
     {
      return self::$class;
     }
    }
    private function __construct()
    {
         // my constructor
    }
    // Then create regular class functions.
   }

Because it has a private constructor, it cannot be instantiated with the new operator, so you are forced to call myClass::get_connection() to get a class. That function can make the new class (because it is a member of the class). Then it stores the class in a static variable, and if you call the function again, it will simply returned the created class.

In the end, the static keyword is used to keep things, well, static, in reference to scope. It means you don't want anything 'changing' because of the current scope. While the Singleton method stretches this a little, it keeps with the same idea that you always have the 'same' class, not matter what scope you are in.

PHP Documentation
Static Keyword
Scope Resolution Operator

StackOverflow Knowledge
How to Avoid Using PHP Global Objects
Share Variables Between Functions in PHP Without Using Globals
Making a Global Variable Accessible For Every Function inside a Class
Global or Singleton for Database Connection
PHP Classes: when to use :: vs. -> ?

Answer 2

Here's a random, though fairly good description of the differences between static and instance methods.

Answer 3

You use static when you want to use a method / variable that is not tied to an instance. That can happen when :

• There is no relation with an instance (useful for toolboxes in languages that doesn't allow anything else that OOP like Java, but not useful in PHP).

• You want to control the access to the instance. Most often, the instance you want to deal with is not defined when you write the code, but will be at execution. The Singleton pattern is the best example. You can use static methods as factories to create an object according to the context or sharing resources with other instances. E.G : a static member can give access to a data base layer so part of the app accesses the same one from anywhere and it's opened / closed without conflicts.

• Performances matter and the method will be executed a lot of times. In that case, you will same some CPU time preventing the interpreter from looking up the member to an instance at each call. Be still, if perf becomes such an issues that you come to this solution, it might time to reconsider whether you architecture, or the use of a binding to a faster language for the critical part of the code.

• You have a method that is related to a type but will be applied to another. It can make sense to write the method into the declaration of the first type, but set it static since it expects an instance of the another one.

The perfect example is a String parser :

class MyObject 
{
 static function parse($str)
 {
    $obj = new MyObject();
    // some parsing / setting happens here
    return $obj;
 }
}

// you create an object "MyObject" from a string, so it's more obvious
// to read it this way :
$new_obj = MyObject::parse("This a description of a super cool object");

Answer 4

Avoid static methods:

blog everyone should follow