There are 3 operations with sets in mathematics: intersection, difference and union (unification). In PHP we can do this operations with arrays:

- intersection:
`array_intersect`

- difference:
`array_diff`

**What function is for union?**

No duplicates can be in the result array (like `array_intersect`

and `array_diff`

).

If indexes are numeric then `array_merge`

will not overwrite the original value, but will be appended (PHP docs).

### Answer：

`array_unique( array_merge( ... ) )`

### Answer：

Adrien’s answer won’t necessary produce a sequentially numbered array from two sequentially numbered arrays – here are some options that will:

```
array_values(array_unique(array_merge($array1, $array2)));
```

(Adrien’s answer with renumbering the keys afterward)

```
array_keys(array_flip($array1)+array_flip($array2))
```

(Put the values in the keys, and use the array union operator)

```
array_merge($array1, array_diff($array2, $array1))
```

(Remove the shared values from the second array before merging)

Benchmark results (for merging two arrays of length 1000 a thousand times on my system):

- Unique (Adrien’s version): 2.862163066864 seconds
- Values_Unique: 3.12 seconds
- Keys_Flip: 2.34 seconds
- Merge_Diff: 2.64 seconds

Same test, but with the two arrays being very similar (at least 80% duplicate):

- Unique (Adrien’s version): 2.92 seconds
- Values_Unique: 3.15 seconds
- Keys_Flip: 1.84 seconds
- Merge_Diff: 2.36 seconds

It seems using the array union operator to do the actual union is the fastest method. Note however that `array_flip`

is only safe if the array’s values are all strings or all integers; if you have to produce the union of an array of objects, I recommend the version with `array_merge`

and `array_diff`

.

### Answer：

Use `array_unique`

and `array_merge`

together.

### Answer：

use “+” operator to do so. See the link Array Operators

### Answer：

From the code in the PHP: Array Operators documentation:

```
<?php
$a = array("a" => "apple", "b" => "banana");
$b = array("a" => "pear", "b" => "strawberry", "c" => "cherry");
$c = $a + $b; // Union of $a and $b
echo "Union of $a and $b: \n";
var_dump($c);
$c = $b + $a; // Union of $b and $a
echo "Union of $b and $a: \n";
var_dump($c);
?>
```

When executed, this script will print the following:

Union of $a and $b: array(3) { ["a"]=> string(5) "apple" ["b"]=> string(6) "banana" ["c"]=> string(6) "cherry" } Union of $b and $a: array(3) { ["a"]=> string(4) "pear" ["b"]=> string(10) "strawberry" ["c"]=> string(6) "cherry" }

### Answer：

```
$result = array_merge_recursive($first, $second);
```

can be useful when you have arrays with arrays inside.

### Answer：

The `+`

operator:

```
$x[0] = 4;
$x[1] = 1;
$y[0] = 9;
$y[2] = 5;
$u = $y + $x;
// Results in:
$u[0] === 9;
$u[1] === 1;
$u[2] === 5;
```

Note that `$x + $y`

!= `$y + $x`

### Answer：

The OP did not specify whether the union is by **value** or by **key** and PHP has `array_merge`

for merging values and `+`

for merging the keys. The results depends on whether the array is indexed or keyed **and** which array comes first.

```
$a = ['a', 'b'];
$b = ['b', 'c'];
$c = ['a' => 'A', 'b' => 'B'];
$d = ['a' => 'AA', 'c' => 'C'];
```

## Indexed array

See `array_merge`

### By value using `array_merge`

```
array_merge($a, $b); // [0 => 'a', 1 => 'b', 2 => 'b', 3 => 'c']
array_merge($b, $a); // [0 => 'b', 1 => 'c', 2 => 'a', 3 => 'b']
```

### merge by key using `+`

operator

See `+`

operator

```
$a + $b; // [0 => 'a', 1 => 'b']
$b + $a; // [0 => 'b', 1 => 'c']
```

## Keyed array

### By value using `array_merge`

```
array_merge($c, $d); // ['a' => 'AA', 'b' => 'B', 'c' => 'C']
array_merge($d, $c); // ['a' => 'A', 'c' => 'C', 'b' => 'B']
```

### merge by key using `+`

operator

```
$c + $d; // ['a' => 'A', 'b' => 'B', 'c' => 'C']
$d + $c; // ['a' => 'AA', 'c' => 'C', 'b' => 'B']
```

### Answer：

Just use `$array1 + $array2`

It will result union of both array.