Verwenden Sie Verschlussfunktionen in Kombination mit IS_A (), um flexible Richter zu erreichen

In PHP wird die IS_A -Funktion verwendet, um festzustellen, ob ein Objekt eine Instanz einer Klasse oder ihrer Unterklasse ist. Es ist sehr geeignet für die Typuserkennung. Wenn Sie jedoch einen flexibleren und erweiterbareren Richter schreiben möchten, können Sie Schließungen (anonyme Funktionen) kombinieren, um eine dynamische Beurteilungslogik zu implementieren, wodurch ein Schreiben einer Reihe von Duplikat -If- oder Schaltanweisungen vermieden wird.

Lassen Sie uns einen Schritt-für-Schritt-Überblick über das Schreiben eines flexiblen Typ-Richters mit der IS_A- Funktion kombiniert mit dem Verschluss schreiben.

1. Eine einfache IS_A -Nutzungsbewertung

 <?php
class Animal {}
class Dog extends Animal {}

$dog = new Dog();

var_dump(is_a($dog, 'Dog'));      // bool(true)
var_dump(is_a($dog, 'Animal'));   // bool(true)
var_dump(is_a($dog, 'Cat'));      // bool(false)
?>

IS_A kann bestimmen, ob ein Objekt eine Instanz einer bestimmten Klasse oder ihrer Unterklasse ist, die uns die Grundlage für uns zur Beurteilung des Typs bietet.

2. verwenden

Wir können Schließungen verwenden, um verschiedene Urteilsregeln zu definieren und sie dann mit einer einheitlichen Schnittstelle aufzurufen.

 <?php
$typeCheckers = [
    'dog' => function($obj) {
        return is_a($obj, 'Dog');
    },
    'animal' => function($obj) {
        return is_a($obj, 'Animal');
    },
    'string' => function($obj) {
        return is_string($obj);
    }
];

// Beispiel für die Nutzung
function checkType($obj, $type, $checkers) {
    if (!isset($checkers[$type])) {
        throw new InvalidArgumentException("Unbekannter Typ: $type");
    }
    return $checkers[$type]($obj);
}

$dog = new Dog();
var_dump(checkType($dog, 'dog', $typeCheckers));      // bool(true)
var_dump(checkType($dog, 'animal', $typeCheckers));   // bool(true)
var_dump(checkType("hello", 'string', $typeCheckers));// bool(true)
?>

Auf diese Weise muss das $ typecheckers -Array nur eine Abschluss eines neuen Typs zum Typen hinzufügen und die Flexibilität des Codes erheblich verbessert.

3.. Unterstützen Sie die Parameter der Klassennamen und die dynamische Erweiterung

Manchmal müssen wir dynamisch einen Richter basierend auf dem Klassennamen erstellen, und wir können eine Funktion schreiben, die uns dabei hilft, schnell Schließungen zu erzeugen:

 <?php
function makeIsATypeChecker(string $className) {
    return function($obj) use ($className) {
        return is_a($obj, $className);
    };
}

$typeCheckers['cat'] = makeIsATypeChecker('Cat');

// prüfen
class Cat extends Animal {}
$cat = new Cat();
var_dump(checkType($cat, 'cat', $typeCheckers)); // bool(true)
?>

Dies macht unser Typ -Richter -System vielseitiger und leicht zu warten.

4. Kombinieren Sie die Schnittstelle und die übergeordnete Klassen-Multi-Konditions-Urteilsvermögen

Manchmal müssen wir feststellen, ob das Objekt eine bestimmte Schnittstelle implementiert oder eine bestimmte Elternklasse erbt, und wir können einen allgemeineren Richter schreiben:

 <?php
function makeClassOrInterfaceChecker(string $name) {
    return function($obj) use ($name) {
        return is_a($obj, $name) || in_array($name, class_implements($obj));
    };
}

interface Pet {}
class Dog extends Animal implements Pet {}

$typeCheckers['pet'] = makeClassOrInterfaceChecker('Pet');

$dog = new Dog();
var_dump(checkType($dog, 'pet', $typeCheckers)); // bool(true)
?>

Auf diese Weise ist es sehr flexibel, sowohl die Vererbungsbeziehung als auch die Implementierung der Schnittstelle zu beurteilen.

5. umfassender Beispielcode

 <?php
class Animal {}
class Dog extends Animal {}
class Cat extends Animal {}

interface Pet {}

class DogPet extends Dog implements Pet {}

function checkType($obj, $type, $checkers) {
    if (!isset($checkers[$type])) {
        throw new InvalidArgumentException("Unbekannter Typ: $type");
    }
    return $checkers[$type]($obj);
}

function makeIsATypeChecker(string $className) {
    return function($obj) use ($className) {
        return is_a($obj, $className);
    };
}

function makeClassOrInterfaceChecker(string $name) {
    return function($obj) use ($name) {
        return is_a($obj, $name) || in_array($name, class_implements($obj));
    };
}

$typeCheckers = [
    'dog' => makeIsATypeChecker('Dog'),
    'animal' => makeIsATypeChecker('Animal'),
    'pet' => makeClassOrInterfaceChecker('Pet'),
    'string' => function($obj) { return is_string($obj); },
];

// prüfen
$dog = new Dog();
$cat = new Cat();
$dogPet = new DogPet();

var_dump(checkType($dog, 'dog', $typeCheckers));      // true
var_dump(checkType($cat, 'animal', $typeCheckers));   // true
var_dump(checkType($dogPet, 'pet', $typeCheckers));   // true
var_dump(checkType("hello", 'string', $typeCheckers));// true
?>

Auf diese Weise können Sie problemlos einen flexiblen und skalierbaren Richter für eine Vielzahl komplexer Geschäftsanforderungen erstellen.