Est-il une fonction pour faire une copie d'un tableau PHP à l'autre?

J'ai été brûlé un peu de temps à essayer de copier les tableaux PHP. Je veux copier un tableau défini à l'intérieur d'un objet à un mondial à l'extérieur.

vraiment la fin, mais dans mon Environnement, j'ai testé (et cela a fonctionné): fonction arrayCopy(array $a) { return $a; } $a1 = array(); for ($i=0; $i<3; $i++) { $a1["clé-$i"] = "valeur #$i"; } $a1["clé-sous-tableau"] = array(1, 2, 3, 4); $a2 = $a1; $a3 = arrayCopy($a1); for ($i=0; $i<3; $i++) { if (!is_array($a2["clé-$i"])) { $a2["clé-$i"] = "nouvelle valeur #$i"; } } $a2["clé-sous-tableau"] = array("a changé de sous-tableau 1", "changé sous-tableau 2"); var_dump($a1); var_dump($a2); var_dump($a3); Le truc, c'est, pour ne pas passer le tableau en tant que référence dans la fonction 😉

InformationsquelleAutor vfclists | 2009-10-07

866

Dans les tableaux PHP sont affectés par copie, tandis que les objets sont affectés par référence. Cela signifie que:
```
$a = array();
$b = $a;
$b['foo'] = 42;
var_dump($a);
```
Donnera:
```
array(0) {
}
```
Considérant ce qui suit:
```
$a = new StdClass();
$b = $a;
$b->foo = 42;
var_dump($a);
```
Rendements:
```
object(stdClass)#1 (1) {
  ["foo"]=>
  int(42)
}
```
Vous pourriez obtenir confus par subtilités comme ArrayObject, qui est un objet qui agit exactement comme un tableau. Un objet, cependant, il est la référence de la sémantique.

Edit: @AndrewLarsson soulève un point dans les commentaires ci-dessous. PHP dispose d'une fonction spéciale appelée "références". Ils sont un peu similaires à des pointeurs dans des langages comme le C/C++, mais pas tout à fait la même. Si votre tableau contient des références, alors que le tableau lui-même est passé par copie, les références sont encore à résoudre à l'objectif initial. C'est bien sûr généralement le comportement souhaité, mais j'ai pensé qu'il était utile de mentionner.
- Vous n'avez pas répondu à la question. Vous ne explique le problème. Qui, pour l'OP, est probablement ce qu'il cherchait. Cependant, pour moi (et les autres aussi), en venant ici, près de quatre ans plus tard avec un problème similaire, je n'ai pas encore un bon moyen pour dupliquer un tableau sans modifier le tableau d'origine (qui comprend des pointeurs internes ainsi). Je suppose qu'il est temps pour moi de poser ma propre question.
- Mais PHP n'est que par défaut, C'est l'essentiel. Les références ne sont pas résolus, si vous avez besoin, vous aurez récursive de parcourir le tableau et de construire un nouveau - de la Même façon, si le tableau contient des objets, et vous voulez que ces cloné, vous devrez le faire manuellement. Gardez également à l'esprit que les références en PHP pas de même que les pointeurs en C. Sans rien connaître au sujet de votre cas, je suggère que c'est étrange d'avoir un tableau de références dans le premier cas, surtout si vous n'avez pas l'intention de les traiter comme des références? Ce qui est le cas d'utilisation?
- J'ai ajouté une réponse à cette question avec une solution à mon problème: stackoverflow.com/a/17729234/1134804
- Mais qu'en est-il, il n'est pas le comportement souhaité? La question demande comment faire un profondeur copier. Il n'est évidemment pas souhaité. Votre réponse n'est pas mieux que: $copy = $original;. Ce qui ne fonctionne pas si les éléments du tableau sont des références.
- Comme toujours php nous présente le moins résultat attendu, parce que cette solution ne fonctionne pas toujours. $a=array(); $b=$a; $b["x"]=0; $c=$b; $b["x"]=1; echo gettype($b), $c["x"]; imprime array0 tout $a=$GLOBALS; $b=$a; $b["x"]=0; $c=$b; $b["x"]=1; echo gettype($b), $c["x"]; imprime array1. Apparemment, certains tableaux sont copiés par référence.
- De revenir à cette question, je vois que vous avez mal compris ce que je voulais dire par "pointeurs internes". Je faisais allusion à l'interne pointeur sur le tableau qui est mû par l'appel de next() et des fonctions similaires. Peut-être que maintenant vous voyez pourquoi j'ai dû faire ma propre réponse à cette question (et vous avez raison, c'était en quelque sorte un cas particulier, mais je le vois avoir l'utilisation de beaucoup d'autres à venir ici).
- Ah - Oui, c'est vrai. J'ai très rarement utiliser ce moyen d'itération d'un tableau en php. Je serais normalement effectuer une itération à l'aide de foreach ou for. Sauf pour les micro-optimisations, je ne peux pas penser à un cas d'utilisation où il serait préférable d'utiliser le next, current etc. constructions?
- Je n'utilise pas le next() fonction, mais j'ai souvent besoin d'utiliser un while(list($key, $value) = each($array)) approche pour parcourir un tableau, qui ne déplacer l'interne pointeur sur le tableau après chaque itération (et que vous avez manuellement reset() avant de commencer et lorsque vous avez terminé). Ma réponse est en raison de m'avoir besoin de cloner le tableau j'étais en train de parcourir, donc j'avais besoin de m'assurer que je n'ai pas toucher à l'interne pointeur sur le tableau (car foreach déplace le pointeur interne, je ne pouvais pas l'utiliser pour le clone). Peut-être que je ne fais pas de sens, mais j'espère que vous voyez pourquoi j'ai fait ce que j'ai fait.
- Non, tu ne te sens. Pas sûr de ce que l'incidence sur les performances peut être (et c'est plutôt spécifique au contexte si c'est un problème), mais une solution pourrait être de faire une copie du tableau. De cette façon, vous ne partagez pas d'un réseau mondial de pointeur entre les différentes itérations.
- Comme c'est le plus voté réponse ici (et pour une bonne raison!), veuillez préciser dès le début (pour PHP débutants) avec quelque chose de simple comme: "En bref: Copie d'un tableau en PHP avec $a_copy = $a;". Jusqu'alors, @Reinis I. réponse obtient mon upvote.
- Dans le courant de PHP, les tableaux sont profilés comme des objets. I. e. $a=[foo=>bar];$b=$a;$b[foo]=42;echo$a[foo]; imprime bar; mais $a=[foo=>bar];$b=$a;$b->foo=42;echo$a[foo]; imprime 42. I. e.: affectation d'un tableau de variable à une autre variable ne va pas créer une copie instantanément (pour des raisons de performances); que si vous modifiez les valeurs - mais pas si vous utilisez la syntaxe objet.
- cela ne fonctionne pas pour le multi niveau arays.
InformationsquelleAutor troelskn
170

PHP va copier le tableau par défaut. Références en PHP doivent être explicites.
```
$a = array(1,2);
$b = $a; //$b will be a different array
$c = &$a; //$c will be a reference to $a
```
- Pour utiliser la référence peut être important si le tableau est énorme. Je ne suis pas sûr, mais je suppose que ça devrait entraîner une baisse de la consommation de la mémoire et de meilleures performances (pas besoin de copier l'ensemble du tableau dans la mémoire).
- au niveau de la logique du programme, le tableau est copié. Mais dans la mémoire, il ne sera pas réellement être copiés jusqu'à ce qu'il est modifié -- parce que PHP utilise de copie sur écriture de la sémantique pour tous les types. stackoverflow.com/questions/11074970/...
- Bon à savoir. Je vous remercie pour cette.
- notez que ce n'est pas vrai pour les tableaux imbriqués, ils sont des références et donc vous vous retrouvez avec une fracture de la mess
InformationsquelleAutor slikts
39

Si vous avez un tableau qui contient des objets, vous devez faire une copie de ce tableau, sans toucher à son pointeur interne, et vous avez besoin de tous les objets à être cloné (de sorte que vous n'êtes pas modifier l'original lorsque vous apportez des modifications à la copie d'un tableau), l'utilisation de ce.

L'astuce pour ne pas toucher le tableau de pointeur interne est de s'assurer que vous travaillez avec une copie de la matrice, et non pas le tableau d'origine (ou une référence), donc à l'aide d'un paramètre de fonction le travail sera fait (donc, c'est une fonction qui prend un tableau).

Noter que vous aurez besoin de mettre en œuvre __clone() sur vos objets si vous souhaitez leurs propriétés aussi être cloné.

Cette fonction fonctionne pour n'importe quel type de tableau (y compris le type mixte).
```
function array_clone($array) {
    return array_map(function($element) {
        return ((is_array($element))
            ? array_clone($element)
            : ((is_object($element))
                ? clone $element
                : $element
            )
        );
    }, $array);
}
```
- Gardez à l'esprit que c'est un peu un cas particulier. Notez également que ce ne clone le premier niveau de référence. Si vous disposez d'une vaste tableau, vous n'obtiendrez pas le plus profond des nœuds cloné, si elles sont des références. Peut-être pas un problème dans votre cas, mais juste garder à l'esprit.
- Je l'ai corrigé en ajoutant de la récursivité. Cette fonction serait maintenant travailler sur tout type de tableau, y compris les types mixtes. Il fonctionne aussi bien pour des tableaux simples, de sorte qu'il n'est pas localisée plus. En gros, c'est un universel de la matrice de clonage de machine. Vous souhaitez toujours besoin de définir de l' __clone() fonction de vos objets si elles sont profondes, mais c'est au-delà de la "portée" de cette fonction (désolé pour le mauvais jeu de mot).
- Je crois fermement que c'est la réponse réelle à cette question, La seule façon que j'ai vu à la réalité profonde de la copie d'un tableau qui contient des objets.
- Il n'a pas d'itérer les propriétés de l'objet qui peut avoir d'autres tableaux et les objets référencés.
- Correct, vous avez encore besoin de mettre en œuvre les __clone() fonction de vos objets. Voir le documentation PHP sur le clonage pour plus d'informations sur que. La grande raison pourquoi mon array_clone fonction ne pas le faire pour vous est l'une des raisons de PHP n'est pas fait pour vous: car il n'est pas efficace, réalisable moyen de se protéger contre les références circulaires.
- pas être invoquée comme par magie pour les objets qui sont stockés à l'intérieur de l'objet cloné ou d'un tableau.
- Exact, c'est pourquoi il est au développeur de mettre en œuvre les __clone() fonction (car seul le développeur sait ce qui doit être cloné). Si A magasins B, vous avez besoin pour mettre en œuvre les __clone() fonction A. Et à l'intérieur de A's __clone() fonction, vous devez vous assurer que vous clone B. Voici un exemple qui montre comment et pourquoi: sandbox.onlinephpfunctions.com/code/...
- Dans mon cas, la cible est une énorme structure multiniveau ce qui signifie qu'il est l'objet C à l'intérieur de B, objet D à l'intérieur de C, etc. Cela signifie que je dois mettre en œuvre __clone() pour tous les objets stockés sur ABC niveau. En outre, puisque ces objets sont des classes de fournisseur, j'ai à redéfinir l'ensemble et de l'instancier avec cette extension de classes pour mettre en œuvre correcte clone de comportement. C'est pratiquement impossible dans la vraie application.
- Vous pouvez prendre ce que j'ai déjà ici et d'aller une étape plus loin et d'utiliser le ReflectionClass pour obtenir toutes les propriétés de chaque objet et de les cloner comme bien. Je ne vais pas vous empêcher de faire, mais je suis d'attention qu'il n'y est probablement la meilleure façon de résoudre votre problème si vous êtes d'avoir à dupliquer des objets que profonde. Sans le savoir beaucoup au sujet de votre situation, peut-être un conteneur d'injection de dépendance aurait quelque chose à voir. Simplement vous donner quelques idées pour fonctionner avec.
- Peut-être Propriétédeepcopy peut aider à ici.
- Propriétédeepcopy fournit le comportement que vous cherchez. On dirait qu'il vont travailler hors de la boîte pour votre situation, et si vous finissez par avoir besoin de plus de contrôle, il semble avoir un montant global de configuration de sorte que vous pouvez gérer des scénarios complexes.
- Cette utilisation de __FUNCTION__ est génial.
- Peut-être était brillant en 2017, mais il ne fonctionne pas sur PHP 7 plus. Utilisez simplement le call_user_func avec une constante à la place.
- Oui, ils ont changé le comportement de __FUNCTION__ lorsqu'utilisé dans une fonction anonyme. Je vais mettre à jour ma réponse juste normal d'utilisation de la récursivité.
- Vous pouvez également stocker la valeur de __FUNCTION__ dans une variable sur la première ligne de array_clone, de sorte que vous n'avez pas à vous rappeler de mettre à jour le nom de la fonction à deux endroits si vous avez l'intention de le mettre quelque part plus longue durée de vie. Voir mes modifications pour un exemple de comment vous pouvez faire cela.
InformationsquelleAutor Andrew Larsson
28

Lorsque vous ne
```
$array_x = $array_y;
```
PHP copie le tableau, donc je ne suis pas sûr de savoir comment vous avez obtenu brûlé. Pour votre cas,
```
global $foo;
$foo = $obj->bar;
```
devrait fonctionner correctement.

Afin de vous brûler, je pense que vous seriez soit ont été à l'aide de références ou d'attendre les objets à l'intérieur de l'tableaux afin d'être cloné.
- +1 pour le présent: ", ou d'attendre les objets à l'intérieur de l'tableaux afin d'être cloné"
InformationsquelleAutor chaos
17

array_merge() est une fonction dans laquelle vous pouvez copier un tableau à l'autre en PHP.
- oui, mais les touches sera modifiée, citation: les Valeurs dans le tableau d'entrée avec les touches numériques seront renumérotés avec incrémentation des clés à partir de zéro dans le tableau résultat.
- pour le maintien de touches: $a_c = array_combine(array_keys($a), array_values($a)).
InformationsquelleAutor Kshitiz Saxena
13

simple et rend la copie en profondeur la rupture de tous les liens
```
$new=unserialize(serialize($old));
```
- En général, il fonctionne très bien cependant, dans certains cas, il peut lancer une exception parce que pas toutes les variables sont sérialisables (par exemple les fermetures et les connexions de base de données).
- Une autre chose à noter est que les références de l'objet peut être restaurée si une classe implémente __wakeup méthode magique.
- Merci, enfin quelque chose qui fonctionne vraiment, pas l'autre bollock réponses ayant beaucoup de upvotes, ils ont sûrement de ne pas traiter avec tableau d'objets tel que précisé dans la question, où nombre d'éléments dans le tableau pourrait changer, mais definitelly pas les références aux objets à l'intérieur d'eux
InformationsquelleAutor Matthew Cornelisse
10

J'aime array_replace (ou array_replace_recursive).

$cloned = array_replace([], $YOUR_ARRAY);

Il fonctionne comme de l'Objet.attribuer à partir de JavaScript.
```
$original = [ 'foo' => 'bar', 'fiz' => 'baz' ];

$cloned = array_replace([], $original);
$clonedWithReassignment = array_replace([], $original, ['foo' => 'changed']);
$clonedWithNewValues = array_replace([], $original, ['add' => 'new']);

$original['new'] = 'val';
```
entraînera
```
//original: 
{"foo":"bar","fiz":"baz","new":"val"}
//cloned:   
{"foo":"bar","fiz":"baz"}
//cloned with reassignment:
{"foo":"changed","fiz":"baz"}
//cloned with new values:
{"foo":"bar","fiz":"baz","add":"new"}
```
- Ce sujet array_slice($arr, 0) ou lorsque vous n'avez pas de soins sur les touches, array_values($arr)? Je suis en train de penser qu'ils pourraient être plus rapide que la recherche dans un tableau. Aussi, en javascript, il est très populaire pour l'utilisation Array.slice() de cloner des tableaux.
- En JS, nous avons Objet pour la clé-valeur des paires et de Array. PHP ne fait pas cette différence. Pour les tableaux PHP avec numérotés index, array_slice et toutes les autres méthodes mentionnées ici, le travail très bien. Mais si vous souhaitez fusionner plusieurs clé-valeur-paires (comme c'est également possible avec JS-Objets via Object.assign ou le propagation de syntaxe), array_replace peut être plus utile.
- merci pour la suggestion de array_values() qui a parfaitement fonctionné pour mon cas d'utilisation.
InformationsquelleAutor Putzi San
9

Si vous avez seulement des types de base dans votre tableau, vous pouvez le faire:
```
$copy = json_decode( json_encode($array), true);
```
Vous n'aurez pas besoin de mettre à jour manuellement les références

Je sais que ça ne marchera pas pour tout le monde, mais il a travaillé pour moi
- +1 c'est vraiment une mauvaise chose à faire, mais est techniquement correct et intelligent. Si je l'ai vu dans le code je ferais face palm, mais je ne peux pas aider, mais comme il.
InformationsquelleAutor chrmcpn

Puisque ce n'était pas dans les réponses, et est maintenant disponible en PHP 5.3 (supposé Post Original a l'aide d'5.2).

Afin de maintenir une structure de tableau et changer ses valeurs, je préfère utiliser array_replace ou array_replace_recursive en fonction de mon cas d'utilisation.

http://php.net/manual/en/function.array-replace.php

Voici un exemple d'utilisation de array_replace et array_replace_recursive démontrant qu'il soit en mesure de maintenir l'ordre indexé et capables de suppression d'une référence.

http://ideone.com/SzlBUZ

Le code ci-dessous est écrit en utilisant le court syntaxe de tableau est disponible depuis PHP 5.4 qui remplace array() avec [].
http://php.net/manual/en/language.types.array.php

Fonctionne sur offset indexées et le nom des tableaux indexés

$o1 = new stdClass;
$a = 'd';
//This is the base array or the initial structure
$o1->ar1 = ['a', 'b', ['ca', 'cb']];
$o1->ar1[3] = & $a; //set 3rd offset to reference $a

//direct copy (not passed by reference)
$o1->ar2 = $o1->ar1; //alternatively array_replace($o1->ar1, []);
$o1->ar1[0] = 'z'; //set offset 0 of ar1 = z do not change ar2
$o1->ar1[3] = 'e'; //$a = e (changes value of 3rd offset to e in ar1 and ar2)

//copy and remove reference to 3rd offset of ar1 and change 2nd offset to a new array
$o1->ar3 = array_replace($o1->ar1, [2 => ['aa'], 3 => 'd']);

//maintain original array of the 2nd offset in ar1 and change the value at offset 0
//also remove reference of the 2nd offset
//note: offset 3 and 2 are transposed
$o1->ar4 = array_replace_recursive($o1->ar1, [3 => 'f', 2 => ['bb']]);

var_dump($o1);

De sortie:

["ar1"]=>
array(4) {
[0]=>
string(1) "z"
[1]=>
string(1) "b"
[2]=>
array(2) {
[0]=>
string(2) "ca"
[1]=>
string(2) "cb"
}
[3]=>
&string(1) "e"
}
["ar2"]=>
array(4) {
[0]=>
string(1) "a"
[1]=>
string(1) "b"
[2]=>
array(2) {
[0]=>
string(2) "ca"
[1]=>
string(2) "cb"
}
[3]=>
&string(1) "e"
}
["ar3"]=>
array(4) {
[0]=>
string(1) "z"
[1]=>
string(1) "b"
[2]=>
array(1) {
[0]=>
string(2) "aa"
}
[3]=>
string(1) "d"
}
["ar4"]=>
array(4) {
[0]=>
string(1) "z"
[1]=>
string(1) "b"
[2]=>
array(2) {
[0]=>
string(2) "bb"
[1]=>
string(2) "cb"
}
[3]=>
string(1) "f"
}

InformationsquelleAutor fyrye

3

Je sais ce que il ya longtemps, mais cela a fonctionné pour moi..
```
$copied_array = array_slice($original_array,0,count($original_array));
```
InformationsquelleAutor bestprogrammerintheworld

C'est la façon dont je suis la copie de mes tableaux en Php:

function equal_array($arr){
$ArrayObject = new ArrayObject($arr);
return $ArrayObject->getArrayCopy();  
}
$test = array("aa","bb",3);
$test2 = equal_array($test);
print_r($test2);

Ce sorties:

Array
(
[0] => aa
[1] => bb
[2] => 3
)

Pourquoi ne pas simplement dire $test2 = $test;? Ce problème est ArrayObject de problèmes ici?

InformationsquelleAutor Baykal

Définir ce:

$copy = create_function('$a', 'return $a;');

Copie $_ARRAY à $_ARRAY2 :

$_ARRAY2 = array_map($copy, $_ARRAY);

InformationsquelleAutor Oscar Gardiazabal

1

Le plus sûr et le moins cher que j'ai trouvé est:
```
<?php 
$b = array_values($a);
```
Cela a aussi l'avantage de réindexer le tableau.

Cela ne fonctionnera pas comme prévu sur le tableau associatif (hash), mais pas plus de réponse précédente.

InformationsquelleAutor Hussard

<?php
function arrayCopy( array $array ) {
$result = array();
foreach( $array as $key => $val ) {
if( is_array( $val ) ) {
$result[$key] = arrayCopy( $val );
} elseif ( is_object( $val ) ) {
$result[$key] = clone $val;
} else {
$result[$key] = $val;
}
}
return $result;
}
?>

InformationsquelleAutor umair

0

En tableau php, vous avez besoin simplement de les affecter à d'autres variables pour obtenir une copie de ce tableau. Mais d'abord, vous devez vous assurer que sur ce genre, si c'est un array ou arrayObject ou stdObject.

Pour un Simple tableau php :
```
$a = array(
'data' => 10
);
$b = $a;
var_dump($b);
output:
array:1 [
"data" => 10
]
```
InformationsquelleAutor MAULIK MODI
0

$arr_one_copy = array_combine(array_keys($arr_one), $arr_one);

Juste pour poster la solution 😉

InformationsquelleAutor Kim

Crée une copie de la ArrayObject

<?php
//Array of available fruits
$fruits = array("lemons" => 1, "oranges" => 4, "bananas" => 5, "apples" => 10);
$fruitsArrayObject = new ArrayObject($fruits);
$fruitsArrayObject['pears'] = 4;
//create a copy of the array
$copy = $fruitsArrayObject->getArrayCopy();
print_r($copy);
?>

de https://www.php.net/manual/en/arrayobject.getarraycopy.php

InformationsquelleAutor kheengz

-1

private function cloneObject($mixed)
{
switch (true) {
case is_object($mixed):
return clone $mixed;
case is_array($mixed):
return array_map(array($this, __FUNCTION__), $mixed);
default:
return $mixed;
}
}

InformationsquelleAutor Artemiy StagnantIce Alexeew

Vous devez vous connecter pour publier un commentaire.