1) Lorsqu'un tableau est passé en argument à une méthode ou une fonction, est-il passé par référence ou par valeur?

2) Lors de l'affectation d'un tableau à une variable, la nouvelle variable est-elle une référence au tableau d'origine ou s'agit-il d'une nouvelle copie?
Et si vous faisiez ça:

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

Est $bune référence à $a?

Pour la deuxième partie de votre question, consultez la page du tableau du manuel , qui indique (citation) :

L'affectation de tableau implique toujours une copie de valeur. Utilisez l'opérateur de référence pour copier un tableau par référence.

Et l'exemple donné:

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

Pour la première partie, le meilleur moyen d'en être sûr est d'essayer ;-)

Considérez cet exemple de code:

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

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

Cela donnera cette sortie:

array
  0 => int 10
  1 => int 20

Ce qui indique que la fonction n'a pas modifié le tableau "extérieur" qui a été passé en paramètre: il est passé en copie et non en référence.

Si vous voulez qu'il soit passé par référence, vous devrez modifier la fonction de cette façon:

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

Et la sortie deviendra:

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

Comme, cette fois, le tableau a été passé "par référence".

N'hésitez pas à lire la section Références expliquées du manuel: il devrait répondre à certaines de vos questions ;-)

En ce qui concerne votre première question, le tableau est passé par référence SAUF s'il est modifié dans la méthode / fonction que vous appelez. Si vous essayez de modifier le tableau dans la méthode / fonction, une copie de celui-ci est effectuée en premier, puis seule la copie est modifiée. Cela donne l'impression que le tableau est passé par valeur alors qu'en réalité il ne l'est pas.

Par exemple, dans ce premier cas, même si vous ne définissez pas votre fonction pour accepter $ my_array par référence (en utilisant le caractère & dans la définition du paramètre), elle est toujours passée par référence (c'est-à-dire: vous ne perdez pas de mémoire avec une copie inutile).

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
}

Cependant, si vous modifiez le tableau, une copie est effectuée en premier (qui utilise plus de mémoire mais ne modifie pas votre tableau d'origine).

function handle_array($my_array) {

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

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

FYI - ceci est connu comme "copie paresseuse" ou "copie sur écriture".

TL; DR

a) la méthode / fonction lit uniquement l'argument tableau => référence implicite (interne)
b) la méthode / fonction modifie l'argument tableau => valeur
c) l'argument méthode / fonction tableau est explicitement marqué comme référence (avec une esperluette) => référence explicite (user-land)

Ou ceci:
- paramètre de tableau non-esperluette : passé par référence; les opérations d'écriture modifient une nouvelle copie du tableau, copie qui est créée lors de la première écriture;
- paramètre de tableau esperluette : transmis par référence; les opérations d'écriture modifient le tableau d'origine.

N'oubliez pas - PHP effectue une copie de valeur au moment où vous écrivez dans le paramètre du tableau non esperluette. Voilà ce que ça copy-on-writeveut dire. J'adorerais vous montrer la source C de ce comportement, mais c'est effrayant là-dedans. Mieux vaut utiliser xdebug_debug_zval () .

Pascal MARTIN avait raison. Kosta Kontos l'était encore plus.

Répondre

Ça dépend.

Version longue

Je pense que je l'écris pour moi. Je devrais avoir un blog ou quelque chose ...

Chaque fois que les gens parlent de références (ou de pointeurs, d'ailleurs), ils se retrouvent généralement dans une logomachie (il suffit de regarder ce fil !).
PHP étant un langage vénérable, j'ai pensé que je devrais ajouter à la confusion (même si c'est un résumé des réponses ci-dessus). Parce que, même si deux personnes peuvent avoir raison en même temps, il vaut mieux se casser la tête en une seule réponse.

Tout d'abord, vous devez savoir que vous n'êtes pas un pédant si vous ne répondez pas en noir et blanc . Les choses sont plus compliquées que «oui / non».

Comme vous le verrez, la chose entière par valeur / par référence est très liée à ce que vous faites exactement avec ce tableau dans la portée de votre méthode / fonction: le lire ou le modifier?

Que dit PHP? (alias "en termes de changement")

Le manuel dit ceci (soulignement le mien):

Par défaut, les arguments de fonction sont passés par valeur (de sorte que si la valeur de l'argument dans la fonction est modifiée , elle ne soit pas modifiée en dehors de la fonction). Pour permettre à une fonction de modifier ses arguments, ils doivent être passés par référence .

Pour qu'un argument d'une fonction soit toujours transmis par référence, ajoutez une esperluette (&) au nom de l'argument dans la définition de la fonction

Pour autant que je sache, lorsque de gros programmeurs sérieux et honnêtes envers Dieu parlent de références, ils parlent généralement de modifier la valeur de cette référence . Et c'est exactement ce que les pourparlers manuels sur: hey, if you want to CHANGE the value in a function, consider that PHP's doing "pass-by-value".

Il y a un autre cas qu'ils ne mentionnent pas: que se passe-t-il si je ne change rien - lisez simplement?
Que se passe-t-il si vous passez un tableau à une méthode qui ne marque pas explicitement une référence et que nous ne changeons pas ce tableau dans la portée de la fonction? Par exemple:

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

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

echo readAndDoStuffWithAnArray($x);

Continuez à lire, mon compagnon de voyage.

Que fait réellement PHP? (aka "mémoire-sage")

Les mêmes programmeurs gros et sérieux, quand ils deviennent encore plus sérieux, ils parlent d '"optimisations de mémoire" en ce qui concerne les références. PHP aussi. Parce PHP is a dynamic, loosely typed language, that uses copy-on-write and reference countingque c'est pour ça .

Il ne serait pas idéal de passer des tableaux HUGE à diverses fonctions, et PHP pour en faire des copies (c'est ce que fait "pass-by-value", après tout):

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

Eh bien maintenant, si c'était réellement une valeur de passage, nous aurions perdu 3 Mo de RAM, car il y a deux copies de ce tableau, non?

Faux. Tant que nous ne changeons pas la $arrvariable, c'est une référence, en termes de mémoire . Vous ne le voyez tout simplement pas. C'est pourquoi PHP mentionne les références utilisateur-terre lors de la discussion &$someVar, pour distinguer les références internes et explicites (avec esperluette).

Les faits

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

J'ai trouvé trois (ouais, trois) cas:
a) la méthode / fonction lit uniquement l'argument tableau
b) la méthode / fonction modifie l'argument tableau
c) l' argument méthode / fonction tableau est explicitement marqué comme référence (avec un esperluette)

Tout d'abord, voyons combien de mémoire ce tableau consomme réellement (exécutez ici ):

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

Que de nombreux octets. Génial.

a) la méthode / fonction lit uniquement l'argument tableau

Faisons maintenant une fonction qui ne lit que ledit tableau comme argument et nous verrons combien de mémoire la logique de lecture prend:

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

Tu veux deviner? J'en ai 80! Voyez par vous-même . C'est la partie que le manuel PHP omet. Si le $arrparamètre était réellement passé par valeur, vous verriez quelque chose de similaire aux 1331840octets. Il semble que cela $arrse comporte comme une référence, n'est-ce pas? C'est parce qu'il est une référence - un interne.

b) la méthode / fonction modifie l'argument tableau

Maintenant, écrivons à ce paramètre, au lieu de le lire:

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

Encore une fois, voyez par vous - même , mais, pour moi, c'est assez proche de 1331840. Donc, dans ce cas, le tableau est en fait copié $arr.

c) l'argument tableau méthode / fonction est explicitement marqué comme référence (avec une esperluette)

Voyons maintenant combien de mémoire prend une opération d'écriture sur une référence explicite (exécutez ici ) - notez l'esperluette dans la signature de la fonction:

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

Je parie que vous obtenez 200 max! Cela consomme donc autant de mémoire que la lecture d'un paramètre non-esperluette .

Par défaut

1. Les primitives sont passées par valeur. Peu probable pour Java, la chaîne est primitive en PHP
2. Les tableaux de primitives sont passés par valeur
3. Les objets sont passés par référence

4. Les tableaux d'objets sont transmis par valeur (le tableau) mais chaque objet est transmis par référence.

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

Remarque: En tant qu'optimisation, chaque valeur unique est transmise comme référence jusqu'à sa modification à l'intérieur de la fonction. S'il est modifié et que la valeur a été transmise par référence, il est copié et la copie est modifiée.

Lorsqu'un tableau est passé à une méthode ou une fonction en PHP, il est passé par valeur à moins que vous ne le passiez explicitement par référence, comme ceci:

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

Dans votre deuxième question, ce $bn'est pas une référence à $a, mais une copie de $a.

Tout comme le premier exemple, vous pouvez faire référence $aen procédant comme suit:

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

Ce fil est un peu plus ancien mais voici quelque chose que je viens de rencontrer:

Essayez ce code:

$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

Notez qu'il n'y a pas d'ampli pour le paramètre $ params et qu'il change toujours la valeur de $ arr ['date']. Cela ne correspond pas vraiment à toutes les autres explications ici et à ce que je pensais jusqu'à présent.

Si je clone l'objet $ params ['date'], la 2ème date sortie reste la même. Si je le mets juste sur une chaîne, cela n'affecte pas non plus la sortie.

Pour étendre l'une des réponses, les sous-tableaux de tableaux multidimensionnels sont également passés par valeur, sauf s'ils sont passés explicitement par référence.

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

Le résultat est:

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

En PHP, les tableaux sont passés aux fonctions par valeur par défaut, sauf si vous les passez explicitement par référence, comme le montre l'extrait de code suivant:

$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

Voici la sortie:

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