PHP 中的数组在传递给函数时是否作为值或对新变量的引用进行复制？

Question

1）当数组作为参数传递给方法或函数时，它是按引用传递还是按值传递？

2) 将数组赋值给变量时，新变量是对原始数组的引用，还是新的副本？
这样做怎么样：

$a = array(1,2,3);
$b = $a;

$b 是对 $a 的引用吗？

Answer 1

对于问题的第二部分，请参阅手册的数组页面 ，其中指出（引用）：

数组赋值总是涉及值
复制。使用引用运算符
通过引用复制数组。

以及给定的示例：

<?php
$arr1 = array(2, 3);
$arr2 = $arr1;
$arr2[] = 4; // $arr2 is changed,
             // $arr1 is still array(2, 3)

$arr3 = &$arr1;
$arr3[] = 4; // now $arr1 and $arr3 are the same
?>

对于第一部分，最好的方法是尝试；-)

考虑这个代码示例：

function my_func($a) {
    $a[] = 30;
}

$arr = array(10, 20);
my_func($arr);
var_dump($arr);

它将给出以下输出：

array
  0 => int 10
  1 => int 20

这表明该函数尚未修改作为参数传递的“外部”数组：它是作为副本传递，而不是参考。

如果您希望它通过引用传递，则必须修改该函数，如下所示：

function my_func(& $a) {
    $a[] = 30;
}

输出将变为：

array
  0 => int 10
  1 => int 20
  2 => int 30

因为，这一次，数组已“通过引用”传递。

不要犹豫，阅读手册的参考解释部分：它应该回答你的一些问题;-)

Answer 2

关于您的第一个问题，数组是通过引用传递的，除非它在您调用的方法/函数中进行了修改。如果您尝试在方法/函数中修改数组，则会首先创建它的副本，然后仅修改该副本。这使得数组看起来好像是按值传递的，但实际上并非如此。

例如，在第一种情况下，即使您没有将函数定义为通过引用接受 $my_array （通过在参数定义中使用 & 字符），它仍然通过引用传递（即：您不会浪费内存中存在不必要的副本）。

function handle_array($my_array) {  

    // ... read from but do not modify $my_array
    print_r($my_array);

    // ... $my_array effectively passed by reference since no copy is made
}

但是，如果您修改数组，则会首先创建它的副本（这会使用更多内存，但不会影响原始数组）。

function handle_array($my_array) {

    // ... modify $my_array
    $my_array[] = "New value";

    // ... $my_array effectively passed by value since requires local copy
}

仅供参考 - 这称为“惰性复制”或“写时复制”。

Answer 3

TL;DR

a) 方法/函数仅读取数组参数 => 隐式（内部）引用
b) 方法/函数修改数组参数 => 价值
c) 方法/函数数组参数被显式标记为引用（带有 & 符号）=> 显式（用户态）参考

或者这样：
- 非＆符号数组参数：通过引用传递；写入操作会更改数组的新副本，该副本是在第一次写入时创建的；
- & 符号数组参数：通过引用传递；写入操作会改变原始数组。

请记住 - PHP 在您写入非＆符号数组参数时执行值复制。这就是copy-on-write的意思。我很想向您展示这种行为的 C 源代码，但其中很可怕。最好使用xdebug_debug_zval()。

帕斯卡·马丁是对的。科斯塔·康托斯更是如此。

回答

这取决于。

长版本

我想我正在为自己写下这篇文章。我应该有一个博客或其他东西......

每当人们谈论参考文献（或指针，就此而言）时，他们通常都会以徽标学结束（只需看看这个 线程！）。
PHP 是一种古老的语言，我认为我应该增加混乱（尽管这是上述答案的总结）。因为，尽管两个人可能同时是正确的，但你最好还是将他们的头脑集中在一起得出一个答案。

首先，你应该知道，如果你不以黑白分明的方式回答，你就不是一个学究。事情比“是/否”更复杂。

正如您将看到的，整个按值/按引用的事情与您在方法/函数作用域中对该数组执行的操作非常相关：读取它还是修改它？

PHP 说什么？ （又名“change-wise”）

手册< /a> 说的是（强调我的）：

默认情况下，函数参数通过值传递（因此，如果
函数内参数的值被更改，但它没有得到
在函数之外更改）。允许函数修改其
参数，它们必须通过引用传递。

有一个论点
函数始终通过引用传递，在前面添加一个与号 (&)
函数定义中的参数名称

据我所知，当大的、严肃的、诚实的程序员谈论引用时，他们通常会谈论改变该引用的值。这正是手册所讨论的内容：嘿，如果您想更改函数中的值，请考虑 PHP 正在执行“按值传递”。

不过，还有另一种情况他们没有提到：如果我不改变任何东西怎么办 - 只是阅读？
如果将数组传递给未显式标记引用的方法，并且我们不在函数作用域中更改该数组，该怎么办？例如：

<?php
function readAndDoStuffWithAnArray($array) 
{
    return $array[0] + $array[1] + $array[2];
}

$x = array(1, 2, 3);

echo readAndDoStuffWithAnArray($x);

请继续阅读，我的旅伴。

PHP 实际上是做什么的？ （又名“内存优化”）

同样的大而严肃的程序员，当他们变得更加严肃时，他们谈论关于引用的“内存优化”。 PHP 也是如此。因为 PHP 是一种动态的、松散类型的语言，它使用写时复制和引用计数，所以这就是 为什么。

将巨大的数组传递给各种函数以及 PHP 来复制它们（毕竟这就是“按值传递”的作用）并不理想：

<?php

// filling an array with 10000 elements of int 1
// let's say it grabs 3 mb from your RAM
$x = array_fill(0, 10000, 1); 

// pass by value, right? RIGHT?
function readArray($arr) { // <-- a new symbol (variable) gets created here
    echo count($arr); // let's just read the array
}

readArray($x);

现在，如果这实际上是按值传递，我们会失去一些 3mb+ RAM，因为该数组有两个副本，对吧？

错误的。只要我们不更改 $arr 变量，它就是一个内存方面的引用。你只是看不到而已。这就是 PHP 提及用户的原因-land 在谈论 &$someVar 时引用，以区分内部和显式（带有＆符号）。

事实

那么，当数组作为参数传递给方法或函数时，它是通过引用传递的吗？

我想出了三个（是的，三个）情况：
a) 方法/函数仅读取数组参数
b) 方法/函数修改数组参数
c) 方法/函数数组参数被显式标记为引用（使用 & 符号）

---

首先，让我们看看该数组实际占用了多少内存（运行 此处）：

<?php
$start_memory = memory_get_usage();
$x = array_fill(0, 10000, 1);
echo memory_get_usage() - $start_memory; // 1331840

那么多字节。伟大的。

a) 方法/函数仅读取数组参数

现在让我们创建一个仅读取所述数组作为参数的函数，我们将看到读取逻辑有多少内存需要：

<?php

function printUsedMemory($arr) 
{
    $start_memory = memory_get_usage();

    count($arr);       // read
    $x = $arr[0];      // read (+ minor assignment)
    $arr[0] - $arr[1]; // read

    echo memory_get_usage() - $start_memory; // let's see the memory used whilst reading
}

$x = array_fill(0, 10000, 1); // this is 1331840 bytes
printUsedMemory($x);

想猜吗？我得80分！ 亲自看看。这是 PHP 手册省略的部分。如果 $arr 参数实际上是按值传递的，您会看到类似于 1331840 字节的内容。看起来 $arr 的行为就像一个引用，不是吗？那是因为它是一个引用 - 一个内部引用。

b) 方法/函数修改数组参数

现在，让我们写入该参数，而不是从中读取：

<?php

function printUsedMemory($arr)
{
    $start_memory = memory_get_usage();

    $arr[0] = 1; // WRITE!

    echo memory_get_usage() - $start_memory; // let's see the memory used whilst reading
}

$x = array_fill(0, 10000, 1);
printUsedMemory($x);

再次，亲自看看，但是，对我来说，这非常接近 1331840。所以在这种情况下，数组实际上被复制到$arr。

c) 方法/函数数组参数被显式标记为引用（使用 & 符号）

现在让我们看看对显式引用的写入操作需要多少内存（运行 此处) - 请注意函数签名中的 & 符号：

<?php

function printUsedMemory(&$arr) // <----- explicit, user-land, pass-by-reference
{
    $start_memory = memory_get_usage();

    $arr[0] = 1; // WRITE!

    echo memory_get_usage() - $start_memory; // let's see the memory used whilst reading
}

$x = array_fill(0, 10000, 1);
printUsedMemory($x);

我打赌您最多会得到 200！因此，这消耗的内存大约与从非＆符号参数读取一样多。

Answer 4

默认情况下，

1. 原语是按值传递的。与 Java 不同的是，字符串在 PHP 中是原始的。
2. 原始数组通过值传递。
3. 对象通过引用 传递。

4. 对象数组通过值（数组）传递，但每个对象都是通过引用传递。

   <前><代码>field='world';

   $原始=数组($obj);

   函数示例($hello) {
   $hello[0]->field='mundo'; // 更改将应用​​于 $original
   $hello[1]=new stdClass(); // 更改不会应用于 $original
   $
   }

   示例（$原始）；

   var_dump($原始);
   // 数组(1) { [0]=>;对象(stdClass)#1 (1) { ["field"]=>字符串(5)“世界”}}

注意：作为优化，每个值都作为引用传递，直到在函数内修改为止。如果它被修改并且值是通过引用传递的，那么它会被复制并修改副本。

Answer 5

当数组传递给 PHP 中的方法或函数时，它是按值传递的，除非您显式通过引用传递它，如下所示：

function test(&$array) {
    $array['new'] = 'hey';
}

$a = $array(1,2,3);
// prints [0=>1,1=>2,2=>3]
var_dump($a);
test($a);
// prints [0=>1,1=>2,2=>3,'new'=>'hey']
var_dump($a);

在第二个问题中， $b 不是对 $a，而是 $a 的副本。

与第一个示例非常相似，您可以通过执行以下操作来引用 $a：

$a = array(1,2,3);
$b = &$a;
// prints [0=>1,1=>2,2=>3]
var_dump($b);
$b['new'] = 'hey';
// prints [0=>1,1=>2,2=>3,'new'=>'hey']
var_dump($a);

Answer 6

在 PHP 中，数组默认按值传递给函数，除非您显式地按引用传递它们，如以下代码片段所示：

$foo = array(11, 22, 33);

function hello($fooarg) {
  $fooarg[0] = 99;
}

function world(&$fooarg) {
  $fooarg[0] = 66;
}

hello($foo);
var_dump($foo); // (original array not modified) array passed-by-value

world($foo);
var_dump($foo); // (original array modified) array passed-by-reference

这是输出：

array(3) {
  [0]=>
  int(11)
  [1]=>
  int(22)
  [2]=>
  int(33)
}
array(3) {
  [0]=>
  int(66)
  [1]=>
  int(22)
  [2]=>
  int(33)
}

Answer 7

为了扩展答案之一，多维数组的子数组也按值传递，除非通过引用显式传递。

<?php
$foo = array( array(1,2,3), 22, 33);

function hello($fooarg) {
  $fooarg[0][0] = 99;
}

function world(&$fooarg) {
  $fooarg[0][0] = 66;
}

hello($foo);
var_dump($foo); // (original array not modified) array passed-by-value

world($foo);
var_dump($foo); // (original array modified) array passed-by-reference

结果是：

array(3) {
  [0]=>
  array(3) {
    [0]=>
    int(1)
    [1]=>
    int(2)
    [2]=>
    int(3)
  }
  [1]=>
  int(22)
  [2]=>
  int(33)
}
array(3) {
  [0]=>
  array(3) {
    [0]=>
    int(66)
    [1]=>
    int(2)
    [2]=>
    int(3)
  }
  [1]=>
  int(22)
  [2]=>
  int(33)
}

Answer 8

这个线程有点旧，但我刚刚遇到了一些东西：

尝试这个代码：

$date = new DateTime();
$arr = ['date' => $date];

echo $date->format('Ymd') . '<br>';
mytest($arr);
echo $date->format('Ymd') . '<br>';

function mytest($params = []) {
    if (isset($params['date'])) {
        $params['date']->add(new DateInterval('P1D'));
    }
}

http://codepad.viper -7.com/gwPYMw

请注意，$params 参数没有放大器，但它仍然更改 $arr['date'] 的值。这与这里的所有其他解释以及我到目前为止的想法并不相符。

如果我克隆 $params['date'] 对象，第二个输出的日期保持不变。如果我只是将其设置为字符串，它也不会影响输出。