类型声明 #

<?php
function add(int $a, int $b): int
{
    return $a + $b;
}

<?php
declare(strict_types=1);

function add(int $a, int $b): int
{
    return $a + $b;
}

add(1, 2);
add("1", "2");

<?php
function process(
    int $integer,
    float $float,
    string $string,
    bool $boolean
): void {
    var_dump($integer, $float, $string, $boolean);
}

process(42, 3.14, "hello", true);

<?php
function processArray(array $data): void
{
    print_r($data);
}

function processObject(object $obj): void
{
    var_dump($obj);
}

function processCallable(callable $fn): void
{
    $fn();
}

<?php
class User {}

function greet(User $user): string
{
    return "Hello!";
}

$user = new User();
greet($user);

<?php
interface LoggerInterface
{
    public function log(string $message): void;
}

function setLogger(LoggerInterface $logger): void
{
    $this->logger = $logger;
}

<?php
class ParentClass {}

class ChildClass extends ParentClass
{
    public function create(): self
    {
        return new self();
    }
    
    public function getParent(): parent
    {
        return new ParentClass();
    }
}

<?php
function getInt(): int
{
    return 42;
}

function getFloat(): float
{
    return 3.14;
}

function getString(): string
{
    return "Hello";
}

function getBool(): bool
{
    return true;
}

function getArray(): array
{
    return [1, 2, 3];
}

<?php
function logMessage(string $message): void
{
    echo $message;
}

function setConfig(array $config): void
{
    $this->config = $config;
}

<?php
function redirect(string $url): never
{
    header("Location: $url");
    exit;
}

function throwError(string $message): never
{
    throw new Exception($message);
}

function infiniteLoop(): never
{
    while (true) {
        
    }
}

<?php
function findUser(int $id): ?User
{
    if ($id <= 0) {
        return null;
    }
    return new User($id);
}

function process(?string $value): string
{
    return $value ?? "default";
}

<?php
function greet(?string $name = null): string
{
    return "Hello, " . ($name ?? "Guest");
}

greet();
greet(null);
greet("John");

<?php
function process(?string $input): ?string
{
    if ($input === null) {
        return null;
    }
    return strtoupper($input);
}

<?php
function process(int|float $number): string
{
    return "Number: $number";
}

echo process(42);
echo process(3.14);

<?php
function format(string|int|float $value): string
{
    return (string) $value;
}

function process(array|Collection $items): int
{
    return count($items);
}

<?php
class PdfExporter {}
class CsvExporter {}

function export(PdfExporter|CsvExporter $exporter): string
{
    return $exporter->export();
}

<?php
function process(int|string|null $value): string
{
    return (string) $value;
}

function process(?int $value): ?string
{
    return $value === null ? null : (string) $value;
}

<?php
interface Serializable
{
    public function serialize(): string;
}

interface Jsonable
{
    public function toJson(): string;
}

function process(Serializable&Jsonable $object): void
{
    echo $object->serialize();
    echo $object->toJson();
}

<?php
interface HasId
{
    public function getId(): int;
}

interface HasName
{
    public function getName(): string;
}

function display(HasId&HasName $entity): void
{
    echo "ID: {$entity->getId()}, Name: {$entity->getName()}";
}

<?php
function process(mixed $value): mixed
{
    return $value;
}

process(42);
process("hello");
process([1, 2, 3]);
process(new stdClass());
process(null);

<?php
function process(
    array|bool|callable|int|float|null|object|resource|string $value
): void {}

<?php
class Entity
{
    public static function create(): static
    {
        return new static();
    }
}

class User extends Entity {}

$user = User::create();

<?php
function process(iterable $items): void
{
    foreach ($items as $item) {
        echo $item;
    }
}

process([1, 2, 3]);
process(new ArrayIterator([1, 2, 3]));

<?php
function execute(callable $fn, mixed ...$args): mixed
{
    return $fn(...$args);
}

echo execute('strtoupper', 'hello');
echo execute(fn($n) => $n * 2, 5);

<?php
function add(int $a, int $b): int
{
    return $a + $b;
}

echo add("1", "2");
echo add(1.5, 2.5);

<?php
declare(strict_types=1);

function add(int $a, int $b): int
{
    return $a + $b;
}

echo add(1, 2);
echo add("1", "2");

<?php
function process(int $value): int
{
    return $value;
}

echo process("42");
echo process(42.9);
echo process(true);

<?php
class UserService
{
    public function __construct(
        private UserRepository $repository,
        private LoggerInterface $logger
    ) {}
    
    public function find(int $id): ?User
    {
        $this->logger->log("Finding user: $id");
        return $this->repository->find($id);
    }
    
    public function create(array $data): User
    {
        return $this->repository->create($data);
    }
}

<?php
interface LoggerInterface {}
class FileLogger implements LoggerInterface {}
class DatabaseLogger implements LoggerInterface {}

class LoggerFactory
{
    public function create(string $type): LoggerInterface
    {
        return match($type) {
            'file' => new FileLogger(),
            'database' => new DatabaseLogger(),
            default => throw new InvalidArgumentException("Unknown type: $type")
        };
    }
}

<?php
class UserDTO
{
    public function __construct(
        public readonly int $id,
        public readonly string $name,
        public readonly string $email,
        public readonly ?string $phone = null
    ) {}
}

function createUser(UserDTO $data): User
{
    return new User($data->name, $data->email);
}

<?php
declare(strict_types=1);

function process(string $input): string
{
    return trim($input);
}

<?php
function process(array $data): array
{
    return $data;
}

function process(mixed $data): mixed
{
    return $data;
}

<?php
function save(LoggerInterface $logger): void
{
    $logger->log("Saved");
}

<?php
function find(int $id): ?User
{
    return $this->repository->find($id);
}

function get(int $id): User
{
    return $this->repository->findOrFail($id);
}