> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# PHP Object Access
The `->` operator, formally known as the object operator (`T_OBJECT_OPERATOR`), is used in object-oriented PHP to access properties and methods of an instantiated object. It acts as a dereferencing operator that resolves the memory reference of an object instance on its left operand to access the specific member (property or method) declared by its right operand.
## Syntax
```php theme={"dark"}
class Entity {
public $property = 'value';
public function method($param1, $param2) {}
}
$object = new Entity();
$arg1 = 'foo';
$arg2 = 'bar';
$object->property;
$object->method($arg1, $arg2);
```
## Technical Mechanics
* **Left Operand:** Expected to evaluate to an object instance. If the operand is not an object, PHP handles the operation based on the context:
* **Method Calls:** Invoking a method on `null` or a non-object scalar type throws a fatal `Error` (e.g., `Call to a member function method() on null`).
* **Property Reads:** Reading a property on `null` or a scalar type emits a `Warning` (e.g., `Attempt to read property "property" on null`) and evaluates to `null`. Execution of the script continues.
* **Property Assignments:** Assigning a value to a property on an uninitialized variable or a variable containing `null` throws a fatal `Error` in PHP 8.0 and later (e.g., `Attempt to assign property "property" on null`). In PHP 7.x, this action emitted a `Warning` and auto-vivified a `stdClass` object. Attempting to assign a property on other non-object scalar types (such as `int`, `string`, or `bool`) strictly throws a fatal `Error` across modern PHP versions.
* **Right Operand:** Must be a valid identifier representing the name of the property or method. When accessing a property, the `$` prefix is strictly omitted from the property name.
* **Resolution Context:** The operator respects class visibility modifiers (`public`, `protected`, `private`). If the operator is used outside the object's scope to access a non-public member, PHP throws a fatal error unless overloading magic methods (`__get`, `__set`, `__call`) are implemented to intercept the operation.
* **Static vs. Non-Static:** The `->` operator cannot be used to access static *properties*; doing so requires the scope resolution operator (`::`). However, PHP does permit calling static *methods* on an object instance using the `->` operator.
## Dynamic Member Access
The right operand can be evaluated dynamically at runtime by providing a variable that holds a string value. This is referred to as variable properties or variable methods.
```php theme={"dark"}
class DynamicEntity {
public $dynamicField = 'data';
public $prefix_key = 'concatenated';
public function dynamicAction() {}
}
$object = new DynamicEntity();
$propertyName = 'dynamicField';
$methodName = 'dynamicAction';
$dynamicString = 'key';
// Evaluates to $object->dynamicField
$object->$propertyName;
// Evaluates to $object->dynamicAction()
$object->$methodName();
```
Complex expressions can be enclosed in curly braces to enforce evaluation precedence during dynamic access:
```php theme={"dark"}
// Evaluates to $object->prefix_key
$object->{'prefix_' . $dynamicString};
```
## Operator Chaining
The `->` operator is left-associative. It can be chained sequentially in a single expression, provided that each preceding operation evaluates to and returns a valid object instance.
```php theme={"dark"}
class Builder {
public $property = 'result';
public function methodOne() { return $this; }
public function methodTwo() { return $this; }
}
$object = new Builder();
// Sequentially resolves each method call before accessing the property
$object->methodOne()->methodTwo()->property;
```
## Nullsafe Operator Extension (`?->`)
Introduced in PHP 8.0, the `?->` (nullsafe operator) is a variant of the standard object operator. It alters the evaluation mechanics by short-circuiting the chain. If the left operand evaluates to `null`, the execution of the entire chain halts immediately, and the expression evaluates to `null` without emitting a `Warning` or throwing a fatal `Error`.
```php theme={"dark"}
class Service {
public $property = 'active';
public function method() { return $this; }
}
$object = null;
// Short-circuits at $object and evaluates to null
$result = $object?->method()?->property;
```
Tired of Poor PHP Skills? Fix That With Deep Grasping!
Learn More
