How to join 2 arrays of objects on the same property?

Question

Suppose I have these 2 arrays of objects:

A:

[
  [0] => (stdClass) {
    id => '0',
    ....
  },
  [1] => (stdClass) {
    id => '1',
    ....
  },
  ,
  [2] => (stdClass) {
    id => '2',
    ....
  }
]

B:

[
  [0] => (stdClass) {
    id => '0',
    name => 'Hello',
    a_id => '2'
    ....
  },
  [1] => (stdClass) {
    id => '1',
    name => 'World',
    a_id => '2'
    ....
  },
  [2] => (stdClass) {
    id => '2',
    name => 'foo',
    a_id => '0'
    ....
  }
]

When B.a_id = A.id, the object from B belongs to A, and I want to add the object in an array to A, like this:

A:

[
  ...,
  [2] => (stdClass) {
    id => '2',
    mapped_objs => [
       [0] => (stdClass) {
       id => '0',
       name => 'Hello',
       a_id => '2'
       ....
       },
      [1] => (stdClass) {
        id => '1',
        name => 'World',
        a_id => '2'
        ....
      },
    ]
  }
  ...,
]

Is there an efficient algorithms or functions in PHP that will solve this problem? Do I have to do this in O(n^2)?

Answer 1

O(n^2)? Depends

If this structure (and the stdClass definitions) are beyond your control, probably. The only alternative in this case, is to lookup B.a_id in A whenever accessing that property. Additionally using array_filter to match a collection from B when needing a list for A. (lots of code duplication) Such a solution will only be more efficient than an O(n^2) if you only need one side of that relationship, and/or won't access all instances of those relationships.

An important component of that solutions is the "whenever accessing that property" piece, which applies to both sides of the one-to-many data-relationship. This leads me to a (correct?) better solution: OOP.

Define the objects as objects, especially for APIs.

Usually when I hear a dev say "I can't change the object or data-structure," what they really mean is that they don't want to. (Or they don't know it can be done easily).

Rather than allowing these objects to be defined as stdClass, make them a real class.

Looping through each set once, and converting them into their own objects, will solve your problem without an nested loop, as well as other problems you haven't yet thought of. The key to solving this problem without a nested loop lies in proper use of the primary-key, A.id <-- B.a_id. If you use A.id as the index for your array of A objects, you need no loop to find a match for B.

That little bit of data-structure basics aside. OOP will save your life if you use it, so that'll be the code sample I provide.

$arrayA = []; // your source for A
$arrayB = []; // your source for B

class A {
    public $id, $bList;

    public function __construct(stdClass $aOrig)
    {
        $this->id = $aOrig->id;
    }
    
    public function addB(B $b) {
        $this->bList[$b->id] = $b;
    }
}

class B {
    public $id, $name, $a_id, $a;
    
    public function __construct(stdClass $bOrig)
    {
        $this->id = $bOrig->id;
        $this->name = $bOrig->name;
        $this->a_id = $bOrig->a_id;
    }
}

$aList = [];
foreach ($arrayA as $aO) {
    // since .id is your data's primary-key, use it like one and make it your array-index
    $aList[$aO->id] = new A($aO); 
}

$bList = []; // not necessary, as you'll these objects in A->bList 
foreach ($arrayB as $bO) {
    // same primary-key trick (can skip creating $bList)
    $b = $bList[$bO->id] = new B($bO);
    // get A by its key (and array-index) AND assign it to B
    $b->a = $a = $aList[$b->a_id];
    // add B to A's bList and you're done.
    $a->addB($b);
}