PHP self vs $this: Difference, Usage, and When to Use Each

By the end of this page, you will understand the difference between self and $this in PHP, how static context differs from instance context, and when each form should be used to access methods and properties inside a class.

self and $this are both used inside PHP classes, but they refer to different things.

• $this refers to the current object instance.
• self refers to the current class itself.

This matters because PHP separates instance members from static members:

• Instance properties and methods belong to a specific object created from a class.
• Static properties and methods belong to the class itself, not to any one object.

$this means “this object”

Use $this when you want to work with data or methods that belong to a particular object.

class User {
    public $name;

    public function setName($name) {
        $this->name = $name;
    }

    public function greet() {
        return "Hello, " . $this->name;
    }
}

Here, $this->name refers to the property of the current object.

Think of a class as a blueprint for houses, and objects as the actual houses built from that blueprint.

• $this means: this specific house.
• self means: the blueprint itself.

If you want to know the color of the kitchen in one house, you use $this because that belongs to a specific house.

If you want to read a rule written on the blueprint, such as a standard ceiling height shared by all houses, you use self.

So:

• $this = object-level access
• self = class-level access

Core syntax

Accessing instance members with $this

class Person {
    public $name = "";

    public function setName($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

• Use -> with $this
• Works with non-static properties and methods

Accessing static members with self

class Counter {
    public static $count = 0;

    public static {
        ::++;
    }
}

Consider this example:

class ScoreBoard {
    public $player;
    public static $gamesPlayed = 0;

    public function __construct($player) {
        $this->player = $player;
        self::$gamesPlayed++;
    }

    public function getPlayer() {
        return $this->player;
    }

    public static function getGamesPlayed() {
        return self::$gamesPlayed;
    }
}

$game1 = new ScoreBoard("Anna");
$game2 = new ScoreBoard("Ben");

echo $game1->getPlayer();
 ::();

$this and self appear often in real PHP applications.

Common uses of $this

Object state

class SessionUser {
    public $email;

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

Each logged-in user object has its own email.

Working with instance methods

class Order {
    public function calculateTotal() {
        return 100;
    }

    public function printInvoice() {
        return "Total: " . $this->calculateTotal();
    }
}

In real codebases, developers usually choose between $this and self based on whether they are writing object behavior or class-level behavior.

$this in application code

Instance services and models

class Product {
    private $price;

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

    public function isExpensive() {
        return $this->price > 100;
    }
}

This is common in domain models, entities, and service objects.

Chaining methods

class QueryBuilder {
    public function where(, ) {
        
         ;
    }
}

1. Using $this inside a static method

This is a very common error.

Broken code

class Test {
    public $name = "Sam";

    public static function showName() {
        return $this->name;
    }
}

This fails because a static method does not have an object instance.

Fix

Either make the method non-static:

class Test {
    public $name = "Sam";

    public function showName() {
        return $this->name;
    }
}

Or make the property static if it truly belongs to the class:

class Test {
       = ;

      {
         ::;
    }
}

Quick rules

• Use $this for instance properties and methods
• Use self for static properties, static methods, and constants
• $this uses ->
• self uses ::
• $this is only available when an object exists
• self works in static methods

Syntax

$this->property;
$this->method();

self::$property;
self::method();
self::CONSTANT;

Remember

• public $name; → access with $this->name
• public static $count; → access with self::$count
• const VERSION = '1.0'; → access with

What is the difference between self and $this in PHP?

$this refers to the current object instance. self refers to the current class and is used for static members and constants.

Can I use $this in a static method in PHP?

No. Static methods do not have an object instance, so $this is not available there.

When should I use self:: in PHP?

Use self:: when accessing static properties, static methods, or class constants from within the same class.

When should I use $this-> in PHP?

Use $this-> when accessing non-static properties or methods that belong to the current object.

Is self the same as a static property or static method?

No. self is the keyword used to refer to the class. It is commonly used to access static members, but it is not itself a property or method.

Can an instance method use self?

Yes. An instance method can access static members with , but it should use for instance members.

• Static properties — closely related because self is commonly used to access them.
• Static methods — important for understanding class-level behavior in PHP.
• Object instances — needed to understand why $this refers to one specific object.
• Class constants — often accessed with self::CONSTANT.
• Instance methods — these are the methods where $this is usually used.
• Late static binding — related because self:: and static:: behave differently with inheritance.
• PHP classes and objects — the broader topic that explains where self and $this fit.