13

So in PHP you can have

Class A{
   function B(){}
}

and you can call this as if it were a static function: 

A::B();

My question is...if I can do this, then why should I ever declare the function B() as static since doing so makes $this unavailable, so there's less flexibility, so you have everything to lose but nothing to gain...

or is there an advantage of declaring the function as static that I'm not aware of?

also I heard that "static calling of non static methods" are "deprecated"....what does that exactly mean especially in relation to this scenario? is calling A::B() when B() is not declared static something that I shouldn't be doing? if so, why is that the case?

kamikaze_pilot
  • 14,304
  • 35
  • 111
  • 171
  • 1
    In strict mode calling a non-static method as a static will throw you an error. This will hopefully become default behavior in the future. – Wesley van Opdorp Aug 10 '11 at 07:05
  • 4
    *(reading tip)* [Statics considered harmful](http://kore-nordmann.de/blog/0103_static_considered_harmful.html) – Gordon Aug 10 '11 at 07:07
  • possible duplicate of [What are good reasons to use static methods in PHP?](http://stackoverflow.com/questions/4685622/what-are-good-reasons-to-use-static-methods-in-php) – Gordon Aug 10 '11 at 07:37
  • "... if I can do this, then why should I ever declare the function B() as static since doing so makes $this unavailable ...". If you are calling a function statically, then `$this` is unavailable, anyway (PHP throws a fatal error). You can still use `self::$var` and `static::$var` for static variables (non-static variables being tied to the object, not the class). – Aether Aug 10 '11 at 07:42
  • The E_STRICT error will throw those notices, as well as other hints on how to optimize your code. error_reporting(E_STRICT); – Oshan Wisumperuma Jul 03 '15 at 03:32

4 Answers4

11

Because PHP tends to be a bit loosy-goosy around strictness (?) these sort of things work. The fact that they are deprecated means that sometime in a future release, it is likely not to work anymore. So if you are calling a non-static function in a static context, your program may break in a future PHP upgrade.

As for using it right now - the advantage to declaring a function as static is that you are deciding right there how that function should be used. If you intend to use a function in a static context, you can't use $this anyway, so you are better of just being clear on what you plan to do. If you want to use the function statically, make it static. If you don't, then don't. If you want to use a function both statically and non-statically, then please recheck your requirements :P

Pelshoff
  • 1,464
  • 10
  • 13
1

For compatibility mode. Now calling non-static methods statically generates an E_STRICT level warning.

Why static and not instantiate the object? Each programmer will tell you a reason. I particulary preffer instantiate object than use static methods. It's clear, traceable and more reusable.

I did a test bench and the difference was minimal between instantiate and call a method than call it staticaly.

Tip: if you foresee calling methods statically defines them as well;-)

corretge
  • 1,751
  • 11
  • 24
1

First off, you couldn't do stuff like that in your post in a strict typed language like Java. Java code doesn't compile, if you call non-static stuff in a static context. PHP is not that strict on these things (yet), but still you shouldn't do things just because you can, although it's bad practice and in some languages even 'incorrect' practice.

There sure are advantages using static methods. And it's not quite right that you gain nothing or even lose flexibility. Let's have an example:

class A {

  private static $prop_a = 'property_a';

  public static function b() {
    echo 'called b()';
    echo self::$prop_a;

    $A = new A();
    $A->c();
  }

  public function c() {
    echo 'called c()';
  }
}

Now we can call the class this way:

A::b();

which outputs

  • called_b
  • property_a
  • called_c

But you can do the same with:

$a = new A();
$a->b();
$a->c();

c() is executed twice now, but you get the idea. Within your class, you can instanciate the class itself and work with it like with a regular object. But from outside, it's simply one line of code while it's 3 lines using the non-static way. Pretty cool, huh?

And as you see, you can use the static function in a non-static context, which means, you can declare your method static, but if you instanciate your class, you can simply call it like a regular method. Sounds pretty flexible to me ;)

And no, you can't use $this in a static context, but that's what self is for ;)

Quasdunk
  • 14,944
  • 3
  • 36
  • 45
-3

If it is a static function you don't have to instantiate the class in order to use the method.

Class A {
  static function hello($arg)
  {
    echo 'Hello, ' . $arg;
  }
}

A::hello('world');

VS

Class A {
  public function hello($arg)
  {
    echo 'Hello, ' . $arg;
  }
}

$a = new A;
$a->hello('world');

The important thing here is the instantiation of the object. After you've instantiated an object, it can be manipulated, and calling your methods may yield unexpected results. If your values and functions are statically declared in the class, they cannot be modified at the time you call the function.

This is not to say they you should always use static methods either. take the following example.

class My_math {
  static function pi()
  { 
   return 3.14
  }
}

class My_bakery {
  private var $pie;  

  function set_pie($pie)
  {
    $this->pie = $pie;
  }
  function pie()
  {
    echo "I made you a " . $this->pie . "pie";
  }
}

I've made My_Math return a constant value, because I know pi doesn't change. But in My_bakery, some days I want blueberry pie and some days I want peach pie.

solidau
  • 4,021
  • 3
  • 24
  • 45