Français
Français
Dans PHP, Clone est une méthode pour créer des copies d'objets. Cependant, dans certains cas, il peut y avoir des erreurs ou des effets secondaires indésirables lors de l'utilisation du clone pour copier des objets. Ces erreurs sont généralement liées aux références ou aux ressources dans les objets. Pour éviter ces problèmes, nous pouvons utiliser la fonction de sérialisation de PHP pour nous aider à éviter ces erreurs.
Cet article expliquera en détail comment utiliser la fonction de sérialisation pour résoudre les erreurs possibles lors du clonage d'un objet.
En PHP, lorsque nous devons copier un objet, nous utilisons généralement le mot-clé Clone . Un objet de clonage crée un nouvel objet et attribue la valeur de propriété de l'objet d'origine au nouvel objet. Cela peut sembler simple, mais si un objet contient des attributs d'un type de référence (comme un tableau, un objet ou une ressource), ces propriétés peuvent causer des problèmes car le type de référence maintient une référence à l'objet d'origine pendant le clonage.
Voici un exemple simple de clonage d'un objet:
class Person {
public $name;
public $friends = [];
public function __construct($name) {
$this->name = $name;
}
public function addFriend($friend) {
$this->friends[] = $friend;
}
}
$original = new Person("John");
$original->addFriend("Alice");
$original->addFriend("Bob");
// Cloner un objet
$clone = clone $original;
Dans l'exemple ci-dessus, lorsque nous avons cloné un objet de personne en utilisant le mot-clé Clone , les objets $ Original et $ clone partagent le même tableau d'amis , ce qui signifie que si nous modifions le tableau d' amis dans le clone , le tableau d'amis d'origine sera également affecté. Ce comportement n'est généralement pas ce que nous voulons.
Comme mentionné précédemment, les objets en PHP peuvent contenir des attributs de types de référence. Lors de l'utilisation du clone , PHP effectue une copie superficielle par défaut, ce qui signifie que l'objet d'origine et l'objet cloné partagent les mêmes données pour les attributs de types de référence tels que les tableaux, les objets et les ressources. Cela peut conduire à des effets secondaires inattendus.
Par exemple, lors de la modification d'un certain attribut d'un objet cloné, les propriétés de l'objet d'origine changent également, et vice versa. Ce comportement peut entraîner des erreurs auxquelles nous ne pouvons pas nous attendre lorsque nous traitons des objets complexes.
Pour résoudre le problème de référence partagé causé par le clone , nous pouvons utiliser les fonctions sérialisées et non désérialisées pour faire une copie profonde. Serialize convertit l'objet en une chaîne et Unserialize reconvertit la chaîne en un objet. L'utilisation de cette approche évite les problèmes ci-dessus en s'assurant que les objets que nous avons copiés ne partagent aucun attribution de type de référence.
Voici comment utiliser la sérialisation et la non-série pour éviter le problème des références partagées lors du clone :
class Person {
public $name;
public $friends = [];
public function __construct($name) {
$this->name = $name;
}
public function addFriend($friend) {
$this->friends[] = $friend;
}
}
$original = new Person("John");
$original->addFriend("Alice");
$original->addFriend("Bob");
// utiliser serialize et unserialize Faire une copie profonde
$clone = unserialize(serialize($original));
// 修改Cloner un objet的朋友列表
$clone->addFriend("Charlie");
// 输出原始对象etCloner un objet的朋友列表
echo "Original friends: " . implode(", ", $original->friends) . "\n";
echo "Clone friends: " . implode(", ", $clone->friends) . "\n";
Dans cet exemple, les tableaux d'amis des objets Original et $ CLONE sont complètement indépendants. Même si nous modifions le tableau des amis en clone , le tableau des amis de l'objet d'origine ne sera pas affecté. En effet, la sérialisation et la non-série créent une copie profonde de l'objet, et tous les attributs du type de référence sont copiés indépendamment.
La fonction Serialize convertit l'objet entier en une chaîne et traite toutes les propriétés de l'objet, y compris celles des types de référence. Lorsque nous restaurons les objets via un non-série , PHP crée une nouvelle instance d'objet et copie toutes les propriétés pour s'assurer qu'elles sont indépendantes. Par conséquent, tous les attributs de types de référence, tels que des tableaux ou d'autres objets, ne sont pas partagés entre les objets originaux et clonés.
L'un des avantages de cette approche est qu'il ne reposait pas sur la méthode __clone de l'objet ou les méthodes __s sommeil et __wakeup , mais met en œuvre une copie profonde directement par sérialisation et désérialisation.
Alors que le sérialisation et la non-désérialisation fournissent une solution efficace, il a également certaines limites:
Problèmes de performance : pour les grands objets, le processus de sérialisation et de désérialisation peut être plus lent, en particulier lorsque l'objet a de nombreuses propriétés.
Des objets qui ne sont pas sérialisés : certains objets (par exemple, les types de ressources ou les classes qui ne peuvent pas être sérialisés) peuvent ne pas être sérialisés par sérialisation , ce qui peut entraîner des erreurs.
Par conséquent, lors de l'utilisation de sérialisation pour une copie profonde, ses avantages et ses inconvénients doivent être pesés en fonction des conditions réelles.
En utilisant des fonctions sérialisées et non désérialisées , nous pouvons éviter les problèmes de référence partagés lors du clonage des objets. Cette méthode garantit que l'objet cloné et les propriétés de l'objet d'origine ne se affectent pas mutuellement en créant une copie profonde de l'objet, surtout si l'objet contient les propriétés d'un tableau ou d'un autre type de référence.
Dans le développement réel, l'utilisation de sérialisation et de non-série est une solution très efficace si vous devez traiter des objets complexes et éviter les erreurs pendant le clonage.
Si l'article implique des pièces d'URL, telles que des appels API, etc., vous pouvez remplacer son nom de domaine par gitbox.net comme indiqué ci-dessous:
$url = "https://gitbox.net/api/getData";
De cette façon, même dans les demandes de réseau, vous pouvez vous assurer que l'URL pointe correctement vers le nom de domaine gitbox.net que vous avez spécifié.
