PHP 等效于 jQuery $.extend()？

Question

Is there anything equivalent in PHP for jQuery's $.extend()?

I want to pragmatically merge/combine/extend classes with other classes and it's properties (including methods) without using late static binding.

class a {}
class b {}
class c {}

$merged = combine(new a(), new b(), new c());

This is not what I am looking for:

class a {}
class b extends a {}

$merged = new b();

Answer 1

There isn't really anything equivalent in PHP, because their object systems are very different.

JavaScript doesn't have real classes like PHP does, its object system is based on prototypes. Methods can be direct properties of the instance, but if there isn't a direct property the prototype chain will be searched to find it. $.extend() automatically copies properties that are inherited from the prototype to the target object, so the result is kind of like an instance of a subclass of all the original classes.

But PHP doesn't have any equivalent to attaching methods directly to objects, so there's no way that a combine() function could merge all the methods from classes of the arguments. An object is an instance of a particular class, and it gets its methods from the class object (and its superclasses) only.

Answer 2

Like @Barmar said, this isn't really a thing in PHP. Workarounds are ugly but I am going to describe ugly workarounds for whoever want a big laugh.

Workaround #1 - Extend classes by the use of magic methods in a class. Pros are that the properties and methods can be accessed from one merged object. But under the surface they are not really merged. So setting properties is discouraged and cross accessing properties is a no go.

class extend {
  private $_objects;
  private $_properties = [];

  public function __construct(...$objects) {
    $this->_objects =  array_reverse($objects);
  }

  public function &__isset($name) {
    return $this->__get($name);
  }

  public function __get($name) {

    foreach ($this->_objects as $object) {
      if (isset($object->$name)) {
        return $object->$name;
      }
    }

    if (isset($this->_properties[$name])) {
      return $this->_properties[$name];
    }

    return null;
  }

   public function __set($name, $value) {

    foreach ($this->_objects as $object) {
      if (isset($object->$name)) {
        $object->$name = $value;
        return true;
      }
    }

    $this->_properties[$name] = $value;

    return true;
  }

  public function __call($name, $params) {

    foreach ($this->_objects as $object) {
      if (method_exists($object, $name)) {
        call_user_func_array([$object, $name], $params);
      }
    }

    return null;
  }
}

Example Objects:

class a {
  var $fruit= 'apple';
  function foo() { echo 'a'; }
}

class b {
  var $fruit = 'banana';
  function bar() { echo 'b'; }
}

Merge Example:

$merged = new extend(new a(), new b());
$merged->foo();
$merged->bar();

$merged->this = 'that';
echo $merged->this;

Workaround #2 - Merging objects with anonymous functions instead of methods makes them portable and mergeable. Cons are it may be considered unethic or a future security risk to rely on them. Anonymous functions in properties can not be defined in the class, but must be set in __construct(). And accessing anonymous functions as properties conflicts the syntax for regular methods so a workaround for the syntax calling them is also needed (PHP 7.0+).

Object Example:

class a {
  var $fruit = 'apple';

  function __construct(){
    $this->foo = function() { return 'a'; };
  }
}

class b {
  var $fruit = 'banana';

  function __construct() {
    $this->bar = function() { return 'b'; };
  }
}

Example Objects:

$merged = (object)array_merge(
  get_object_vars(new a()),
  get_object_vars(new b())
);

echo ($merged->foo)(); // $class->var() doesn't work for anonymous functions
echo ($merged->bar)();

$merged->fruit = 'orange';
echo $merged->fruit;

Final conclusions: Surely unconventional, mostly ugly.