Creando un archivo de configuración en PHP

Quiero crear un archivo de configuración para mi proyecto PHP, pero no estoy seguro de cuál es la mejor manera de hacerlo.

Tengo 3 ideas hasta ahora.

Variable de 1 uso

$config['hostname'] = "localhost";
$config['dbuser'] = "dbuser";
$config['dbpassword'] = "dbpassword";
$config['dbname'] = "dbname";
$config['sitetitle'] = "sitetitle";

Const de 2 usos

define('DB_NAME', 'test');
define('DB_USER', 'root');
define('DB_PASSWORD', '');
define('DB_HOST', 'localhost');
define('TITLE', 'sitetitle');

Base de datos de 3 usos

Usaré la configuración en clases, así que no estoy seguro de cuál sería la mejor o si hay una mejor.

Una forma simple pero elegante es crear un config.phparchivo (o como lo llame) que solo devuelva una matriz:

<?php

return array(
    'host' => 'localhost',
    'username' => 'root',
);

Y entonces:

$configs = include('config.php');

¡Usar un archivo INI es una solución flexible y poderosa! PHP tiene una función nativa para manejarlo correctamente. Por ejemplo, es posible crear un archivo INI como este:

app.ini

[database]
db_name     = mydatabase
db_user     = myuser
db_password = mypassword

[application]
app_email = mailer@myapp.com
app_url   = myapp.com

Entonces, lo único que debe hacer es llamar:

$ini = parse_ini_file('app.ini');

Luego, puede acceder a las definiciones fácilmente usando la $inimatriz.

echo $ini['db_name'];     // mydatabase
echo $ini['db_user'];     // myuser
echo $ini['db_password']; // mypassword
echo $ini['app_email'];   // mailer@myapp.com

IMPORTANTE: Por razones de seguridad, el archivo INI debe estar en una carpeta no pública.

Yo uso una ligera evolución de @hugo_leonardo 's solución :

<?php

return (object) array(
    'host' => 'localhost',
    'username' => 'root',
    'pass' => 'password',
    'database' => 'db'
);

?>

Esto le permite usar la sintaxis del objeto cuando incluye php: en $configs->hostlugar de $configs['host'].

Además, si su aplicación tiene configuraciones que necesita en el lado del cliente (como para una aplicación Angular), puede hacer que este config.phparchivo contenga todas sus configuraciones (centralizadas en un archivo en lugar de uno para JavaScript y otro para PHP). El truco entonces sería tener otro archivo PHP que echosolo contenga la información del lado del cliente (para evitar mostrar información que no desea mostrar como la cadena de conexión de la base de datos). Llámalo decir get_app_info.php:

<?php

    $configs = include('config.php');
    echo json_encode($configs->app_info);

?>

Lo anterior asumiendo que config.phpcontiene un app_infoparámetro:

<?php

return (object) array(
    'host' => 'localhost',
    'username' => 'root',
    'pass' => 'password',
    'database' => 'db',
    'app_info' => array(
        'appName'=>"App Name",
        'appURL'=> "http://yourURL/#/"
    )
);

?>

Entonces, la información de su base de datos permanece en el lado del servidor, pero se puede acceder a la información de su aplicación desde su JavaScript, por ejemplo, con un $http.get('get_app_info.php').then(...);tipo de llamada.

Las opciones que veo con méritos / debilidades relativas son:

Mecanismos basados ​​en archivos

Estos requieren que su código busque en ubicaciones específicas para encontrar el archivo ini. Este es un problema difícil de resolver y que siempre surge en grandes aplicaciones PHP. Sin embargo, es probable que deba resolver el problema para encontrar el código PHP que se incorpora / reutiliza en tiempo de ejecución.

Los enfoques comunes para esto son siempre usar directorios relativos, o buscar desde el directorio actual hacia arriba para encontrar un archivo nombrado exclusivamente en el directorio base de la aplicación.

Los formatos de archivo comunes que se utilizan para los archivos de configuración son código PHP, archivos con formato ini, JSON, XML, YAML y PHP serializado

Código PHP

Esto proporciona una gran cantidad de flexibilidad para representar diferentes estructuras de datos y (asumiendo que se procesa mediante incluir o requerir) el código analizado estará disponible en la caché de código de operación, lo que brinda un beneficio de rendimiento.

El include_path proporciona un medio para abstraer los lugares potenciales del archivo sin depender de código adicional.

Por otro lado, una de las principales razones para separar la configuración del código es separar las responsabilidades. Proporciona una ruta para inyectar código adicional en el tiempo de ejecución.

Si la configuración se crea a partir de una herramienta, puede ser posible validar los datos en la herramienta, pero no existe una función estándar para escapar de los datos para incrustarlos en el código PHP como existe para HTML, URL, declaraciones MySQL, comandos de shell ... .

Datos serializados Esto es relativamente eficiente para pequeñas cantidades de configuración (hasta alrededor de 200 elementos) y permite el uso de cualquier estructura de datos PHP. Requiere muy poco código para crear / analizar el archivo de datos (por lo que puede dedicar sus esfuerzos a asegurarse de que el archivo solo se escriba con la autorización adecuada).

El escape del contenido escrito en el archivo se gestiona automáticamente.

Dado que puede serializar objetos, crea una oportunidad para invocar código simplemente leyendo el archivo de configuración (el método mágico __wakeup).

Archivo estructurado

Almacenarlo como un archivo INI como lo sugiere Marcel o JSON o XML también proporciona una API simple para mapear el archivo en una estructura de datos PHP (y con la excepción de XML, para escapar de los datos y crear el archivo) mientras se elimina la invocación del código. vulnerabilidad utilizando datos PHP serializados.

Tendrá características de rendimiento similares a los datos serializados.

Almacenamiento de base de datos

Esto se considera mejor cuando tiene una gran cantidad de configuración pero es selectivo en lo que se necesita para la tarea actual; me sorprendió encontrar que en alrededor de 150 elementos de datos, era más rápido recuperar los datos de una instancia local de MySQL que anular la serialización de un archivo de datos.

¡OTOH no es un buen lugar para almacenar las credenciales que usa para conectarse a su base de datos!

El entorno de ejecución

Puede establecer valores en el entorno de ejecución en el que se ejecuta PHP.

Esto elimina cualquier requisito para que el código PHP busque en un lugar específico para la configuración. OTOH no escala bien a grandes cantidades de datos y es difícil de cambiar universalmente en tiempo de ejecución.

En el cliente

Un lugar que no he mencionado para almacenar datos de configuración es el cliente. Una vez más, la sobrecarga de la red significa que esto no se adapta bien a grandes cantidades de configuración. Y dado que el usuario final tiene control sobre los datos, deben almacenarse en un formato en el que se pueda detectar cualquier manipulación (es decir, con una firma criptográfica) y no debe contener ninguna información que se vea comprometida por su divulgación (es decir, cifrada reversiblemente).

Por el contrario, esto tiene muchos beneficios para almacenar información confidencial que es propiedad del usuario final; si no la almacena en el servidor, no puede ser robada desde allí.

Directorios de red Otro lugar interesante para almacenar información de configuración es DNS / LDAP. Esto funcionará para una pequeña cantidad de pequeños fragmentos de información, pero no es necesario que se ciña a la primera forma normal; considere, por ejemplo, SPF .

La infraestructura admite el almacenamiento en caché, la replicación y la distribución. Por tanto, funciona bien para infraestructuras muy grandes.

Sistemas de control de versiones

La configuración, como el código, debe administrarse y controlarse la versión; por lo tanto, obtener la configuración directamente desde su sistema de VC es una solución viable. Pero a menudo esto viene con una sobrecarga de rendimiento significativa, por lo que el almacenamiento en caché puede ser aconsejable.

Bueno, sería un poco difícil almacenar los datos de configuración de su base de datos en una base de datos, ¿no cree?

Pero en realidad, esta es una pregunta con muchas opiniones porque cualquier estilo funciona realmente y todo es cuestión de preferencias. Personalmente, optaría por una variable de configuración en lugar de constantes, generalmente porque no me gustan las cosas en el espacio global a menos que sea necesario. Ninguna de las funciones en mi base de código debería poder acceder fácilmente a la contraseña de mi base de datos (excepto la lógica de conexión de mi base de datos), por lo que la usaría allí y luego probablemente la destruiría.

Editar : para responder a su comentario, ninguno de los mecanismos de análisis sería el más rápido (ini, json, etc.), pero tampoco son las partes de su aplicación en las que realmente debería concentrarse en optimizar, ya que la diferencia de velocidad sería ser insignificante en archivos tan pequeños.

Define hará que la constante esté disponible en todas partes de tu clase sin necesidad de usar global, mientras que la variable requiere global en la clase, yo usaría DEFINE. pero de nuevo, si los parámetros de db cambian durante la ejecución del programa, es posible que desee seguir con la variable.

Si cree que va a utilizar más de 1 db por cualquier motivo, elija la variable porque podrá cambiar un parámetro para cambiar a un db completamente diferente. Es decir, para pruebas, copias de seguridad automáticas, etc.

Puede crear una clase de configuración con propiedades estáticas

class Config 
{
    static $dbHost = 'localhost';
    static $dbUsername = 'user';
    static $dbPassword  = 'pass';
}

entonces puedes usarlo simplemente:

Config::$dbHost  

A veces en mis proyectos utilizo un patrón de diseño SINGLETON para acceder a los datos de configuración. Es muy cómodo de usar.

¿Por qué?

Por ejemplo, tiene 2 fuentes de datos en su proyecto. Y puede elegir si está habilitado.

• mysql
• json

En algún lugar del archivo de configuración que elija:

$dataSource = 'mysql' // or 'json'

Cuando cambia la fuente, toda la aplicación debe cambiar a una nueva fuente de datos, funciona bien y no necesita cambiar el código.

Ejemplo:

Config:

class Config 
{
  // ....
  static $dataSource = 'mysql';
  / .....
}

Clase singleton:

class AppConfig
{
    private static $instance;
    private $dataSource;

    private function __construct()
    {
        $this->init();
    }

    private function init()
    {
        switch (Config::$dataSource)
        {
            case 'mysql':
                $this->dataSource = new StorageMysql();
                break;
            case 'json':
                $this->dataSource = new StorageJson();
                break;
            default:
                $this->dataSource = new StorageMysql();
        }
    }

    public static function getInstance()
    {
        if (empty(self::$instance)) {
            self::$instance = new self();
        }
        return self::$instance;
    }

    public function getDataSource()
    {
        return $this->dataSource;
    }
}

... y en algún lugar de su código (por ejemplo, en alguna clase de servicio):

$container->getItemsLoader(AppConfig::getInstance()->getDataSource()) // getItemsLoader need Object of specific data source class by dependency injection

Podemos obtener un objeto AppConfig desde cualquier lugar del sistema y obtener siempre la misma copia (gracias a static). El método init () de la clase se llama En el constructor, lo que garantiza una sola ejecución. El cuerpo de Init () comprueba el valor de config $ dataSource y crea un nuevo objeto de una clase de fuente de datos específica. Ahora nuestro script puede obtener un objeto y operar en él, sin saber siquiera qué implementación específica existe realmente.

Normalmente termino creando un solo archivo conn.php que tiene mis conexiones de base de datos. Luego incluyo ese archivo en todos los archivos que requieren consultas a la base de datos.

Este es mi camino.

<?php

define('DEBUG',0);

define('PRODUCTION',1);



#development_mode : DEBUG / PRODUCTION

$development_mode = PRODUCTION;



#Website root path for links

$app_path = 'http://192.168.0.234/dealer/';



#User interface files path

$ui_path = 'ui/';

#Image gallery path

$gallery_path = 'ui/gallery/';


$mysqlserver = "localhost";
$mysqluser = "root";
$mysqlpass = "";
$mysqldb = "dealer_plus";

?>

Cualquier duda comenta