---
title: "Reading Configurations"
version: "3.4"
---

> Documentation Index
> Fetch the complete documentation index at: https://docs.phalcon.io/llms.txt
> Use this file to discover all available pages before exploring further.

# Reading Configurations

[Phalcon\Config](/3.4/api/phalcon_config/) is a component used to convert configuration files of various formats (using adapters) into PHP objects for use in an application.

Values can be obtained from `Phalcon\Config` as follows:

```php
<?php

use Phalcon\Config;

$config = new Config(
[
    'test' => [
        'parent' => [
            'property'  => 1,
            'property2' => 'yeah',
        ],
    ],  
]
);

echo $config->get('test')->get('parent')->get('property');  // displays 1
echo $config->test->parent->property;                       // displays 1
echo $config->path('test.parent.property');                 // displays 1
```

## Factory
Loads Config Adapter class using `adapter` option, if no extension is provided it will be added to `filePath`

```php
<?php

use Phalcon\Config\Factory;

$options = [
'filePath' => 'path/config',
'adapter'  => 'php',
 ];

 $config = Factory::load($options);
```

## Native Arrays
The first example shows how to convert native arrays into [Phalcon\Config](/3.4/api/phalcon_config/) objects. This option offers the best performance since no files are read during this request.

```php
<?php

use Phalcon\Config;

$settings = [
'database' => [
    'adapter'  => 'Mysql',
    'host'     => 'localhost',
    'username' => 'scott',
    'password' => 'cheetah',
    'dbname'   => 'test_db'
],
 'app' => [
    'controllersDir' => '../app/controllers/',
    'modelsDir'      => '../app/models/',
    'viewsDir'       => '../app/views/'
],
'mysetting' => 'the-value'
];

$config = new Config($settings);

echo $config->app->controllersDir, "\n";
echo $config->database->username, "\n";
echo $config->mysetting, "\n";
```

If you want to better organize your project you can save the array in another file and then read it.

```php
<?php

use Phalcon\Config;

require 'config/config.php';

$config = new Config($settings);
```

## File Adapters
The adapters available are:

| Class                         | Description                                                                                      |
|-------------------------------|--------------------------------------------------------------------------------------------------|
| [Phalcon\Config\Adapter\Ini](/3.4/api/phalcon_config/)  | Uses INI files to store settings. Internally the adapter uses the PHP function `parse_ini_file`. |
| [Phalcon\Config\Adapter\Json](/3.4/api/phalcon_config/) | Uses JSON files to store settings.                                                               |
| [Phalcon\Config\Adapter\Php](/3.4/api/phalcon_config/)  | Uses PHP multidimensional arrays to store settings. This adapter offers the best performance.    |
| [Phalcon\Config\Adapter\Yaml](/3.4/api/phalcon_config/) | Uses YAML files to store settings.                                                               |

## Reading INI Files
Ini files are a common way to store settings. [Phalcon\Config](/3.4/api/phalcon_config/) uses the optimized PHP function `parse_ini_file` to read these files. Files sections are parsed into sub-settings for easy access.

```ini
[database]
adapter  = Mysql
host     = localhost
username = scott
password = cheetah
dbname   = test_db

[phalcon]
controllersDir = '../app/controllers/'
modelsDir      = '../app/models/'
viewsDir       = '../app/views/'

[models]
metadata.adapter  = 'Memory'
```

You can read the file as follows:

```php
<?php

use Phalcon\Config\Adapter\Ini as ConfigIni;

$config = new ConfigIni('path/config.ini');

echo $config->phalcon->controllersDir, "\n";
echo $config->database->username, "\n";
echo $config->models->metadata->adapter, "\n";
```

## Merging Configurations
[Phalcon\Config](/3.4/api/phalcon_config/) can recursively merge the properties of one configuration object into another. New properties are added and existing properties are updated.

```php
<?php

use Phalcon\Config;

$config = new Config(
[
    'database' => [
        'host'   => 'localhost',
        'dbname' => 'test_db',
    ],
    'debug' => 1,
]
);

$config2 = new Config(
[
    'database' => [
        'dbname'   => 'production_db',
        'username' => 'scott',
        'password' => 'secret',
    ],
    'logging' => 1,
]
);

$config->merge($config2);

print_r($config);
```

The above code produces the following:

```bash
Phalcon\Config Object
(
[database] => Phalcon\Config Object
    (
        [host] => localhost
        [dbname]   => production_db
        [username] => scott
        [password] => secret
    )
[debug] => 1
[logging] => 1
)
```

There are more adapters available for this components in the [Phalcon Incubator](https://github.com/phalcon/incubator)

## Nested Configuration
You may easily access nested configuration values using the `Phalcon\Config::path` method. This method allows to obtain values, without caring about the fact that some parts of the path are absent. Let's look at an example:

```php
<?php

use Phalcon\Config;

$config = new Config(
   [
    'phalcon' => [
        'baseuri' => '/phalcon/'
    ],
    'models' => [
        'metadata' => 'memory'
    ],
    'database' => [
        'adapter'  => 'mysql',
        'host'     => 'localhost',
        'username' => 'user',
        'password' => 'passwd',
        'name'     => 'demo'
    ],
    'test' => [
        'parent' => [
            'property' => 1,
            'property2' => 'yeah'
        ],
    ],
   ]
);

// Using dot as delimiter
$config->path('test.parent.property2');    // yeah
$config->path('database.host', null, '.'); // localhost

$config->path('test.parent'); // Phalcon\Config

// Using slash as delimiter. A default value may also be specified and
// will be returned if the configuration option does not exist.
$config->path('test/parent/property3', 'no', '/'); // no

Config::setPathDelimiter('/');
$config->path('test/parent/property2'); // yeah
```

The following example shows how to create usefull facade to access nested configuration values:

```php
<?php

use Phalcon\Di;
use Phalcon\Config;

/**
 * @return mixed|Config
 */
function config() {
$args = func_get_args();
$config = Di::getDefault()->getShared(__FUNCTION__);

if (empty($args)) {
   return $config;
}

return call_user_func_array([$config, 'path'], $args);
}
```

## Injecting Configuration Dependency
You can inject your configuration to the controller allowing us to use [Phalcon\Config](/3.4/api/phalcon_config/) inside [Phalcon\Mvc\Controller](/3.4/api/phalcon_mvc_controller/). To be able to do that, you have to add it as a service in the Dependency Injector container. Add following code inside your bootstrap file:

```php
<?php

use Phalcon\Di\FactoryDefault;
use Phalcon\Config;

// Create a DI
$di = new FactoryDefault();

$di->set(
'config',
function () {
    $configData = require 'config/config.php';

    return new Config($configData);
}
);
```

Now in your controller you can access your configuration by using dependency injection feature using name `config` like following code:

```php
<?php

use Phalcon\Mvc\Controller;

class MyController extends Controller
{
private function getDatabaseName()
{
    return $this->config->database->dbname;
}
}
```

Source: https://docs.phalcon.io/3.4/config/index.mdx