gestion multi-langue et tables

Version imprimable

Bonjour,

on m'a proposé un système multi-langue qui utilise json ; il convient pour traduire plusieurs mots par contre je ne vois pas comment l'adapter pour traduire des tables si les données à traduire appartiennent à des tables (MySql).
Voici le système :
On a cette fonction
Code:

1 2 3 4 5 6 7 8 9 function getPageLanguage($lang,$pages) { $dataPage=[]; foreach($pages as $p){ $jsonString=file_get_contents('_lang/'.$lang.'/'.$p.'.json'); $json=json_decode($jsonString); $dataPage[$p]=$json; }; return (object) $dataPage; }
qu retourne un objet dont chaque propriété contient les traductions d'une page (sous forme d'un objet qui lui-même contient toutes les traductions de la page)

Initialement, les traductions d'une page sont contenues dans un fichier json dont voici un petit exemple :
Code:

1 2 3 4 { "home":"Accueil", "var1":"test_fr" }
Donc si la page ne contient que des mots (statiques) à traduire, c'est clair pour moi. Voici comment accéder à l'un d'eux, une fois appelée la fonction ci-dessus : $lang->home->var1 (pour la page nommée "home").
Là où je ne vois pas comment faire, c'est si on veut afficher des données contenues dans une table. Ce que je suppose, c'est qu'on a une table par langue et que selon la langue demandée par l'utilisateur, on va chercher la bonne table. C'est bien ça ?

Bonjour Laurent,

comme tu l'as constaté, il y a 2 types de textes.

1- les textes "statiques"
Là, en effet, des fichiers json peuvent convenir. (il existe d'autres moyens, mais simplifions...)

2- les textes "dynamiques" (contenu d'articles,... générés dynamiquement via des formulaires, et enregistrés en BDD)
Là, c'est au rédacteur/administrateur de rédiger les traductions dans les différentes langues.

2a- La SOLUTION 1 est d'avoir, dans la table "t_articles", des colonnes différentes pour CHAQUE TRADUCTION :

titre_fr
titre_en
...
contenu_fr
contenu_en
...
date_creation
date_update
publier (1/0)

Puis, en fonction de la langue du site, on affiche les colonnes concernées.

Un inconvénient est de devoir définir des nouvelles colonnes pour chaque nouvelle langue... :calim2:
Mais quand on n'a que 2 ou 3 langues à gérer, ça peut être une solution simple à mettre en oeuvre.

2b- La SOLUTION 2 (utilisée notamment par Prestashop), est d'avoir une 2ème table "t_articles_lang", pour les colonnes nécessitant des TRADUCTIONS.

On aura "t_articles" :

id_article (index auto-incrémenté)
date_creation
date_update
publier (1/0)
... (BREF : TOUT ce qui NE dépend PAS de la langues)

On aura "t_articles_lang" :

id_article
id_lang (il existe une table "ts_lang" *)
titre
contenu
... (TOUT ce qui dépend de la langues)

Via une requête avec JOINTURE, on peut donc afficher la ligne/traduction concernée, en fonction de la langue du site

L'intérêt est de pouvoir définir AUTANT de nouvelles langues qu'on veut, sans changer la structure des tables !

* Exemple de table "ts_lang" (ici, Prestashop) :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 -- -- Structure de la table `ps_lang` -- CREATE TABLE `ps_lang` ( `id_lang` int(11) NOT NULL, `name` varchar(32) COLLATE utf8_unicode_ci NOT NULL, `active` tinyint(1) NOT NULL, `iso_code` varchar(2) COLLATE utf8_unicode_ci NOT NULL, `language_code` varchar(5) COLLATE utf8_unicode_ci NOT NULL, `locale` varchar(5) COLLATE utf8_unicode_ci NOT NULL, `date_format_lite` varchar(32) COLLATE utf8_unicode_ci NOT NULL, `date_format_full` varchar(32) COLLATE utf8_unicode_ci NOT NULL, `is_rtl` tinyint(1) NOT NULL ) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci; -- -- Contenu de la table `ps_lang` -- INSERT INTO `ps_lang` (`id_lang`, `name`, `active`, `iso_code`, `language_code`, `locale`, `date_format_lite`, `date_format_full`, `is_rtl`) VALUES (1, 'Français (French)', 1, 'fr', 'fr', 'fr-FR', 'd/m/Y', 'd/m/Y H:i:s', 0);

11/07/2019, 12h55
laurentSc

Merci pour ta réponse Jérôme.
Je teste la méthode 2-b et en rendrai compte.

langue au chat ; je vois pas comment faire. Pour simplifier, je prend la table "categories" (car bien sûr il faut aussi traduire les catégories). Le but est donc d'afficher le nom dans la bonne langue.

Voici le code (j'ai rajouté dans la table une colonne "id_lang", mais je sais pas comment récupérer le nom dans la bonne langue, donc la table a la nouvelle structure mais le code PHP est celui qui fonctionnait avec une seule langue (c'est de la poo, désolé)).

la table :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 CREATE TABLE IF NOT EXISTS `categories` ( `id` int(11) NOT NULL AUTO_INCREMENT, `id_lang` int(11) NOT NULL, `name` varchar(255) COLLATE utf8_bin NOT NULL, PRIMARY KEY (`id`) ) ENGINE=MyISAM AUTO_INCREMENT=5 DEFAULT CHARSET=utf8 COLLATE=utf8_bin; INSERT INTO `categories` (`id`, `id_lang`, `name`) VALUES (1, 0, 'documentaire'), (2, 0, 'essai politique'), (3, 1, 'documentary'), (4, 1, 'political essay'); COMMIT;
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 function __construct($id) { global $db; $sql="SELECT * from categories where id=?"; $reqCategory=$db->prepare($sql); $reqCategory=execute([$id]); $data=$reqCategory->fetch(); $this->id=$id; $this->name=$data['name']; } ----------------- static function getAllCategories() { global $db; $sql="SELECT * from categories"; $reqCategory=$db->prepare($sql); $reqCategory->execute([]); return($reqCategory->FetchAll()); } ----------------- $AllCategories=Categories::getAllCategories(); -----------------
Code:

<?=$Category['name'] ?>

Laurent,
tu n'as pas compris le principe...

A-

Il faut DEUX tables "categories" et "categories_lang"
+ la table "langs"

1- table "langs" (simplifiée) :

Code:

1
2
3
4
5
6
7
8
9
10
CREATE TABLE `langs` (
  `id_lang` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(32) COLLATE utf8_unicode_ci NOT NULL,
  `active` tinyint(1) NOT NULL,
  `iso_code` varchar(2) COLLATE utf8_unicode_ci NOT NULL,
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci;
 
INSERT INTO `langs` (`id_lang`, `name`, `active`, `iso_code`) VALUES
(1, 'Français (French)', 1, 'fr'),
(2, 'Anglais (English)', 1, 'en');

2- table "categories" :

Code:

1
2
3
4
5
6
7
8
9
10
11
CREATE TABLE IF NOT EXISTS `categories` (
  `id_categorie` int(11) NOT NULL AUTO_INCREMENT,
 
-- ICI, on peut/va ajouter toutes les colonnes, qui N'ont PAS de rapport avec la langue (date, publier,....)
 
  PRIMARY KEY (`id_categorie`)
) ENGINE=MyISAM AUTO_INCREMENT=3 DEFAULT CHARSET=utf8 COLLATE=utf8_bin;
 
INSERT INTO `categories` (`id`) VALUES
(1),
(2);

3- table "categories_lang" :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
CREATE TABLE IF NOT EXISTS `categories_lang` (
  `id_categorie` int(11) NOT NULL,
  `id_lang` int(11) NOT NULL,
  `name` varchar(255) COLLATE utf8_bin NOT NULL,
 
-- ICI, on peut/va ajouter toutes les colonnes, qui ONT un rapport avec la langue -> traductions (contenu, title,....)
 
) ENGINE=MyISAM DEFAULT CHARSET=utf8 COLLATE=utf8_bin;
 
INSERT INTO `categories_lang` (`id_categorie`, `id_lang`, `name`) VALUES
(1, 1, 'documentaire'),
(2, 1, 'essai politique'),
(1, 2, 'documentary'),
(2, 2, 'political essay');

B- ENSUITE, il faut une requête avec JOINTURE, pour récupérer la(les) catégorie(s), avec les bonnes traductions :

1- SI la langue du site est enregistrée dans une variable $_SESSION['id_lang'], et vaut "1" (fr) ou "2" (en) :

Code:

1
2
3
4
5
6
$sql = "SELECT * FROM categories C
   INNER JOIN categories_lang CL
      ON C.id_categorie = CL.id_categorie
   WHERE CL.id_lang = ?
   AND C.id_categorie = ?
";

Code:

1
2
    $reqCategory = $db->prepare($sql);
    $reqCategory = execute([$_SESSION['id_lang'], $id_categorie]);

2- SI la langue du site est enregistrée dans une variable $_SESSION['lang'], et vaut "fr" ou "en", il faut AJOUTER LA JOINTURE avec la table langs :

Code:

1
2
3
4
5
6
7
8
$sql = "SELECT * FROM categories C
   INNER JOIN categories_lang CL
      ON C.id_categorie = CL.id_categorie
   INNER JOIN langs LG
      ON CL.id_lang = LG.id_lang
   WHERE LG.lang = ?
   AND C.id_categorie = ?
";

Code:

1
2
    $reqCategory = $db->prepare($sql);
    $reqCategory = execute([$_SESSION['lang'], $id_categorie]);

J'en suis qu'au SQL,

mais
Code:

1 2 3 4 5 6 7 8 9 10 11 12 CREATE TABLE IF NOT EXISTS `categories_lang` ( `id_categorie` int(11) NOT NULL, `id_lang` int(11) NOT NULL, `name` varchar(255) COLLATE utf8_bin NOT NULL, PRIMARY KEY (`id_categorie`) ) ENGINE=MyISAM AUTO_INCREMENT=5 DEFAULT CHARSET=utf8 COLLATE=utf8_bin; INSERT INTO `categories` (`id_categorie`, `id_lang`, `name`) VALUES (1, 1, 'documentaire'), (2, 1, 'essai politique'), (1, 2, 'documentary'), (2, 2, 'political essay');
donne

Citation:

INSERT INTO `categories` (`id_categorie`, `id_lang`, `name`) VALUES
(1, 1, 'documentaire'),
(2, 1, 'essai politique'),
(1, 2, 'documentary'),
(2, 2, 'political essay')

MySQL a répondu : Documentation
#1054 - Champ 'id_categorie' inconnu dans field list

???

11/07/2019, 20h19
Invité

J'avais fait des copier-coller.... "rapidement".

1- Supprime PRIMARY KEY (`id_categorie`) pour la table categories_lang.

2- et c'est INSERT INTO `categories_lang`....

Fais des efforts pour comprendre.... et corriger toi-même.
12/07/2019, 10h23
laurentSc
Bonjour Jérôme,

comme hier soir, j'y arrivais pas, j'ai décidé de laisser passer la nuit en me disant que je serai plus en forme le matin...mais je n'y arrive toujours pas :aie:

Il y a quand même 2 trucs qui me gênent dans ce que tu me proposes :
- dans le post #5, tu parles d'une table langs, mais celle-ci n'est jamais utilisée
- dans ce même post, tu mets dans la requête SQL la clause WHERE C.id_categorie = ? alors que le but est de trouver toutes les catégories ; donc je pense qu'il faut retirer cette clause (d'ailleurs des essais dans phpMyadmin semblent le confirmer)
Que penses-tu de tout ça ?
12/07/2019, 10h42
Invité

Bonjour Laurent,

1- Si tu ne vois pas l'utilité d'une table "langs", alors laisse tomber...
Utilise TA PROPRE façon de gérer les langues.

2- Quant à la requête... tu fais comme tu veux.
Je t'ai indiqué un principe. C'est tout

Je vais te laisser réfléchir encore un peu...

J'ai un peu cherché ; j'ai changé ma méthode, mais je suis bloqué.

Voici mon idée :

2 tables :
langs :

Code:

1
2
3
4
5
6
7
8
9
10
CREATE TABLE IF NOT EXISTS `langs` (
  `id_lang` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(32) COLLATE utf8_unicode_ci NOT NULL,
  PRIMARY KEY (`id_lang`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci;
 
INSERT INTO `langs` (`id_lang`, `name`) VALUES
(1, 'fr'),
(2, 'en');
COMMIT;

categories_lang :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
CREATE TABLE IF NOT EXISTS `categories_lang` (
  `id_categorie` int(11) NOT NULL,
  `id_lang` int(11) NOT NULL,
  `name` varchar(255) COLLATE utf8_bin NOT NULL
) ENGINE=MyISAM AUTO_INCREMENT=5 DEFAULT CHARSET=utf8 COLLATE=utf8_bin;
 
INSERT INTO `categories_lang` (`id_categorie`, `id_lang`, `name`) VALUES
(1, 1, 'documentaire'),
(2, 1, 'essai politique'),
(1, 2, 'documentary'),
(2, 2, 'political essay');
COMMIT;

Le code :

Code:

1
2
3
4
5
6
7
 $sql = "CL.name categories_lang CL
          INNER JOIN Langs L
             ON CL.id_lang = L.id_lang
          WHERE CL.id_lang=?";   
          $reqCategory=$db->prepare($sql); 
          $reqCategory->execute([$_SESSION['lang']]);
          $AllCategories= $reqCategory->fetchAll(PDO::FETCH_ASSOC);var_dump($AllCategories[0]);exit();

souci : Le var_dump retourne null et d'ailleurs la requête testée dans phpMyAdmin retourne rien. Qu'est-ce qui va pas ? (la variable de session existe).

Tu as oublié "select" et "from" :

Code:

1
2
3
4
5
 
$sql = "select CL.name from categories_lang CL
          INNER JOIN Langs L
             ON CL.id_lang = L.id_lang
          WHERE CL.id_lang=?";

12/07/2019, 18h57
laurentSc
Merci pour ta remarque, mais ce n'est qu'une faute de frappe. En réalité, je ne les ai pas oubliés.
Code:

1 2 3 4 $sql = "SELECT CL.name FROM categories_lang CL INNER JOIN Langs L ON CL.id_lang = L.id_lang WHERE CL.name=?";
mais le problème est réel et avec cette requête-là...
12/07/2019, 18h58
Invité

Laurent,

1- Tu fais n'importe quoi...

Tu n'as toujours RIEN compris au principe.
RELIS très attentivement ce que j'ai écrit.

2- pour la requête... Pffffffffffff...

Vas prendre l'air.
Ça te fera du bien.
12/07/2019, 19h12
laurentSc

Je reconnais que j'ai pas du tout compris pourquoi y avait les 2 tables (categories et categories_lang). Peux-tu m'en dire plus ?

prendre l'air ? Impossible : je suis pour quelques semaines en fauteuil roulant ; pas le droit de marcher et je peux même pas aller tout seul sur la terrasse car y a des rebords...
12/07/2019, 19h23
Invité

1- Je t'ai donné un exemple avec "articles".

Cet exemple explique l'intérêt des 2 tables.

2- Et tout ce qu'il faut pour "catégories" : structures des tables sql + requête à faire.
Il suffisait de les reprendre.

Mais toi, comme d'habitude, tu préfères faire tes "bricolages"...
C'est fatigant.

Désolé de te fatiguer. Tu m'avais dit de réfléchir ; c'est ce que j'ai fait, mais visiblement, pas comme il faut...:aie:

Bon, c'est vrai que je ne comprends pas ta proposition ; mais si je la prends :
le SQL (avec tes corrections) :
table categories :

Code:

1
2
3
4
5
6
7
8
CREATE TABLE IF NOT EXISTS `categories` (
  `id_categorie` int(11) NOT NULL
) ENGINE=MyISAM AUTO_INCREMENT=3 DEFAULT CHARSET=utf8 COLLATE=utf8_bin;
 
INSERT INTO `categories` (`id_categorie`) VALUES
(1),
(2);
COMMIT;

table categories_lang :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
CREATE TABLE IF NOT EXISTS `categories_lang` (
  `id_categorie` int(11) NOT NULL,
  `id_lang` int(11) NOT NULL,
  `name` varchar(255) COLLATE utf8_bin NOT NULL
) ENGINE=MyISAM DEFAULT CHARSET=utf8 COLLATE=utf8_bin;
 
INSERT INTO `categories_lang` (`id_categorie`, `id_lang`, `name`) VALUES
(1, 1, 'documentaire'),
(2, 1, 'essai politique'),
(1, 2, 'documentary'),
(2, 2, 'political essay');
COMMIT;

code PHP :

Code:

1
2
3
4
5
6
7
 $sql = "SELECT * FROM categories C
          INNER JOIN categories_lang CL
             ON C.id_categorie = CL.id_categorie
          WHERE CL.id_lang = ?";
          $reqCategory = $db->prepare($sql);
          $reqCategory->execute([$_SESSION['lang']]);  
          $AllCategories= $reqCategory->fetchAll(PDO::FETCH_ASSOC);var_dump($AllCategories[0]);exit();

mais avec ça, le var_dump est null (note que j'ai supprimé dans la requête la clause AND C.id_categorie = ?). Donc y a encore un problème....

12/07/2019, 21h35
Invité

Laurent,

1- Dans ta gestion de langue, $_SESSION['lang'] contient "fr", ou "en".
Or, id_lang vaut 1 ou 2 !

Ce qui explique le résultat nul.

2- Il te suffit de créer une autre variable $_SESSION['id_lang'], qui contiendra "1", ou "2".

3- Ou alors, ajouter une jointure avec la table langs.
Voilà à quoi sert la table langs.

Je suis content car cette fois, j'ai réfléchi correctement :

table langs :

Code:

1
2
3
4
5
6
7
8
9
CREATE TABLE IF NOT EXISTS `langs` (
  `id_lang` int(11) NOT NULL,
  `name` varchar(32) COLLATE utf8_unicode_ci NOT NULL,
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci;
 
INSERT INTO `langs` (`id_lang`, `name`) VALUES
(1, 'fr'),
(2, 'en');
COMMIT;

code PHP :

Code:

1
2
3
4
5
6
7
8
9
$sql = "SELECT * FROM categories C
          INNER JOIN categories_lang CL
             ON C.id_categorie = CL.id_categorie
          INNER JOIN langs LG
            ON CL.id_lang = LG.id_lang
          WHERE LG.name = ?";
           $reqCategory = $db->prepare($sql);
           $reqCategory->execute([$_SESSION['lang']]);  
          $AllCategories= $reqCategory->fetchAll(PDO::FETCH_ASSOC);print_r($AllCategories[0]);exit();

12/07/2019, 23h04
Invité
:lahola:

[EDIT] J'ai ajouté des explications dans mes messages précédents :
- post #2
- post #5
Je t'invite à les RELIRE attentivement.
13/07/2019, 03h01
Toufik83

jreaux62 :frenchy::frenchy::frenchy:
13/07/2019, 10h29
laurentSc

@ Toufik83 : faut dormir la nuit :mouarf:

@ jreaux62 : j'ai crié victoire hier ; il y a certes du mieux, mais je ne récupère pas encore le nom des catégories. J'ai bien relu tes explications supplémentaires. Notamment, ta requête est un peu différente de la mienne. Le print_r du fetch de la mienne donne :

Citation:

Array ( [id_categorie] => 1 [id_lang] => 1 [name] => fr )

Donc j'ai pas l'information souhaitée. La tienne, je ne peux pas l'utiliser simplement car $id_categorie n'existe pas. Certes je peux interroger la bdd pour les récupérer (de la table categories_lang), mais est-ce la bonne méthode ?

1- J'hésite entre :

être désespéré
ou être inquiet pour toi...

Si tu ne sais même plus faire la différence entre "sélectionner TOUTES les catégories" et "sélectionner LA catégorie dont l'id est..."... :ouin:

2-
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 $sql = "SELECT * FROM categories C INNER JOIN categories_lang CL ON C.id_categorie = CL.id_categorie INNER JOIN langs LG ON CL.id_lang = LG.id_lang WHERE LG.name = ?"; $reqCategory = $db->prepare($sql); $reqCategory->execute([$_SESSION['lang']]); $AllCategories = $reqCategory->fetchAll(PDO::FETCH_ASSOC); echo($_SESSION['lang']); var_dump($AllCategories); exit();
Ça donne quoi ?

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
fr
 
C:\wamp64\www\mvc_udemy\views\home_view.php:28:
array (size=2)
  0 => 
    array (size=3)
      'id_categorie' => int 1
      'id_lang' => int 1
      'name' => string 'fr' (length=2)
  1 => 
    array (size=3)
      'id_categorie' => int 2
      'id_lang' => int 1
      'name' => string 'fr' (length=2)

OK.

C'est normal, puisque tu as des colonnes qui ont le même nom ("name"), dans plusieurs tables.
"name" est donc ambigu dans la requête.

1- Il faut dont les différencier au niveau de la requête, et, tant qu'à faire, NE sélectionner QUE les colonnes nécessaires :
Code:

1 2 3 4 5 6 7 $sql = "SELECT C.id_categorie, CL.name FROM categories C INNER JOIN categories_lang CL ON C.id_categorie = CL.id_categorie INNER JOIN langs LG ON CL.id_lang = LG.id_lang WHERE LG.name = ?";
A ta place, je remplacerais "name" par "lg_name" dans la table langs.
Ça évitera cette confusion.

2- OU ALORS, tu suis MON CONSEIL, et tu crées une variable $_SESSION['id_lang'] :
La requête devient :
Code:

1 2 3 4 5 $sql = "SELECT C.id_categorie, CL.name FROM categories C INNER JOIN categories_lang CL ON C.id_categorie = CL.id_categorie WHERE CL.id_lang = ?";
Mais bon.....
Je ne voudrais pas que tu te fasses des nœuds au cerveau...

Merci de te préoccuper de mon cerveau :mouarf: et de me proposer la solution. J'avais bien compris que c'était cette requête-là qu'il fallait faire (cf la requête que je donnais au post #18) mais j'avais déjà rencontré l'ambiguïté des 2 "name", mais pas pensé à en renommer un des 2.
Sinon, je ne comprends pas l'utilité de la colonne C.id_categorie car avec la requête
Code:

1 2 3 4 5 6 7 $sql = "SELECT CL.name FROM categories C INNER JOIN categories_lang CL ON C.id_categorie = CL.id_categorie INNER JOIN langs LG ON CL.id_lang = LG.id_lang WHERE LG.lg_name = ?";
j'obtiens l'information recherchée.

Autre point que je n'ai pas compris : ce que retourne les requêtes avec jointure. Si je cherche des renseignements avec Google, je trouve N fois comment faire ce type de requêtes mais jamais ce qu'elles retournent.

Prenons un exemple de requête :
Code:

1 2 3 4 5 6 7 $sql = "SELECT * FROM categories C INNER JOIN categories_lang CL ON C.id_categorie = CL.id_categorie INNER JOIN langs LG ON CL.id_lang = LG.id_lang WHERE LG.lg_name = ?";
Le from de la requête porte sur la table categories qui comporte une seule colonne mais le fetchAll de la requête retourne un tableau qui en contient 4
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 array (size=2) 0 => array (size=4) 'id_categorie' => int 1 'id_lang' => int 1 'name' => string 'documentaire' (length=12) 'lg_name' => string 'fr' (length=2) 1 => array (size=4) 'id_categorie' => int 2 'id_lang' => int 1 'name' => string 'essai politique' (length=15) 'lg_name' => string 'fr' (length=2)
Ca semble être le mix des 3 tables categories, categories_lang et langs. C'est bien ça ?

13/07/2019, 14h37
Invité
1- Oui.
- SQL INNER JOIN
2- Pour que tu comprennes (??) l'intérêt de la table "categories" :
- Ajoute une colonne "publier" TINYINT(2) à la table "categories"
- Si "publier" vaut 1 : la catégorie sera publiée ("affichée")
- Si "publier" vaut 0 : la catégorie NE sera PAS publiée ("pas affichée")
Exercice : ECRIS la requête "sélectionner toutes les catégories publiées"

merci pour le lien qui a rejoint mes favoris (je crois que je l'avais déjà vu, mais lu trop vite).

Pour l'exercice, y a sûrement plus simple, mais voilà :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
$sql = "SELECT CL.name  
      FROM categories C
      INNER JOIN categories_lang CL
        ON C.id_categorie = CL.id_categorie
      INNER JOIN langs LG
        ON CL.id_lang = LG.id_lang
      WHERE LG.lg_name = ? AND C.publier=1";
      $reqCategory = $db->prepare($sql);
      $reqCategory->execute([$_SESSION['lang']]);  
      $AllCategories = $reqCategory->fetchAll(PDO::FETCH_ASSOC);
      $nb_lignes=sizeof($AllCategories);
      $cat=[];$i=0;
      for ($j=0;$j<$nb_lignes;$j++)
        $cat[$i++]=$AllCategories[$j]['name'];
 
    foreach ($cat as $Category=>$index) 
        echo $index."<br/>";
      ?>

Je suis épaté par ta capacité à... TOUJOURS, SYSTÉMATIQUEMENT, TOUT COMPLIQUER... :cfou:

1-

Code:

1
2
3
4
5
6
7
8
9
10
$sql = "SELECT CL.name  
      FROM categories C
      INNER JOIN categories_lang CL
        ON C.id_categorie = CL.id_categorie
      INNER JOIN langs LG
        ON CL.id_lang = LG.id_lang
      WHERE LG.lg_name = ? AND C.publier=1";
      $reqCategory = $db->prepare($sql);
      $reqCategory->execute([$_SESSION['lang']]);  
      $AllCategories = $reqCategory->fetchAll(PDO::FETCH_ASSOC);

Ça, C'est OK !!

2- Par contre :

Code:

1
2
3
4
5
6
7
8
      $nb_lignes=sizeof($AllCategories);
      $cat=[];$i=0;
      for ($j=0;$j<$nb_lignes;$j++)
        $cat[$i++]=$AllCategories[$j]['name'];
 
    foreach ($cat as $Category=>$index) 
        echo $index."<br/>";
      ?>

C'est N'IMPORTE QUOI.

$AllCategories est DÉJÀ un array, contenant toutes les données nécessaires !!!
DONC, pour afficher les lignes, il suffit d'écrire :

Code:

1
2
3
4
5
6
<?php
    foreach ($AllCategories as $data) 
    {
        echo $data['name']."<br/>";
    }
?>

ET C'EST TOUT !

13/07/2019, 16h44
laurentSc

C'était simplement la confirmation de mes lacunes en PHP ; je croyais que cette écriture (foreach ($cat as $Category=>$index)) pour foreach était la seule...