PHP fonction récursive pour afficher les combinaisons valides de tableau des valeurs

Question

J'ai un tableau PHP qui ressemble à ceci:

Array 
(
[340] => Array 
    (
     [1] => 1 
     [2] => 18 
     [3] => 23 
    ) 

[341] => Array 
    (
     [1] => 1 
     [2] => 17 
     [3] => 23 
    ) 

[342] => Array 
    (
     [1] => 1 
     [2] => 16 
     [3] => 23 
    ) 

[343] => Array 
) 

Le tableau est en fait plus longue et contient environ 40 éléments. Il y aura d'autres tableaux qui contiennent un nombre différent d'éléments enfants. Le tableau est au format

productID => array (
    $attributeID => attributeValueID, 
    $attributeID => attributeValueID, 
    $attributeID => attributeValueID 
) 

Ce dont j'ai besoin est un tableau qui affiche les valeurs valides pour tous les autres attributs. Le tableau de sortie pourrait ressemble

Array 
(
18 => array(
    1 => array(
     11, 12, 13, 14, 15 
    ) 
    2 => array(
     19, 20, 21, 22 
    ) 
) 
19 => array(
    1 => array(
     11, 13, 14, 15 
    ) 
    2 => array(
     21, 22 
    ) 
) 

Le format de ce tableau est

attributeValueID => array(
    attributeID => attributeValues, 
    attributeID => attributeValues 
) 

Je travaille avec des fonctions récursives mais je n'ai été en mesure d'obtenir une liste de tous les possibles combinaison entre toutes les valeurs qui n'est pas ce dont j'ai besoin. Toute aide serait grandement appréciée. Clarification de ce que je veux dire par valeurs "valides": Ce que les valeurs 1, 2 et 3 représentent ici sont la couleur, la taille et la longueur. Le but ultime ici est de créer une série de tableaux javascript que je vais utiliser pour mettre à jour les options sur la page lorsqu'un utilisateur sélectionne des valeurs. Par exemple, quand ils sélectionnent la couleur noire, j'ai besoin de mettre à jour les tailles et les longueurs sur la page pour refléter seulement les tailles et les longueurs disponibles en noir. Je peux créer les tableaux manuellement mais ce n'est pas une bonne solution.

Answer 1

En supposant que la sortie devrait effectivement être:

attributeValueID => array(
    attributeID => productID, 
    attributeID => productID 
) 

(? Dans le cas contraire où proviennent les valeurs d'attribut proviennent de)

Recursion ne serait pas nécessaire, juste quelque chose le long de ces lignes de re-jig la tableau:

$products = array( 340 => array(
            1 => 1, 
            2 => 18, 
            3 => 23 
            ), 

         341 => array(
            1 => 1, 
            2 => 17, 
            3 => 23 
            ), 

         342 => array(
            1 => 1, 
            2 => 16, 
            3 => 23 
            ), 

         343 => array() 
        ); 
$output = array(); 

foreach($products as $product_id=>$attributes){ 
    $attribute_id; 
    foreach($attributes as $attribute_id=>$attribute_value){ 
     $output[$attribute_value][$attribute_id][] = $product_id; 
    } 

    // optionaly filter for dup product ids 
    //$output[$attribute_value][$attribute_id] = array_unique($output[$attribute_value][$attribute_id], SORT_NUMERIC); 
} 

Answer 2

Ok, si je reçois ce moment, vous avez des produits avec quatre attributs: id, la couleur, la taille et la longueur, que vous représentez comme

[product_id] => array (
    1 => [color_id], 
    2 => [size_id], 
    3 => [length_id] 
) 

Personnellement, je trouve cette structure un peu maladroite. L'identifiant du produit doit figurer dans le tableau, car il s'agit d'un attribut du produit. En outre, l'utilisation de numéros d'index au lieu des noms de propriété rend vos produits difficiles à comprendre.

Maintenant, ce que vous voulez faire est de trouver toutes les combinaisons possibles d'un des attributs, par ex. all size_id et length_id lorsque l'utilisateur sélectionne color_id pour, par exemple, noir.

Vous pouvez le faire avec une méthode de recherche:

function findCombinationsByColorId($color_id, $products) 
{ 
    $combos = array($color_id => array(
     'sizes' => array(), 
     'lengths' => array(), 
     'products' => array() 
    )); 

    foreach($products as $productId => $product) 
    { 
     if($product[1] === $color_id) { 
      $combos['sizes'][] = $product[2]; 
      $combos['lengths'][] = $product[3]; 
      $combos['products'][] = $productId; 
     } 
    } 
    return $combos; 
} 

Maintenant, quand vous avez besoin de trouver toutes les combinaisons pour le noir et le noir est color_id de 0, vous feriez findCombinationsByColorId(0, $productArray) et reviendriez un tableau contenant toutes les tailles, longueurs et identifiants de produit possibles pour cette couleur.

Vous écririez des fonctions supplémentaires pour obtenir des combinaisons par les autres attributs. Vous pourriez rendre la méthode finder générique, mais je vous laisse le soin de comprendre comment. Ce que je ne comprends pas, c'est pourquoi vous trier tout cela au niveau de la baie. Je suppose que vous obtenez les produits possibles de quelque part, par ex. une base de données.Alors pourquoi ne pas avoir les combos à partir de là. Ce serait probablement aussi simple que SELECT size_id, length_id, product_id from products where color_id = 0.

Answer 3

La réponse fournie par Gordon est la plus proche de ce que je recherche mais n'est pas très efficace étant donné la façon dont mon tableau initial a été formaté. Bien que je ne me souvienne pas pourquoi maintenant, mon objectif initial en utilisant des tableaux était d'éviter d'avoir à faire une nouvelle requête chaque fois que quelqu'un sélectionne une option. La solution facile est juste de continuer avec les requêtes, c'est ce que je vais faire.