Traits and Namespaces in PHP

1<?php
2declare(strict_types=1);
3
4trait Timestampable {
5    protected DateTime $createdAt;
6    protected DateTime $updatedAt;
7
8    public function initTimestamps(): void {
9        $this->createdAt = new DateTime();
10        $this->updatedAt = new DateTime();
11    }
12
13    public function touch(): void {
14        $this->updatedAt = new DateTime();
15    }
16
17    public function getCreatedAt(): DateTime {
18        return $this->createdAt;
19    }
20
21    public function getUpdatedAt(): DateTime {
22        return $this->updatedAt;
23    }
24}
25
26class Article {
27    use Timestampable;
28
29    public function __construct(private string $title) {
30        $this->initTimestamps();
31    }
32
33    public function update(string $title): void {
34        $this->title = $title;
35        $this->touch();
36    }
37}
38
39class Comment {
40    use Timestampable;
41
42    public function __construct(private string $content) {
43        $this->initTimestamps();
44    }
45}
46
47$article = new Article('My Article');
48sleep(1);
49$article->update('Updated Article');
50
51echo "Created: " . $article->getCreatedAt()->format('H:i:s') . "\n";
52echo "Updated: " . $article->getUpdatedAt()->format('H:i:s') . "\n";
53?>

1<?php
2trait Loggable {
3    protected array $logs = [];
4
5    public function log(string $message): void {
6        $this->logs[] = [
7            'message' => $message,
8            'time' => new DateTime()
9        ];
10    }
11
12    public function getLogs(): array {
13        return $this->logs;
14    }
15}
16
17trait Cacheable {
18    protected ?array $cache = null;
19    protected int $cacheTTL = 3600;
20
21    public function getCached(string $key): mixed {
22        if ($this->cache === null || !isset($this->cache[$key])) {
23            return null;
24        }
25        return $this->cache[$key];
26    }
27
28    public function setCache(string $key, mixed $value): void {
29        $this->cache[$key] = $value;
30    }
31
32    public function clearCache(): void {
33        $this->cache = null;
34    }
35}
36
37class DataService {
38    use Loggable, Cacheable;
39
40    public function fetchData(string $id): array {
41        // Check cache first
42        $cached = $this->getCached($id);
43        if ($cached !== null) {
44            $this->log("Cache hit for: $id");
45            return $cached;
46        }
47
48        // Fetch from database
49        $this->log("Fetching from DB: $id");
50        $data = ['id' => $id, 'value' => 'data'];
51
52        // Store in cache
53        $this->setCache($id, $data);
54
55        return $data;
56    }
57}
58?>

1<?php
2trait Validatable {
3    protected array $errors = [];
4
5    protected function addError(string $field, string $message): void {
6        $this->errors[$field][] = $message;
7    }
8
9    public function getErrors(): array {
10        return $this->errors;
11    }
12
13    public function hasErrors(): bool {
14        return !empty($this->errors);
15    }
16
17    public function clearErrors(): void {
18        $this->errors = [];
19    }
20}
21
22class UserForm {
23    use Validatable;
24
25    public function validate(array $data): bool {
26        $this->clearErrors();
27
28        if (empty($data['email'])) {
29            $this->addError('email', 'Email is required');
30        } elseif (!filter_var($data['email'], FILTER_VALIDATE_EMAIL)) {
31            $this->addError('email', 'Invalid email format');
32        }
33
34        if (empty($data['password'])) {
35            $this->addError('password', 'Password is required');
36        } elseif (strlen($data['password']) < 8) {
37            $this->addError('password', 'Password must be at least 8 characters');
38        }
39
40        return !$this->hasErrors();
41    }
42}
43?>

1<?php
2declare(strict_types=1);
3
4trait Logger {
5    public function log(string $message): void {
6        echo "[LOG] $message\n";
7    }
8}
9
10trait Debugger {
11    public function log(string $message): void {
12        echo "[DEBUG] " . date('Y-m-d H:i:s') . " $message\n";
13    }
14}
15
16class Application {
17    use Logger, Debugger {
18        // Use Debugger's log instead of Logger's
19        Debugger::log insteadof Logger;
20    }
21}
22
23$app = new Application();
24$app->log('Application started');
25// Output: [DEBUG] 2024-01-15 10:30:00 Application started
26?>

1<?php
2trait EmailSender {
3    public function send(string $to, string $message): void {
4        echo "Sending email to $to: $message\n";
5    }
6}
7
8trait SmsSender {
9    public function send(string $to, string $message): void {
10        echo "Sending SMS to $to: $message\n";
11    }
12}
13
14class NotificationService {
15    use EmailSender, SmsSender {
16        // Keep both methods with different names
17        EmailSender::send as sendEmail;
18        SmsSender::send as sendSms;
19        // Choose one as the default 'send'
20        EmailSender::send insteadof SmsSender;
21    }
22}
23
24$service = new NotificationService();
25$service->send('[email protected]', 'Hello');  // Uses email
26$service->sendEmail('[email protected]', 'Hello');
27$service->sendSms('+1234567890', 'Hello');
28?>

1<?php
2trait DatabaseOperations {
3    protected function connect(): void {
4        echo "Connecting to database...\n";
5    }
6
7    protected function disconnect(): void {
8        echo "Disconnecting from database...\n";
9    }
10}
11
12class Repository {
13    use DatabaseOperations {
14        // Make connect public
15        connect as public;
16        // Keep disconnect protected
17    }
18
19    public function save(): void {
20        $this->connect();
21        echo "Saving data...\n";
22        $this->disconnect();
23    }
24}
25
26$repo = new Repository();
27$repo->connect(); // Now accessible
28$repo->save();
29?>

1<?php
2trait Sortable {
3    public function sort(): array {
4        $items = $this->getItems();
5        usort($items, fn($a, $b) => $a <=> $b);
6        return $items;
7    }
8
9    // Trait requires this method from the using class
10    abstract protected function getItems(): array;
11}
12
13class Collection {
14    use Sortable;
15
16    private array $items = [];
17
18    public function add(int $item): void {
19        $this->items[] = $item;
20    }
21
22    // Must implement this for the trait
23    protected function getItems(): array {
24        return $this->items;
25    }
26}
27
28$collection = new Collection();
29$collection->add(3);
30$collection->add(1);
31$collection->add(2);
32
33print_r($collection->sort()); // [1, 2, 3]
34?>

1<?php
2trait HasTimestamps {
3    protected DateTime $createdAt;
4    protected DateTime $updatedAt;
5
6    protected function initializeTimestamps(): void {
7        $this->createdAt = new DateTime();
8        $this->updatedAt = new DateTime();
9    }
10}
11
12trait SoftDeletes {
13    protected ?DateTime $deletedAt = null;
14
15    public function delete(): void {
16        $this->deletedAt = new DateTime();
17    }
18
19    public function restore(): void {
20        $this->deletedAt = null;
21    }
22
23    public function isDeleted(): bool {
24        return $this->deletedAt !== null;
25    }
26}
27
28trait Model {
29    use HasTimestamps, SoftDeletes;
30
31    public function __construct() {
32        $this->initializeTimestamps();
33    }
34}
35
36class Post {
37    use Model;
38
39    public function __construct(private string $title) {
40        parent::__construct(); // Call trait constructor logic
41    }
42}
43?>

1<?php
2declare(strict_types=1);
3
4namespace App\Models;
5
6class User {
7    public function __construct(
8        private string $name,
9        private string $email
10    ) {}
11
12    public function getName(): string {
13        return $this->name;
14    }
15}
16
17// In another file:
18namespace App\Controllers;
19
20use App\Models\User;
21
22class UserController {
23    public function create(string $name, string $email): User {
24        return new User($name, $email);
25    }
26}
27?>

1<?php
2// File: src/Database/Connections/MySQLConnection.php
3namespace App\Database\Connections;
4
5class MySQLConnection {
6    public function connect(): void {
7        echo "Connecting to MySQL...\n";
8    }
9}
10
11// File: src/Database/Connections/PostgreSQLConnection.php
12namespace App\Database\Connections;
13
14class PostgreSQLConnection {
15    public function connect(): void {
16        echo "Connecting to PostgreSQL...\n";
17    }
18}
19
20// File: src/Database/ConnectionManager.php
21namespace App\Database;
22
23use App\Database\Connections\MySQLConnection;
24use App\Database\Connections\PostgreSQLConnection;
25
26class ConnectionManager {
27    public function getMySql(): MySQLConnection {
28        return new MySQLConnection();
29    }
30
31    public function getPostgreSQL(): PostgreSQLConnection {
32        return new PostgreSQLConnection();
33    }
34}
35?>

1<?php
2namespace App\Services;
3
4// Import specific class
5use App\Models\User;
6
7// Import with alias
8use App\Database\ConnectionManager as DB;
9
10// Import multiple classes from same namespace
11use App\Repositories\{UserRepository, PostRepository, CommentRepository};
12
13// Import function
14use function App\Helpers\formatDate;
15
16// Import constant
17use const App\Config\MAX_UPLOAD_SIZE;
18
19class UserService {
20    public function __construct(
21        private UserRepository $repository,
22        private DB $db
23    ) {}
24
25    public function createUser(string $name): User {
26        return new User($name);
27    }
28}
29?>

1<?php
2namespace App\Utils;
3
4class DateTime {
5    // Custom DateTime class
6}
7
8class DateFormatter {
9    public function format(): void {
10        // Use custom DateTime from current namespace
11        $custom = new DateTime();
12
13        // Use global DateTime class
14        $global = new \DateTime();
15
16        // Fully qualified class name
17        $user = new \App\Models\User('John', '[email protected]');
18    }
19}
20?>

1<?php
2namespace App\Config;
3
4const APP_NAME = 'My Application';
5const APP_VERSION = '1.0.0';
6const DEBUG_MODE = true;
7
8function getConfig(string $key): mixed {
9    return match($key) {
10        'name' => APP_NAME,
11        'version' => APP_VERSION,
12        'debug' => DEBUG_MODE,
13        default => null
14    };
15}
16
17// In another file:
18namespace App;
19
20use const App\Config\APP_NAME;
21use function App\Config\getConfig;
22
23echo APP_NAME . "\n";
24echo getConfig('version') . "\n";
25?>

1src/
2├── Controllers/
3│   ├── UserController.php
4│   └── PostController.php
5├── Models/
6│   ├── User.php
7│   └── Post.php
8├── Services/
9│   ├── UserService.php
10│   └── EmailService.php
11└── Repositories/
12    ├── UserRepository.php
13    └── PostRepository.php

1{
2    "autoload": {
3        "psr-4": {
4            "App\\": "src/"
5        }
6    }
7}

1<?php
2// File: src/Controllers/UserController.php
3namespace App\Controllers;
4
5use App\Services\UserService;
6use App\Models\User;
7
8class UserController {
9    public function __construct(
10        private UserService $service
11    ) {}
12
13    public function index(): array {
14        return $this->service->getAllUsers();
15    }
16}
17
18// File: src/Services/UserService.php
19namespace App\Services;
20
21use App\Repositories\UserRepository;
22use App\Models\User;
23
24class UserService {
25    public function __construct(
26        private UserRepository $repository
27    ) {}
28
29    public function getAllUsers(): array {
30        return $this->repository->findAll();
31    }
32
33    public function createUser(array $data): User {
34        return $this->repository->create($data);
35    }
36}
37
38// File: src/Models/User.php
39namespace App\Models;
40
41class User {
42    public function __construct(
43        private int $id,
44        private string $name,
45        private string $email
46    ) {}
47
48    public function getId(): int {
49        return $this->id;
50    }
51
52    public function getName(): string {
53        return $this->name;
54    }
55}
56
57// File: src/Repositories/UserRepository.php
58namespace App\Repositories;
59
60use App\Models\User;
61
62class UserRepository {
63    public function findAll(): array {
64        // Fetch from database
65        return [
66            new User(1, 'John', '[email protected]'),
67            new User(2, 'Jane', '[email protected]')
68        ];
69    }
70
71    public function create(array $data): User {
72        // Insert into database
73        return new User(
74            random_int(1, 1000),
75            $data['name'],
76            $data['email']
77        );
78    }
79}
80?>

1<?php
2// File: public/index.php
3require __DIR__ . '/../vendor/autoload.php';
4
5use App\Controllers\UserController;
6use App\Services\UserService;
7use App\Repositories\UserRepository;
8
9// Classes are automatically loaded
10$repository = new UserRepository();
11$service = new UserService($repository);
12$controller = new UserController($service);
13
14$users = $controller->index();
15
16foreach ($users as $user) {
17    echo $user->getName() . " - " . $user->getEmail() . "\n";
18}
19?>

1<?php
2// File: src/Traits/Timestampable.php
3namespace App\Traits;
4
5use DateTime;
6
7trait Timestampable {
8    protected DateTime $createdAt;
9    protected DateTime $updatedAt;
10
11    public function initTimestamps(): void {
12        $this->createdAt = new DateTime();
13        $this->updatedAt = new DateTime();
14    }
15
16    public function touch(): void {
17        $this->updatedAt = new DateTime();
18    }
19}
20
21// File: src/Traits/SoftDeletes.php
22namespace App\Traits;
23
24use DateTime;
25
26trait SoftDeletes {
27    protected ?DateTime $deletedAt = null;
28
29    public function delete(): void {
30        $this->deletedAt = new DateTime();
31    }
32
33    public function restore(): void {
34        $this->deletedAt = null;
35    }
36
37    public function isDeleted(): bool {
38        return $this->deletedAt !== null;
39    }
40}
41
42// File: src/Models/Post.php
43namespace App\Models;
44
45use App\Traits\Timestampable;
46use App\Traits\SoftDeletes;
47
48class Post {
49    use Timestampable, SoftDeletes;
50
51    public function __construct(private string $title) {
52        $this->initTimestamps();
53    }
54}
55?>

1<?php
2namespace App\Repositories;
3
4trait HasPagination {
5    protected int $perPage = 15;
6
7    public function paginate(int $page): array {
8        $offset = ($page - 1) * $this->perPage;
9        return $this->query()
10            ->limit($this->perPage)
11            ->offset($offset)
12            ->get();
13    }
14
15    public function setPerPage(int $perPage): void {
16        $this->perPage = $perPage;
17    }
18
19    abstract protected function query();
20}
21
22trait HasFilters {
23    protected array $filters = [];
24
25    public function where(string $column, mixed $value): self {
26        $this->filters[$column] = $value;
27        return $this;
28    }
29
30    public function getFilters(): array {
31        return $this->filters;
32    }
33}
34
35abstract class BaseRepository {
36    use HasPagination, HasFilters;
37
38    abstract public function find(int $id);
39    abstract public function findAll(): array;
40}
41
42class UserRepository extends BaseRepository {
43    public function find(int $id) {
44        // Implementation
45    }
46
47    public function findAll(): array {
48        // Implementation
49    }
50
51    protected function query() {
52        // Return query builder
53    }
54}
55?>

1<?php
2namespace App\Services;
3
4use App\Traits\Loggable;
5use App\Repositories\UserRepository;
6use App\Events\UserCreated;
7
8class UserService {
9    use Loggable;
10
11    public function __construct(
12        private UserRepository $repository
13    ) {}
14
15    public function createUser(array $data): User {
16        $this->log('Creating new user: ' . $data['email']);
17
18        try {
19            $user = $this->repository->create($data);
20            $this->log('User created successfully: ' . $user->getId());
21
22            // Dispatch event
23            event(new UserCreated($user));
24
25            return $user;
26        } catch (\Exception $e) {
27            $this->log('User creation failed: ' . $e->getMessage());
28            throw $e;
29        }
30    }
31}
32?>

1<?php
2namespace App\Container;
3
4class Container {
5    private array $bindings = [];
6    private array $instances = [];
7
8    public function bind(string $abstract, callable $concrete): void {
9        $this->bindings[$abstract] = $concrete;
10    }
11
12    public function singleton(string $abstract, callable $concrete): void {
13        $this->bindings[$abstract] = function() use ($abstract, $concrete) {
14            if (!isset($this->instances[$abstract])) {
15                $this->instances[$abstract] = $concrete($this);
16            }
17            return $this->instances[$abstract];
18        };
19    }
20
21    public function make(string $abstract) {
22        if (isset($this->bindings[$abstract])) {
23            return $this->bindings[$abstract]($this);
24        }
25
26        throw new \Exception("No binding found for: $abstract");
27    }
28}
29
30// Usage:
31use App\Services\UserService;
32use App\Repositories\UserRepository;
33
34$container = new Container();
35
36$container->singleton(UserRepository::class, function() {
37    return new UserRepository();
38});
39
40$container->bind(UserService::class, function($container) {
41    return new UserService(
42        $container->make(UserRepository::class)
43    );
44});
45
46$service = $container->make(UserService::class);
47?>