Detailed explanation of shallow copy and deep copy in php

Detailed examples of shallow copy and deep copy in PHP

Foreword:

Recently reviewed the Design Pattern When I saw the design pattern of Prototype Pattern, I noticed that it involves a problem of shallow copying and deep copying. Let me summarize it here and remind myself to pay more attention in the future.

Since PHP5, the newoperator automatically returns a reference. An object variable no longer saves the value of the entire object, but only saves an identifier to access the real object content. When an object is passed as a parameter, returned as a result, or assigned to another variable, the other variable has no reference relationship with the original one, but they both store a copy of the same identifier, which points to the real content of the same object. .

Here is a chestnut:

class Example1
{
  public $name;

  public function construct($name)
  {
    $this->name = $name;
  }
}

$ex1 = new Example('test1');// $ex1->name现在是：test1
$ex2 = $ex1;// $ex2->name现在是：test1

$ex2->name = 'test2';// 这样修改一下之后，$ex1->name与$ex2->name都变为了：test2

Through the above example, you should be able to understand the concept of references between objects, then we continue to go down and provide clone in php Keyword to object copy, let’s use the above class to demonstrate:

$ex1 = new Example('test1');// $ex1->name现在是：test1
$ex2 = clone $ex1;//$ex2->name现在是：test1

$ex2->name = 'test2';//现在$ex1->name还是test1,而$ex2->name是test2

As you can see here, after cloning, $ex1 and $ex2 are two different objects. Have their own variable environment. But it should be noted here that inside these two objects, what is owned is value type data. If what is owned internally is a reference type, then the reference in the new object obtained through cloning still points to the original reference. Here the concepts of shallow copy and deep copy are extended:

Shallow copy: Use clone to copy objects. This kind of copy is called "shallow copy". All of the assigned objects The variables still have the same value as the original object, and all references to other objects still point to the original object.

Deep copy: All variables of the copied object contain the same values ​​as the original object, except those variables that refer to other objects.

The default use of clone is to perform a shallow copy, so how can we perform a deep copy?

Method 1: Use the clone method

public function clone()
{
  $this->obj = new Obj();
}

This method is very intuitive, but it has a very troublesome operation method, that is, when the class contains multiple When referenced, you need to reset them one by one in the clone method. And we also have to deal with some cyclic reference issues. It's very complicated.

Method 2: Use serialization (refrigeration and thawing)

$tmp = serialize($ex1);
$ex2 = unserialize($tmp);

The $ex2 obtained at this time is a brand new object. This process is also called in java Perform the "refrigeration" and "thawing" processes.

Serialization is a recursive process. We don’t need to care about how many objects are referenced within the object and how many layers of objects are referenced. We can copy them completely. Method 2 is really pornographic and violent, but I like it very much.

The above is the detailed content of Detailed explanation of shallow copy and deep copy in php. For more information, please follow other related articles on the PHP Chinese website!