When writing PHP applications, you may need to replace all stored elements and retrieve the previous collection. This is useful in everyday tasks such as working with imported data, application settings, user-facing lists, and reports.
The ArrayObject::exchangeArray() operation provides this behavior directly. The examples below show what happens to the inputs and what to check before using the result in your application.
What Is ArrayObject::exchangeArray() in PHP?
Replace all stored elements and retrieve the previous collection.
Its syntax is:
$collection->exchangeArray(array|object $array): array
Parameters used by this operation:
$array— The collection being examined or updated.
Sorting methods change internal order and retain key associations; count() does not mutate the collection. exchangeArray() replaces everything and returns the previous array.
Example 1: Basic Usage
Start with a small, self-contained input so you can inspect exactly how the operation behaves.
<?php
$collection = new ArrayObject(["mode" => "test", "debug" => true]);
$previousItems = $collection->exchangeArray(["mode" => "production"]);
print_r($previousItems);
print_r($collection->getArrayCopy());
Output:
Array
(
[mode] => test
[debug] => 1
)
Array
(
[mode] => production
)
The output shows the result of the first call. Check the printed keys and values as well as their order.
Example 2: Another Important Case
This variation highlights another input shape, a comparison option, or a change in the collection.
<?php
$collection = new ArrayObject(["host" => "old", "port" => 80]);
$previousItems = $collection->exchangeArray(["mode" => "production"]);
print_r($previousItems);
print_r($collection->getArrayCopy());
Output:
Array
(
[host] => old
[port] => 80
)
Array
(
[mode] => production
)
Compare this result with Example 1: the difference comes from the input or option selected, not from additional processing.
Practical Example: Use this method when a ArrayObject instance needs an in-place update or measurement without first rebuilding its data manually
Use this method when a ArrayObject instance needs an in-place update or measurement without first rebuilding its data manually. Save the code in a PHP file and adapt the sample data to your project.
<?php
$configuration = new ArrayObject(["mode" => "development", "log" => true]);
$previousConfiguration = $configuration->exchangeArray(["mode" => "production", "log" => false]);
echo "Old mode: " . $previousConfiguration["mode"] . PHP_EOL;
echo "New mode: " . $configuration["mode"];
Output:
Old mode: development
New mode: production
The output comes from the completed workflow shown above. When adapting it, change the source records and keep the same checks for missing, unexpected, or invalid values.
Important Behavior and Edge Cases
Sorting methods change internal order and retain key associations; count() does not mutate the collection. exchangeArray() replaces everything and returns the previous array.
- Test the operation with empty or missing input and decide how your application should respond.
- Read the return value independently from any changes to variables passed by reference.
- Validate untrusted input before using the result for permissions, database changes, or user-visible output.
Comparison With Related Functions
| Function or Approach | When to Use It |
|---|---|
ArrayObject::exchangeArray() | Replace all stored elements and retrieve the previous collection |
| Related functions | getArrayCopy() returns a snapshot without replacing the contents. |
Common Beginner Mistakes
| Mistake | Correct Approach |
|---|---|
| Confusing key sorting with value sorting | Check whether the comparison applies to keys or values before selecting the sort method. |
| Expecting an unchanged collection | The sorting operation updates the array or collection in place; copy it first when you need the original. |
| Ignoring comparison rules | Sorting methods change internal order and retain key associations; count() does not mutate the collection. exchangeArray() replaces everything and returns the previous array. |
Key Takeaways
ArrayObject::exchangeArray()helps you replace all stored elements and retrieve the previous collection.- Sorting methods change internal order and retain key associations; count() does not mutate the collection. exchangeArray() replaces everything and returns the previous array.
- getArrayCopy() returns a snapshot without replacing the contents.
- Use the practical example as a starting point, but validate real application inputs.
ArrayObject::exchangeArray() is useful when you need to replace all stored elements and retrieve the previous collection. Use its documented rules and the examples above to choose the right behavior for your data.