Contrôler l'ordre d'affichage des attributs produit dans PrestaShop

Comprendre le tri des attributs produit dans PrestaShop

Par défaut, PrestaShop affiche les déclinaisons d'un produit selon un ordre déterminé par la position des groupes d'attributs, puis la position de chaque attribut au sein de son groupe. Cet ordre est défini dans le back-office via un simple glisser-déposer dans Catalogue > Attributs et caractéristiques.

Mais dans certains cas métier — notamment lorsque vos déclinaisons suivent une nomenclature précise basée sur des références — cet ordre par position ne correspond pas à la logique souhaitée. Vous préférez alors que les combinaisons s'affichent triées par leur référence fournisseur ou interne.

Le mécanisme technique : la méthode getAttributesGroups()

Le tri des attributs côté front-office est piloté par la méthode getAttributesGroups() de la classe Product. C'est cette méthode qui alimente la fiche produit avec la liste des déclinaisons disponibles.

Voici la clause ORDER BY par défaut :

ORDER BY ag.`position` ASC, a.`position` ASC, agl.`name`, pa.`reference` ASC

Cette clause trie d'abord par position du groupe d'attributs, puis par position de l'attribut, puis par nom du groupe, et enfin par référence de la combinaison. La référence n'intervient donc qu'en dernier recours.

Solution : modifier l'ordre de tri par référence

Étape 1 — Localiser le fichier à modifier

Version PrestaShopFichier 1.6`classes/Product.php` 1.7`classes/Product.php` 8.x`classes/Product.php` (ou override)

Recherchez la méthode getAttributesGroups dans le fichier. Vous y trouverez la requête SQL complète.

Étape 2 — Modifier la clause ORDER BY

Remplacez la clause de tri existante :

// Avant (tri par position)
ORDER BY ag.`position` ASC, a.`position` ASC, agl.`name`, pa.`reference` ASC

Par un tri basé uniquement sur la référence de la combinaison :

// Après (tri par référence de déclinaison)
ORDER BY pa.`reference` ASC

La colonne pa.reference correspond au champ Référence de chaque combinaison dans la table ps_product_attribute. C'est la référence que vous saisissez dans le back-office pour chaque déclinaison.

Étape 3 — Utiliser un override (recommandé)

Plutôt que de modifier directement le fichier core, créez un override pour préserver la compatibilité lors des mises à jour :

<?php
/**
 * @author Alexandre Carette <contact@alexandrecarette.fr>
 * @copyright 2026 Alexandre Carette
 * @license Propriétaire et Confidentiel
 */

class Product extends ProductCore
{
    public function getAttributesGroups($id_lang)
    {
        if (!Combination::isFeatureActive()) {
            return array();
        }

        $sql = 'SELECT ag.`id_attribute_group`, ag.`is_color_group`,
                    agl.`name` AS group_name, agl.`public_name` AS public_group_name,
                    a.`id_attribute`, al.`name` AS attribute_name,
                    a.`color` AS attribute_color,
                    product_attribute_shop.`id_product_attribute`,
                    IFNULL(stock.quantity, 0) as quantity,
                    product_attribute_shop.`price`,
                    product_attribute_shop.`ecotax`,
                    product_attribute_shop.`weight`,
                    product_attribute_shop.`default_on`,
                    pa.`reference`,
                    product_attribute_shop.`unit_price_impact`,
                    product_attribute_shop.`minimal_quantity`,
                    product_attribute_shop.`available_date`,
                    ag.`group_type`
                FROM `'._DB_PREFIX_.'product_attribute` pa
                '.Shop::addSqlAssociation('product_attribute', 'pa').'
                '.Product::sqlStock('pa', 'pa').'
                LEFT JOIN `'._DB_PREFIX_.'product_attribute_combination` pac
                    ON (pac.`id_product_attribute` = pa.`id_product_attribute`)
                LEFT JOIN `'._DB_PREFIX_.'attribute` a
                    ON (a.`id_attribute` = pac.`id_attribute`)
                LEFT JOIN `'._DB_PREFIX_.'attribute_group` ag
                    ON (ag.`id_attribute_group` = a.`id_attribute_group`)
                LEFT JOIN `'._DB_PREFIX_.'attribute_lang` al
                    ON (a.`id_attribute` = al.`id_attribute`
                        AND al.`id_lang` = '.(int)$id_lang.')
                LEFT JOIN `'._DB_PREFIX_.'attribute_group_lang` agl
                    ON (ag.`id_attribute_group` = agl.`id_attribute_group`
                        AND agl.`id_lang` = '.(int)$id_lang.')
                WHERE pa.`id_product` = '.(int)$this->id.'
                AND pac.`id_product_attribute` IS NOT NULL
                ORDER BY pa.`reference` ASC';

        return Db::getInstance(_PS_USE_SQL_SLAVE_)->executeS($sql);
    }
}

Placez ce fichier dans override/classes/Product.php, puis supprimez le cache des classes :

rm var/cache/prod/class_index.php
# ou en 1.6 :
rm cache/class_index.php

Comprendre les colonnes de référence dans la base de données

Il est important de ne pas confondre les différents champs de référence dans PrestaShop :

ColonneTableSignification `pa.reference``ps_product_attribute`Référence de la **combinaison/déclinaison** `p.reference``ps_product`Référence du **produit parent** `a.id_attribute``ps_attribute`Identifiant technique de l'attribut (taille, couleur…)

Lorsque vous souhaitez trier par référence de déclinaison, c'est bien pa.reference qu'il faut utiliser, car cette colonne contient la valeur saisie dans le champ « Référence » de chaque combinaison au niveau du back-office.

Variantes de tri selon vos besoins

Vous pouvez adapter la clause ORDER BY selon votre logique métier :

-- Tri alphabétique par nom d'attribut
ORDER BY al.`name` ASC

-- Tri par prix croissant de la déclinaison
ORDER BY product_attribute_shop.`price` ASC

-- Tri par stock décroissant (les disponibles en premier)
ORDER BY quantity DESC, pa.`reference` ASC

-- Tri hybride : groupe par position, puis attributs par référence
ORDER BY ag.`position` ASC, pa.`reference` ASC

Bonnes pratiques pour PrestaShop 8.x

Depuis PrestaShop 8, le système d'overrides reste fonctionnel mais Symfony encourage une approche plus modulaire. Voici les recommandations :

1. **Privilégiez un module** plutôt qu'un override brut si vous distribuez cette personnalisation à plusieurs boutiques
2. **Vérifiez la compatibilité** de votre override après chaque mise à jour mineure
3. **Indexez la colonne `reference`** si votre catalogue comporte des milliers de déclinaisons, car le tri SQL sur un champ non indexé peut dégrader les performances :

ALTER TABLE ps_product_attribute ADD INDEX idx_reference (reference);

1. **Videz systématiquement le cache** après toute modification d'override ou de requête SQL

Vérifier le résultat en base de données

Pour valider que vos références sont bien renseignées et comprendre l'ordre actuel, exécutez cette requête directement :

SELECT pa.id_product_attribute, pa.reference, al.name AS attribut, agl.name AS groupe
FROM ps_product_attribute pa
JOIN ps_product_attribute_combination pac ON pac.id_product_attribute = pa.id_product_attribute
JOIN ps_attribute a ON a.id_attribute = pac.id_attribute
JOIN ps_attribute_lang al ON al.id_attribute = a.id_attribute AND al.id_lang = 1
JOIN ps_attribute_group_lang agl ON agl.id_attribute_group = a.id_attribute_group AND agl.id_lang = 1
WHERE pa.id_product = 42
ORDER BY pa.reference ASC;

Remplacez 42 par l'identifiant de votre produit. Si la colonne reference est vide pour certaines déclinaisons, le tri ne sera pas exploitable — assurez-vous de renseigner une référence cohérente pour chaque combinaison.