Moteur de recherche Web en Php

Pour partager cette vidéo sur les réseaux sociaux ou sur un site, voici son url :


Sujets que vous pourriez aussi aimer :


Moteur de recherche en PHP

Dans cette formation Php, nous proposons de bâtir un véritable moteur de recherche pour le Web. L'internaute doit pouvoir taper les mots clés de recherche dans une zone de saisie. Ces mots clés doivent être recoupés dans une clause WHERE d'une requête SQL, à la recherche de tous les enregistrements concordants.

Sources et présentation de la problématique
Pour développer une telle application, nous avons besoin d'une page Web et de données à manipuler. Ces sources sont proposées au téléchargement.

• Télécharger le fichier moteur-de-recherche-php.rar en cliquant sur son lien,
• Puis, le décompresser dans le dossier de votre choix,

La décompression conduit à plusieurs fichiers Php à la racine. Le fichier de la page Web principale est nommé index.php. Il est accompagné de ses ressources externes dans les sous dossiers. Les pages Web sont conçues par imbrications grâce à l'instruction Php include, tel que nous l'avions appris. Ces codes communs à toutes les pages du site sont précisément placés dans le sous dossier commun. C'est dans le fichier connexion.php qu'est initialisée la liaison à la base de données MySql. Cette connexion est fermée à l'issue des transactions, dans le fichier pied-page.php, qui intervient en queue de liste dans la chronologie de la construction. Et ces données sont proposées au format Sql, dans le sous dossier bdd. Ce fichier se nomme formations.sql. Il va s'agir de l'importer grâce à l'interface d'administration PhpMyAdmin.

Mais avant cela et comme vous le savez, le projet doit être référencé dans l'interface d'EasyPhp. Un nom doit lui être attribué. Son adresse prélevée depuis l'explorateur Windows doit être désignée. Les deux serveurs, Http et Database, doivent être démarrés.



Comme les connexions à la base de données sont initialisées dans le fichier commun de configuration, avant d'accéder à la page d'accueil, nous devons commencer par importer les données. Et pour ce faire, nous avons besoin de créer une base de données MySql capable d'héberger la table et ses informations.

• En bas de l'interface d'EasyPhp, cliquer sur le bouton Open du module MySql Administration,

Nous accédons ainsi à l'interface de PhpMyAdmin. Le volet de gauche énumère les bases de données existantes. Nous devons y ajouter la nôtre, pour les besoins du moteur de recherche.

• Dans ce volet sur la gauche, cliquer sur le lien Nouvelle base de données,
• Au centre de l'interface, la nommer Supports,
• Puis, régler l'interclassement sur l'encodage utf8_general_ci,

Comme nous l'avons déjà expliqué lors de précédentes formations, cet interclassement fonctionne de façon rapide et simple. Il facilite de même la gestion des caractères latins, dont les accents notamment.

• Cliquer sur le bouton Créer,

La nouvelle base de données apparaît bien dans l'énumération du volet de gauche. Elle est vide pour l'instant. Nous devons y importer les données externes.

• Dans le volet de gauche, cliquer sur le lien de la base de données Supports pour la désigner,
• En haut de l'interface de PhpMyAdmin, cliquer sur l'onglet Importer,
• Au centre de l'écran, cliquer sur le bouton Parcourir,
• Double cliquer sur le fichier formations.sql situé dans le sous dossier bdd,

L'importation des données au format Sql est standard. Les autres réglages peuvent donc être conservés, tels que définis par défaut.

• Tout en bas de la page, cliquer sur le bouton Exécuter pour procéder à l'importation,

Le processus peut durer plusieurs dizaines de secondes. Tout dépend du volume des informations à importer. A l'issue du traitement, un message de succès apparaît.

• Dans le volet de gauche, déployer l'affichage de la base de données Supports,
• Puis, cliquer sur le lien de la table formations créée durant la phase d'importation,

Nous affichons ainsi son contenu au centre de l'écran. Il s'agit d'un extrait de la base de données MySql du site Bonbache.fr.



La structure de la table a néanmoins été largement simplifiée pour focaliser notre attention sur les besoins essentiels. Elle est composée de trois champs. Le premier f_num est celui de la clé primaire. Il alloue automatiquement un numéro d'identification unique à chacun des enregistrements. Le deuxième est le champ f_titre. Comme son nom l'indique, il permet de spécifier le titre de la formation. Le dernier champ est nommé f_motscles. Il est particulièrement important pour les besoins du moteur de recherche. Et il s'agit d'une astuce fortement conseillée à produire en amont, soit à chaque création de nouvelle entrée. Il énumère tous les mots clés, séparés d'un point-virgule, décrivant l'article. Ainsi, plutôt que de réaliser des recherches gourmandes en termes de ressources dans un champ de descriptif, souvent lourd et dense, nous pourrons faire agir la requête Sql directement sur ce champ.

Nous retournerons ainsi les titres de chaque formation répondant à la demande internaute, via la zone de saisie du moteur de recherche.

Un compte utilisateur doit désormais être créé pour permettre au code Php d'accéder aux informations de cette base de données. Des identifiants sont déjà spécifiés dans la chaîne de connexion du fichier connexion.php, situé dans le sous dossier commun.

...
$liaison = mysqli_connect("127.0.0.1", "moteur", "m127T888");
mysqli_select_db($liaison,"ids");
...

Nous proposons de conserver et répliquer ces informations. Cependant, nous devrons y adapter le nom de la base de données. Il ne s'agit pas de la base ids mais de la base supports, telle que nous l'avons créée.

• Dans le volet de gauche, cliquer sur le lien de la base supports pour la désigner,
• En haut de l'interface de PhpMyAdmin, cliquer sur l'onglet Privilèges,
• Dans la section Nouvel utilisateur, cliquer sur le lien Ajouter un compte d'utilisateur,
• Dans la zone nom d'utilisateur, saisir moteur,
• Dans la zone nom d'hôte, définir l'adresse locale, ici : 127.0.0.1,
• Dans la zone Mot de passe, taper : m127T888,
• Puis, taper de nouveau ce mot de passe dans le champ Saisir à nouveau,
• Plus bas, cocher la case Tout cocher des Privilèges globaux,
• Enfin, tout en bas de l'écran, cliquer sur le bouton Exécuter pour procéder à la création du compte,

Un message de confirmation apparaît indiquant que l'utilisateur a été ajouté. Nous ne devons pas oublier d'adapter le nom de la base de données dans le fichier de connexion.

• Ouvrir le sous dossier commun du dossier de décompression,
• Cliquer droit sur le fichier connexion.php,
• Dans le menu contextuel, choisir de l'ouvrir avec un éditeur comme le Notepad++,
• Dans la fonction Php mysqli_select_db, remplacer le nom ids en deuxième argument par le nom supports ,

...
$liaison = mysqli_connect("127.0.0.1", "moteur", "m127T888");
mysqli_select_db($liaison,"supports");
...

• Enregistrer les modifications (CTRL + S) et fermer le fichier de connexion,

Il est temps d'exécuter l'application telle qu'elle a été livrée.

• Revenir sur l'interface d'EasyPhp,
• Cliquer sur le lien du projet pour accéder à sa page d'accueil,

Nous y découvrons une interface Web relativement simple. Un bandeau horizontal offre une zone de saisie. Il s'agit du moteur de recherche à bâtir par le code Php. Le bouton Valider sur sa droite permet de soumettre ces mots clés au serveur. Ces contrôles sont donc nécessairement placés dans un formulaire Html. Nous allons bientôt le constater. Les résultats répondant à la demande internaute, donc correspondant à tous les mots clés recoupés, doivent être livrés dans le cadre du dessous (Liste des résultats).

• A la racine du dossier de décompression, cliquer droit sur le fichier index.php,
• Dans le menu contextuel, choisir de l'ouvrir avec un éditeur comme le Notepad++,
• Faire défiler le code vers le bas jusqu'à atteindre la ligne 29 pour un éditeur Notepad,

Nous y trouvons le formulaire Html encapsulant les contrôles du moteur de recherche. Juste en dessous, vous notez la présence du calque (Balise Html Div) d'identifiant colonne_gauche, pour restituer les résultats de la recherche.

...
<div class="centre">
<div class="titre_centre">
<form id="formulaire" name="formulaire" method="post" action="index.php">
<div class="liste_div">
<input type="text" id="mc" name="mc" class="liste" value="Vos mots clés de recherche" onClick="this.value='';" />
</div>
<div class="liste_div" style="float:right;">
<input type="submit" id="valider" name="valider" class="liste" style="width:100px;" value="Valider" />
</div>
</form>
</div>
</div>

<div class="colonne" id="colonne_gauche">
Liste des résultats
</div>
...

La zone de saisie du moteur de recherche est nommée mc. Le bouton de validation est un contrôle Html de type submit. Sans contrôle préalable, il génère donc un PostBack pour transférer les données du formulaire au serveur.

Transmettre les mots clés de recherche au serveur
Comme vous l'avez remarqué dans l'extrait de code ci-dessus, la méthode de soumission du formulaire est post. Donc côté serveur, les mots clés doivent être réceptionnés par l'instruction Php $_POST. La page appelée est la page courante, index.php, d'où le fameux PostBack (Aller-retour serveur).

Nous devons commencer par récupérer les termes saisis par l'internaute et déclarer quelques variables nécessaires à la suite du traitement.

• Dans la section Php en entête de page, après les instructions include pour les imbrications, ajouter les traitements Php suivants :

<?php
include("commun/connexion.php");
include("commun/entete.php");

include("fonction/traitement_chaine.php");

if(isset($_POST["mc"]) && $_POST["mc"]!="")
{
$chaque_mot=""; $url_fiche=""; $titre_fiche=""; $chaine_fiche=""; $compteur=0;
$les_mots_cles = strtolower(utf8_decode($_POST["mc"]));
$les_mots_cles = supprAccents(supprSpeciaux($les_mots_cles));
$mots_a_exclure="avec|pour|dans|";
$tableau_exclure = explode("|",$mots_a_exclure);
$requete_et="SELECT * FROM formations ";

echo $les_mots_cles;
}
?>
<div style="width:100%; display:block; text-align:center;">
</div>
...

Nous faisons tout d'abord référence à un fichier Php externe que nous avons déjà exploité dans une formation précédente. Il se nomme traitement_chaine.php et il est situé dans le sous dossier fonction du dossier de décompression. C'est tout naturellement l'instruction include qui permet de l'intégrer dans la construction de la page. Dès lors ses fonctions pourront être exploitées par le code Php. Les fonctions de ce fichier se nomment respectivement supprAccents et supprSpeciaux. Comme leurs noms l'indiquent, la première supprime les accents tandis que la seconde purge les caractères spéciaux. Ces traitements sont essentiels pour reconstruire les Url des rubriques concordantes.

Ensuite et comme souvent, avant d'enclencher la moindre action, nous testons l'existence des informations transmises, grâce à la fonction Php isset. Nous lui passons en paramètre les données de la zone de saisie, transférées à soumission du formulaire. Et c'est donc l'instruction Php $_Post avec le nom du contrôle ($_POST["mc"]) qui opère cette réception. Si les mots clés existent et qu'ils ne sont pas vides (&& $_POST["mc"]!=""), alors nous poursuivons.

Nous déclarons les variables nécessaires. $chaque_mot sera utilisée pour bâtir la clause Where de la requête Sql afin d'établir la correspondance avec tous les mots clés cherchés. $url_fiche est la variable dans laquelle nous allons réécrire l'adresse de la page Web de destination, pour chaque enregistrement concordant. A ce titre, nous répliquerons des techniques que nous avions mises en oeuvre dans la formation Php sur l'Url Rewriting. $titre_fiche doit restituer le nom de la fiche de formation, issue de la base de données. $chaine_fiche doit correspondre au bloc de résultat final et concaténé que nous devons restituer sur la page, en réponse à la recherche. $compteur est une variable précieuse pour la construction itérative de la requête Sql, en fonction des mots clés qui seront passés en revue dans une boucle.

Nous exploitons ensuite les fonctions supprAccents et supprSpeciaux imbriquées pour nettoyer la chaîne des mots clés. Grâce à l'interclassement utf8_general_ci, les requêtes Sql seront insensibles aux différences dues précisément à ces accents.

Nous créons ensuite une chaîne énumérant des termes parasites récurrents et ne devant pas intervenir dans la recherche. Elle est appelée à être complétée. Grâce à la fonction Php explode, nous la découpons en tableau de variables sur le caractère remarquable de la barre verticale (|). Nous exploiterons ce tableau, par le biais d'une boucle, pour exclure les termes parasites de la chaîne des mots clés réceptionnés.

Nous stockons le début de la syntaxe de la requête Sql dans la variable $requete_et. Nous devrons lui concaténer sa clause Where à construire au fur et à mesure des mots clés passés en revue et à recouper.

Enfin et à ce stade, nous nous permettons de réaliser un premier test grâce à la fonction Php echo. Il est destiné à vérifier d'une part que les données sont correctement réceptionnées et d'autre part qu'elles sont conformément traitées.

• Enregistrer les modifications (CTRL + S) et basculer sur le navigateur Web,
• Taper plusieurs mots clés comme : Références absolues Excel,
• Puis, valider en cliquant sur le bouton ou en enfonçant la touche Entrée du clavier,

La chaîne est parfaitement restituée. Elle est basculée en minuscules. Les accents ont disparu. Cependant, des tirets ont fait leur apparition, en lieu et place des espaces. C'est la fonction externe supprSpeciaux qui l'impose. Nous devrons replacer ces tirets pour afficher des titres de formation conventionnels, en guise de résultats de recherche. C'est ce que nous proposons de réaliser dans l'enchaînement, mais pas seulement. Nous devons exploiter le tableau des termes à exclure, pour supprimer les mots clés parasites potentiels.

• Revenir dans le code de la page index.php,
• Passer l'instruction echo en commentaire (//),
• A la suite du code précédent, toujours dans les bornes de l'instruction conditionnelle, ajouter les traitements Php suivants :

...
if(isset($_POST["mc"]) && $_POST["mc"]!="")
{
$chaque_mot=""; $url_fiche=""; $titre_fiche=""; $chaine_fiche=""; $compteur=0;
$les_mots_cles = strtolower(utf8_decode($_POST["mc"]));
$les_mots_cles = supprAccents(supprSpeciaux($les_mots_cles));
$mots_a_exclure = "avec|pour|dans|";
$tableau_exclure = explode("|", $mots_a_exclure);
$requete_et = "SELECT * FROM formations ";

//echo $les_mots_cles;

for($i=0; $i< sizeof($tableau_exclure); $i++)
{
$les_mots_cles = str_replace($tableau_exclure[$i], "", $les_mots_cles);
}

$les_mots_cles = str_replace(" ", " ", str_replace(" ", " ", $les_mots_cles));
$les_mots_cles = str_replace("-", " ", $les_mots_cles);

echo $les_mots_cles;
}
...

Grâce à la fonction Php sizeof, nous connaissons le nombre d'éléments contenus dans le tableau de variables des termes à exclure. Nous initions donc une boucle de traitement jusqu'à cette valeur seuille, afin de passer en revue tous les mots qu'il recèle. Ainsi, à chaque passage dans la boucle, grâce à la fonction Php str_replace, nous remplaçons le potentiel terme parasite par une chaîne vide, dans la chaîne des mots clés. En d'autres termes, nous les supprimons tous, un par un.

Puis, nous exploitons de nouveau la fonction str_replace en cascade. Nous remplaçons les potentiels espaces cumulés par un seul, afin de séparer correctement les mots clés. Ce sont des défauts de frappe récurrents durant la saisie. Enfin et comme nous le disions, toujours grâce à la fonction str_replace, nous remplaçons le tiret pour repositionner l'espace de séparation.

A l'issue et comme toujours, nous réalisons un test intermédiaire grâce à la fonction echo. L'objectif est de contrôler la cohérence des résultats induits par ces traitements.

• Enregistrer les modifications (CTRL + S) et basculer sur le navigateur Internet,
• Taper les mots clés de recherche suivants : Références absolues pour Excel,
• Valider avec la touche Entrée ou le bouton du formulaire,

Comme vous le constatez, les espaces ont parfaitement remplacé les tirets. De plus, le terme parasite pour a été exclu du résultat.

Avant de débuter le traitement consistant à construire la clause Where de la requête Sql pour interroger la base de données, sur tous les termes à recouper, nous devons poser quelques gardes fous. Nous devons passer ce moteur de recherche en production. Nous devons donc préserver les ressources. Et donc, nous devons veiller à ne répondre qu'aux demandes sérieuses. Toutes celles qui ne possèdent pas assez ou trop de caractères, doivent être exclues. De même, un assemblage de mots clés sans la moindre lettre de l'alphabet est suspicieux. Afin d'économiser les ressources, nous proposons de les intercepter pour les exclure.

• Revenir dans le code de la page index.php,
• A la suite des instructions précédentes, toujours dans les bornes de l'instruction conditionnelle, ajouter les traitements Php suivants :

...
for($i=0; $i<sizeof($tableau_exclure); $i++)
{
$les_mots_cles = str_replace($tableau_exclure[$i], "", $les_mots_cles);
}

$les_mots_cles=str_replace(" ", " ", str_replace(" ", " ", $les_mots_cles));
$les_mots_cles = str_replace("-", " ", $les_mots_cles);

//echo $les_mots_cles;


if(strlen(str_replace("", "", $les_mots_cles))<4)
$chaine_fiche = "Oups !<br /><br />Le contenu de votre demande est insuffisant pour être traité.";
else if(strlen(str_replace(" ", "", $les_mots_cles))>50)
$chaine_fiche="Oula !<br /><br />Votre demande semble bien compliquée !<br /> Veuillez la simplifier.";
else if(strpos($les_mots_cles, "a")===false && strpos($les_mots_cles, "e")===false && strpos($les_mots_cles, "i")===false && strpos($les_mots_cles, "o")===false && strpos($les_mots_cles, "u")===false && strpos($les_mots_cles, "y")===false)
$chaine_fiche="Désolé !<br /><br />Votre demande ne semble pas correcte !<br /> Il faut être plus clair.";
else
{

}

}
?>
...

Si la chaîne des mots clés est trop courte, jugée grâce à la fonction php strlen, nous en informons l'internaute. La demande ne sera pas traitée. Cette variable doit être restituée dans le calque d'identifiant colonne_gauche. Sinon si (else if) elle est trop longue, l'issue est la même. Nous jugeons que la demande est trop complexe ou farfelue. L'information doit être restituée elle aussi et au même endroit. Sinon si (else if) aucune voyelle n'est décelée dans la chaîne des mots clés, nous refusons là encore de traiter la demande. C'est la fonction Php strpos qui permet de tester la position et donc l'existence de chacune de ces lettres. Lorsque la fonction renvoie zéro, elle indique que le caractère est absent de la chaîne. Comme toutes les recherches de voyelles sont recoupées (&&), si aucune position positive n'est retournée, nous en déduisons qu'il s'agit d'une succession de consonnes. Enfin, nous préparons le cas restant (else). Il s'agit du contexte ou les termes tapés semblent conformes et doivent être traités pour interroger la base de données.

Avant de pouvoir tester le bon fonctionnement de ces gardes fous, nous devons donc restituer le résultat dans le code Html.

• Dans le calque d'identifiant colonne_gauche, ajouter la section Php suivante :

...
</div>

<div class="colonne" id="colonne_gauche">
Liste des résultats<br /><br />
<?php
if(isset($_POST["mc"]) && $_POST["mc"]!="")
echo $chaine_fiche;
?>
</div>

<div class="centre">
...

Nous ne restituons aucun message tant que nous n'avons pas la certitude qu'une demande a été formulée. Et pour ce faire, nous exploitons une fois de plus la fonction Php isset dans une instruction conditionnelle. En revanche, si les mots clés ont bien été transmis, ils ont nécessairement été traités par nos instructions en entête. Nous choisissons donc de restituer la conclusion, comme toujours, grâce à la fonction php echo.

• Enregistrer les modifications et basculer sur le navigateur Web,
• Taper des mots clés trop courts ou trop longs ou encore sans voyelles,
• Puis, valider à l'aide de la touche Entrée pour soumettre le formulaire et les mots clés,

Comme vous le constatez, notre code Php intercepte les demandes farfelues pour couper l'exécution du traitement. En ce sens, il préserve les ressources du serveur et pérennise le bon fonctionnement en production. En revanche, si vous tapez des termes de recherche tout à fait conformes, le résultat retourné est vierge pour l'instant. Il s'agit de la dernière instruction else que nous avons prévue et qui est encore vide de code. Elle doit se déclencher à la recherche de chaque mot clé recoupé, dans la table de la base de données. Nous devons y construire, par concaténation dans une boucle, la clause Where à assembler dans la syntaxe Sql initiée.

Requête SQL pour moteur de recherche
La requête est la clé du succès pour un moteur de recherche efficace en Php. Souvenez-vous néanmoins du concept visant à optimiser les ressources et temps de réponse. Tous les mots clés décrivant l'enregistrement sont assemblés dans le champ f_motscles. La clasue Where de la requête SQL doit y pointer pour l'interroger. Chacun des mots clés saisis par l'internaute doit s'y trouver. Il s'agit donc de recouper ces critères. Et pour ce faire, nous devons parcourir le tableau des mots clés par une boucle d'instruction, afin de compléter la syntaxe de la requête SQL.

• Revenir dans le code de la page index.php,
• Dans la branche else de l'instruction conditionnelle, ajouter les traitements Php suivants :

...
if(strlen(str_replace(" ", "", $les_mots_cles))<4)
$chaine_fiche="Oups !<br /><br />Le contenu de votre demande est insuffisant pour être traité.";
else if(strlen(str_replace(" ", "", $les_mots_cles))>50)
$chaine_fiche="Oula !<br /><br />Votre demande semble bien compliquée !<br /> Veuillez la simplifier.";
else if(strpos($les_mots_cles, "a")===false && strpos($les_mots_cles, "e")===false && strpos($les_mots_cles, "i")===false && strpos($les_mots_cles, "o")===false && strpos($les_mots_cles, "u")===false && strpos($les_mots_cles, "y")===false)
$chaine_fiche="Désolé !<br /><br />Votre demande ne semble pas correcte !<br /> Il faut être plus clair.";
else
{
$tableau_mots_cles=explode(" ", $les_mots_cles);
for($i=0; $i<sizeof($tableau_mots_cles); $i++)
{
$chaque_mot = rtrim($tableau_mots_cles[$i], "s");
if(strlen($chaque_mot)>3)
{
if($compteur==0)
{
$requete_et .= "WHERE f_motscles LIKE'%".$chaque_mot."%' ";
}
else
{
$requete_et .= "AND f_motscles LIKE '%".$chaque_mot."%' ";
}

$compteur++;
}
}

$requete_et .= "LIMIT 0,10;";
}
...

Grâce à la fonction Php explode désormais bien connue, nous découpons la chaîne des mots clés sur l'espace. Il en résulte un tableau de variables affecté à la volée et nommé $tableau_mots_cles. De fait, nous initions une boucle afin de parcourir toutes les rangées de ce tableau de variables. C'est la fonction Php sizeof qui renvoie le nombre d'éléments qu'il contient. Nous fixons ainsi la borne supérieure de la boucle pour passer en revue chaque mot clé, du premier au dernier.

Dans la boucle, nous exploitons la fonction Php rtim afin de supprimer la potentielle lettre s située en fin de mot. L'objectif est de réaliser des comparaisons toujours au singulier. Le mot clé ainsi retravaillé est stocké dans la variable chaque_mot. Nous engageons la suite de la construction de la requête Sql, seulement dans la mesure où il ne s'agit pas d'un petit mot clé (strlen($chaque_mot)>3). Nous ignorons ainsi les particules de liaison du type : Le, La, Les, Des etc...

Le test sur la variable $compteur est essentiel. Il permet de savoir s'il s'agit du premier mot clé. Dans ce cas en effet, l'assemblage de la requête SQL diffère puisqu'il s'agit d'y inclure la clause WHERE. Cette contrainte est posée sur le champ f_motscles. Grâce à l'opérateur SQL LIKE, nous cherchons à vérifier la présence d'un terme contenant le mot clé en cours d'analyse. Il ne faut surtout pas oublier l'espace avant de fermer la double côte. Ce bout de requête est susceptible d'être assemblé à une suite de contraintes.

Dans le cas effectivement où il ne s'agit pas du premier mot clé, nous poursuivons la construction de la requête Sql. Et pour cela, nous exploitons l'opérateur And afin de recouper ce mot clé avec les précédents dans la construction. Le reste de la syntaxe est identique à la précédente.

Puis, nous n'oublions pas d'incrémenter la variable $compteur à chaque fois qu'un mot clé a été traité. Une fois la boucle terminée et donc une fois tous les mots clés assemblés dans la clause Where de la requête Sql, nous finalisons sa syntaxe. Nous lui ajoutons une clause LIMIT. Elle indique que l'extraction doit débuter à partir du premier enregistrement trouvé et ne restituer au plus que 10 résultats (LIMIT 0,10).

Avant d'aller plus loin, nous proposons de vérifier la bonne construction de la requête Sql. Et pour ce faire, nous choisissons de la restituer dans le calque d'identifiant colonne_gauche.

• Dans la fonction echo du calque colonne_gauche, assembler la variable $requete_et comme suit :

...
<div class="colonne" id="colonne_gauche">
Liste des résultats<br /><br />
<?php
if(isset($_POST["mc"]) && $_POST["mc"]!="")
echo $chaine_fiche."<br/>".$requete_et;
?>
</div>
...

Nous concaténons le message de retour à un saut de ligne Html lui-même assemblé à la requête.

• Enregistrer les modifications et basculer sur le navigateur Internet,
• Taper une succession de mots clés comme : Références absolues Excel,
• Puis, valider pour soumettre les termes de recherche,

Comme vous le constatez, la requête Sql est parfaitement construite. Elle recoupe en effet chacun des termes saisis, au singulier, afin d'extraire uniquement les enregistrements correspondant à toutes les contraintes.

Nous devons désormais exécuter cette requête. Nous devons découper les informations résultantes dans un tableau de variables pour y placer les enregistrements indépendamment. Nous devons parcourir toutes les rangées de ce tableau afin de reconstruire et restituer les réponses correspondantes sur la page Web.

• Revenir dans la section Php en entête de code de la page index.php,
• A la suite des traitements précédents, toujours dans la branche else, ajouter les instructions Php suivantes :

...
if(strlen(str_replace(" ", "", $les_mots_cles))<4)
$chaine_fiche="Oups !<br /><br />Le contenu de votre demande est insuffisant pour être traité.";
else if(strlen(str_replace(" ", "", $les_mots_cles))>50)
$chaine_fiche="Oula !<br /><br />Votre demande semble bien compliquée !<br /> Veuillez la simplifier.";
else if(strpos($les_mots_cles, "a")===false && strpos($les_mots_cles, "e")===false && strpos($les_mots_cles,"i")===false && strpos($les_mots_cles, "o")=== false && strpos($les_mots_cles, "u")===false && strpos($les_mots_cles, "y")===false)
$chaine_fiche="Désolé !<br /><br />Votre demande ne semble pas correcte !<br /> Il faut être plus clair.";
else
{
$tableau_mots_cles=explode(" ", $les_mots_cles);
for($i=0; $i<sizeof($tableau_mots_cles); $i++)
{
$chaque_mot = rtrim($tableau_mots_cles[$i], "s"); //Supprime le s de fin soit le pluriel
if(strlen($chaque_mot)>3)
{
if($compteur==0)
{
$requete_et .= "WHERE f_motscles LIKE '%".$chaque_mot."%'";
}
else
{
$requete_et .= "AND f_motscles LIKE '%".$chaque_mot."%' ";
}

$compteur++;
}
}

$requete_et .= "LIMIT 0,10;";

$compteur=0;
$retours = mysqli_query($liaison, $requete_et);
while($retour = mysqli_fetch_array($retours))
{
$url_fiche = "https://www.bonbache.fr/".supprAccents( supprSpeciaux( strtolower($retour["f_titre"])))."-".$retour["f_num"].".html";

$titre_fiche = stripslashes($retour["f_titre"]);
$titre_fiche = supprSpeciaux(strtolower($titre_fiche));
$titre_fiche = str_replace("-"," ",$titre_fiche);
for($i=0; $i<sizeof($tableau_mots_cles); $i++)
{
$chaque_mot = rtrim($tableau_mots_cles[$i], "s"); //Supprime le s de fin soit le pluriel
if(strlen($chaque_mot)>3)
{
$titre_fiche = str_replace($chaque_mot,"<span style='background-color:yellow;'>".$chaque_mot."</span>", $titre_fiche);
}
}

$chaine_fiche.= "<div style='float:left; width:100%; padding-bottom:5px;'>";
$chaine_fiche.= "<a href='".$url_fiche."' target='_self' style='color:#666666;'>".ucfirst(utf8_encode($titre_fiche))."</a>";
$chaine_fiche.= "</div>";

$compteur++;
}

}
}
?>
<div style="width:100%; display:block; text-align:center;">
</div>
...

Comme toujours, nous exploitons la fonction Php mysqli_query pour exécuter la requête que nous venons d'approuver. Nous découpons l'information retournée grâce à la fonction mysqli_fetch_array. Il en résulte un tableau de variables dont nous parcourons chaque rangée ($retour) grâce à une boucle while.

Nous réécrivons l'url de la page de destination, telle qu'elle est conçue sur le site Bonbache.fr. Il s'agit d'un assemblage du titre et du numéro de la clé primaire permettant de restituer la bonne rubrique. Ce titre est bien évidemment traité par les fonctions externes. Nous restituons ainsi une Url conforme.

Nous travaillons ensuite le titre de la formation correspondante dans la variable $titre_fiche. La fonction stripslashes permet d'exclure les apostrophes problématiques dans l'assemblage des chaînes, elles-mêmes encadrées de côtes. Nous remplaçons les tirets par des espaces grâce à la fonction str_replace.

Puis, dans une boucle vérifiant que le mot clé en cours d'analyse est suffisamment long, nous décelons sa présence potentielle dans la chaîne de titre restituée. L'objectif est de le faire apparaître en surbrillance. S'il est trouvé, la fonction str_replace le remplace par le mot lui-même encadré d'une balise Html le mettant en forme.

Enfin et c'est classique, nous assemblons le résultat à restituer dans des balises Html, afin d'aérer la présentation. Le titre de la formation est encadré d'un lien en dur, défini par la variable $url_fiche. La fonction Php ucfirst porte bien son nom. Elle convertit la première lettre de la chaîne en majuscule.

• Enregistrer les modifications et basculer sur le navigateur Web,
• Taper des mots clés de recherche comme : Références absolues Excel,
• Puis, valider pour soumettre les termes au code Php,

Tous les enregistrements recoupant tous les mots clés sans exception, sont parfaitement restitués. De plus, ils pointent chacun vers leur page dédiée. Les termes cherchés retrouvés dans le titre, sont mis en évidence. Il convient désormais de supprimer la restitution de la requête Sql en queue de liste.

Si vous tapez d'autres mots clés de recherche, vous obtenez de nouveaux résultats pertinents instantanément. Tel que nous l'avons construit, notre moteur de recherche Php est à la fois efficace et pertinent.

Dans une prochaine formation, nous verrons comment proposer des résultats approchants lorsqu'aucune information adéquate n'est trouvée.