Les fonctions - Les clefs du PHP

La fonction est une unité de programme enfermée à l’intérieur d’accolades
avec comme entrée, des parenthèses. Nous verrons cependant qu’une
variable déclarée global peut agir à l’intérieur de la fonction.

Le rôle de la fonction

En PHP, vous pouvez utiliser des fonctions c’est-à-dire de petits programmes
dédiés à une tâche. Une fonction est autonome, elle reçoit ou non des
paramètres et exécute son code, puis retourne le résultat à l’expression qui
l’a appelée.

L’intérêt de ces programmes est que vous n’avez pas besoin de faire à
chaque fois un couper/coller dans vos applications pour récupérer ces
petits morceaux de programme, il vous suffit de les appeler. Ainsi, vos
programmes sont plus lisibles. Quand vous traitez une variable dans une
fonction, vous n’avez pas besoin de connaître le nom de la variable
utilisée par la fonction.

Ici, nous créerons une fonction qui nous servira plus loin. Si vous voulez
rendre votre site web interactif, invitez les visiteurs à s’inscrire dans votre
club. Vous leur demandez leur nom et prénom et les remerciez ensuite.
Vous souhaitez que votre site ait l’air professionnel, mais parfois, les
personnes ne mettent pas leur nom en majuscules, ce qui fait désordre quand vous les nommez dans les remerciements. Et puis le français n’est pas simple et vous ne voulez pas vous fâcher pour un nom écorché. La solution est d’y penser tout de suite pour ne plus y revenir. Vous
fabriquerez donc une fonction traitant les noms de famille qui nécessitent
des capitales.

Voici la fonction que nous vous engageons à mettre dans un fichier
fonctions.inc.php. Nous verrons au cours du chapitre 4 comment l’utiliser
dans un programme :

function majuscules($majuscule){
$majuscule=trim($majuscule);
$majuscule=strtolower($majuscule);
$majuscule=str_replace("d’", "d’ ",$majuscule);
$passage=1;
///vous pouvez ajouter d’autres séparateurs dans le tableau///
$motif[]=" ";
$motif[]="-";
$nombre=count($motif);

Nous avons fourni les variables avec des valeurs. Nous allons signaler les
différentes étapes avec le marqueur $passage. La boucle testera les séparateurs de mots pour vérifier qu’ils sont présents dans le paramètre fourni ($majuscule). La variable $nom_complet sert temporairement de
transport aux éléments du nom décomposé. Une fois qu’elle a servi, elle rend son butin et s’efface avec la fonction unset() :

for ($i=0;$i<$nombre;$i++){
$particule=$motif[$i];
if (ereg($particule,$majuscule)) {
if ($passage==2){
$majuscule=$nom_complet;
unset($nom_complet);
}
$passage=2;
$majuscules=split($particule,$majuscule);
$combien=count($majuscules);

Cette boucle for nichée dans la boucle principale gère les tronçons du
nom coupé par le séparateur en mettant la première lettre en capitale.

for ($j=0;$j<$combien;$j++){
$maj=$majuscules[$j];

Nous plaçons la première lettre de chaque tronçon en majuscule, sauf pour
ces mots-là :

if ($maj!=’de’ && $maj!=’d\’’ && $maj!=’et’ &&
$maj!=’&’){
$maj=ucfirst($maj);
}

Nous reconstituons le nom complet au fil des boucles avec $nom_complet
qui ne sert qu’au transport et qui, après une série de transformations,
restitue sa valeur à la variable $majuscule :

$nom_complet.=$maj;
if ($j<$combien-1){
$nom_complet.=$particule;
}

Tant que nous n’en sommes pas au dernier tronçon, nous ajoutons le
séparateur :

Mettre un nom en majuscules : majuscules.php
}
/////FIN DU PLUS PETIT FOR//////////
}
////FIN DES MOTS QUI POSSÈDENT UN SÉPARATEUR " " ou -///////
}
///////FIN DU PLUS GRAND FOR/////////
if($passage==1){
$majuscule=ucfirst($majuscule);
}
elseif ($passage==2){
$majuscule=$nom_complet;
}
//RESTITUTION DE LA VALEUR///
unset ($nom_complet);
///DESTRUCTION DU VÉHICULE AVEC UNSET////
$majuscule=str_replace("d’ ", "d’",$majuscule);
////élision de l’espace supplémentaire pour d’///
return $majuscule;
}

La fonction commence par le mot-clé function. Ensuite, trim() enlève
les espaces éventuels qui encadreraient le nom puis met la chaîne en bas
de casse. Le str_replace() est présent pour introduire une astuce car un
nom à particule peut être composé d’un de ou d’ qui ne prend pas de
capitales. Ici, la fonction introduit un espace après d’ pour l’assimiler à
de. Il suffira ensuite de retirer l’espace pour que le nom soit correct.

Les lignes qui suivent insèrent les séparateurs (ici espace ou tiret) dans
un tableau. Il est possible d’ajouter des séparateurs car la fonction
count() qui suit donne le nombre d’éléments, donc de boucles à faire
pour traiter le nom.

Nous entrons dans deux boucles, la première va traiter le nom en regard
de chaque séparateur inséré dans le tableau. La deuxième est imbriquée
dans la première, elle intervient pour traiter les tronçons de noms avant de
les reconstituer. À chaque tour de la grande boucle, il est nécessaire de
vider la variable de sa valeur de résultat, pour éviter plusieurs concaténations
du même nom d’un séparateur à l’autre. Pour cela le marqueur
$passage se révèle nécessaire.

Mettre en majuscules