1) Quando uma matriz é passada como argumento para um método ou função, é passada por referência ou por valor?

2) Ao atribuir uma matriz a uma variável, a nova variável é uma referência à matriz original ou é uma nova cópia?
Que tal fazer isso:

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

É $buma referência a $a?

Para a segunda parte da sua pergunta, consulte a página da matriz do manual , que declara (citando) :

A atribuição de matrizes sempre envolve cópia de valor. Use o operador de referência para copiar uma matriz por referência.

E o exemplo dado:

<?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
?>

Para a primeira parte, a melhor maneira de ter certeza é tentar ;-)

Considere este exemplo de código:

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

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

Isso dará a saída:

array
  0 => int 10
  1 => int 20

O que indica que a função não modificou a matriz "externa" que foi passada como parâmetro: é passada como uma cópia e não como uma referência.

Se você deseja que seja passado por referência, terá que modificar a função, desta maneira:

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

E a saída se tornará:

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

Como, desta vez, a matriz foi passada "por referência".

Não hesite em ler a seção Referências explicadas do manual: ele deve responder a algumas de suas perguntas ;-)

Com relação à sua primeira pergunta, o array é passado por referência, a menos que seja modificado no método / função que você está chamando. Se você tentar modificar a matriz dentro do método / função, uma cópia dela será feita primeiro e somente a cópia será modificada. Isso faz parecer que a matriz é passada por valor quando na verdade não é.

Por exemplo, neste primeiro caso, mesmo que você não esteja definindo sua função para aceitar $ my_array por referência (usando o caractere & na definição de parâmetro), ela ainda será passada por referência (por exemplo: você não desperdiça memória com uma cópia desnecessária).

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
}

No entanto, se você modificar a matriz, uma cópia dela será feita primeiro (que usa mais memória, mas deixa a matriz original inalterada).

function handle_array($my_array) {

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

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

Para sua informação, isso é conhecido como "cópia lenta" ou "cópia na gravação".

TL; DR

a) o método / função lê apenas o argumento da matriz => referência implícita (interna)
b) o método / função modifica o argumento da matriz => valor
c) o argumento da matriz do método / função é explicitamente marcado como uma referência (com um e comercial) => referência explícita (terra do usuário)

Ou isto:
- parâmetro não comercial e comercial : passado por referência; as operações de gravação alteram uma nova cópia da matriz, cópia criada na primeira gravação;
- e comercial array param : passado por referência; as operações de gravação alteram a matriz original.

Lembre-se - o PHP faz uma cópia de valor no momento em que você escreve no parâmetro da matriz não comercial. É isso que copy-on-writesignifica. Eu adoraria mostrar a fonte C desse comportamento, mas é assustador lá. Melhor usar xdebug_debug_zval () .

Pascal MARTIN estava certo. Kosta Kontos foi ainda mais.

Responda

Depende.

Versão longa

Acho que estou escrevendo isso para mim. Eu deveria ter um blog ou algo assim ...

Sempre que as pessoas falam de referências (ou ponteiros, na verdade), elas geralmente acabam em um logotipo (apenas olhe para este tópico !).
Sendo o PHP uma linguagem venerável, pensei que deveria aumentar a confusão (mesmo que este seja um resumo das respostas acima). Porque, embora duas pessoas possam estar certas ao mesmo tempo, é melhor você apenas quebrar a cabeça em uma resposta.

Primeiro, você deve saber que não é pedante se não responder de maneira em preto e branco . As coisas são mais complicadas do que "sim / não".

Como você verá, todo o valor por referência / referência está muito relacionado ao que exatamente você está fazendo com essa matriz no seu escopo de método / função: lendo ou modificando?

O que o PHP diz? (também conhecido como "alteração")

O manual diz o seguinte (ênfase minha):

Por padrão, os argumentos da função são passados ​​por valor (para que, se o valor do argumento dentro da função for alterado , ele não seja alterado fora da função). Para permitir que uma função modifique seus argumentos, eles devem ser passados ​​por referência .

Para ter um argumento para uma função sempre passada por referência, coloque um e comercial (&) no nome do argumento na definição da função

Até onde eu sei, quando grandes programadores sérios e honestos falam sobre referências, geralmente falam em alterar o valor dessa referência . E isso é exatamente o que as negociações manuais sobre: hey, if you want to CHANGE the value in a function, consider that PHP's doing "pass-by-value".

Há outro caso que eles não mencionam: e se eu não mudar nada - apenas leia?
E se você passar uma matriz para um método que não marca explicitamente uma referência e não alteramos essa matriz no escopo da função? Por exemplo:

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

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

echo readAndDoStuffWithAnArray($x);

Continue lendo, meu companheiro de viagem.

O que o PHP realmente faz? (também conhecido como "memória")

Os mesmos programadores grandes e sérios, quando ficam ainda mais sérios, falam sobre "otimizações de memória" em relação às referências. O mesmo acontece com o PHP. Porque PHP is a dynamic, loosely typed language, that uses copy-on-write and reference countingé por isso .

Não seria ideal passar matrizes ENORME para várias funções, e o PHP para fazer cópias delas (afinal, o que "passa por valor" faz):

<?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);

Bem, agora, se isso realmente foi passado por valor, teríamos mais de 3 MB + RAM, porque existem duas cópias dessa matriz, certo?

Errado. Contanto que não alteremos a $arrvariável, isso é uma referência em memória . Você simplesmente não vê. É por isso que o PHP menciona referências de terra do usuário ao falar sobre &$someVar, para distinguir entre internas e explícitas (com e comercial).

Fatos

Assim, when an array is passed as an argument to a method or function is it passed by reference?

Eu vim com três (sim, três) casos:
a) o método / função lê apenas o argumento da matriz
b) o método / função modifica o argumento da matriz
c) o argumento da matriz do método / função é explicitamente marcado como uma referência (com um e comercial)

Primeiro, vamos ver quanta memória esse array realmente consome (execute aqui ):

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

Que muitos bytes. Ótimo.

a) o método / função lê apenas o argumento do array

Agora vamos criar uma função que apenas leia o referido array como argumento e veremos quanta memória a lógica de leitura leva:

<?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);

Quer adivinhar? Eu tenho 80! Veja você mesmo . Esta é a parte que o manual do PHP omite. Se o $arrparâmetro fosse realmente passado por valor, você veria algo semelhante aos 1331840bytes. Parece que $arrse comporta como uma referência, não é? Isso porque é uma referência - interna.

b) o método / função modifica o argumento do array

Agora, vamos escrever para esse parâmetro, em vez de ler:

<?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);

Mais uma vez, veja por si mesmo , mas, para mim, isso é muito próximo de 1331840. Portanto, nesse caso, a matriz está realmente sendo copiada $arr.

c) o argumento de matriz de método / função é explicitamente marcado como uma referência (com um e comercial)

Agora vamos ver quanta memória uma operação de gravação leva a uma referência explícita (execute aqui ) - observe oe comercial na assinatura da função:

<?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);

Minha aposta é que você receba 200 no máximo! Portanto, isso consome aproximadamente a mesma quantidade de memória que a leitura de um parâmetro que não seja E comercial .

Por padrão

1. Primitivas são passadas por valor. Improvável para Java, a string é primitiva no PHP
2. Matrizes de primitivas são passadas por valor
3. Objetos são passados ​​por referência

4. Matrizes de objetos são passadas por valor (a matriz), mas cada objeto é passado por referência.

   <?php
   $obj=new stdClass();
   $obj->field='world';
   
   $original=array($obj);
   
   
   function example($hello) {
       $hello[0]->field='mundo'; // change will be applied in $original
       $hello[1]=new stdClass(); // change will not be applied in $original
       $
   }
   
   example($original);
   
   var_dump($original);
   // array(1) { [0]=> object(stdClass)#1 (1) { ["field"]=> string(5) "mundo" } } 

Nota: Como uma otimização, todos os valores são passados ​​como referência até serem modificados dentro da função. Se ele foi modificado e o valor foi passado por referência, é copiado e a cópia é modificada.

Quando uma matriz é passada para um método ou função no PHP, é passada por valor, a menos que você a passe explicitamente por referência, da seguinte maneira:

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);

Na sua segunda pergunta, $bnão é uma referência a $a, mas uma cópia de $a.

Muito parecido com o primeiro exemplo, você pode $afazer referência fazendo o seguinte:

$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);

Esta discussão é um pouco mais antiga, mas aqui algo que me deparei:

Tente este código:

$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

Observe que não há amplificador para o parâmetro $ params e ainda assim altera o valor de $ arr ['date']. Isso realmente não combina com todas as outras explicações aqui e o que eu pensava até agora.

Se eu clonar o objeto $ params ['date'], a segunda data de saída permanecerá a mesma. Se eu apenas configurá-lo como uma string, também não afeta a saída.

Para estender uma das respostas, também as sub-matrizes de matrizes multidimensionais são passadas por valor, a menos que sejam explicitamente passadas por referência.

<?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

O resultado é:

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)
}

Em matrizes PHP, são passadas para funções por valor, por padrão, a menos que você as passe explicitamente por referência, como mostra o seguinte trecho:

$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

Aqui está a saída:

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