this, self, and Me are keywords used in some computer programming languages to refer to the object, class, or other entity which the currently running code is a part of. The entity referred to thus depends on the execution context (such as which object has its method called). Different programming languages use these keywords in slightly different ways. In languages where a keyword like "this" is mandatory, the keyword is the only way to access data and methods stored in the current object. Where optional, these keywords can disambiguate variables and functions with the same name.

Object-oriented programming

In many object-oriented programming languages, (also called or ) is a variable that is used in instance methods to refer to the object on which they are working. The first OO language, SIMULA 67, used to explicitly reference the local object. C++ and languages which derive in style from it (such as Java, C#, D, and PHP) also generally use. Smalltalk and others, such as Object Pascal, Perl, Python, Ruby, Rust, Objective-C, DataFlex and Swift, use. Microsoft's Visual Basic uses. The concept is similar in all languages: is usually an immutable reference or pointer which refers to the current object; the current object often being the code that acts as 'parent' or 'invocant' to the property, method, sub-routine or function that contains the keyword. After an object is properly constructed, or instantiated, is always a valid reference. Some languages require it explicitly; others use lexical scoping to use it implicitly to make symbols within their class visible. Or alternatively, the current object referred to by may be an independent code object that has called the function or method containing the keyword. Such a thing happens, for example, when a JavaScript event handler attached to an HTML tag in a web page calls a function containing the keyword stored in the global space outside the document object; in that context, will refer to the page element within the document object, not the enclosing window object. In some languages, for example C++, Java, and Raku or is a keyword, and the variable automatically exists in instance methods. In others, for example, Python, Rust, and Perl 5, the first parameter of an instance method is such a reference. It needs to be specified explicitly. In Python and Perl, the parameter need not necessarily be named or ; it can be named freely by the programmer like any other parameter. However, by informal convention, the first parameter of an instance method in Perl or Python is named. Rust requires the self object to be called or , depending on whether the invoked function borrows the invocant, or moves it in, respectively. Static methods in C++ or Java are not associated with instances but classes, and so cannot use, because there is no object. In other languages, such as Ruby, Smalltalk, Objective-C, or Swift, the method is associated with a class object that is passed as, and they are called class methods. For class methods, Python uses to access to the class object.

Subtleties and difficulties

When lexical scoping is used to infer, the use of in code, while not illegal, may raise warning bells to a maintenance programmer, although there are still legitimate uses of in this case, such as referring to instance variables hidden by local variables of the same name, or if the method wants to return a reference to the current object, i.e. , itself. In some compilers (for example GCC), pointers to C++ instance methods can be directly cast to a pointer of another type, with an explicit pointer parameter.

Open recursion

The dispatch semantics of, namely that method calls on are dynamically dispatched, is known as open recursion, and means that these methods can be overridden by derived classes or objects. By contrast, direct named recursion or anonymous recursion of a function uses closed recursion, with static dispatch. For example, in the following Perl code for the factorial, the token is a reference to the current function: By contrast, in C++ (using an explicit for clarity, though not necessary) the binds to the object itself, but if the class method was declared "virtual" i.e. polymorphic in the base, it's resolved via dynamic dispatch so that derived classes can override it. This example is artificial since this is direct recursion, so overriding the method would override this function; more natural examples are when a method in a derived class calls the same method in a base class, or in cases of mutual recursion. The fragile base class problem has been blamed on open recursion, with the suggestion that invoking methods on default to closed recursion (static dispatch) rather than open recursion (dynamic dispatch), only using open recursion when it is specifically requested; external calls (not using ) would be dynamically dispatched as usual. The way this is solved in practice in the JDK is through a certain programmer discipline; this discipline has been formalized by C. Ruby and G. T. Leavens; it consists of the following rules:

Implementations

C++

Early versions of C++ would let the pointer be changed; by doing so a programmer could change which object a method was working on. This feature was eventually removed, and now in C++ is an r-value. Early versions of C++ did not include references and it has been suggested that had they been so in C++ from the beginning, would have been a reference, not a pointer. C++ lets objects destroy themselves with the source code statement:.

C#

The keyword in C# works the same way as in Java, for reference types. However, within C# value types, has quite different semantics, being similar to an ordinary mutable variable reference, and can even occur on the left side of an assignment. One use of in C# is to allow reference to an outer field variable within a method that contains a local variable that has the same name. In such a situation, for example, the statement within the method will assign the type and value of the local variable to , whereas the statement will assign the type and value of the outer field variable to.

D

In D in a class, struct, or union method refers to an immutable reference of the instance of the enclosing aggregate. Classes are reference types, and structs and unions are value types. In the first version of D, the keyword is used as a pointer to the instance of the object the method is bound to, while in D2 it has the character of an implicit function argument.

Dylan

In the programming language Dylan, which is an object-oriented language that supports multimethods and doesn't have a concept of, sending a message to an object is still kept in the syntax. The two forms below work in the same way; the differences are just syntactic sugar. object.method(param1, param2) and method (object, param1, param2)

Eiffel

Within a class text, the current type is the type obtained from the current class. Within features (routines, commands and queries) of a class, one may use the keyword to reference the current class and its features. The use of the keyword is optional as the keyword is implied by simply referring to the name of the current class feature openly. For example: One might have a feature foo' in a class MY_CLASS and refer to it by: Line #10 (above) has the implied reference to by the call to simple foo'. Line #10 (below) has the explicit reference to by the call to `Current.foo'. Either approach is acceptable to the compiler, but the implied version (e.g. ) is preferred as it is less verbose. As with other languages, there are times when the use of the keyword is mandated, such as: In the case of the code above, the call on line #11 to make_with_something is passing the current class by explicitly passing the keyword.

Java

The keyword is a Java language keyword that represents the current instance of the class in which it appears. It is used to access class variables and methods. Since all instance methods are virtual in Java, can never be null.

JavaScript

In JavaScript, which is a programming or scripting language used extensively in web browsers, is an important keyword, although what it evaluates to depends on where it is used. To work around the different meaning of in nested functions such as DOM event handlers, it is a common idiom in JavaScript to save the reference of the calling object in a variable (commonly called or ), and then use the variable to refer to the calling object in nested functions. For example: Notably, JavaScript makes use of both and the related keyword (in contrast to most other languages which tend to employ one or the other), with being restricted specifically to web workers. Finally, as a reliable way of specifically referencing the global (window or equivalent) object, JavaScript features the keyword.

Lua

In Lua, is created as syntactic sugar when functions are defined using the operator. When invoking a method using, the object being indexed will be implicitly given as the first argument to the function being invoked. For example, the following two functions are equivalent: Lua itself is not object-oriented, but when combined with another feature called metatables, the use of lets programmers define functions in a manner resembling object-oriented programming.

PowerShell

In PowerShell, the special automatic variable contains the current object in the pipeline object. You can use this variable in commands that perform an action on every object or on selected objects in a pipeline. Also starting with PowerShell 5.0, which adds a formal syntax to define classes and other user-defined types, variable describes the current instance of the object.

Python

In Python, there is no keyword for. When a member function is called on an object, it invokes the member function with the same name on the object's class object, with the object automatically bound to the first argument of the function. Thus, the obligatory first parameter of instance methods serves as ; this parameter is conventionally named , but can be named anything. In class methods (created with the decorator), the first argument refers to the class object itself, and is conventionally called ; these are primarily used for inheritable constructors, where the use of the class as a parameter allows subclassing the constructor. In static methods (created with the decorator), no special first argument exists.

Rust

In Rust, types are declared separately from the functions associated with them. Functions designed to be analogous to instance methods in more traditionally object-oriented languages must explicitly take as their first parameter. These functions can then be called using syntax sugar. For example: This defines a type,, which has four associated functions. The first,, is not an instance function and must be specified with the type prefix. The remaining three all take a parameter in a variety of ways and can be called on a instance using the dot-notation syntax sugar, which is equivalent to calling the type-qualified function name with an explicit first parameter.

Self

The Self language is named after this use of "self".

Xbase++

is strictly used within methods of a class. Another way to refer to is to use.