Pregunta Análisis de un archivo INI "avanzado" con PHP


Básicamente, me gustaría una forma simple, fácil, de un solo archivo para analizar un archivo INI con características "avanzadas", como la herencia de secciones y la anidación de propiedades, como Zend_Config_Ini.

Por ejemplo:

[foo]
a = 1
b.a = 2
b.b = 3
b.c = 4
c = 5

[bar : foo]
b.b = 17
c = 42

Analizaría en

array(
  'foo'=>array(
    'a'=>'1',
    'b'=>array(
      'a'=>'2',
      'b'=>'3',
      'c'=>'4'
    ),
    'c'=>'5'
  ),
  'bar'=>array(
    'a'=>'1',
    'b'=>array(
      'a'=>'2',
      'b'=>'17',
      'c'=>'4'
    ),
    'c'=>'42'
  )
)

PHP incorporado parse_ini_file, no maneja nada más que simples INI con secciones simples y claves simples.

Mi problema con el uso Zend_Config_Ini es que tendría que incluir prácticamente todo el subpaquete Zend_Config, y está súper hinchado y configurable.

Hay un pequeña y sencillo biblioteca disponible para analizar esto?
Si no, ¿hay un fácil implementación que no estoy viendo?

Por pequeño y simple, me refiero a algo así como el sfYaml de los archivos INI.

Para mi (muy inexperto) ojos, tendría que analizar una vez con parse_ini_file, luego regrese y resuelva la herencia, luego ejecute cada sección y expanda las claves recursivamente ...

ACTUALIZAR: Dado que esta parece ser una pregunta popular, me gustaría señalar que Tengo una clase simple implementando esto en GitHub, siéntase libre de enviar solicitudes de extracción, problemas, etc.


12
2017-07-13 22:50


origen


Respuestas:


No estoy seguro de si debería editar mi respuesta anterior o agregar una nueva.

Prueba esta versión, debería ser lo que estás buscando.

function parse_ini_advanced($array) {
    $returnArray = array();
    if (is_array($array)) {
        foreach ($array as $key => $value) {
            $e = explode(':', $key);
            if (!empty($e[1])) {
                $x = array();
                foreach ($e as $tk => $tv) {
                    $x[$tk] = trim($tv);
                }
                $x = array_reverse($x, true);
                foreach ($x as $k => $v) {
                    $c = $x[0];
                    if (empty($returnArray[$c])) {
                        $returnArray[$c] = array();
                    }
                    if (isset($returnArray[$x[1]])) {
                        $returnArray[$c] = array_merge($returnArray[$c], $returnArray[$x[1]]);
                    }
                    if ($k === 0) {
                        $returnArray[$c] = array_merge($returnArray[$c], $array[$key]);
                    }
                }
            } else {
                $returnArray[$key] = $array[$key];
            }
        }
    }
    return $returnArray;
}
function recursive_parse($array)
{
    $returnArray = array();
    if (is_array($array)) {
        foreach ($array as $key => $value) {
            if (is_array($value)) {
                $array[$key] = recursive_parse($value);
            }
            $x = explode('.', $key);
            if (!empty($x[1])) {
                $x = array_reverse($x, true);
                if (isset($returnArray[$key])) {
                    unset($returnArray[$key]);
                }
                if (!isset($returnArray[$x[0]])) {
                    $returnArray[$x[0]] = array();
                }
                $first = true;
                foreach ($x as $k => $v) {
                    if ($first === true) {
                        $b = $array[$key];
                        $first = false;
                    }
                    $b = array($v => $b);
                }
                $returnArray[$x[0]] = array_merge_recursive($returnArray[$x[0]], $b[$x[0]]);
            } else {
                $returnArray[$key] = $array[$key];
            }
        }
    }
    return $returnArray;
}

Sería llamado así:

$array = parse_ini_file('test.ini', true);
$array = recursive_parse(parse_ini_advanced($array));

Esto podría hacerse mucho mejor / más claro, pero para una solución simple debería funcionar bien.

Si tu configuración es:

[foo]
a = 1
b.a = 2
b.b = 3
b.c = 4
c = 5

[bar : foo]
b.x.c = 33
b.b = 17
c = 42

[hot : bar : foo]
b.a = 83
b.d = 23

El resultado debería ser:

Array
(
[foo] => Array
    (
        [a] => 1
        [b] => Array
            (
                [a] => 2
                [b] => 3
                [c] => 4
            )

        [c] => 5
    )

[bar] => Array
    (
        [a] => 1
        [b] => Array
            (
                [a] => 2
                [b] => 17
                [c] => 4
                [x] => Array
                    (
                        [c] => 33
                    )

            )

        [c] => 42
    )

[hot] => Array
    (
        [a] => 1
        [b] => Array
            (
                [a] => 83
                [b] => 17
                [c] => 4
                [x] => Array
                    (
                        [c] => 33
                    )

                [d] => 23
            )

        [c] => 42
    )
)

16
2017-07-15 19:08



Primero, para responder una cosa, la anidación de propiedades está disponible desde parse_ini_file (), establezca el segundo param como verdadero, es decir, parse_ini_file ('test.ini', true); Eso te dará una matriz multidimensional, es decir

Array
(
    [foo] => Array
        (
            [a] => 1
            [b.a] => 2
            [b.b] => 3
            [b.c] => 4
            [c] => 5
        )

    [bar : foo] => Array
        (
            [b.b] => 17
            [c] => 42
        )
)

Aquí hay una pequeña función que analizará la matriz devuelta por parse_ini_file () y la convertirá en categorías.

/**
 * Parse INI files Advanced
 * process_sections = true
 * scanner_mode = default
 * 
 * Supports section inheritance
 * and has property nesting turned on
 * 
 * @param string $filename
 * return array
 */
function parse_ini_file_advanced($filename) {
    $array = parse_ini_file($filename, true);
    $returnArray = array();
    if (is_array($array)) {
        foreach ($array as $key => $value) {
            $x = explode(':', $key);
            if (!empty($x[1])) {
                $x = array_reverse($x, true);
                foreach ($x as $k => $v) {
                    $i = trim($x[0]);
                    $v = trim($v);
                    if (empty($returnArray[$i])) {
                        $returnArray[$i] = array();
                    }
                    if (isset($array[$v])) {
                        $returnArray[$i] = array_merge($returnArray[$i], $array[$v]);
                    }
                    if ($k === 0) {
                        $returnArray[$i] = array_merge($returnArray[$i], $array[$key]);
                    }
                }
            } else {
                $returnArray[$key] = $array[$key];
            }
        }
    } else {
        return false;
    }

    return $returnArray;
}

Devolverá esto:

Array
(
    [foo] => Array
        (
            [a] => 1
            [b.a] => 2
            [b.b] => 3
            [b.c] => 4
            [c] => 5
        )

    [bar] => Array
        (
            [a] => 1
            [b.a] => 2
            [b.b] => 17
            [b.c] => 4
            [c] => 42
        )
)

La última escritura gana, es decir
[bar2: foo2: bar: foo]
Bar2 gana con su configuración en su propia matriz
NOTA: las otras 3 matrices estarán allí hasta ese punto.

Espero que esto sea lo que estabas buscando.


3
2017-07-14 19:26



He escrito algo como esto y por ahora está funcionando bien para mí:

        $config = array();
        $configSrc = parse_ini_file( $filePath, true );
        foreach( $configSrc as $sectionName => $section )
        {
            $config[$sectionName] = array();
            foreach( $section as $itemName => $item )
            {
                $itemNameArray = explode( '.', $itemName );
                eval( sprintf('$config[$sectionName][\'%s\'] = $item;', join("']['", $itemNameArray)) );
            }
        }

        // marge inheritance;
        foreach( $config as $sectionName => $section )
        {
            $ancestryArray = explode( ':', $sectionName );
            $ancestryCount = count( $ancestryArray );
            if( $ancestryCount > 1 )
            { //
                $config[$sectionNameTrimmed = trim($ancestryArray[0])] = array();
                $ancestryArray = array_reverse( array_slice($ancestryArray, 1) );
                foreach( $ancestryArray as $ancestryName )
                {
                    $ancestryName = trim( $ancestryName );
                    if( isset($config[$ancestryName]) ) {
                        $config[$sectionNameTrimmed] = array_replace_recursive( $config[$sectionNameTrimmed], $config[$ancestryName] );
                    }
                }

                $config[$sectionNameTrimmed] = array_replace_recursive( $config[$sectionNameTrimmed], $section );
                unset( $config[$sectionName] );
            }

        }

0
2018-06-15 07:09



Otra opción: este es el par, compilación y análisis.

function build_ini_string_nested( $data, $path = null ){
  $content = array();
  foreach( $data AS $key => $val ){
    if( is_array($val) ){
      $content[] = build_ini_string_nested( $val, ($path ? $path. '.' : '') . $key );
    }
    else if( $path ) {
      $content[] = $path . '[' . ($path && is_numeric($key) ? '' : $key) . '] = ' . $val;
    }
    else {
      $content[] = $key . ' = ' . $val;
    }
  }
  return implode("\n", $content);
}

function parse_ini_string_nested( $data, $path = null ){
  if( is_string($data) )
    $data = parse_ini_string($data);
  if( $path )
    foreach( $data AS $key => $val ){
      if( strpos( $key, $path.'.' ) !== false ){
        $find_node = explode('.', $path);
        $this_path = reset(explode('.', substr($key, strlen($path.'.'))));
        $node =& $data;
        do {
          $node =& $node[ array_shift($find_node) ];
        } while( count($find_node) );
        if( is_array($node[ $this_path ]) ){
          $node[ $this_path ][] = $val;
        }
        else {
          $node[ $this_path ] = $val;
        }
      }
    }
  else {
    $drop_keys = array();
    foreach( $data AS $key => $val ){
      if( count(explode('.', $key)) > 1 ){
        $path = reset(explode('.', $key));
        $data[ $path ] = array();
        $data = parse_ini_string_nested( $data, $path );
        $drop_keys[] = $key;
      }
    }
    foreach( $drop_keys AS $key ){
      unset($data[ $key ]);
    }
  }
  return $data;
}

0
2018-03-22 16:33