Deutsch
Deutsch
In PHP wird die Serialize () -Funktion verwendet, um ein Objekt oder ein Array für Speicher oder Übertragung in eine Zeichenfolge umzuwandeln. Die Serialize () -Funktion kann jedoch auf Probleme stoßen, wenn das Objekt rekursive Referenzen enthält (d. H. Das Objekt verweist sich selbst oder Verweise auf einander). In diesem Artikel wird erläutert, wie die Funktion Serialize () verwendet wird, um mit komplexen Objekt -Serialisierungsproblemen mit rekursiven Referenzen umzugehen und verwandte Lösungen bereitzustellen.
Rekursive Referenz bezieht sich auf die Eigenschaften eines Objekts, die Verweise auf sich selbst enthalten, oder es gibt eine Beziehung zwischen mehreren Objekten, die sich gegenseitig verweisen. Diese Situation ist häufiger in komplexen Datenstrukturen, insbesondere in Datenmodellen wie Baumstrukturen und Grafikstrukturen. Angenommen, es gibt ein übergeordnetes Objekt, das ein untergeordnetes Objekt enthält, und das untergeordnete Objekt enthält einen Verweis auf das übergeordnete Objekt. Diese Struktur kann das Problem rekursiver Referenzen verursachen.
In PHP ist die Serialize () -Funktion eine Standardmethode, um PHP -Variablen in Zeichenfolgen umzuwandeln. Wenn es jedoch rekursive Referenzen innerhalb des Objekts gibt, fällt Serialize () in eine tote Schleife, da es ständig versucht, dasselbe Objekt zu serialisieren, was zu einem Stapelüberlauf oder einer unendlichen Rekursion führt. Hier ist ein einfaches Beispiel, das einen Fall mit rekursiven Referenzen zeigt:
class Node {
public $value;
public $next;
public function __construct($value) {
$this->value = $value;
}
}
$node1 = new Node(1);
$node2 = new Node(2);
$node3 = new Node(3);
$node1->next = $node2;
$node2->next = $node3;
$node3->next = $node1; // Rekursive Referenzen
echo serialize($node1);
Im obigen Code beziehen sich $ node1 , $ node2 und $ node3 und bilden eine Schleife. Wenn serialize () aufgerufen wird, tritt PHP in einen unendlichen Rekursionszustand ein, was zu einem Fehler führt.
Um das Problem rekursiger Referenzen zu lösen, können wir verschiedene Methoden anwenden. Die beiden häufigsten Methoden sind die benutzerdefinierte Prozessor von Serialize () oder mit den magischen Methoden von PHP __sleep () und __wakeup (), um den Serialisierungsprozess von Objekten zu steuern.
Die __sleep () -Methode kann die Eigenschaften des Objekts verarbeiten, bevor das Objekt serialisiert wird, während die __Wakeup () -Methode den Zustand des Objekts wiederherstellt, wenn das Objekt deserialisiert wird. Wir können diese Methoden anwenden, um Probleme zu verhindern, die durch rekursive Referenzen verursacht werden.
class Node {
public $value;
public $next;
public function __construct($value) {
$this->value = $value;
}
public function __sleep() {
// Hier können Sie nur die erforderlichen Attribute serialisieren，避免Rekursive Referenzen
return ['value'];
}
public function __wakeup() {
// Operationen während der Deserialisierung，Beziehungen zwischen Objekten können wiederhergestellt werden
}
}
$node1 = new Node(1);
$node2 = new Node(2);
$node3 = new Node(3);
$node1->next = $node2;
$node2->next = $node3;
$node3->next = $node1; // Rekursive Referenzen
echo serialize($node1);
In diesem Beispiel gibt die __sleep () -Methode nur das Wertattribut zurück, so dass nur das Attribut während des Serialisierungsprozesses gespeichert wird, wodurch das Problem rekursiver Referenzen vermieden wird.
Ein weiterer Ansatz besteht darin, rekursive Referenzen manuell zu behandeln, die mithilfe eines globalen Arrays zum Aufzeichnen bereits serialisierter Objekte aufgezeichnet werden können. Auf diese Weise können Sie diese bereits verarbeiteten Objekte während der Serialisierung überspringen und so das Problem der unendlichen Rekursion vermeiden. Diese Methode kann in komplexen Objektstrukturen gut verwendet werden.
class Node {
public $value;
public $next;
public function __construct($value) {
$this->value = $value;
}
}
$visited = [];
function safe_serialize($obj) {
global $visited;
if (in_array(spl_object_hash($obj), $visited)) {
return ''; // Vermeiden Sie doppelte Serialisierung
}
$visited[] = spl_object_hash($obj);
return serialize($obj);
}
$node1 = new Node(1);
$node2 = new Node(2);
$node3 = new Node(3);
$node1->next = $node2;
$node2->next = $node3;
$node3->next = $node1; // Rekursive Referenzen
echo safe_serialize($node1);
In diesem Beispiel verwenden wir Global $ Visited , um die Kennung des bereits serialisierten Objekts zu speichern (erhalten über spl_object_hash () ). Wenn ein Objekt serialisiert wurde, überspringen Sie das Objekt, um das Problem rekursiger Referenzen zu vermeiden.
Um mit komplexen Objekt-Serialisierungsproblemen mit rekursiven Referenzen umzugehen, können Sie die Serialisierung durch integrierte __-Sleep ()- und __wakeup () magische Methoden von PHP anpassen oder den Serialisierungsprozess manuell implementieren, um eine wiederholte Serialisierung zu vermeiden. Bei verschiedenen Anforderungen und Objektstrukturen können wir verschiedene Methoden auswählen, um tote Schleifen oder Stapelüberlauffehler zu vermeiden, die durch rekursive Referenzen verursacht werden.
