Français
Français
Lorsque vous utilisez PDO pour les opérations de base de données, Pdostation :: FetchObject est une méthode très pratique, qui peut dire directement une ligne de données du résultat de la requête dans un objet. Cependant, par défaut, si la base de données renvoie les champs avec des traits de soulignement ou nommés dans différents styles, l'utilisation de fetchObject ne peut pas mapper correctement ces champs aux propriétés de l'objet. Cet article expliquera en détail comment gérer cette situation gracieusement.
Supposons que les utilisateurs de votre table de base de données aient les champs suivants:
identifiant
nom d'utilisateur
email_address
Généralement, nous pouvons interroger ceci:
<?php
$pdo = new PDO('mysql:host=localhost;dbname=testdb', 'root', 'password');
$stmt = $pdo->query('SELECT id, user_name, email_address FROM users WHERE id = 1');
$user = $stmt->fetchObject();
echo $user->id; // Sortie normale
echo $user->user_name; // Sortie normale
echo $user->email_address; // Sortie normale
?>
Tout a l'air lisse ici. Mais si votre classe d'entité (telle que l'utilisateur ) utilise la dénomination de camel, telle que le nom d'utilisateur et le courrier électronique , alors l'utilisation de fetchObject ('utilisateur') n'attribue pas directement la valeur correctement.
Parce que FetchObject est attribué directement aux attributs d'objet en fonction des noms de colonne renvoyés par la base de données par défaut. Les champs de la base de données sont soulignés ( user_name ), tandis que les objets sont chameaux ( nom d'utilisateur ), qui ne correspondent naturellement pas.
Par exemple, la classe utilisateur suivante:
<?php
class User {
public int $id;
public string $userName;
public string $emailAddress;
}
?>
Utilisez $ stmt-> fetchObject ('utilisateur') directement, et le nom d'utilisateur et le courrier électronique ne peuvent pas obtenir la valeur.
La manière la plus simple et la plus brute est de donner un alias au champ qui correspond au nom d'attribut d'objet lors de l'interrogation SQL:
<?php
$stmt = $pdo->query('
SELECT
id,
user_name AS userName,
email_address AS emailAddress
FROM users
WHERE id = 1
');
$user = $stmt->fetchObject('User');
echo $user->userName; // Sortie correcte
echo $user->emailAddress; // Sortie correcte
?>
Cette méthode est simple et directe, sans modifier la classe d'entité. Cependant, s'il existe de nombreux champs de requête et des tables complexes, il est facile de maintenir difficile.
Si vous souhaitez conserver les noms de champ dans SQL incessant, vous pouvez retirer manuellement le tableau et l'attribuer à l'objet:
<?php
$stmt = $pdo->query('SELECT id, user_name, email_address FROM users WHERE id = 1');
$data = $stmt->fetch(PDO::FETCH_ASSOC);
$user = new User();
$user->id = $data['id'];
$user->userName = $data['user_name'];
$user->emailAddress = $data['email_address'];
echo $user->userName; // Sortie correcte
?>
C'est flexible, mais il est difficile d'écrire. Vous devez attribuer manuellement les valeurs à chaque fois, ce qui n'est pas assez élégant.
Si vous souhaitez être plus automatique, vous pouvez écrire une petite fonction qui convertit automatiquement le champ de base de données en nom de chameau, puis attribue la valeur à l'objet.
<?php
function snakeToCamel(string $string): string {
return lcfirst(str_replace(' ', '', ucwords(str_replace('_', ' ', $string))));
}
function mapToEntity(array $data, string $className) {
$object = new $className();
foreach ($data as $key => $value) {
$property = snakeToCamel($key);
if (property_exists($object, $property)) {
$object->$property = $value;
}
}
return $object;
}
// Exemple d'utilisation
$stmt = $pdo->query('SELECT id, user_name, email_address FROM users WHERE id = 1');
$data = $stmt->fetch(PDO::FETCH_ASSOC);
$user = mapToEntity($data, 'User');
echo $user->userName; // Sortie correcte
?>
De cette façon, vous n'avez besoin d'écrire la logique de conversion qu'une seule fois, et toutes les requêtes suivantes peuvent être traitées automatiquement.
FetchObject convient à une acquisition de données simple et rapide. Si une logique complexe est requise, il est recommandé d'utiliser un cadre ORM (tel que l'éloquente de Laravel, la doctrine de Symfony, etc.).
Assurez-vous que les attributs de la classe d'entité sont publics , sinon FetchObject ne peut être attribué directement.
Si vous devez protéger les attributs, vous devez coopérer avec la méthode de construction ou la méthode magique __set () pour gérer l'affectation.
Pdostatement :: fetchObject est une fonctionnalité pratique mais prudente. Si le style de dénomination du champ n'est pas synchronisé, il est recommandé d'utiliser un alias dans SQL ou d'écrire votre propre méthode de mappage, afin que le code puisse être maintenu propre et robuste. Pour les projets moyens et grands, il est également recommandé d'utiliser directement les bibliothèques ORM matures pour gérer la cartographie des entités afin de réduire le risque d'erreurs.
Si vous souhaitez voir des conseils plus avancés sur l'APD, l'optimisation de la base de données ou la cartographie des entités, vous pouvez visiter notre blog technologique https://gitbox.net/blog pour plus d'articles!
