类型检测 #

<?php
echo gettype(42);
echo gettype(3.14);
echo gettype("hello");
echo gettype(true);
echo gettype([1, 2, 3]);
echo gettype(new stdClass());
echo gettype(null);
echo gettype(fopen('php://stdin', 'r'));

<?php
echo get_debug_type(42);
echo get_debug_type(3.14);
echo get_debug_type("hello");
echo get_debug_type(true);
echo get_debug_type([1, 2, 3]);
echo get_debug_type(new stdClass());
echo get_debug_type(null);

<?php
var_dump(is_int(42));
var_dump(is_int(3.14));
var_dump(is_integer(42));

var_dump(is_float(3.14));
var_dump(is_float(42));
var_dump(is_double(3.14));

var_dump(is_string("hello"));
var_dump(is_string(42));

var_dump(is_bool(true));
var_dump(is_bool(1));

<?php
var_dump(is_array([1, 2, 3]));
var_dump(is_array("array"));

var_dump(is_object(new stdClass()));
var_dump(is_object([]));

var_dump(is_callable('strlen'));
var_dump(is_callable(['DateTime', 'createFromFormat']));
var_dump(is_callable(function() {}));

var_dump(is_iterable([1, 2, 3]));
var_dump(is_iterable(new ArrayIterator([1, 2])));

<?php
var_dump(is_null(null));
var_dump(is_null(0));
var_dump(is_null(""));

$fp = fopen('php://stdin', 'r');
var_dump(is_resource($fp));
fclose($fp);
var_dump(is_resource($fp));

<?php
var_dump(is_numeric(42));
var_dump(is_numeric(3.14));
var_dump(is_numeric("42"));
var_dump(is_numeric("3.14"));
var_dump(is_numeric("42abc"));
var_dump(is_numeric("0x1A"));

var_dump(is_scalar(42));
var_dump(is_scalar("hello"));
var_dump(is_scalar([1, 2, 3]));

<?php
declare(strict_types=1);

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

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

<?php
declare(strict_types=1);

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

include 'non_strict_file.php';

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

echo add("10", "20");
echo add(10.5, 20.5);

<?php
function greet(string $name): void
{
    echo "Hello, $name";
}

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

function process(array $data): void
{
    print_r($data);
}

<?php
function getName(): string
{
    return "John";
}

function getAge(): int
{
    return 25;
}

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

function getUser(): ?User
{
    return new User();
}

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

function process(?string $value): void
{
    if ($value !== null) {
        echo $value;
    }
}

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

<?php
function process(mixed $value): mixed
{
    if (is_int($value)) {
        return $value * 2;
    }
    if (is_string($value)) {
        return strtoupper($value);
    }
    return $value;
}

<?php
function format(int|float $number): string
{
    return number_format($number, 2);
}

function getId(): int|string
{
    return $this->id;
}

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

<?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
declare(strict_types=1);

class UserService
{
    public function find(int $id): ?User
    {
        return $this->repository->find($id);
    }
    
    public function create(array $data): User
    {
        return $this->repository->create($data);
    }
}

<?php
function processInput(mixed $input): string
{
    if (!is_string($input)) {
        throw new InvalidArgumentException(
            "Expected string, got " . get_debug_type($input)
        );
    }
    
    return trim($input);
}

<?php
function divide(float $a, float $b): float
{
    assert($b !== 0.0, "Divisor cannot be zero");
    return $a / $b;
}

<?php
class TypeHelper
{
    public static function ensureInt(mixed $value): int
    {
        if (!is_int($value)) {
            throw new TypeError(
                "Expected int, got " . get_debug_type($value)
            );
        }
        return $value;
    }
    
    public static function ensureString(mixed $value): string
    {
        if (!is_string($value)) {
            throw new TypeError(
                "Expected string, got " . get_debug_type($value)
            );
        }
        return $value;
    }
}

<?php
class User {}
class Admin extends User {}

$user = new User();
$admin = new Admin();

var_dump($user instanceof User);
var_dump($admin instanceof User);
var_dump($user instanceof Admin);

<?php
interface Loggable {}
class User implements Loggable {}

$user = new User();
var_dump($user instanceof Loggable);

<?php
if (!($user instanceof Admin)) {
    echo "需要管理员权限";
}

<?php
$className = 'User';
var_dump($user instanceof $className);

<?php
$a = 42;
$b = "hello";
$c = [1, 2, 3];
$d = new DateTime();

<?php
function getValue()
{
    return 42;
}

echo gettype(getValue());