函数返回值 #

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

$result = add(1, 2);
echo $result;

<?php
function divide(float $a, float $b): ?float
{
    if ($b === 0.0) {
        return null;
    }
    return $a / $b;
}

echo divide(10, 2);
echo divide(10, 0);

<?php
function getGrade(int $score): string
{
    if ($score >= 90) return "A";
    if ($score >= 80) return "B";
    if ($score >= 70) return "C";
    if ($score >= 60) return "D";
    return "F";
}

echo getGrade(85);

<?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
class User
{
    public function __construct(
        public string $name
    ) {}
}

function createUser(string $name): User
{
    return new User($name);
}

$user = createUser("John");
echo $user->name;

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

class FileLogger implements LoggerInterface
{
    public function log(string $message): void
    {
        file_put_contents('app.log', $message . "\n", FILE_APPEND);
    }
}

function createLogger(): LoggerInterface
{
    return new FileLogger();
}

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

$user = findUser(1);
if ($user !== null) {
    echo $user->name;
}

<?php
function logMessage(string $message): void
{
    echo "[" . date('Y-m-d H:i:s') . "] $message\n";
}

logMessage("Application started");

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

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

<?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;
}

echo format("hello");
echo format(42);
echo format(3.14);

<?php
function getName(): string|null
{
    return $this->name;
}

function getName(): ?string
{
    return $this->name;
}

<?php
function getMinMax(array $numbers): array
{
    return [
        'min' => min($numbers),
        'max' => max($numbers),
        'avg' => array_sum($numbers) / count($numbers)
    ];
}

$result = getMinMax([1, 2, 3, 4, 5]);
echo "Min: {$result['min']}, Max: {$result['max']}, Avg: {$result['avg']}";

<?php
function getCoordinates(): array
{
    return [10, 20];
}

[$x, $y] = getCoordinates();
echo "X: $x, Y: $y";

<?php
function parseUrl(string $url): array
{
    return [
        'scheme' => parse_url($url, PHP_URL_SCHEME),
        'host' => parse_url($url, PHP_URL_HOST),
        'path' => parse_url($url, PHP_URL_PATH),
    ];
}

['host' => $host, 'path' => $path] = parseUrl('https://example.com/page');
echo "Host: $host, Path: $path";

<?php
class Result
{
    public function __construct(
        public bool $success,
        public mixed $data = null,
        public ?string $error = null
    ) {}
}

function fetchData(int $id): Result
{
    if ($id <= 0) {
        return new Result(false, null, "Invalid ID");
    }
    return new Result(true, ['id' => $id, 'name' => "Item $id"]);
}

$result = fetchData(1);
if ($result->success) {
    print_r($result->data);
}

<?php
class Counter
{
    private int $count = 0;
    
    public function &getCount(): int
    {
        return $this->count;
    }
}

$counter = new Counter();
$count = &$counter->getCount();
$count = 10;

<?php
class Collection
{
    private array $items = [];
    
    public function &getItem(int $index): mixed
    {
        return $this->items[$index];
    }
    
    public function setItem(int $index, mixed $value): void
    {
        $this->items[$index] = $value;
    }
}

$collection = new Collection();
$collection->setItem(0, 'original');
$item = &$collection->getItem(0);
$item = 'modified';

<?php
function &getReference(): int
{
    static $value = 0;
    return $value;
}

$ref = &getReference();
$ref = 10;
echo getReference();

<?php
declare(strict_types=1);

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

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

<?php
function createEmail(string $address): ?Email
{
    if (!filter_var($address, FILTER_VALIDATE_EMAIL)) {
        return null;
    }
    return new Email($address);
}

$email = createEmail('user@example.com');
if ($email === null) {
    throw new InvalidArgumentException("Invalid email");
}

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

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

<?php
class QueryBuilder
{
    private array $select = [];
    private string $table = '';
    private array $where = [];
    
    public function select(array $columns): self
    {
        $this->select = $columns;
        return $this;
    }
    
    public function from(string $table): self
    {
        $this->table = $table;
        return $this;
    }
    
    public function where(string $condition): self
    {
        $this->where[] = $condition;
        return $this;
    }
    
    public function build(): string
    {
        $sql = "SELECT " . implode(', ', $this->select);
        $sql .= " FROM " . $this->table;
        
        if (!empty($this->where)) {
            $sql .= " WHERE " . implode(' AND ', $this->where);
        }
        
        return $sql;
    }
}

$query = (new QueryBuilder())
    ->select(['id', 'name'])
    ->from('users')
    ->where('active = 1')
    ->build();

<?php
class Result
{
    private function __construct(
        private bool $success,
        private mixed $value,
        private ?string $error
    ) {}
    
    public static function ok(mixed $value): self
    {
        return new self(true, $value, null);
    }
    
    public static function error(string $error): self
    {
        return new self(false, null, $error);
    }
    
    public function isSuccess(): bool
    {
        return $this->success;
    }
    
    public function getValue(): mixed
    {
        return $this->value;
    }
    
    public function getError(): ?string
    {
        return $this->error;
    }
}

function divide(float $a, float $b): Result
{
    if ($b === 0.0) {
        return Result::error("Division by zero");
    }
    return Result::ok($a / $b);
}

$result = divide(10, 2);
if ($result->isSuccess()) {
    echo $result->getValue();
} else {
    echo $result->getError();
}

<?php
function findUser(int $id): ?User
{
    
}

<?php
function log(string $message): void
{
    file_put_contents('app.log', $message . "\n", FILE_APPEND);
}

<?php
function process(array $data): array|false
{
    if (empty($data)) {
        return false;
    }
    return $data;
}

function process(array $data): ?array
{
    if (empty($data)) {
        return null;
    }
    return $data;
}

<?php
function fetchData(int $id): Result
{
    if ($id <= 0) {
        return Result::error("Invalid ID");
    }
    return Result::ok($this->repository->find($id));
}