What does the variable $this mean in PHP?

I see the variable $this in PHP all the time and I have no idea what it's used for. I've never personally used it.

Can someone tell me how the variable $this works in PHP?

11 Answers

It's a reference to the current object, it's most commonly used in object oriented code.

Reference:
Primer:

Example:

<?php
class Person { public $name; function __construct( $name ) { $this->name = $name; }
};
$jack = new Person('Jack');
echo $jack->name;

This stores the 'Jack' string as a property of the object created.

The best way to learn about the `$this` variable in PHP is to try it against the interpreter in various contexts:

print isset($this); //true, $this exists
print gettype($this); //Object, $this is an object
print is_array($this); //false, $this isn't an array
print get_object_vars($this); //true, $this's variables are an array
print is_object($this); //true, $this is still an object
print get_class($this); //YourProject\YourFile\YourClass
print get_parent_class($this); //YourBundle\YourStuff\YourParentClass
print gettype($this->container); //object
print_r($this); //delicious data dump of $this
print $this->yourvariable //access $this variable with ->

So the $this pseudo-variable has the Current Object's method's and properties. Such a thing is useful because it lets you access all member variables and member methods inside the class. For example:

Class Dog{ public $my_member_variable; //member variable function normal_method_inside_Dog() { //member method //Assign data to member variable from inside the member method $this->my_member_variable = "whatever"; //Get data from member variable from inside the member method. print $this->my_member_variable; }
}

$this is reference to a PHP Object that was created by the interpreter for you, that contains an array of variables.

If you call $this inside a normal method in a normal class, $this returns the Object (the class) to which that method belongs.

It's possible for $this to be undefined if the context has no parent Object.

php.net has a big page talking about PHP object oriented programming and how $this behaves depending on context.

I know its old question, anyway another exact explanation about $this. $this is mainly used to refer properties of a class.

Example:

Class A
{ public $myname; //this is a member variable of this class
function callme() { $myname = 'function variable'; $this->myname = 'Member variable'; echo $myname; //prints function variable echo $this->myname; //prints member variable }
}

output:

function variable
member variable

It is the way to reference an instance of a class from within itself, the same as many other object oriented languages.

From the PHP docs:

The pseudo-variable $this is available when a method is called from within an object context. $this is a reference to the calling object (usually the object to which the method belongs, but possibly another object, if the method is called statically from the context of a secondary object).

Lets see what happens if we won't use $this and try to have instance variables and constructor arguments with the same name with the following code snippet

<?php
class Student { public $name; function __construct( $name ) { $name = $name; }
};
$tom = new Student('Tom');
echo $tom->name;
?>

It echos nothing but

<?php
class Student { public $name; function __construct( $name ) { $this->name = $name; // Using 'this' to access the student's name }
};
$tom = new Student('Tom');
echo $tom->name;
?>

this echoes 'Tom'

when you create a class you have (in many cases) instance variables and methods (aka. functions). $this accesses those instance variables so that your functions can take those variables and do what they need to do whatever you want with them.

another version of meder's example:

class Person { protected $name; //can't be accessed from outside the class public function __construct($name) { $this->name = $name; } public function getName() { return $this->name; }
}
// this line creates an instance of the class Person setting "Jack" as $name.
// __construct() gets executed when you declare it within the class.
$jack = new Person("Jack");
echo $jack->getName();
Output:
Jack

This is long detailed explanation. I hope this will help the beginners. I will make it very simple.

First, let's create a class

<?php
class Class1
{
}

You can omit the php closing tag ?> if you are using php code only.

Now let's add properties and a method inside Class1.

<?php
class Class1
{ public $property1 = "I am property 1"; public $property2 = "I am property 2"; public function Method1() { return "I am Method 1"; }
}

The property is just a simple variable , but we give it the name property cuz its inside a class.

The method is just a simple function , but we say method cuz its also inside a class.

The public keyword mean that the method or a property can be accessed anywhere in the script.

Now, how we can use the properties and the method inside Class1 ?

The answer is creating an instance or an object, think of an object as a copy of the class.

<?php
class Class1
{ public $property1 = "I am property 1"; public $property2 = "I am property 2"; public function Method1() { return "I am Method 1"; }
}
$object1 = new Class1;
var_dump($object1);

We created an object, which is $object1 , which is a copy of Class1 with all its contents. And we dumped all the contents of $object1 using var_dump() .

This will give you

object(Class1)#1 (2) { ["property1"]=> string(15) "I am property 1" ["property2"]=> string(15) "I am property 2" }

So all the contents of Class1 are in $object1 , except Method1 , i don't know why methods doesn't show while dumping objects.

Now what if we want to access $property1 only. Its simple , we do var_dump($object1->property1); , we just added ->property1 , we pointed to it.

we can also access Method1() , we do var_dump($object1->Method1());.

Now suppose i want to access $property1 from inside Method1() , i will do this

<?php
class Class1
{ public $property1 = "I am property 1"; public $property2 = "I am property 2"; public function Method1() { $object2 = new Class1; return $object2->property1; }
}
$object1 = new Class1;
var_dump($object1->Method1());

we created $object2 = new Class1; which is a new copy of Class1 or we can say an instance. Then we pointed to property1 from $object2

return $object2->property1;

This will print string(15) "I am property 1" in the browser.

Now instead of doing this inside Method1()

$object2 = new Class1;
return $object2->property1;

We do this

return $this->property1;

The $this object is used inside the class to refer to the class itself.

It is an alternative for creating new object and then returning it like this

$object2 = new Class1;
return $object2->property1;

Another example

<?php
class Class1
{ public $property1 = 119; public $property2 = 666; public $result; public function Method1() { $this->result = $this->property1 + $this->property2; return $this->result; }
}
$object1 = new Class1;
var_dump($object1->Method1());

We created 2 properties containing integers and then we added them and put the result in $this->result.

Do not forget that

$this->property1 = $property1 = 119

they have that same value .. etc

I hope that explains the idea.

This series of videos will help you a lot in OOP

$this is a reference to the calling object (usually the object to which the method belongs, but possibly another object, if the method is called statically from the context of a secondary object).

$this is a special variable and it refers to the same object ie. itself.

it actually refer instance of current class

here is an example which will clear the above statement

<?php class Books { /* Member variables */ var $price; var $title; /* Member functions */ function setPrice($par){ $this->price = $par; } function getPrice(){ echo $this->price ."<br/>"; } function setTitle($par){ $this->title = $par; } function getTitle(){ echo $this->title ." <br/>"; }
}
?>

It refers to the instance of the current class, as meder said.

See the PHP Docs. It's explained under the first example.

Generally, this keyword is used inside a class, generally with in the member functions to access non-static members of a class(variables or functions) for the current object.

this keyword should be preceded with a $ symbol.
In case of this operator, we use the -> symbol.
Whereas, $this will refer the member variables and function for a particular instance.

Let's take an example to understand the usage of $this.

<?php
class Hero { // first name of hero private $name; // public function to set value for name (setter method) public function setName($name) { $this->name = $name; } // public function to get value of name (getter method) public function getName() { return $this->name; }
}
// creating class object
$stark = new Hero();
// calling the public function to set fname
$stark->setName("IRON MAN");
// getting the value of the name variable
echo "I Am " . $stark->getName();
?>

OUTPUT: I am IRON MAN

NOTE: A static variable acts as a global variable and is shared among all the objects of the class. A non-static variables are specific to instance object in which they are created.