class_alias

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

class_alias — Erzeugt einen Alias für eine Klasse

Beschreibung

class_alias(string $class, string $alias, bool $autoload = true): bool

Erzeugt einen Alias namens alias basierend auf der benutzerdefinierten Klasse class. Die abgeleitete Klasse ist genau die gleiche wie die Originalklasse.

Hinweis: Seit PHP 8.3.0 kann mit class_alias() auch ein Alias einer internen Klasse erstellt werden. creating an alias of an PHP internal class.

Parameter-Liste

class: Die Originalklasse
alias: Der Alias-Name für die Klasse
autoload: Gibt an, ob automatisch geladen werden soll, wenn die Originalklasse nicht gefunden wird

Rückgabewerte

Gibt bei Erfolg true zurück. Bei einem Fehler wird false zurückgegeben.

Changelog

Version	Beschreibung
8.3.0	Mit class_alias() kann nun ein Alias einer internen Klasse erstellt werden.

Beispiele

Beispiel #1 class_alias()-Beispiel

<?php

class Foo { }

class_alias('Foo', 'Bar');

$a = new Foo;
$b = new Bar;

// die Objekte sind identisch
var_dump($a == $b, $a === $b);
var_dump($a instanceof $b);

// die Klassen sind identisch
var_dump($a instanceof Foo);
var_dump($a instanceof Bar);

var_dump($b instanceof Foo);
var_dump($b instanceof Bar);

?>

Das oben gezeigte Beispiel erzeugt folgende Ausgabe:

bool(true)
bool(false)
bool(true)
bool(true)
bool(true)
bool(true)
bool(true)

Anmerkungen

Hinweis:
In PHP wird bei Klassennamen nicht zwischen Groß- und Kleinschreibung unterschieden, was sich auch in dieser Funktion widerspiegelt. Aliase, die mit class_alias() erstellt werden, werden in Kleinbuchstaben deklariert. Das bedeutet, dass im Fall der Klasse MyClass durch den Aufruf class_alias('MyClass', 'MyClassAlias') eine neue Alias-Klasse namens myclassalias erstellt wird.

Siehe auch

get_parent_class() - Gibt den Namen der Elternklasse eines Objektes zurück
is_subclass_of() - Prüft ob ein Objekt von der angegebenen Klasse abstammt oder sie implementiert

Improve This Page

Learn How To Improve This Page • Submit a Pull Request • Report a Bug

＋add a note

User Contributed Notes 14 notes

down

mweierophinney at gmail dot com ¶

11 years ago

class_alias() gives you the ability to do conditional imports.

Whereas the following will not work:

<?php
namespace Component;

if (version_compare(PHP_VERSION, '5.4.0', 'gte')) {
    use My\ArrayObject;
} else {
    use ArrayObject;
}

class Container extends ArrayObject
{
}
?>

the following, using class_alias, will:

<?php
namespace Component;

if (version_compare(PHP_VERSION, '5.4.0', 'lt')) {
    class_alias('My\ArrayObject', 'Component\ArrayObject');
} else {
    class_alias('ArrayObject', 'Component\ArrayObject');
}

class Container extends ArrayObject
{
}
?>

The semantics are slightly different (I'm now indicating that Container extends from an ArrayObject implementation in the same namespace), but the overall idea is the same: conditional imports.

down

robsonvnasc at gmail dot com ¶

8 years ago

It also works with Traits!

<?php 
trait Foo {}
class_alias("Foo","Bar");
echo trait_exists("Bar") ? 'yes' : 'no'; 
?>
//yes

down

nicolas dot grekas+php at gmail dot com ¶

13 years ago

class_alias also works for interfaces!

<?php
interface foo {}
class_alias('foo', 'bar');
echo interface_exists('bar') ? 'yes!' : 'no'; // prints yes!
?>

down

programmer-comfreek at hotmail dot com ¶

13 years ago

If you defined the class 'original' in a namespace, you will have to specify the namespace(s), too:
<?php
namespace ns1\ns2\ns3;

class A {}

class_alias('ns1\ns2\ns3\A', 'B');
/* or if you want B to exist in ns1\ns2\ns3 */
class_alias('ns1\ns2\ns3\A', 'ns1\ns2\ns3\B');
?>

down

elliseproduction at gmail dot com ¶

4 years ago

You can add a alias inside a class :

<?php

class foo{

    function __construct(){
        
        echo('yes!');
    
    }
}

class bar {

    function __construct(){
        
        class_alias('foo', 'fooAlias');
    
    }
    
    function test(){
        
        new fooAlias;
        
    }

}

$bar=new bar;

$bar->test(); // yes!

down

stanislav dot eckert at vizson dot de ¶

9 years ago

class_alias() creates aliases only for user defined classes, not for classes supplied by PHP (PHP will show the warning "First argument of class_alias() must be a name of user defined class"). To create aliases for every kind of classes, use namespaces:

<?php

// Does not work
class_alias("ZipArchive", "myZip");

// Creates class alias "myZip" of class "ZipArchive"
use \ZipArchive as myZip;

?>

down

Hayley Watson ¶

6 years ago

The alias really is an alias for the existing class. It's not a new class of any kind - whether by inheritance or otherwise; it doesn't just look and behave exactly like the existing class; it really is the same class.

<?php

class foo
{
    public static $count = 0;
}

class_alias('foo', 'bar');

bar::$count++;

echo foo::$count; // Output: 1

echo get_class(new Bar); // Output: foo
?>
Note in the last line there that aliases are just as case-insensitive as "genuine" class names.

down

sergey dot karavay at gmail dot com ¶

11 years ago

At first, you might wonder that:

<?php class A {}; class_alias('A', 'B'); ?>



is equivalent to:

<?php class A {}; class B extends A {}; ?>



class_alias is NOT equivalent to class extending! Private methods/properties are unseen in child classes, but in alias classes they are.

down

Anonymous ¶

4 years ago

Check is alias:
<?php
/**
 * @param string $class Class name
 * @return bool
 */
function is_alias(string $class): bool
{
    return $class !== (new ReflectionClass($class))->name;
}
?>
Get class aliases:
<?php
/**
 * @param string $class Class name
 * @param bool $throw Throw exception at error?
 * @return string[]|null Aliases or null at error in silent mode
 * @throws InvalidArgumentException Class not exists or it's alias
 */
function get_class_aliases(string $class, bool $throw = false): ?array
{
    /**
     * @var array An array of defined classes: keys - classes, values - aliases
     */
    static $classes = [];
    // check: class exists
    if (! class_exists($class, true)) {
        if ($throw) {
            throw new InvalidArgumentException('Class ' . $class . ' not exists');
        }
        return null;
    }
    // refresh list
    $newClasses = array_diff(get_declared_classes(), array_keys($classes));
    if ($newClasses) {
        $abc = range('a', 'z');
        foreach ($newClasses as $newClass) {
            // fast check first char: class_alias() convert alias to lower case
            if (in_array($newClass[0], $abc, true)) {
                $realClass = (new ReflectionClass($newClass))->getName();
                $classes[$newClass] = $newClass !== $realClass ? $realClass : null;
            } else {
                $classes[$newClass] = null;
            }
        }
        unset($abc, $newClasses);
    }
    // check: is alias?
    if (! empty($classes[$class])) {
        if ($throw) {
            throw new InvalidArgumentException($class . ' is alias for class ' . $classes[$class]);
        }
        return null;
    }
    // find aliases
    return array_keys($classes, $class, true);
}
?>
Usage:
<?php
class Foo {}
class_alias('Foo', 'Bar');
class_alias('Bar', 'Baz');
$aliases = get_class_aliases('Foo', true); // ['bar', 'baz']
?>

down

adam at adamhahn dot com ¶

13 years ago

Something to note,

If the $original class has not yet been defined or loaded, the auto loader will be invoked in order to try and load it.

If the class for which you are trying to create an alias does not exist, or can not be loaded with the auto loader, you will generate a PHP Warning.

down

info at ensostudio dot ru ¶

4 years ago

Note: this function set alias for user classes, you can't use something like this
<?php
class_alias('ArrayObject', 'ArrObj');
?>

down

nicolas dot grekas+php at gmail dot com ¶

13 years ago

At first, you might wonder that:
<?php class A {}; class_alias('A', 'B'); ?>

is equivalent to:
<?php class A {}; class B extends A {}; ?>

BUT when derivation creates a new class name - that means, you can then instantiate a new kind of objects - aliasing is just what it says: a synonym, so objects instantiated with the aliased name are of the exact same kind of objects instantiated with the non-aliased name.

See this code for example:
<?php
class A {};
class B1 extends A {};
class_alias('A', 'B2');

$b1 = new B1; echo get_class($b1); // prints B1
$b2 = new B2; echo get_class($b2); // prints A !
?>

down

-3

sofe2038 at gmail dot com ¶

7 years ago

Doesn't work with coupled classes when used along with autoloading.

For example, in these classes where each class is autoloaded in a separate class file:

Foo.php:

<?php
interface Foo{
  public function fx(Bar $bar);
}
?>

Bar2.php:

<?php
class Bar2 implements Foo{
  public function fx(Bar2 $bar){
    // some implementation code here
  }
}
?>

Bar.php:

<?php
class_alias("Bar2", "Bar");
?>

When used with an autoloader like this:

<?php
spl_autoload_register(function($class){
  require($class . ".php");
});
new Bar;
?>

Results in fatal error:

    Declaration of Bar2::fx(Bar2 $bar) must be compatible with Foo::fx(Bar $bar) in ~/Bar2.php on line 2

down

-5

sofe2038 at gmail dot com ¶

7 years ago

Doesn't work with coupled classes when used along with autoloading.

For example, in these classes where each class is autoloaded in a separate class file:

Foo.php:

<?php
interface Foo{
  public function fx(Bar $bar);
}
?>

Bar2.php:

<?php
class Bar2 implements Foo{
  public function fx(Bar2 $bar){
    // some implementation code here
  }
}
?>

Bar.php:

<?php
class_alias("Bar2", "Bar");
?>

When used with an autoloader like this:

<?php
spl_autoload_register(function($class){
  require($class . ".php");
});
new Bar;
?>

Results in fatal error:

    Declaration of Bar2::fx(Bar2 $bar) must be compatible with Foo::fx(Bar $bar) in ~/Bar2.php on line 2

＋add a note