In PHP, what is the difference between :: and -> when referencing a class?

Question

Possible Duplicate:
PHP: self vs this

I'm working on some code and the previous author seems to intermingle the two.

example:

class DB {
    // Some functions
}

Outside the class he references it like so:

DB::somefunction();

and also like this:

$db = new DB;
$db->somefunction();

What's the difference between the two and is one better than the other?

Answer 1

:: is for accessing attributes on a class, -> is for accessing attributes on an instance.

Answer 2

See http://www.php.net/manual/en/language.oop5.paamayim-nekudotayim.php

The Scope Resolution Operator :: (also called Paamayim Nekudotayim) or in simpler terms, the double colon, is a token that allows access to static, constant, and overridden properties or methods of a class.

If you have to ask this though, I suggest reading through the chapter on OOP in the PHP manual before continue working on the code at hand. It's basic knowledge.

Answer 3

:: In this instance means its a static method. A static method can be called without an instance of the class in question, whereas -> accesses a method on an objec instance.

Answer 4

:: is for accessing static class functions and members where as -> is for accessing non-static members and functions.

They can be used interchangeably when calling methods, however, it does give a warning if all warnings are enabled (E_STRICT). When you call a non-static method using ::, $this will not be passed to the function (meaning you cannot access any of the objects non-static members).

Example code:

class Foo{
    public function Bar(){
        if ( !isset($this) ){
            echo "Baz";
        }
    }
}

Foo::Bar();

Result:

Baz

For these reasons you should never access a non static function using :: as you will encounter errors if you ever decided to use $this in the function (and immense confusion from the next maintainer).

Answer 5

When you call

DB::somefunction();

$this is undefined (NULL) inside somefunction(). So these functions are supposed to not use any instance data. This is accessing class variables/functions.

When you call

$db = new DB;
$db->somefunction();

$this is defined inside somefunction(). These functions are supposed to use instance data. This is accessing instance variables/functions.

parrot:~ more a.php
<?php
class DB {
        var $a = 45;
        function somefunction() {
                var_dump($this);
        }
}

DB::somefunction();
$db = new DB;
$db->somefunction();
?>
parrot:~ php a.php
NULL
object(DB)#1 (1) {
  ["a"]=>
  int(45)
}

Answer 6

• :: for static attribute
• -> instance attribute

Answer 7

:: is for static invocation. Write Class::Method()

-> is for instance invocation. Write Object->Method()

For the second you first need to instanciate a class, further there is a $this to access instance variables.

Answer 8

This is in addition to the answers already given i.e. :: static access -> instance access
You will quite often see :: used in documentation when a method of a class is being referred to even though it is not static just for convenience. You would still use -> if you are working with an instance of the class.