PHP array copy strategy: deep copy and shallow copy, parsing and performance comparison

In PHP, there are two strategies for array copying: deep copying and shallow copying. A deep copy creates an independent copy of the source array, and changes to one array do not affect the other array. Shallow copy only copies the references of the arrays, changes to one array are reflected in the other array. Deep copy requires traversing the array and creating new entities, so it is more resource intensive than shallow copy, but shallow copy can only copy references, so it is faster. Deep copy is used to create an independent collection of database records, while shallow copy is used to pass an array to a function.

PHP Array Copy Strategy: Deep Copy vs Shallow Copy

In PHP, array variables are passed by reference. This means that any changes made to the original array will be reflected in all variables that reference the array. However, when we need to create copies of arrays in order to make independent changes to them, it is necessary to understand the difference between deep copy and shallow copy.

Deep Copy

Deep copy creates a completely independent copy of the source array in the destination array. Changes to the destination array do not affect the original array and vice versa.

$original_array = ['foo' => 'bar', 'baz' => ['a' => 1, 'b' => 2]];

// 深度复制
$deep_copy = clone $original_array; // 或使用深拷贝函数如 array_map(function($value) { return clone $value; }, $original_array)

$deep_copy['foo'] = 'new_bar';
$deep_copy['baz']['a'] = 3;

var_dump($original_array); // 输出: ['foo' => 'bar', 'baz' => ['a' => 1, 'b' => 2]]
var_dump($deep_copy); // 输出: ['foo' => 'new_bar', 'baz' => ['a' => 3, 'b' => 2]]

Shallow copy

Shallow copy only copies the reference of the source array. Changes to the destination array are also reflected in the original array.

$original_array = ['foo' => 'bar', 'baz' => ['a' => 1, 'b' => 2]];

// 浅复制
$shallow_copy = $original_array;

$shallow_copy['foo'] = 'new_bar';
$shallow_copy['baz']['a'] = 3;

var_dump($original_array); // 输出: ['foo' => 'new_bar', 'baz' => ['a' => 3, 'b' => 2]]
var_dump($shallow_copy); // 输出: ['foo' => 'new_bar', 'baz' => ['a' => 3, 'b' => 2]]

Performance Difference

Deep copy is more resource intensive than shallow copy because the entire source array must be traversed and new entities created for the target array. Shallow copies only copy references and are therefore usually much faster than deep copies.

Practical case

Use deep copy to create an independent database record collection

// 从数据库获取记录
$records = $db->fetchRecords();

// 深度复制记录集合以进行独立更新
$updated_records = clone $records;

Use shallow copy to pass the array to the function

function updateRecord($record) {
  $record['updated'] = true;
}

$original_record = ['id' => 1, 'name' => 'John'];

// 浅复制原始记录并更新副本
$shallow_copy = $original_record;
updateRecord($shallow_copy);

// 更新会反映在原始记录中
var_dump($original_record); // 输出: ['id' => 1, 'name' => 'John', 'updated' => true]

The above is the detailed content of PHP array copy strategy: deep copy and shallow copy, parsing and performance comparison. For more information, please follow other related articles on the PHP Chinese website!