> ## 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 Trait Use
The `use` statement within a class body is the mechanism by which PHP incorporates a trait, enabling horizontal code reuse. It instructs the PHP compiler to flatten the trait's methods, properties, and constants directly into the composing class at compile time, effectively bypassing PHP's single-inheritance limitation.
## Basic Syntax
To include a trait, declare the `use` keyword followed by the trait name inside the class definition. Multiple traits can be imported by separating them with commas.
```php theme={"dark"}
trait Logger {
public function log(string $message): void {
echo $message;
}
}
trait Authenticator {
public function authenticate(): bool {
return true;
}
}
class User {
use Logger, Authenticator;
}
```
## Method Precedence
PHP enforces a strict precedence order when resolving method names during trait composition:
1. **Composing Class:** Methods defined directly in the class override methods provided by a trait.
2. **Trait:** Methods provided by a trait override inherited methods from a parent class.
3. **Parent Class:** Inherited methods have the lowest precedence.
```php theme={"dark"}
class Base {
public function process(): void {
echo "Base";
}
}
trait ProcessorTrait {
public function process(): void {
echo "Trait";
}
}
class Child extends Base {
use ProcessorTrait;
// If uncommented, this overrides the trait method.
// public function process(): void { echo "Child"; }
}
```
## Method Conflict Resolution
If a class uses multiple traits that define methods with the same name, PHP throws a fatal error. Because PHP does not support method overloading by signature, any matching method name causes a collision regardless of its parameters or return type. You must explicitly resolve these naming collisions using the `insteadof` and `as` operators within a block appended to the `use` statement.
* **`insteadof`**: Instructs the compiler to use a specific trait's method over another.
* **`as`**: Creates an alias for a method, allowing the overridden method to still be accessed under a different name.
```php theme={"dark"}
trait TraitA {
public function execute(): void { echo "A"; }
}
trait TraitB {
public function execute(): void { echo "B"; }
}
class Task {
use TraitA, TraitB {
TraitA::execute insteadof TraitB;
TraitB::execute as executeB;
}
}
```
## Property and Constant Conflicts
Unlike methods, conflicts involving properties or constants (supported in traits as of PHP 8.2) **cannot** be resolved using the `insteadof` or `as` operators.
If multiple traits define a property with the same name, or if the composing class defines a property with the same name as a trait, PHP throws a fatal error. The collision is only permitted if the properties are strictly compatible. To be strictly compatible, the properties must share the exact same:
* Visibility (`public`, `protected`, `private`)
* Type declaration
* `readonly` modifier
* Initial value
```php theme={"dark"}
trait StateA {
public string $status = 'active';
public int $code = 1;
}
trait StateB {
public string $status = 'active'; // Strictly compatible: Allowed
// public int $code = 2; // Incompatible initial value: Fatal Error
}
class Entity {
use StateA, StateB;
public string $status = 'active'; // Strictly compatible: Allowed
}
```
## Visibility Modification
The `as` operator can mutate the access modifier (`public`, `protected`, `private`) of a trait method within the composing class. This can be done with or without aliasing the method name.
```php theme={"dark"}
trait Utility {
private function calculate(): int {
return 42;
}
}
class Service {
use Utility {
// Elevate visibility to public without renaming
calculate as public;
// Elevate visibility to public AND alias the method
calculate as public getCalculation;
}
}
```
## Trait Composition
Traits can utilize the `use` statement to compose other traits. The syntax and conflict resolution mechanics remain identical to those used within classes.
```php theme={"dark"}
trait Database {
public function connect(): void {}
}
trait Cache {
public function set(): void {}
}
trait Repository {
use Database, Cache;
public function save(): void {
$this->connect();
$this->set();
}
}
```
Tired of Poor PHP Skills? Fix That With Deep Grasping!
Learn More
