PHP 8.3.4 Released!

class_uses

(PHP 5 >= 5.4.0, PHP 7, PHP 8)

class_uses Retorna os traits usados pela classe fornecida

Descrição

class_uses(object|string $object_or_class, bool $autoload = true): array|false

Esta função retorna um array com os nomes dos traits que a object_or_class fornecida usa. No entanto, isso não inclui quaisquer traits usados por uma classe pai.

Parâmetros

object_or_class

Um objeto (instância de classe) ou uma string (nome da classe).

autoload

Se deve autoload caso ainda não tenha sido carregado.

Valor Retornado

Um array em caso de sucesso, ou false quando a classe fornecida não existe.

Exemplos

Exemplo #1 Exemplo de class_uses()

<?php

trait foo { }
class
bar {
use
foo;
}

print_r(class_uses(new bar));

print_r(class_uses('bar'));

spl_autoload_register();

// use autoloading to load the 'not_loaded' class
print_r(class_uses('not_loaded', true));

?>

O exemplo acima produzirá algo semelhante a:

Array
(
    [foo] => foo
)
Array
(
    [foo] => foo
)
Array
(
    [trait_of_not_loaded] => trait_of_not_loaded
)

Veja Também

add a note

User Contributed Notes 7 notes

up
35
stealz at op dot pl
11 years ago
To get ALL traits including those used by parent classes and other traits, use this function:

<?php
function class_uses_deep($class, $autoload = true) {
$traits = [];
do {
$traits = array_merge(class_uses($class, $autoload), $traits);
} while(
$class = get_parent_class($class));
foreach (
$traits as $trait => $same) {
$traits = array_merge(class_uses($trait, $autoload), $traits);
}
return
array_unique($traits);
}
?>
up
9
Jos Macedo
3 years ago
Another alternative to get all parent traits is:

<?php
function getUsedTraits($classInstance) {
$parentClasses = class_parents($classInstance);
$traits = class_uses($classInstance);

foreach (
$parentClasses as $parentClass) {
$traits = array_merge($traits, class_uses($parentClass));
}

return
$traits;
}
?>
up
17
ulf
10 years ago
A slighly modified version from Stealz that also checks all the "parent" traits used by the traits:

<?php
public static function class_uses_deep($class, $autoload = true)
{
$traits = [];

// Get traits of all parent classes
do {
$traits = array_merge(class_uses($class, $autoload), $traits);
} while (
$class = get_parent_class($class));

// Get traits of all parent traits
$traitsToSearch = $traits;
while (!empty(
$traitsToSearch)) {
$newTraits = class_uses(array_pop($traitsToSearch), $autoload);
$traits = array_merge($newTraits, $traits);
$traitsToSearch = array_merge($newTraits, $traitsToSearch);
};

foreach (
$traits as $trait => $same) {
$traits = array_merge(class_uses($trait, $autoload), $traits);
}

return
array_unique($traits);
}
?>
up
4
Daniel Klein
6 years ago
If the class does not exist, you will get a warning, even if $autoload == false; I.e., if the class is not found, setting $autoload to false is not sufficient to silence the warning.

This is different from class_exists ($class_name, $autoload = true), which doesn't generate a warning in either case.
up
4
Daniel Klein
6 years ago
I have improved on ulf's improvement of stealz' code. I'm pretty sure the last "foreach" adds nothing, so I've removed it, as well as adding a check for string class names (as opposed to objects) to prevent the warning if the class is not found:

<?php
function class_uses_deep($class, $autoload = true) {
$traits = [];

// Get all the traits of $class and its parent classes
do {
$class_name = is_object($class)? get_class($class): $class;
if (
class_exists($class_name, $autoload)) {
$traits = array_merge(class_uses($class, $autoload), $traits);
}
} while (
$class = get_parent_class($class));

// Get traits of all parent traits
$traits_to_search = $traits;
while (!empty(
$traits_to_search)) {
$new_traits = class_uses(array_pop($traits_to_search), $autoload);
$traits = array_merge($new_traits, $traits);
$traits_to_search = array_merge($new_traits, $traits_to_search);
};

return
array_unique($traits);
}
up
0
donatj at gmail dot com
3 years ago
The popular stealz solution doesn't handle traits that use other traits. A little bit of recursion can clean the entire thing up a bit and make it more robust.

<?php

public function class_uses_deep( string $class, bool $autoload = true ) : array {
$traits = class_uses($class, $autoload);

if(
$parent = get_parent_class($class)) {
$traits = array_merge($traits, class_uses_deep($parent, $autoload));
}

foreach(
$traits as $trait ) {
$traits = array_merge($traits, class_uses_deep($trait, $autoload));
}

return
$traits;
}

?>
up
-46
adam at adamhahn dot com
10 years ago
FYI: It is not explicitly stated, but if you run this function against a class that does not use any traits it will return an empty array.

<?php

class iDontUseTraits {
}

class_uses('iDontUseTraits'); // Returns empty array

?>
To Top