¿Cómo agregar e indexar dimensiones de matrices en php dinámicamente?

Tengo una matriz en una clase PHP y dos funciones miembro.

Primero uno recibe dos enteros, uno es la dimensión y el otro es el valor:

private $complexArray;

function setValueToGivenDimension($dimension, $value)

Lo que quiero hacer es establecer el valor en la dimensión dada de la matriz.

Por ejemplo, si llamo a la función de la siguiente manera:

setValueToGivenDimension(3,"key","myValue")

Quiero que la matriz sea

array [
  0 => array [
    0 => array [
      "key" => "myValue"
    ]
  ]
]

Y la segunda es la función getValueOfGivenDimension($dimension, $key)

Por ejemplo, si llamo a la función de la siguiente manera:

getValueOfGivenDimension(3,"key")

Debería devolver el valor de la clave dada, que es 0 en este caso de la tercera dimensión de $complexArray:

"myValue"

*array puede tener cualquier nivel de dimensión y quiero crear e indexar las dimensiones de la matriz dinámicamente.

Answer

Aquí hay una manera de hacerlo. Tenga en cuenta el uso de &para obtener una referencia en la matriz:

function setValueToGivenDimension(&$array, $dimension, $key, $value)
{
    for($i=1;$i<$dimension;$i++)
    {
        if(!isset($array[0]))
            $array[0] = [];
        $array = &$array[0];
    }
    $array[$key] = $value;
}

function getValueOfGivenDimension($array, $dimension, $key)
{
    for($i=1;$i<$dimension;$i++)
    {
        if(!isset($array[0]))
            return null;
        $array = $array[0];
    }
    if(!isset($array[$key]))
        return null;
    return $array[$key];
}

$complexArray = [];
setValueToGivenDimension($complexArray, 3, 'key', 'value');
echo getValueOfGivenDimension($complexArray, 3, 'key');

Puedes usar la recursividad para ambos.

El siguiente método devolverá la matriz que desea, por lo que puede configurar su variable privada en la salida.

function setValueToGivenDimension($dimension, $value) {
     // Base case: if the dimension is 0, then we should return the value
     if ($dimension == 0) return $value;
     
     // If the dimension is greater than 0, then return the recursive function call, wrapped in a new array
     return [setValueToGivenDimension($dimension - 1, $value)];
}

El siguiente método tomará una matriz, una dimensión y una clave, y generará el valor de la enésima dimensión de esa matriz, utilizando la clave en la dimensión más interna.

function getValueOfGivenDimension($array, $dimension, $key) {
     // Base case: if the function is at dimension 1, then return the value at the given key for the array
     if ($dimension == 1) return $array[$key];
     
     // If the dimension is greater than 0, then recursively call the function on the only child of the given array
     return getValueOfGivenDimension($array[0], $dimension - 1, $key);
}

Basado en la respuesta de Oliver, aquí está el código dentro de una clase:

<?php

class MyClass
{
    private $complexArray;

    /**
     * @return void
     */
    public function doSomething()
    {
        $this->setValueToGivenDimension(3, 'key', 'value');
        print_r($this->complexArray);
        echo $this->getValueOfGivenDimension(3, 'key') . PHP_EOL;
    }

    /**
     * @param int $dimension
     * @param mixed $key
     * @param mixed $value
     * @return $this
     */
    private function setValueToGivenDimension($dimension, $key, $value)
    {
        if (!is_array($this->complexArray)) {
            $this->complexArray = [];
        }
        if ($dimension > 0) {
            $array = &$this->complexArray;
            for ($i = 1; $i < $dimension; $i++) {
                if (!isset($array[0])) {
                    $array[0] = [];
                }
                $array = &$array[0];
            }
            $array[$key] = $value;
        }
        return $this;
    }

    /**
     * @param int $dimension
     * @param mixed $key
     * @return mixed|null
     */
    private function getValueOfGivenDimension($dimension, $key)
    {
        if ($dimension > 0) {
            $array = $this->complexArray;
            for ($i = 1; $i < $dimension; $i++) {
                if (!isset($array[0])) {
                    return null;
                }
                $array = $array[0];
            }
            if (!isset($array[$key])) {
                return null;
            }
            return $array[$key];
        }
        return null;
    }

}

Ejecutarlo:

$mc = new MyClass();
$mc->doSomething();

Producción:

Array
(
    [0] => Array
        (
            [0] => Array
                (
                    [key] => value
                )

        )

)
value

Prueba este código:

<?php

class ComplexArray {

      private $complexArray = [["key1" => "value1"]];

      function setValueToGivenDimension($dimension, $key, $value) {
            $current = &$this->complexArray;

            for($i = 1; $i < $dimension; $i++) {
                  $current = &$current[0];
            }
            $current = &$current[$key];
            $current = $value;

            return $this->complexArray;
      }

      function getValueOfGivenDimension($dimension, $key) {
            $current = $this->complexArray;

            for($i = 1; $i < $dimension; $i++) {
                  $current = $current[0];
            }
            return $current[$key];
      }
}

$whaat = new ComplexArray();
print_r($whaat->setValueToGivenDimension(3, "key2", "value2"));
echo $whaat->getValueOfGivenDimension(3, "key2");

?>

Esta es la salida:

Array
(
    [0] => Array
        (
            [key1] => value1
            [0] => Array
                (
                    [key2] => value2
                )

        )

)
value2
Nuevo colaborador
Perttu es un nuevo colaborador de este sitio. Tenga cuidado al pedir aclaraciones, comentar y responder. Consulta nuestro Código de Conducta .