PHP中要实现类似于Java中的getter和setter有多种方法，比较常用的有：

1. 直接箭头->调用属性(最常用)，不管有没有声明这个属性，都可以使用，但会报Notice级别的错误

1
2

$dog = new Dog();
$dog->name = 'hey';

2. 添加setter和getter方法，类似于Java

1
2
3
4
5
6
7
8
9
10

class Dog 
{
    private $name = '';
    public function setName($name) {
        $this->name = $name;
    }
    public function getName() {
        return $this->name;
    }
}

3. 使用魔术方法(最装x)

1
2
3
4
5
6
7
8
9
10

class Dog1
{
    private $_name = '';
    function __set($property, $value) {
        if ($property === 'name') $this->_name = $value;
    }
    function __get($property) {
        if ($property === 'name') return $this->_name;
    }
}

上面三种方法，大部分人能都想到的也就是前两种方法，对于第三种方法PHP小白看了第一感觉就是好厉害（心中暗想这人一定是大佬），但是这样写真的能体现出编程水平吗？

对这几种方法，我们来对比下它们的执行效率：

方法一代码：

方法二代码：

方法三代码：

主要就是两个for循环，外层循环10次，内层一百万次，总计循环了一千万次，convert函数只是用来输出可读性更高的内存使用情况。现在在我本地测试一下，测试的机器时2015款的MBP，i5 16GB内存，PHP是7.2.13(cli)版本，执行结果分别如下：

方法一：

方法二：

方法三：

会什么方法三会这么慢？有人可能会说可能因为魔术方法里面的if判断，那我现在把if去掉试试：

执行结果如下：

发现if的影响很小，而且这种写法也并不推荐，这里的魔术方法就相当于一个拦截器，当调用未定义的属性时就会调用魔术方法，但这里只是测试，真实环境一定不能这么写。

从结果可以看出，我们直接使用箭头函数速度是最快的，最常用最简单的方法执行效率也是最高的，后面两种方法不仅代码行数多了一些，而且执行效率不及第一种，特别是使用魔术方法，执行效率是第一种的6倍左右，是第二种的2倍左右，古人常说“智者千虑必有一失，愚者千虑必有一得”大概就是这个意思吧，在这里代码行数和执行效率都增多了。

不过，对于第一种方法，可读性就不是很高，不管属性有没有定义都能随便调用，代码并不规范，其他人在审查你的代码时就不是很方便，建议属性属性使用前声明下。

####魔术方法还有哪些？

PHP中，__call()方法可能是最有用的魔术方法了，用它可以实现很tricky的东西。当要调用类中未定义的方法时，__call()会被调用，第一个参数是调用未定义的方法名称，第二个参数是传递给调用方法的所有参数，是一个数组，__call()的返回值会返回给调用者，这样就好像调用一个真实存在的方法一样。

同时__call也可以用来实现委托，委托是指一个对象转发一个请求给另一个对象，把请求的处理委托给另一个对象。这就有点类似于继承，和在子类中调用父类的方法有点相似。但在继承是父类与子类的关系是固定的，而使用委托可以在运行时改变使用的对象，委托比继承具有更大的灵活性。代码如下：

代码中Doctor类接收一个PersonWriter对象作为构造函数的参数，并将它存储在$printer中，在__call()中检查PersonWriter中是否存在$methodName方法，如果存在，就委托PersonWriter对象来处理，并将当前类Doctor的实例传给它，运行结果如下：

这样我们就不用在Doctor中手动调用如下方法：

1

$this->printer->printMe($this);

如果此时给PersonWriter增加几个新的方法，使用委托可以节省很多时间，但代码也会变得不清晰，不易理解。对于调用者来说，你提供的是一个动态的接口，没有办法进行反射（reflection），因为调用的类与被委托的类之间的交互比较模糊，使用时需要提供说明文档。

回到文章主题，我们对PHP的getter和setter相关使用进行了对比，以Java程序猿的思维看第二种方法中规中矩，没有任何套路，第一种和第三种应该是PHP才有的，但第三种方式执行的效率远不及前两种，而第一种方式虽然效率最高，但使用时尽量还是把属性声明下，使代码的结构更清晰。

今天小伙伴在群里问了这么一个问题：

出现这种情况就是因为内存不足，PHP程序直接退出了，报错大概如下：

上图的意思就是说，我们能使用的内存最大是8M，但是处理这个图片还需要额外的41bytes，就会导致内存不足，这是一个很严重的错误。在对图片进行操作前需要将图片的所有信息读入内存中，同时还会使用另一部分内存同于处理计算并缓存输出，所以内存大小的使用还是和图片的大小有关。

PHP中图片的处理都是使用了GD库，这个库提供了很多方法让PHP可以更方便地对图片进行操作，支持的图片格式如下：

回到一开始的问题，那个小伙伴需要处理高分辨的图片，图片大小必然很大，所以就会出现内存不够的情况，解决方法还是有很多的。

1. 设置图片最大可上传的大小

前端上传前可以先检测下大小，如果超过最大值直接就不请求接口，同时为安全起见，后端接收到请求后也要检测大小，防止程序异常退出。

2. 压缩图片

3. 关闭memory_limit

群里的小伙伴最后使用了一种简单粗暴的方式解决了该问题，直接在PHP中关闭memory_limit：

1
2

 set_time_limit(0);
@ini_set('memory_limit','-1');

这样虽然解决了问题，但不优雅也不安全，同样在php.ini配置文件中将memory_limit的值设置很大也能解决：

1

memory_limit = 256M

PHP代码中也可以这样设置：

1

ini_set('memory_limit', '256M');

上面我们将memory_limit参数固定了，这就带来一个弊端，因为大多数情况下不需要这么大的内存，有点浪费资源，最好的做法就是根据需要来设置memory_limit，我写了一个如下方法可供参考：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

public function setMemoryLimit($filename){
    // 控制执行时间
    set_time_limit(50);

    $maxMemoryUsage = 256M;
    $width = 0;
    $height = 0;
    $size = ini_get('memory_limit');

    // 获取图片大小
    list($width, $height) = getimagesize($filename);

    // 计算需要的内存，并转换成'M'单位
    // 4 因为png图片一个像素有4字节
    // 1.5 是一个调整因子，因为memory_limit不是那么精确
    // 详细可以查看: http://php.net/imagecreatefromjpeg#76968
    $size = $size + floor(($width * $height * 4 * 1.5 + 1048576) / 1048576);

    if ($size > $maxMemoryUsage){
        $size = $maxMemoryUsage;
   }

   // 更新
   ini_set('memory_limit',$size.'M');
}

最后说一下，GD库其实是比较耗内存的，但我这里没有做过测试。Github上有个C的项目叫libvips/libvips：

可以在不占用很多内存的情况下提高图片处理的速度，这是地址:https://github.com/libvips/libvips，有时间可以学习下。

PHP中数组插入数据通常有这么几种：

1. 定义的时候直接赋值

1

$arr = array(‘apple’, ’banana’);

2. 使用数组变量操作

1
2
3

$arr = array();
$arr[] = ‘apple’;
$arr[] = ‘banana’;

3. 使用array_push()插入

1
2

$arr = array(‘apple’);
array_push($arr, ‘banana’, ‘orange’);

在项目中，我们大部分情况都是先从数据库中获取数据，然后转成数组形式，而对于第一种情况，在定义数组的时候直接赋值往往只适合数据量很小，而且是已知的情况，所以就不存在什么代码优化了，我们主要讲第二种和第三种。

关于array_push的使用，就不多介绍，自己看官方文档(https://secure.php.net/manual/en/function.array-push.php)。

性能比较

我们使用php 7.2来测试，并且没有做任何配置上的优化。测试方法：定义一个数组，分别用第二种和第三种方式插入10万条记录，代码大致如下：

convert函数用来查看内存占用情况，运行结果如下：

通过多次运行上述代码，可以发现直接使用数组变量赋值耗时在0.0045左右，而使用array_push的方式耗时在0.006左右，消耗的内存都是一样的，因为都是10万条记录。

对比两种方法，发现方法二确实比调用array_push快，因为在每次循环时函数调用需要消耗一些时间，但仅仅看上面的测试，并不觉得第二种方法比第三种方法快多少，完全可以忽略不计的。

的确，这种优化在绝大多数应用中和没优化没啥区别，但是当应用达到瓶颈的时候，每一处不起眼的优化可能都会使性能提高不少，况且我们的测试中数组的结构很简单，真实项目中数据类型不是这么单一，可能还是嵌套的数组，数组的大小可能也不止10万。

我们再来看看两者的差异，array_push()是函数调用，另一个不是，这就是说了，从代码量上看两者也是一样的，从数组结构上看，测试中我们都没有使用索引，默认都是从0开始，如果要使用key => value形式插入数据时，array_push()就不是很好处理了，这时使用法二就很方便：$array1[$key] => $x。

前面都是说array_push()怎么不好，但有时候array_push还是很好用的。比如我们要一次插入多个元素时，就可以这样使用：

1
2
3

$arr = array(‘a’, ’b’);
array_push($arr, ‘c’, ‘d’);
// $arr = array(‘a’, ’b’, ‘c’, ‘d’);

通过上面对比可见，PHP中数组插值的方法有很多，虽然每种方法差不多，但了解每一种方法何时使用还是很有必要的。

欢迎关注我的公众号：

PHP读取excel、csv文件的库有很多，但用的比较多的有： PHPOffice/PHPExcel、PHPOffice/PhpSpreadsheet，现在PHPExcel已经不再维护了，最新的一次提交还是在2017年12月25号，建议直接使用PhpSpreadsheet，而且这两个项目都是同一个组织维护的，本文介绍PhpSpreadsheet的使用。

介绍PhpSpreadsheet

PhpSpreadsheet这个库是纯PHP写的，提供了非常丰富的类和方法，而且支持很多文件格式：

环境要求

• PHP >= 5.6
• 开启php_zip扩展
• 开启php_xml扩展
• 开启php_gd2扩展

开始使用😄

我们写一个简单的demo，来学习PhpSpreadsheet的使用，大概就是一个简单的文件上传页面，上传我们要读取的Excel文件，PHP接收到文件，调用PhpSpreadsheet读取Excel里面的内容。

0. 配置环境

略…，自己配置
我当前的PHP版本是7.2.13

1. 新建一个项目

1
2

mkdir demo
cd demo

2. 安装

使用composer安装：

1

composer require phpoffice/phpspreadsheet

默认安装的是最新的稳定版本(1.5)，如果想要安装dev版本，可以执行下面的命令：

1

composer require phpoffice/phpspreadsheet:develop

上面步骤执行完毕后，目录结构是这样的：

3. 新建一个简单的html文件，用来上传Excel文件

1

vim index.html

index.html里面的内容很简单，如下：

这里要注意下：form表单的enctype一定要是multipart/form-data

这只是一个简单的demo，一个form表单就可以了，运行后就是下面这样了 :)

4. PhpSpreadsheet如何使用？

在处理前端传过来的Excel文件之前，先来介绍下PhpSpredsheet如何使用。

4.1 读取文件

PhpSpreadsheet中读取文件有很多种，对于不同格式的文件有不同的读取方法，比如：xlsx格式，使用\PhpOffice\PhpSpreadsheet\Reader\Xlsx()，csv格式，使用\PhpOffice\PhpSpreadsheet\Reader\Csv()，乍一看这么多类就感觉有点复杂，其实这些类都实现了\PhpOffice\PhpSpreadsheet\Reader\IReader和\PhpOffice\PhpSpreadsheet\Writer\IWriter接口，指定了要加载的文件类型。我们可以直接使用\PhpOffice\PhpSpreadsheet\IOFactory这个工厂类：

1

$spreadsheet = \PhpOffice\PhpSpreadsheet\IOFactory::load('demo.xlsx');

如果想在读写文件的时候设置一些属性，比如读写属性，可以这样设置：

1
2
3

$reader = \PhpOffice\PhpSpreadsheet\IOFactory::createReaderForFile("demo.xlsx");
$reader->setReadDataOnly(true);
$reader->load("demo.xlsx");

使用这个工厂类的好处就是你不需要关心文件上传的格式，它能自动帮识别，其实这个工厂类就是对你上传的文件做一些识别，如果识别出来是xls格式，就返回xls的reader，如果是csv，就返回csv的reader，通过分析代码我们可以看到这个IOFactory可以生产出如下的reader和writer：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

abstract class IOFactory
{
    private static $readers = [
        'Xlsx' => Reader\Xlsx::class,
        'Xls' => Reader\Xls::class,
        'Xml' => Reader\Xml::class,
        'Ods' => Reader\Ods::class,
        'Slk' => Reader\Slk::class,
        'Gnumeric' => Reader\Gnumeric::class,
        'Html' => Reader\Html::class,
        'Csv' => Reader\Csv::class,
    ];

    private static $writers = [
        'Xls' => Writer\Xls::class,
        'Xlsx' => Writer\Xlsx::class,
        'Ods' => Writer\Ods::class,
        'Csv' => Writer\Csv::class,
        'Html' => Writer\Html::class,
        'Tcpdf' => Writer\Pdf\Tcpdf::class,
        'Dompdf' => Writer\Pdf\Dompdf::class,
        'Mpdf' => Writer\Pdf\Mpdf::class,
    ];
...

可以看到支持的类型还是蛮多的，但是很多都不常用。

在IOFactory工厂中还可以指定读写的文件类型，返回对应的reader，这样就免去了识别文件类型的步骤，如下：

1
2

$reader = \PhpOffice\PhpSpreadsheet\IOFactory::createReader("Xlsx");  // 指定为xlsx格式
$spreadsheet = $reader->load("demo.xlsx");

4.2 从源码比较两种读写方式

首先，来看下IOFactory这个工厂类，我们在不指定reader类型时直接load，代码内部是要做一个识别格式的操作：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

// 源码解析
// 不指定reader，直接获取上传的文件创建
$reader = \PhpOffice\PhpSpreadsheet\IOFactory::load($_FILES['file']['tmp_name']);

// IOFactory::load()
public static function load($pFilename)
{
    // 这步棋室就是创建reader，免去了你手动创建
    $reader = self::createReaderForFile($pFilename);
    return $reader->load($pFilename);
}

// IOFactory::createReaderForFile()
// 这步就是返回一个reader，具体返回什么reader，是根据文件名来的
public static function createReaderForFile($filename)
{
    // 判断文件是否存在并且可读，会抛出InvalidArgumentException
    File::assertFile($filename);

    // 根据文件后缀猜测类型
    $guessedReader = self::getReaderTypeFromExtension($filename);
        if ($guessedReader !== null) {
            $reader = self::createReader($guessedReader);

            // Let's see if we are lucky
            if (isset($reader) && $reader->canRead($filename)) {
                return $reader;
            }
        }

    // 如果没有检测到类型，就会遍历默认的reader数组，直到找到可以使用的那个reader
    foreach (self::$readers as $type => $class) {
        if ($type !== $guessedReader) {
            $reader = self::createReader($type);
            if ($reader->canRead($filename)) {
                return $reader;
            }
        }
    }
    throw new Reader\Exception('Unable to identify a reader for this file');
}

从上面的代码，可以看到在load前是做了文件检测和类型判断的操作，然后再返回对应的reader，接下来，再来看看当我们指定了类型后，做了哪些操作的：

1
2
3

// 指定reader
$reader = new \PhpOffice\PhpSpreadsheet\Reader\Xlsx();
$spreadsheet = $reader->load($_FILES['file']['tmp_name']);

上面的就比较简单了，直接创建reader，然后就load了，只是做了一些实例化的操作。这两种方法相比，第二种方法性能更好一点，当然前提是要知道文件格式。

5. 读取Excel文件内容

让我们接着继续上面的index.html，我们需要编写一个PHP文件来处理请求：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

require 'vendor/autoload.php';

$reader = new \PhpOffice\PhpSpreadsheet\Reader\Xlsx();

try {
    $spreadsheet = $reader->load($_FILES['file']['tmp_name']);
} catch (\PhpOffice\PhpSpreadsheet\Reader\Exception $e) {
    die($e->getMessage());
}

$sheet = $spreadsheet->getActiveSheet();

$res = array();
foreach ($sheet->getRowIterator(2) as $row) {
    $tmp = array();
    foreach ($row->getCellIterator() as $cell) {
        $tmp[] = $cell->getFormattedValue();
    }
    $res[$row->getRowIndex()] = $tmp;
}

echo json_encode($res);

我们先引入autoload，接着创建了一个Xlsx的reader，然后load我们上传的文件，因为在excel中，内容都是按sheet区分的，每一个sheet中都由行和列组成，我们获取到当前使用的sheet，通过sheet获取到行的迭代对象，再针对每一行得到每一列对象，在PhpSpreadsheet中，cell是一个最小的单元，对应着第几行第几列，数据都是存在cell中，得到cell对象我们就能获取到数据。

当我们上传如下内容后：

返回结果如下：

因为我们在读取时，是从第二行开始的，所以第一行的内容就不显示了。

这里说一下，在Excel中第三列是一个时间，PhpSpreadsheet对时间的处理有点特殊。在PhpSpreadsheet中date和time在存储时都是作为数字类型，当要区分数字是时间格式时，需要用到format mask，默认情况下，format mask是开启了的，但如果设置setReadDataOnly等于true的话，就不能使用format mask，从而就区分不了数字和时间格式，PhpSpreatsheet将会全部作为数字处理。

此时，我们开启只读模式看一下，

1
2

$reader = new \PhpOffice\PhpSpreadsheet\Reader\Xlsx();
$reader->setReadDataOnly(true);

输出结果如下：

第三列就变成了奇怪的数字，当初这个问题还困扰了我半天。

5. PhpSpreadsheet读取文件时的一些常用方法

1. 如果一个Excel中有多个sheet，只想操作其中的某几个sheet，可以设置setLoadSheetsOnly

1
2
3

$reader = new \PhpOffice\PhpSpreadsheet\Reader\Xlsx();
// 参数支持字符串或一个数组
$reader->setLoadSheetsOnly(['sheet1','sheet3']);

2. 读取指定行和列的数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

class MyReadFilter implements \PhpOffice\PhpSpreadsheet\Reader\IReadFilter
{
    public function readCell($column, $row, $worksheetName = '') {
        // 只读取A1:E7的数据
        if ($row >= 1 && $row <= 7) {
            if (in_array($column,range('A','E'))) {
                return true;
            }
        }
        return false;
    }
}

$myFilter = new MyReadFilter();
$reader = new \PhpOffice\PhpSpreadsheet\Reader\Xlsx();
$reader->setReadFilter($filterSubset);
$spreadsheet = $reader->load('demo.xlsx');

上面的例子不够通用，可以修改下使之更为通用：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

class MyReadFilter implements \PhpOffice\PhpSpreadsheet\Reader\IReadFilter
{
    private $startRow = 0;
    private $endRow   = 0;
    private $columns  = [];

    public function __construct($startRow, $endRow, $columns) {
        $this->startRow = $startRow;
        $this->endRow   = $endRow;
        $this->columns  = $columns;
    }

    public function readCell($column, $row, $worksheetName = '') {
        if ($row >= $this->startRow && $row <= $this->endRow) {
            if (in_array($column,$this->columns)) {
                return true;
            }
        }
        return false;
    }
}

$myFilter = new MyReadFilter(9,15,['A', 'B', 'D']);

3. 列出Excel中所有sheet的名字

1

$reader->listWorksheetNames('demo.xlsx');

4. 列出一个sheet的信息，包括多少列、多少行

1

$reader->listWorksheetInfo('demo.xlsx');

PhpSpreadsheet的学习与使用就到这，真的很强大，几乎满足了日常的所有需求，是读取Excel、CSV文件的利器。

PHP中，=的作用都是将一个值复制给另一个（大多数编程语言都是一样），将=作用在基本数据类型上时，就直接进行了赋值，并且变量的修改互不影响，如下：

1
2
3
4
5

$a = 1;
$b = $a;
$b = 2;
print_r($a);  // 1
print_r($b);  // 2

而在复制对象时，=只是简单地将两个变量指向同一个类实例，测试一下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

class Student
{
    public $name;
    public $age;

    function __construct($name, $age) {
        $this->name = $name;
        $this->age = $age;
    }
}

$student1 = new Student('mike', 19);
$student2 = $student1;

print_r($student1);
print_r($student2);
var_dump($student1 == $student2);
var_dump($student1 === $student2);

// 输出
Student Object
(
    [name] => mike
    [age] => 19
)
Student Object
(
    [name] => mike
    [age] => 19
)
bool(true)
bool(true)

从上面的代码中，就能明显看出$student1和$student2两个变量指向的是同一个对象，新手看到这可能并没有发现其中蹊跷，而且等值检测也没有问题啊（其实这里的等值检测是看不出什么的），这时，如果我继续修改$student2中的属性时，就能发现问题：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

$student2->name = 'Jack';
$student2->age = 22;

print_r($student1);
print_r($student2);

// 输出
Student Object
(
    [name] => Jack
    [age] => 22
)
Student Object
(
    [name] => Jack
    [age] => 22
)

为什么会这样呢，我只是想修改$student2的属性，为什么$student1也改了，这就好比Dota里面的地卜师，只要逮到你一个分身，你就挂了。

其实，看到这种情况，大概就能猜到PHP中对象的赋值都是通过引用操作，$student1和$student2没有各自保留一份单独的副本，在内存中的分配大概就是这样的：

两个变量指向的是同一个内存地址，所以我们改变其中一个变量的属性是另一个也会变，但如果我们想要对两个变量做不同的操作并且互不影响该怎么办？

好在PHP提供了一个clone关键字来达到这个目的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

$student1 = new Student('mike', 19);
$student2 = clone $student1;

$student2->name = 'Jack';
$student2->age = 22;

print_r($student1);
print_r($student2);

// 输出
Student Object
(
    [name] => mike
    [age] => 19
)
Student Object
(
    [name] => Jack
    [age] => 22
)

通过clone复制后，现在$student1和$student2就是两个不同的变量，修改互不影响。

关于__clone()方法

现在有这么一种情况，在复制对象时，想做一些修改操作，实际开发中，$id属性可能会与数据库表中某条记录一一对应，在复制之后，两个对象就指向数据库中的同一条记录了，那么使用__clone()就能控制复制时，哪些属性可以复制，哪些应该不复制或者置空。__clone()是个魔术方法，在对象上调用clone关键字时会自动调用。如下代码所示：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

class Student
{
    public $id;
    public $name;
    public $age;

    function __construct($id, $name, $age) {
        $this->id = $id;
        $this->name = $name;
        $this->age = $age;
    }

    function __clone() {
        $this->id = 0;
    }
}

$student1 = new Student(1,'mike', 19);
$student2 = clone $student1;

print_r($student1);
print_r($student2);

// 输出
Student Object
(
    [id] => 1
    [name] => mike
    [age] => 19
)
Student Object
(
    [id] => 0
    [name] => mike
    [age] => 19
)

当在$student1上调用clone时，产生一个新的副本给$student2 ，这时$student2上就会自动调用__clone方法，使$id为0。

上面通过clone和__clone()可以保证所有的基础数据类型可以被完全复制，但如果复制的对象中的属性也是一个对象时，复制后的两个对象都会引用同一个属性，修改时会互相影响，如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

Class Score {
    public $english;
    public $math;

    function __construct($english, $math) {
        $this->english = $english;
        $this->math = $math;
    }
}

class Student
{
    public $id;
    public $name;
    public $age;
    public $score;

    function __construct($id, $name, $age, Score $score) {
        $this->id = $id;
        $this->name = $name;
        $this->age = $age;
        $this->score = $score;
    }

    function __clone() {
        $this->id = 0;
    }
}

$student1 = new Student(1,'mike', 19, new Score(80, 90));
$student2 = clone $student1;

// 我们需要修改$student1的英语成绩
$student1->score->english = 99;

//结果$student2的英语成绩也被修改了
echo $student2->score->english;

// 输出
99

上面这种情况并不是我们希望看到的，我们不想对象属性复制后被共享。解决方法就是在__clone()做做一些修改：

1
2
3
4
5
6
7

function __clone() {
      $this->id = 0;
      $this->score = clone $this->score;
}

// 输出
80

我所了解的PHP中对象复制大概就是这样，类似__clone()这样的魔术方法还有好几个，常见的还有：__set()、__unset()、__call()等，利用这些魔术方法可以实现更多复杂的操作，以后慢慢学习。