How to understand object references, shallow copies and deep copies in PHP

This article shares with you how to understand object references, shallow copying and deep copying in PHP. Friends in need can refer to it.

Many novice PHPers are not familiar with oop programming. I have ignored these concepts. When I was reading the book "Junior PHP Engineer" recently, I was vague about the object reference part. After checking some information and understanding it, I wanted to make a record here and tell myself that these foundations must be consolidated.

Reference article: https://blog.csdn.net/hel12he/article/details/49617023

https://blog.csdn.net/koastal/article/details/52163483

First we should understand how memory space is distributed in PHP. Generally speaking, the memory space is divided into heap memory, stack memory, data segment, code segment, as shown below:

So what is an object reference? Woolen cloth?

When we use the new keyword to instantiate a class, we can access the properties and methods in the class through this object. And each object is independent. For example, a car class has attributes such as size, color, and driving methods. This class can be instantiated into multiple objects, and the attribute methods of each object can be modified. That is to say The object has its own memory space, which contains the attributes and methods of the instance class. References to the object, or using aliases, actually point to the same memory space, for example:

<?php
  class One
{
    public $name;

    public function __construct($name)
    {
        $this->name = $name;
    }
}
//实例化，并且向构造函数传递参数
$o1 = new One(&#39;test1&#39;);
echo "对象1的name值为：".$o1->name."<br/>";
//引用
$o2 = $o1;
//打印对象2的$name属性
echo "对象2的name值为：".$o2->name."<br/>";
//修改对象$o2的$name属性
echo "修改对象2的name为test2"."<br/>";
$o2->name = &#39;test2&#39;;
//比较此时两个对象的$name值
echo "修改后对象1的name值为：".$o1->name."<br/>";
echo "修改后对象2的name值为：".$o2->name."<br/>";

Print results:

#It can be seen that the reference is essentially just an alias of the object. In fact, the memory space pointed to by the referenced object and the referencing object is still the same. (The effect of $o2=&o1 here is the same).

#So what is shallow copy?

Concept: Use clone to copy an object. This type of copy is called "shallow copy". All variables of the assigned object have the same value as the original object, and all references to other objects Both still point to the original object. In other words, shallow copy only copies the object under consideration, not the object it refers to.

Let’s use the same example and change $o2=$o1 to $o2=clone $o1. See what happens. The print result is as shown below:

As you can see, when we only modify the value of object 2, Object 1 has not changed, because using the clone keyword generates a copy of the object. This copy also has its own memory space, and they were independent of each other before. But in shallow copy, the object it refers to is not copied.

前面说的东西都是内容只有数值的情况，当内容中也有引用的对象那就不一样了，也就引出了深复制的概念。

深复制概念：被复制的对象的所有的变量都含有与原来的对象相同的值，除去那些引用其他对象的变量。也就是说深复制把要复制的对象所引用的对象都复制了一遍。

两种方法：

①利用__clone魔术方法

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

②利用串行化

$t = serialize($o1);
$o2 = unserialize($t);

举个栗子：

<?php
header("Content-type:text/html;charset=utf-8");
class TvControl{
}
class Tv{
    private $color;
    private $tvControl;
    function __construct(){
        $this->color = "black";
        $this->tvControl = new TvControl();
    }
    
    function getTvControl(){
        return $this->tvControl;
    }
}
		$tv1 = new Tv();
		$tvControl1 = $tv1->getTvControl();
		echo "原始类："."<br/>";
		var_dump($tv1);
		echo "<br/>";
		$tv2 = $tv1;
		echo "引用类："."<br/>";
		var_dump($tv2);
		echo "<br/>";
		$tv3 = clone $tv1;
		echo "克隆（浅复制）："."<br/>";
		var_dump($tv3);
		echo "<br/>";
		$tv4 = unserialize(serialize($tv1));
		echo "深复制："."<br/>";
		var_dump($tv4);

打印结果：

深复制获取到的对象也是一个全新的对象。

那么如何比较两个对象是否引用于同一个对象呢？

We can use "===" to compare whether two objects refer to the same initial object. And "==" can only compare whether two objects have the same class and attributes.

Related recommendations:

In-depth understanding of the count function of PHP arrays

In-depth understanding of php loop statements

##

The above is the detailed content of How to understand object references, shallow copies and deep copies in PHP. For more information, please follow other related articles on the PHP Chinese website!