Arrays of objects in PHP contain class instances, allowing direct property or method-based modifications; 2. Update properties using foreach loops since objects are passed by reference, or use setters for encapsulated properties; 3. Filter objects with array_filter() to create subsets based on conditions without altering the original array; 4. Sort arrays using usort() with a comparison function on object properties, noting it modifies the original unless a copy is used; 5. Transform data via array_map(), extracting values or modifying objects, though keys may require reindexing with array_values(); 6. Search for objects using a loop for the first match or array_filter() for multiple results, then retrieve the first element if needed; 7. Add objects with [] or array_push(), remove by key using unset() followed by array_values() to reindex, or filter out based on conditions; 8. Avoid pitfalls by checking property existence, reindexing after removal, and cloning objects with clone to prevent unintended side effects, ensuring safe and predictable manipulation of object arrays.

Modifying arrays of objects in PHP is a common task when working with data from databases, APIs, or structured application logic. Whether you're filtering, updating, sorting, or transforming object collections, understanding the right techniques ensures clean, efficient code.

Here’s a practical guide to help you confidently manipulate arrays of objects in PHP.

1. Understanding Arrays of Objects

In PHP, an array of objects is simply an array where each element is an instance of a class. For example:

class User {
    public $name;
    public $age;
    public $active;

    public function __construct($name, $age, $active = true) {
        $this->name = $name;
        $this->age = $age;
        $this->active = $active;
    }
}

$users = [
    new User("Alice", 30),
    new User("Bob", 25, false),
    new User("Charlie", 35)
];

Now $users is an array of User objects. You can modify this array in various ways.

2. Updating Object Properties

You can loop through the array and modify object properties directly since objects are passed by reference.

foreach ($users as $user) {
    if ($user->age < 30) {
        $user->category = 'young';
    } else {
        $user->category = 'adult';
    }
}

Now each user has a new category property. Note: PHP allows dynamic property assignment unless the class uses __set() restrictions.

If you're using a class with private/protected properties and setters, call the appropriate method:

$user->setActive(true);

3. Filtering Objects

Use array_filter() to create a new array containing only objects that match a condition.

// Get only active users
$activeUsers = array_filter($users, function($user) {
    return $user->active;
});

// Get users over 30
$olderUsers = array_filter($users, function($user) {
    return $user->age > 30;
});

The original array remains unchanged unless you reassign it.

4. Sorting Objects

Use usort() to sort the array based on object properties.

// Sort users by age (ascending)
usort($users, function($a, $b) {
    return $a->age <=> $b->age;
});

// Sort by name (alphabetically)
usort($users, function($a, $b) {
    return strcmp($a->name, $b->name);
});

usort() modifies the original array. Use sorted = $users and sort the copy if you want to preserve order.

5. Transforming Objects (Map Pattern)

PHP doesn’t have a native array_map equivalent for objects that preserves object types, but you can still transform data.

// Extract names into a simple array
$names = array_map(function($user) {
    return $user->name;
}, $users);

// Or modify and return new objects
$updatedUsers = array_map(function($user) {
    $user->name = strtoupper($user->name);
    return $user; // returning same object (modified)
}, $users);

Be careful: array_map() doesn't preserve keys unless you reindex or use array_values().

6. Searching for Objects

Use array_filter() for multiple matches or a loop for the first match.

// Find first user named Alice
$found = null;
foreach ($users as $user) {
    if ($user->name === 'Alice') {
        $found = $user;
        break;
    }
}

Or use array_filter() and grab the first result:

$matches = array_filter($users, fn($u) => $u->name === 'Alice');
$found = !empty($matches) ? array_values($matches)[0] : null;

7. Adding or Removing Objects

• Add an object using [] or array_push():

$users[] = new User("Diana", 28);
// or
array_push($users, new User("Eve", 32));

• Remove by key (if known):

unset($users[0]); // removes first element
$users = array_values($users); // reindex array

• Remove by condition:

$users = array_filter($users, function($user) {
    return $user->age <= 100; // example: remove users over 100
});

Remember: array_filter() returns a new array, so reassign to update.

8. Avoid Common Pitfalls

• Objects are passed by reference: Modifying an object inside a loop affects the original.
• Use array_values() after unset() or array_filter() if you need clean numeric keys.
• Don’t assume properties exist — check with isset() or in class definition.
• Immutable patterns: If you want to avoid side effects, clone objects:

$clonedUsers = array_map(fn($user) => clone $user, $users);

Now modifications to $clonedUsers won’t affect the original.

Modifying arrays of objects in PHP comes down to combining array functions with object-oriented access. Use loops for direct changes, array_filter, usort, and array_map for transformations, and always consider whether you’re working with references or copies.

Basically, once you’re comfortable mixing array operations with object property access, these tasks become straightforward and powerful.

The above is the detailed content of A Guide to Modifying Arrays of Objects in PHP. For more information, please follow other related articles on the PHP Chinese website!