Learn PHP Programming

<?php
declare(strict_types=1);

interface Storable {
    public function save(): bool;
    public function delete(): bool;
    public function findById(int $id): ?array;
}

interface Validatable {
    public function validate(): bool;
    public function getErrors(): array;
}

// Interface constants
interface HttpStatus {
    const OK = 200;
    const NOT_FOUND = 404;
    const SERVER_ERROR = 500;
}

// A class implementing multiple interfaces
class UserRepository implements Storable, Validatable, HttpStatus {
    private array $errors = [];
    private array $data = [];

    public function __construct(private string $name, private string $email) {}

    public function validate(): bool {
        $this->errors = [];
        if (empty($this->name)) {
            $this->errors[] = 'Name is required';
        }
        if (!filter_var($this->email, FILTER_VALIDATE_EMAIL)) {
            $this->errors[] = 'Invalid email';
        }
        return empty($this->errors);
    }

    public function getErrors(): array { return $this->errors; }

    public function save(): bool {
        if (!$this->validate()) return false;
        $this->data[] = ['name' => $this->name, 'email' => $this->email];
        return true;
    }

    public function delete(): bool { return true; }
    public function findById(int $id): ?array { return $this->data[$id] ?? null; }
}

// Type-hint against the interface for flexibility
function persist(Storable $entity): int {
    return $entity->save() ? HttpStatus::OK : HttpStatus::SERVER_ERROR;
}

$repo = new UserRepository('Alice', 'alice@test.com');
echo persist($repo);  // 200
?>

<?php
trait Timestamps {
    private ?string $createdAt = null;
    private ?string $updatedAt = null;

    public function setCreatedAt(): void {
        $this->createdAt = date('Y-m-d H:i:s');
    }

    public function setUpdatedAt(): void {
        $this->updatedAt = date('Y-m-d H:i:s');
    }

    public function getTimestamps(): array {
        return ['created' => $this->createdAt, 'updated' => $this->updatedAt];
    }
}

trait SoftDelete {
    private ?string $deletedAt = null;

    public function softDelete(): void { $this->deletedAt = date('Y-m-d H:i:s'); }
    public function restore(): void { $this->deletedAt = null; }
    public function isTrashed(): bool { return $this->deletedAt !== null; }
}

trait HasSlug {
    public function slugify(string $text): string {
        return preg_replace('/-+/', '-', preg_replace('/[^a-z0-9-]/', '-', strtolower(trim($text))));
    }
}

// Using multiple traits in a single class
class BlogPost {
    use Timestamps, SoftDelete, HasSlug;

    private string $slug;

    public function __construct(private string $title, private string $body) {
        $this->slug = $this->slugify($title);
        $this->setCreatedAt();
    }

    public function getSlug(): string { return $this->slug; }
}

$post = new BlogPost('My First Post!', 'Content...');
echo $post->getSlug();      // my-first-post-
echo $post->isTrashed();    // false
$post->softDelete();
echo $post->isTrashed();    // true
$post->restore();
echo $post->isTrashed();    // false
?>

<?php
trait JsonOutput {
    public function render(array $data): string {
        return json_encode($data);
    }
    public function contentType(): string { return 'application/json'; }
}

trait XmlOutput {
    public function render(array $data): string {
        $xml = '<root>';
        foreach ($data as $key => $val) {
            $xml .= "<{$key}>{$val}</{$key}>";
        }
        return $xml . '</root>';
    }
    public function contentType(): string { return 'application/xml'; }
}

class ApiResponse {
    // Resolve conflicts: choose which trait method wins
    use JsonOutput, XmlOutput {
        JsonOutput::render insteadof XmlOutput;        // JSON render wins
        XmlOutput::render as renderXml;                // Alias XML version
        JsonOutput::contentType insteadof XmlOutput;   // JSON contentType wins
        XmlOutput::contentType as xmlContentType;      // Alias XML version
    }
}

$response = new ApiResponse();
echo $response->render(['status' => 'ok']);       // {"status":"ok"}
echo $response->renderXml(['status' => 'ok']);    // <root><status>ok</status></root>
echo $response->contentType();                      // application/json

// Changing visibility with 'as'
trait InternalHelper {
    public function compute(): int { return 42; }
}

class Service {
    use InternalHelper {
        compute as private;  // Make public method private in this class
    }

    public function getResult(): int {
        return $this->compute() * 2;  // Can still use internally
    }
}
?>

<?php
// Interface constants — shared across all implementations
interface Priority {
    const LOW = 1;
    const MEDIUM = 5;
    const HIGH = 10;
}

// PHP 8.1 Enums — modern type-safe alternative to interface constants
enum Status: string {
    case Active = 'active';
    case Inactive = 'inactive';
    case Suspended = 'suspended';

    // Enums can have methods
    public function label(): string {
        return match($this) {
            Status::Active => '✓ Active',
            Status::Inactive => '✗ Inactive',
            Status::Suspended => '⚠ Suspended',
        };
    }

    public function canLogin(): bool {
        return $this === self::Active;
    }
}

// Enums can implement interfaces
interface HasColor {
    public function color(): string;
}

enum Role: string implements HasColor {
    case Admin = 'admin';
    case Editor = 'editor';
    case Viewer = 'viewer';

    public function color(): string {
        return match($this) {
            self::Admin => 'red',
            self::Editor => 'blue',
            self::Viewer => 'gray',
        };
    }
}

// Usage with type safety
function setUserStatus(Status $status): string {
    return "Status set to: {$status->label()}";
}

echo setUserStatus(Status::Active);    // Status set to: ✓ Active
echo Status::Suspended->canLogin();   // false
echo Role::Admin->color();            // red

// Enums are comparable and enumerable
$all = Status::cases();  // Array of all enum values
echo Status::Active->value;  // "active"
echo Status::from('inactive') === Status::Inactive;  // true
?>