A developer begins by defining methods in a block preceded by the keyword “trait” and an identifier. Once you’ve defined a trait, you import its methods into a class with the keyword “use” followed by the trait name. You can import more than one trait per “use” statement by including multiple trait names separated by commas. Additionally, you can can limit which methods are imported by defining a block following the trait names. The traits feature includes conflict detection, and syntax for indicating which methods to use when you attempt to use more than one trait with the same method. Here is an example:

trait bigBar {
    public function toString() {
        return implode(', ', $this->_data);
    }
    public bar() {
        return 'Big ' . $this->_bar;
    }
}
 
trait littleBar {
    public bar() {
        return 'Little ' . $this->_bar;
   }
}
 
class foo {
    use bigBar, littleBar {
        bigBar::bar;
        littleBar::bar as smallBar;
    }
}

The first line inside the “use” block resolves the conflict between the bar methods present in both traits. The second line renames littleBar’s “bar” method to smallBar. This makes it possible to use both “bar” methods.

I can imagine horizontal code reuse being messy if one were allowed to import methods from one class into another, but the syntax of Traits ensures that developers only use components that are designed for reuse, rather than piecing them together from a variety of sources. I see Traits making code easier to maintain, not only because it simplifies reuse in a number of contexts, but also because it will be easier to test code included at compile time.

This is the second minor release of PHP that has added the kind of language features that are commonly associated with major releases. Version 5.3 introduced both namespaces and lambdas, and with the addition of Traits, PHP has gained three truly groundbreaking features in two minor version updates. It will be interesting to see whether the PHP team continues to add language features with minor releases – or maybe these point releases shouldn’t be thought of as minor releases at all.

You can read more about Traits here:
https://wiki.php.net/rfc/horizontalreuse

In it’s first form, you supply a function name as the first argument.

function sum(x, y, z) {
    return x + y + z;
} 
 
$arr = array(1, 3, 5);
echo call_user_func_array('sum', $arr);    // prints 9

In the second form, you pass an array containing an object reference and the name of a method as the first argument. The following would call $obj->sum.

echo call_user_func_array(array($obj, 'sum'), $arr);

The third form involves the use of a lambda, and so it only works with versions of PHP >= 5.3. In this form you simply define the lambda, and use its reference as the first parameter.

$func = function(x, y, z) {
    return x + y + z;
}
$arr = array(5, 2, 7);
echo call_user_func_array($func, $arr);    // prints 14