Configurations are widely used in Yii when creating new objects or initializing existing objects.
Configurations usually include the class name of the object being created, and a list of initial values
that should be assigned to the object's properties. Configurations may also include a list of
handlers that should be attached to the object's events and/or a list of
behaviors that should also be attached to the object.

In the following, a configuration is used to create and initialize a database connection:

The Yii::createObject() method takes a configuration array as its argument, and creates an object by instantiating
the class named in the configuration. When the object is instantiated, the rest of the configuration
will be used to initialize the object's properties, event handlers, and behaviors.

If you already have an object, you may use Yii::configure() to initialize the object's properties with
a configuration array:

Yii::configure($object, $config);

Note that, in this case, the configuration array should not contain a class element.

The class element specifies a fully qualified class name for the object being created.

The propertyName elements specify the initial values for the named property. The keys are the property names, and the
values are the corresponding initial values. Only public member variables and properties
defined by getters/setters can be configured.

The on eventName elements specify what handlers should be attached to the object's events.
Notice that the array keys are formed by prefixing event names with on . Please refer to
the Events section for supported event handler formats.

The as behaviorName elements specify what behaviors should be attached to the object.
Notice that the array keys are formed by prefixing behavior names with as ; the value, $behaviorConfig, represents
the configuration for creating a behavior, like a normal configuration described here.

Below is an example showing a configuration with initial property values, event handlers, and behaviors:

Configurations are used in many places in Yii. At the beginning of this section, we have shown how to
create an object according to a configuration by using Yii::createObject(). In this subsection, we will
describe application configurations and widget configurations - two major usages of configurations.

The configuration for an application is probably one of the most complex arrays in Yii.
This is because the application class has a lot of configurable properties and events.
More importantly, its components property can receive an array of configurations
for creating components that are registered through the application. The following is an abstract from the application
configuration file for the Basic Project Template.

When a configuration is very complex, a common practice is to store it in one or multiple PHP files, known as
configuration files. A configuration file returns a PHP array representing the configuration.
For example, you may keep an application configuration in a file named web.php, like the following,

Because the components configuration is complex too, you store it in a separate file called components.php
and "require" this file in web.php as shown above. The content of components.php is as follows,

Configurations often vary according to the environment in which an application runs. For example,
in development environment, you may want to use a database named mydb_dev, while on production server
you may want to use the mydb_prod database. To facilitate switching environments, Yii provides a constant
named YII_ENV that you may define in the entry script of your application.
For example,

defined('YII_ENV') or define('YII_ENV', 'dev');

You may define YII_ENV as one of the following values:

prod: production environment. The constant YII_ENV_PROD will evaluate as true.
This is the default value of YII_ENV if you do not define it.

dev: development environment. The constant YII_ENV_DEV will evaluate as true.

test: testing environment. The constant YII_ENV_TEST will evaluate as true.

With these environment constants, you may specify your configurations conditionally based on
the current environment. For example, your application configuration may contain the following
code to enable the debug toolbar and debugger in development environment.