Есть ли функция, чтобы сделать копию массива PHP в другой?

PHP будет копировать массив по умолчанию. Ссылки на PHP должны быть явными.

$a = array(1,2);
$b = $a; // $b will be a different array
$c = &$a; // $c will be a reference to $a

Если у вас есть массив, содержащий объекты, вам нужно сделать копию этого массива, не касаясь его внутреннего указателя, и вам необходимо клонировать все объекты (чтобы не изменять оригиналы при внесении изменений в скопированный объект). массив), используйте это.

Хитрость в том, чтобы не касаться внутреннего указателя массива, заключается в том, чтобы убедиться, что вы работаете с копией массива, а не с исходным массивом (или ссылкой на него), поэтому использование параметра функции позволит выполнить работу (таким образом, это функция, которая принимает массив).

Обратите внимание, что вам все равно нужно будет реализовать __clone() на ваших объектах, если вы хотите, чтобы их свойства также были клонированы.

Эта функция работает для любого типа массива (включая смешанный тип).

function array_clone($array) {
    return array_map(function($element) {
        return ((is_array($element))
            ? array_clone($element)
            : ((is_object($element))
                ? clone $element
                : $element
            )
        );
    }, $array);
}

Когда вы делаете

$array_x = $array_y;

PHP копирует массив, поэтому я не уверен, как вы сожгли бы. Для вашего случая,

global $foo;
$foo = $obj->bar;

должен работать нормально.

Чтобы сгореть, я думаю, вам придется либо использовать ссылки, либо ожидать, что объекты внутри массивов будут клонированы.

array_merge() - это функция, в которой вы можете скопировать один массив в другой в PHP.

простой и делает глубокую копию всех ссылок

$new=unserialize(serialize($old));

просто и аккуратно для PHP> = 5.3

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

array_replace (или array_replace_recursive). Для меня самый чистый путь и просто как Object.assign из 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';

приведет к

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

Если у вас есть только базовые типы в вашем массиве, вы можете сделать это:

$copy = json_decode( json_encode($array), true);

Вам не нужно вручную обновлять ссылки
Я знаю, что это не сработает для всех, но это сработало для меня.

Так как это не было затронуто ни в одном из ответов и теперь доступно в PHP 5.3 (предполагается, что Original Post использовала 5.2).

Чтобы сохранить структуру массива и изменить его значения, я предпочитаю использовать array_replace или array_replace_recursive в зависимости от моего варианта использования.

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

Вот пример использования array_replace и array_replace_recursive, демонстрирующий, что он способен поддерживать индексированный порядок и способен удалить ссылку.

http://ideone.com/SzlBUZ

Код ниже написан с использованием синтаксиса короткого массива, доступного с PHP 5.4, который заменяет array() на []. http://php.net/manual/en/language.types.array.php

Работает как с индексированными, так и с индексированными массивами с надписью

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

Вывод:

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

Я знаю это уже давно, но это сработало для меня.

$copied_array = array_slice($original_array,0,count($original_array));

Так я копирую свои массивы в Php:

function equal_array($arr){
  $ArrayObject = new ArrayObject($arr);
  return $ArrayObject->getArrayCopy();  
}

$test = array("aa","bb",3);
$test2 = equal_array($test);
print_r($test2);

Выводится:

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

Самый безопасный и самый дешевый способ:

<?php 
$b = array_values($a);

Это также дает возможность переиндексировать массив.

Это не будет работать так, как ожидалось, в ассоциативном массиве (хэш), но ни один из предыдущих ответов.

Определите это:

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

Скопируйте $_ARRAY в $_ARRAY2:

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

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

Просто чтобы опубликовать еще одно решение;)

В php-массиве вам нужно просто назначить их другой переменной, чтобы получить копию этого массива. Но сначала вам нужно убедиться в этом, будь то массив или arrayObject или stdObject.

Для простого массива php:

$a = array(
'data' => 10
);

$b = $a;

var_dump($b);

output:

array:1 [
  "data" => 10
]

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

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