Français
Français
Dans le développement quotidien de PHP, nous devons souvent vérifier si la variable est une instance d'une classe spécifique. Bien que PHP fournit une variété de façons de juger les types, tels que l'opérateur d'instance OFF , la fonction IS_A () est devenue le premier choix pour de nombreux développeurs en raison de sa flexibilité et de sa simplicité.
Cet article vous mènera étape par étape pour créer une classe d'outils de vérification de type simple basée sur la fonction is_a () , vous aidant à juger rapidement les types d'objets et à améliorer la lisibilité et la réutilisabilité du code.
IS_A () est une fonction intégrée fournie par PHP, qui est utilisée pour déterminer si un objet appartient à une certaine classe ou à une sous-classe de cette classe.
bool is_a(object|string $object_or_class, string $class, bool $allow_string = false)
$ object_or_class : le nom de l'objet ou de la classe à vérifier.
$ Classe : Nom de la classe cible.
$ allow_string : s'il faut passer le nom de l'objet dans les chaînes (pour les appels statiques).
Nous utiliserons la fonction is_a () pour encapsuler une classe d'outils simple TypeChecker pour simplifier et gérer de manière centralisée la logique de jugement de type.
<code>
class TypeChecker
{
/**
* Déterminez si l'objet est une instance d'une certaine classe
*
* @param object|string $objectOrClass
* @param string $expectedClass
* @param bool $allowString
* @return bool
*/
public static function isInstanceOf($objectOrClass, string $expectedClass, bool $allowString = false): bool
{
return is_a($objectOrClass, $expectedClass, $allowString);
}
/**
* Vérification par lots de plusieurs types d'objets
*
* @param array $objectsWithExpectedClasses
* @return array
*/
public static function validateMultiple(array $objectsWithExpectedClasses): array
{
$results = [];
foreach ($objectsWithExpectedClasses as $label => [$objectOrClass, $expectedClass]) {
$results[$label] = self::isInstanceOf($objectOrClass, $expectedClass);
}
return $results;
}
}
</code>
Cette classe fournit deux méthodes:
isInstanceOf () : Vérifiez le type d'un seul objet.
ValidateMultiple () : prend en charge la vérification par lots de la correspondance entre les objets et les classes.
Voyons comment cette classe d'outils est utilisée dans les projets réels.
<code>
interface LoggerInterface {}
class FileLogger implements LoggerInterface {}
class MailLogger {}
$logger1 = new FileLogger();
$logger2 = new MailLogger();
// Vérification unique
if (TypeChecker::isInstanceOf($logger1, LoggerInterface::class)) {
echo "logger1 Oui LoggerInterface Exemples\n";
}
// Vérification par lots
$results = TypeChecker::validateMultiple([
'fileLogger' => [$logger1, LoggerInterface::class],
'mailLogger' => [$logger2, LoggerInterface::class],
]);
print_r($results);
</code>
Le résultat de sortie est le suivant:
logger1 Oui LoggerInterface Exemples
Array
(
[fileLogger] => 1
[mailLogger] =>
)
Supposons que vous développez une classe d'usine qui charge dynamiquement la classe à partir du fichier de configuration et instancie l'objet. Vous pouvez utiliser TypeChecker pour vous assurer que ces classes implémentent l'interface souhaitée et éviter les erreurs de type au moment de l'exécution.
<code>
class LoggerFactory
{
public static function create(string $className): LoggerInterface
{
$instance = new $className();
if (!TypeChecker::isInstanceOf($instance, LoggerInterface::class)) {
throw new InvalidArgumentException("gentil $className Doit être atteint LoggerInterface interface");
}
return $instance;
}
}
$logger = LoggerFactory::create('FileLogger'); // normale
$logger = LoggerFactory::create('MailLogger'); // faire une exception
</code>
L'encapsulation d'une classe d'outils de vérification de type simple via IS_A () peut considérablement améliorer la robustesse et la lisibilité du code. Que ce soit pour la détection de type de base dans des projets de petite et moyenne taille, ou en tant que couche de vérification de la sécurité dans de grands cadres, il peut être utile.
Si vous souhaitez créer davantage un système de vérification complet, vous pouvez même ajouter une logique telle que la source d'URL et les classes d'injection de dépendance à vérifier. Par exemple, la vérification du registre des services si une classe implémente l'interface nécessaire ou hérite d'une classe de base spécifique peut empêcher les erreurs cachées dans la logique métier:
