# Class yii\BaseYii

Inheritance | yii\BaseYii
Subclasses | Yii
Available since version | 2.0
Source Code | https://github.com/yiisoft/yii2/blob/master/framework/BaseYii.php

BaseYii is the core helper class for the Yii framework.

Do not use BaseYii directly. Instead, use its child class Yii which you can replace to customize methods of BaseYii.

## Public Properties

Hide inherited properties

Property | Type | Description | Defined By
--- | --- | --- | ---
$aliases | array | Registered path aliases | yii\BaseYii
$app | yii\console\Application|yii\web\Application | The application instance | yii\BaseYii
$classMap | array | Class map used by the Yii autoloading mechanism. | yii\BaseYii
$container | yii\di\Container | The dependency injection (DI) container used by createObject(). | yii\BaseYii

## Public Methods

Hide inherited methods

Method | Description | Defined By
--- | --- | ---
autoload() | Class autoload loader. | yii\BaseYii
beginProfile() | Marks the beginning of a code block for profiling. | yii\BaseYii
configure() | Configures an object with the initial property values. | yii\BaseYii
createObject() | Creates a new object using the given configuration. | yii\BaseYii
debug() | Logs a debug message. | yii\BaseYii
endProfile() | Marks the end of a code block for profiling. | yii\BaseYii
error() | Logs an error message. | yii\BaseYii
getAlias() | Translates a path alias into an actual path. | yii\BaseYii
getLogger() |  | yii\BaseYii
getObjectVars() | Returns the public member variables of an object. | yii\BaseYii
getRootAlias() | Returns the root alias part of a given alias. | yii\BaseYii
getVersion() | Returns a string representing the current version of the Yii framework. | yii\BaseYii
info() | Logs an informative message. | yii\BaseYii
powered() | Returns an HTML hyperlink that can be displayed on your Web page showing "Powered by Yii Framework" information. | yii\BaseYii
setAlias() | Registers a path alias. | yii\BaseYii
setLogger() | Sets the logger object. | yii\BaseYii
t() | Translates a message to the specified language. | yii\BaseYii
trace() | Alias of debug(). | yii\BaseYii
warning() | Logs a warning message. | yii\BaseYii

## Property Details

Hide inherited properties

$aliases public static property

Registered path aliases

See also:

- getAlias()
- setAlias()

public static array $aliases = [
'@yii' => __DIR__,
]
$app public static property

The application instance

public static yii\console\Application|yii\web\Application $app = null
$classMap public static property

Class map used by the Yii autoloading mechanism. The array keys are the class names (without leading backslashes), and the array values are the corresponding class file paths (or path aliases). This property mainly affects how autoload() works.

See also autoload().

public static array $classMap = []
$container public static property

The dependency injection (DI) container used by createObject(). You may use yii\di\Container::set() to set up the needed dependencies of classes and their initial property values.

See also:

- createObject()
- yii\di\Container

public static yii\di\Container $container = null

## Method Details

Hide inherited methods

autoload() public static method

Class autoload loader.

This method is invoked automatically when PHP sees an unknown class. The method will attempt to include the class file according to the following procedure:

1. Search in $classMap;
2. If the class is namespaced (e.g. `yii\base\Component`), it will attempt to include the file associated with the corresponding path alias (e.g. `@yii/base/Component.php`);

This autoloader allows loading classes that follow the PSR-4 standard and have its top-level namespace or sub-namespaces defined as path aliases.

Example: When aliases `@yii` and `@yii/bootstrap` are defined, classes in the `yii\bootstrap` namespace will be loaded using the `@yii/bootstrap` alias which points to the directory where the bootstrap extension files are installed and all classes from other `yii` namespaces will be loaded from the yii framework directory.

Also the guide section on autoloading.

public static void autoload ( $className )
$className | string | The fully qualified class name without a leading backslash "\"
throws | yii\base\UnknownClassException | if the class does not exist in the class file

Source code

                    public static function autoload($className)
    {
        if (isset(static::$classMap[$className])) {
            $classFile = static::$classMap[$className];
            if (strncmp($classFile, '@', 1) === 0) {
                $classFile = static::getAlias($classFile);
            }
        } elseif (strpos($className, '\\') !== false) {
            $classFile = static::getAlias('@' . str_replace('\\', '/', $className) . '.php', false);
            if ($classFile === false || !is_file($classFile)) {
                return;
            }
        } else {
            return;
        }
        include $classFile;
        if (YII_DEBUG && !class_exists($className, false) && !interface_exists($className, false) && !trait_exists($className, false)) {
            throw new UnknownClassException("Unable to find '$className' in file: $classFile. Namespace missing?");
        }
    }

beginProfile() public static method

Marks the beginning of a code block for profiling.

This has to be matched with a call to endProfile() with the same category name. The begin- and end- calls must also be properly nested. For example,

    \Yii::beginProfile('block1');
    // some code to be profiled
        \Yii::beginProfile('block2');
        // some other code to be profiled
        \Yii::endProfile('block2');
    \Yii::endProfile('block1');

See also endProfile().

public static void beginProfile ( $token, $category = 'application' )
$token | string | Token for the code block
$category | string | The category of this log message

Source code

                    public static function beginProfile($token, $category = 'application')
    {
        static::getLogger()->log($token, Logger::LEVEL_PROFILE_BEGIN, $category);
    }

configure() public static method

Configures an object with the initial property values.

public static object configure ( $object, $properties )
$object | object | The object to be configured
$properties | array | The property initial values given in terms of name-value pairs.
return | object | The object itself

Source code

                    public static function configure($object, $properties)
    {
        foreach ($properties as $name => $value) {
            $object->$name = $value;
        }
        return $object;
    }

createObject() public static method

Creates a new object using the given configuration.

You may view this method as an enhanced version of the `new` operator. The method supports creating an object based on a class name, a configuration array or an anonymous function.

Below are some usage examples:

    // create an object using a class name
    $object = Yii::createObject('yii\db\Connection');

    // create an object using a configuration array
    $object = Yii::createObject([
        'class' => 'yii\db\Connection',
        'dsn' => 'mysql:host=127.0.0.1;dbname=demo',
        'username' => 'root',
        'password' => '',
        'charset' => 'utf8',
    ]);

    // create an object with two constructor parameters
    $object = \Yii::createObject('MyClass', [$param1, $param2]);

Using dependency injection container, this method can also identify dependent objects, instantiate them and inject them into the newly created object.

See also yii\di\Container.

public static object createObject ( $type, array $params = [] )

$type

string|array|callable

The object type. This can be specified in one of the following forms:

- a string: representing the class name of the object to be created
- a configuration array: the array must contain a `class` element which is treated as the object class, and the rest of the name-value pairs will be used to initialize the corresponding object properties
- a PHP callable: either an anonymous function or an array representing a class method (`[$class or $object, $method]`). The callable should return a new instance of the object being created.

$params | array | The constructor parameters
return | object | The created object
throws | yii\base\InvalidConfigException | if the configuration is invalid.

Source code

                    public static function createObject($type, array $params = [])
    {
        if (is_string($type)) {
            return static::$container->get($type, $params);
        }
        if (is_callable($type, true)) {
            return static::$container->invoke($type, $params);
        }
        if (!is_array($type)) {
            throw new InvalidConfigException('Unsupported configuration type: ' . gettype($type));
        }
        if (isset($type['__class'])) {
            $class = $type['__class'];
            unset($type['__class'], $type['class']);
            return static::$container->get($class, $params, $type);
        }
        if (isset($type['class'])) {
            $class = $type['class'];
            unset($type['class']);
            return static::$container->get($class, $params, $type);
        }
        throw new InvalidConfigException('Object configuration must be an array containing a "class" or "__class" element.');
    }

debug() public static method (available since version 2.0.14)

Logs a debug message.

Trace messages are logged mainly for development purposes to see the execution workflow of some code. This method will only log a message when the application is in debug mode.

public static void debug ( $message, $category = 'application' )
$message | string|array | The message to be logged. This can be a simple string or a more complex data structure, such as an array.
$category | string | The category of the message.

Source code

                    public static function debug($message, $category = 'application')
    {
        if (YII_DEBUG) {
            static::getLogger()->log($message, Logger::LEVEL_TRACE, $category);
        }
    }

endProfile() public static method

Marks the end of a code block for profiling.

This has to be matched with a previous call to beginProfile() with the same category name.

See also beginProfile().

public static void endProfile ( $token, $category = 'application' )
$token | string | Token for the code block
$category | string | The category of this log message

Source code

                    public static function endProfile($token, $category = 'application')
    {
        static::getLogger()->log($token, Logger::LEVEL_PROFILE_END, $category);
    }

error() public static method

Logs an error message.

An error message is typically logged when an unrecoverable error occurs during the execution of an application.

public static void error ( $message, $category = 'application' )
$message | string|array | The message to be logged. This can be a simple string or a more complex data structure, such as an array.
$category | string | The category of the message.

Source code

                    public static function error($message, $category = 'application')
    {
        static::getLogger()->log($message, Logger::LEVEL_ERROR, $category);
    }

getAlias() public static method

Translates a path alias into an actual path.

The translation is done according to the following procedure:

1. If the given alias does not start with '@', it is returned back without change;
2. Otherwise, look for the longest registered alias that matches the beginning part of the given alias. If it exists, replace the matching part of the given alias with the corresponding registered path.
3. Throw an exception or return false, depending on the `$throwException` parameter.

For example, by default '@yii' is registered as the alias to the Yii framework directory, say '/path/to/yii'. The alias '@yii/web' would then be translated into '/path/to/yii/web'.

If you have registered two aliases '@foo' and '@foo/bar'. Then translating '@foo/bar/config' would replace the part '@foo/bar' (instead of '@foo') with the corresponding registered path. This is because the longest alias takes precedence.

However, if the alias to be translated is '@foo/barbar/config', then '@foo' will be replaced instead of '@foo/bar', because '/' serves as the boundary character.

Note, this method does not check if the returned path exists or not.

See the guide article on aliases for more information.

See also setAlias().

public static string|false getAlias ( $alias, $throwException = true )
$alias | string | The alias to be translated.
$throwException | boolean | Whether to throw an exception if the given alias is invalid. If this is false and an invalid alias is given, false will be returned by this method.
return | string|false | The path corresponding to the alias, false if the root alias is not previously registered.
throws | yii\base\InvalidArgumentException | if the alias is invalid while $throwException is true.

Source code

                    public static function getAlias($alias, $throwException = true)
    {
        if (strncmp((string)$alias, '@', 1) !== 0) {
            // not an alias
            return $alias;
        }
        $pos = strpos($alias, '/');
        $root = $pos === false ? $alias : substr($alias, 0, $pos);
        if (isset(static::$aliases[$root])) {
            if (is_string(static::$aliases[$root])) {
                return $pos === false ? static::$aliases[$root] : static::$aliases[$root] . substr($alias, $pos);
            }
            foreach (static::$aliases[$root] as $name => $path) {
                if (strpos($alias . '/', $name . '/') === 0) {
                    return $path . substr($alias, strlen($name));
                }
            }
        }
        if ($throwException) {
            throw new InvalidArgumentException("Invalid path alias: $alias");
        }
        return false;
    }

getLogger() public static method

public static yii\log\Logger getLogger ( )
return | yii\log\Logger | Message logger

Source code

                    public static function getLogger()
    {
        if (self::$_logger !== null) {
            return self::$_logger;
        }
        return self::$_logger = static::createObject('yii\log\Logger');
    }

getObjectVars() public static method

Returns the public member variables of an object.

This method is provided such that we can get the public member variables of an object. It is different from "get_object_vars()" because the latter will return private and protected variables if it is called within the object itself.

public static array getObjectVars ( $object )
$object | object | The object to be handled
return | array | The public member variables of the object

Source code

                    public static function getObjectVars($object)
    {
        return get_object_vars($object);
    }

getRootAlias() public static method

Returns the root alias part of a given alias.

A root alias is an alias that has been registered via setAlias() previously. If a given alias matches multiple root aliases, the longest one will be returned.

public static string|false getRootAlias ( $alias )
$alias | string | The alias
return | string|false | The root alias, or false if no root alias is found

Source code

                    public static function getRootAlias($alias)
    {
        $pos = strpos($alias, '/');
        $root = $pos === false ? $alias : substr($alias, 0, $pos);
        if (isset(static::$aliases[$root])) {
            if (is_string(static::$aliases[$root])) {
                return $root;
            }
            foreach (static::$aliases[$root] as $name => $path) {
                if (strpos($alias . '/', $name . '/') === 0) {
                    return $name;
                }
            }
        }
        return false;
    }

getVersion() public static method

Returns a string representing the current version of the Yii framework.

public static string getVersion ( )
return | string | The version of Yii framework

Source code

                    public static function getVersion()
    {
        return '2.0.50-dev';
    }

info() public static method

Logs an informative message.

An informative message is typically logged by an application to keep record of something important (e.g. an administrator logs in).

public static void info ( $message, $category = 'application' )
$message | string|array | The message to be logged. This can be a simple string or a more complex data structure, such as an array.
$category | string | The category of the message.

Source code

                    public static function info($message, $category = 'application')
    {
        static::getLogger()->log($message, Logger::LEVEL_INFO, $category);
    }

powered() public static method
Deprecated since 2.0.14, this method will be removed in 2.1.0.

Returns an HTML hyperlink that can be displayed on your Web page showing "Powered by Yii Framework" information.

public static string powered ( )
return | string | An HTML hyperlink that can be displayed on your Web page showing "Powered by Yii Framework" information

Source code

                    public static function powered()
    {
        return \Yii::t('yii', 'Powered by {yii}', [
            'yii' => '<a href="https://www.yiiframework.com/" rel="external">' . \Yii::t('yii', 'Yii Framework') . '</a>',
        ]);
    }

setAlias() public static method

Registers a path alias.

A path alias is a short name representing a long path (a file path, a URL, etc.) For example, we use '@yii' as the alias of the path to the Yii framework directory.

A path alias must start with the character '@' so that it can be easily differentiated from non-alias paths.

Note that this method does not check if the given path exists or not. All it does is to associate the alias with the path.

Any trailing '/' and '\' characters in the given path will be trimmed.

See the guide article on aliases for more information.

See also getAlias().

public static void setAlias ( $alias, $path )
$alias | string | The alias name (e.g. "@yii"). It must start with a '@' character. It may contain the forward-slash '/' which serves as a boundary character when performing alias translation by getAlias().

$path

string|null

The path corresponding to the alias. If this is null, the alias will be removed. Trailing '/' and '\' characters will be trimmed. This can be

- a directory or a file path (e.g. `/tmp`, `/tmp/main.txt`)
- a URL (e.g. `https://www.yiiframework.com`)
- a path alias (e.g. `@yii/base`). In this case, the path alias will be converted into the actual path first by calling getAlias().

throws | yii\base\InvalidArgumentException | if $path is an invalid alias.

Source code

                    public static function setAlias($alias, $path)
    {
        if (strncmp($alias, '@', 1)) {
            $alias = '@' . $alias;
        }
        $pos = strpos($alias, '/');
        $root = $pos === false ? $alias : substr($alias, 0, $pos);
        if ($path !== null) {
            $path = strncmp($path, '@', 1) ? rtrim($path, '\\/') : static::getAlias($path);
            if (!isset(static::$aliases[$root])) {
                if ($pos === false) {
                    static::$aliases[$root] = $path;
                } else {
                    static::$aliases[$root] = [$alias => $path];
                }
            } elseif (is_string(static::$aliases[$root])) {
                if ($pos === false) {
                    static::$aliases[$root] = $path;
                } else {
                    static::$aliases[$root] = [
                        $alias => $path,
                        $root => static::$aliases[$root],
                    ];
                }
            } else {
                static::$aliases[$root][$alias] = $path;
                krsort(static::$aliases[$root]);
            }
        } elseif (isset(static::$aliases[$root])) {
            if (is_array(static::$aliases[$root])) {
                unset(static::$aliases[$root][$alias]);
            } elseif ($pos === false) {
                unset(static::$aliases[$root]);
            }
        }
    }

setLogger() public static method

Sets the logger object.

public static void setLogger ( $logger )
$logger | yii\log\Logger|null | The logger object.

Source code

                    public static function setLogger($logger)
    {
        self::$_logger = $logger;
    }

t() public static method

Translates a message to the specified language.

This is a shortcut method of yii\i18n\I18N::translate().

The translation will be conducted according to the message category and the target language will be used.

You can add parameters to a translation message that will be substituted with the corresponding value after translation. The format for this is to use curly brackets around the parameter name as you can see in the following example:

    $username = 'Alexander';
    echo \Yii::t('app', 'Hello, {username}!', ['username' => $username]);

Further formatting of message parameters is supported using the PHP intl extensions message formatter. See yii\i18n\I18N::translate() for more details.

public static string t ( $category, $message, $params = [], $language = null )
$category | string | The message category.
$message | string | The message to be translated.
$params | array | The parameters that will be used to replace the corresponding placeholders in the message.
$language | string|null | The language code (e.g. `en-US`, `en`). If this is null, the current application language will be used.
return | string | The translated message.

Source code

                    public static function t($category, $message, $params = [], $language = null)
    {
        if (static::$app !== null) {
            return static::$app->getI18n()->translate($category, $message, $params, $language ?: static::$app->language);
        }
        $placeholders = [];
        foreach ((array) $params as $name => $value) {
            $placeholders['{' . $name . '}'] = $value;
        }
        return ($placeholders === []) ? $message : strtr($message, $placeholders);
    }

trace() public static method
Deprecated since 2.0.14. Use debug() instead.

Alias of debug().

public static void trace ( $message, $category = 'application' )
$message | string|array | The message to be logged. This can be a simple string or a more complex data structure, such as an array.
$category | string | The category of the message.

Source code

                    public static function trace($message, $category = 'application')
    {
        static::debug($message, $category);
    }

warning() public static method

Logs a warning message.

A warning message is typically logged when an error occurs while the execution can still continue.

public static void warning ( $message, $category = 'application' )
$message | string|array | The message to be logged. This can be a simple string or a more complex data structure, such as an array.
$category | string | The category of the message.

Source code

                    public static function warning($message, $category = 'application')
    {
        static::getLogger()->log($message, Logger::LEVEL_WARNING, $category);
    }