Comment définir de façon dynamique les clés du tableau en php

Ne serait-il pas plus facile de faire ce qui suit

$calcs = array(
    $meter['Resource']['name'] => array(
        $meter['UnitType']['name'] => 'Some Value',
        $meter['UnitType']['name2'] => 'Some Value Again'
    ),
);

ou vous pouvez utiliser des Objets

$calcs = new stdClass();
$calcs->{$meter['UnitType']['name']} = 'Some Value';

mais je voudrais des conseils que vous créez votre structure dans les tableaux et ensuite faire!

$calcs = (object)$calcs_array;

ou vous pouvez boucler votre premier tableau dans un nouveau tableau!

$new = array();
$d = date('Y-m',$start);
foreach($meter as $key => $value)
{
    $new[$key]['name'][$d] = array();
}

Donner il y a et de voir comment la structure du tableau qui vient de sortir.

OriginalL'auteur RobertPitt

Je suis d'accord avec le commentaire sur l'OP par @Jake N que peut-être l'aide d'objets est une meilleure approche. Néanmoins, si vous souhaitez utiliser des tableaux, vous pouvez vérifier l'existence de clés dans un conditionnel, comme suit:

if(
    array_key_exists('Resource', $meter)
) {
    $calcs[$meter['Resource']['name']][$meter['UnitType']['name']][date('Y-m',$start)] = $data;
} else {
    $calcs[$meter['UnitType']['name']] = $data;
}

D'autre part, si vous souhaitez utiliser des objets, vous pouvez créer un MeterReading type d'objet, puis ajouter MeterReading instances comme des éléments d'un tableau à votre $calcs tableau, comme suit:

//Object defintion
class MeterReading {
    private $data;
    private $resource;
    private $startDate;
    private $unitType;

    public function __construct(Array $meter, $start, $data) {
        $this->unitType   = $meter['UnitType']['name'];
        $this->resource   = $meter['Resource']['name'];
        $this->startDate  = date('Y-m',$start);
    }

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

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

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

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

//Example population
$calcs[] = new MeterReading($meter, $start, $data);

//Example usage
foreach($calcs as $calc) {
    if($calc->resource()) {
        echo 'Resource: ' . $calc->resource() . '<br>';
    }
    echo 'Unit Type: ' . $calc->unitType() . '<br>';
    echo 'Start Date: ' . $calc->startDate() . '<br>';
    echo 'Data: ' . $calc->data() . '<br>';
}

Évidemment, vous pouvez profiter de cette plus loin, comme la vérification de l'existence de la matrice de touches dans le constructeur de l'objet, donnant à la propriété de l'objet resource une valeur par défaut si non fourni, et ainsi de suite, mais c'est un début pour une approche OO.

OriginalL'auteur e_i_pi

Voici une fonction que j'ai écrit pour le réglage de profondément imbriqués les membres sur les tableaux ou objets:

function dict_set($var, $path, $val) {
    if(empty($var))
        $var = is_array($var) ? array() : new stdClass();

    $parts = explode('.', $path);
    $ptr =& $var;

    if(is_array($parts))
    foreach($parts as $part) {
        if('[]' == $part) {
            if(is_array($ptr))
                $ptr =& $ptr[];

        } elseif(is_array($ptr)) {
            if(!isset($ptr[$part]))
                $ptr[$part] = array();

            $ptr =& $ptr[$part];

        } elseif(is_object($ptr)) {
            if(!isset($ptr->$part))
                $ptr->$part = array();

            $ptr =& $ptr->$part;
        }
    }

    $ptr = $val;

    return $var;
}

À l'aide de vos données d'exemple:

$array = [];

$array = dict_set($array, 'resource1.unit1.2017-10', 'value1');
$array = dict_set($array, 'resource1.unit2.2017-11', 'value2');
$array = dict_set($array, 'resource2.unit1.2017-10', 'value3');

print_r($array);

Résultats en sortie comme:

Array
(
    [resource1] => Array
        (
            [unit1] => Array
                (
                    [2017-10] => value1
                )

            [unit2] => Array
                (
                    [2017-11] => value2
                )

        )

    [resource2] => Array
        (
            [unit1] => Array
                (
                    [2017-10] => value3
                )

        )

)

Le deuxième argument de dict_set() est un $path chaîne dans dot notation. Vous pouvez construire cette dynamique à l'aide de touches avec la période des séparateurs entre les parties. La fonction travaille avec des tableaux et des objets.

Il peut également ajouter des différentiels membres de profondément imbriqués tableau à l'aide de [] comme un élément de la $path. Par exemple: parent.child.child.[]

OriginalL'auteur Jeff Standen