Forum d'entraide PHPFrance

Bonjour
je suis plus que novice en php et je me demandais s'il était possible d'utiliser un fichier xls pour le transformer en programme php.
En fait j'utilise un cms en php et il y a dedans des modules. J'ai pour ma part un mini programme de numérologie qui est en xls et qui marche donc sous excel, on rentre son nom, son prénom, sa date de naissance et il calcule le thème et on peut le lire sur une page web. Ce que j'aimerais c'est réaliser mon premier module avec ce programme. Sauf que je ne sais absolument pas comment commencer et même si c'est possible.

Merci d'avance.

Récupèrer le fichier xls pour en faire une appli php est à mon sens impossible, mais tu peux comprendre la logique du xls pour la reproduire en php.
Mais par contre pour créer un module pour ton CMS, impossible de t'aiguiller sans connaitre le CMS

c'est phpboost le cms. Donc ma 2eme idee est surement meilleure, c'est décomposer ce fichier xls pour comme tu le dis le reproduire en php. Je vais essayer, est ce que tu connais un bon tuto sur les bases de données stp parce que je ne sais pas pourquoi j ai vraiment du mal avec l'idee de mettre des objets dans des petites boites, mon cerveau n'arrive pas a assimiler ce truc. J ai lu pas mal de tuto et ca ne veut pas rentrer. Pourtant je t'assure que j y mets de la bonne volonté

salut,

pour le SQL http://sqlpro.developpez.com/

@+

rebonjour !
j'ai mis un peu de temps pour revenir compléter mes messages car entre temps j'ai télécharger les cours d'openclassroom et je les aient lus (oui c'est mieux quand même )
J ai bien avancer, j'ai récupérer les donner du fichiers xls, je les aient mis dans plusieurs bases de données, car il y a plusieurs calculs et donc plusieurs définitions et cela semble fonctionner.
Mais j'ai quelques soucis et malgré mes recherches il y a des choses que je ne comprends pas
Je veux maintenant récupérer mes résultats et les afficher au propre dans un tableau.
J ai une fonction dont le nom est aspiration_intime_texte

function aspiration_intime_texte($aspiration_intime) {
	$host    = 'localhost';
	$db      = 'test';
	$table   = 'aspiration';
	$user    = 'root';
	$pass    = '';
	$charset = 'utf8';
	$opt = [];
	$dsn = "mysql:host=$host;dbname=$db;charset=$charset";

	$pdo = new PDO($dsn, $user, $pass, $opt);
	// On va preparer un statement plutot que executer directement.
	// Ca nous permet de neutraliser les entrees dangereuses en
	// demandant a la base de donnee de les nettoyer elle-meme
	// (c'est l'utilite de ':chiffre' ici)
	$stmt = $pdo->prepare(
		'SELECT texte FROM aspiration WHERE chiffre=:chiffre');
	$stmt->execute(['chiffre' => $aspiration_intime]);
	$row = $stmt->fetch();
	return $row['texte'];
}

une autre qui s'appelle chemin_de_vie_texte

function chemin_vie_texte($chemin_de_vie) {
	$host    = 'localhost';
	$db      = 'test';
	$table   = 'chemin';
	$user    = 'root';
	$pass    = '';
	$charset = 'utf8';
	$opt = [];
	$dsn = "mysql:host=$host;dbname=$db;charset=$charset";

	$pdo = new PDO($dsn, $user, $pass, $opt);
	// On va preparer un statement plutot que executer directement.
	// Ca nous permet de neutraliser les entrees dangereuses en
	// demandant a la base de donnee de les nettoyer elle-meme
	// (c'est l'utilite de ':chiffre' ici)
	$stmt = $pdo->prepare(
		'SELECT texte FROM chemin WHERE chiffre=:chiffre');
	$stmt->execute(['chiffre' => $chemin_de_vie]);
	$row = $stmt->fetch();
	return $row['texte'];
}

bon j'ai d'autre fonction mais pour faire simple j'explique avec 2

donc j'appelle mes infos sur une page avec des formulaires (nom/prenom) (date de naissance jour/mois/annee) et avec ca je fais mes calculs. Ensuite je veux les affichés, donc je fais :

echo "<p><strong>Voici le texte pour la personnalite:</strong></p>";
		echo nl2br(aspiration_intime_texte($resultats['aspiration_intime']));
		echo "<p><strong>Voici le texte pour chemin de vie:</strong></p>";
		echo nl2br(chemin_vie_texte($resultats['chemin_de_vie']));

et la ca affiche bien ce que je veux MAIS comme il y en a plusieurs je me suis dis si j'utilise des variables peut etre que cela sera mieux si plus tard j'en rajoute.

j'ai donc tester avec

echo "<p><strong>Voici le tableau qui contient les resultats:</strong></p>";
		print_r($resultats);

et j'ai bien comme résultats :
aspiration_intime 5
chemin_de_vie 6

donc je fais un tableau et histoire de lire tout d'un coup je fais un foreach :

foreach ($resultats as $_POST => $element) 
		{ 
		echo "<table><tr><td>$_POST</td><td>$element</td><td>";
		echo (aspiration_intime_texte($resultats['aspiration_intime']));
		echo "</td></tr></table>";
		}

mais je vois que mon $_POST m'affiche bien aspiration_intime et chemin_de_vie (comme nom)
et $element le chiffre qui va avec. Donc j'en déduis que si je fais un

foreach ($resultats as $_POST => $element) 
		{ 
		echo "<table><tr><td>$_POST</td><td>$element</td><td>";
		echo ($_POST_texte($resultats[$_POST]));
		echo "</td></tr></table>";
		}

Sauf que dans ce cas, quand je fais un test il m'affiche bien dans ma première case de mon tableau aspiration_intime, dans la 2eme le chiffre correspondant mais dans la 3eme case il me crie du fond du coeur : Notice: Undefined variable: _POST_texte in F:\www\testphp\numtest.php on line 42
ne devrait il pas m'afficher a la place de $_POST la chaîne de caractères correspondante ? ( $_POST étant la première fois aspiration_intime et la 2eme chemin_de_vie ? Le probleme est dans le 1er $_POST celui que j'aimerais qu'il me remplace la premiere partie du nom de ma fonction. Car si je mets :

foreach ($resultats as $_POST => $element) 
		{ 
		echo "<table><tr><td>$_POST</td><td>$element</td><td>";
		echo (aspiration_intime_texte($resultats[$_POST]));
		echo "</td></tr></table>";
		}

Il m'affiche bien le bon chiffre dans la partie ($resultats[$_POST]));

En fait du coup je me pose la question est ce que je peux remplacer réellement une partie du nom d'une fonction par un morceau de variable ? et si non comment je peux faire pour ne pas avoir a retaper plusieurs fois la même ligne juste pour écrire les différentes fonction puisque mes définitions, suivant le nom de $_POST dans le tableau sont différentes car elles ne sont pas dans les mêmes bases de données ?

je sais mon message est très long ... j’espère qu moins qu'il est clair

je vous mets pour finir tout mon code au cas ou cela vous aide.

Je vous remercie d'avance, j'ai passer la journée pour chercher la solution avant de vous demander.

<?php
/* Ce fichier contient code qui displait une page avec un formulaire,
 * et le code qui est invoque quand ce formulaire est soumis.
 * Donc, nos variables seront contenues dans $_POST
 * Variables in $_POST: nom, annee_naissance, mois_naissance, jour_naissance
 */

// Reporte erreurs. Ce bordel marche jamais et reporte pas
// de toute facon. Saloperie, php.
error_reporting(E_ALL); ini_set('display_errors', 1);

// Le corps de la logique
 if(empty($_POST['fais_le_calcul'])) {
	affiche_formulaire();
}
else {
	if(
		empty($_POST['nom']) ||
		empty($_POST['jour_naissance']) ||
		empty($_POST['mois_naissance']) ||
		empty($_POST['annee_naissance'])
	) {
		affiche_formulaire("Vous devez entrer toute l'information");
	}
	else {
		$resultats = fais_le_calcul(
			$_POST['nom'],
			$_POST['jour_naissance'],
			$_POST['mois_naissance'],
			$_POST['annee_naissance']);

		// C'est la pour afficher l'info pour verifier les resultats.
		// Le code pour afficher les resultats remplacerait celui-ci.
		echo "<p><strong>Voici le tableau qui contient les resultats:</strong></p>";
		print_r($resultats);
		
		foreach ($resultats as $_POST => $element) 
		{ 
		echo "<table><tr><td>$_POST</td><td>$element</td><td>";
		echo nl2br(aspiration_intime_texte($resultats['$_POST']));
		echo "</td></tr></table>";
		}
		





		// Convertis personnalite dans son texte, retrouve dans
		// la base de donnee
		echo "<p><strong>Voici le texte pour la personnalite:</strong></p>";
		echo nl2br(personnalite_texte($resultats['personnalite']));
		echo "<p><strong>Voici le texte pour chemin de vie:</strong></p>";
		echo nl2br(chemin_vie_texte($resultats['chemin_de_vie']));

	}
}

function affiche_formulaire($texte_erreur="") {
	echo str_replace(
		"<!--TEXTE_ERREUR-->",
		$texte_erreur,
		file_get_contents('indextest.php'));
}

function fais_le_calcul($nom, $jour, $mois, $annee) {
	$nom_bien_propre = nettoie_nom($nom);
	return array(
		"personnalite" => personnalite($nom_bien_propre),
		"aspiration_intime" => intime_aspiration($nom_bien_propre),
		"capacite_realisation" => capacite_realisation($nom_bien_propre),
		"chemin_de_vie" => chemin_de_vie($jour, $mois, $annee),
		"energie_cette_annee" => cette_annee_energie(),
		"cette_annee_ton_energie" => cette_annee_ton_energie($jour, $mois),
		"psychique" => psychique($jour),
		"evolution" => evolution($jour, $mois)
	);
}

function chemin_vie_texte($chemin_de_vie) {
	$host    = 'localhost';
	$db      = 'test';
	$table   = 'chemin';
	$user    = 'root';
	$pass    = '';
	$charset = 'utf8';
	$opt = [];
	$dsn = "mysql:host=$host;dbname=$db;charset=$charset";

	$pdo = new PDO($dsn, $user, $pass, $opt);
	// On va preparer un statement plutot que executer directement.
	// Ca nous permet de neutraliser les entrees dangereuses en
	// demandant a la base de donnee de les nettoyer elle-meme
	// (c'est l'utilite de ':chiffre' ici)
	$stmt = $pdo->prepare(
		'SELECT texte FROM chemin WHERE chiffre=:chiffre');
	$stmt->execute(['chiffre' => $chemin_de_vie]);
	$row = $stmt->fetch();
	return $row['texte'];
}

function aspiration_intime_texte($aspiration_intime) {
	$host    = 'localhost';
	$db      = 'test';
	$table   = 'aspiration';
	$user    = 'root';
	$pass    = '';
	$charset = 'utf8';
	$opt = [];
	$dsn = "mysql:host=$host;dbname=$db;charset=$charset";

	$pdo = new PDO($dsn, $user, $pass, $opt);
	// On va preparer un statement plutot que executer directement.
	// Ca nous permet de neutraliser les entrees dangereuses en
	// demandant a la base de donnee de les nettoyer elle-meme
	// (c'est l'utilite de ':chiffre' ici)
	$stmt = $pdo->prepare(
		'SELECT texte FROM aspiration WHERE chiffre=:chiffre');
	$stmt->execute(['chiffre' => $aspiration_intime]);
	$row = $stmt->fetch();
	return $row['texte'];
}

function personnalite_texte($personnalite) {
	$host    = 'localhost';
	$db      = 'test';
	$table   = 'personnalites';
	$user    = 'root';
	$pass    = '';
	$charset = 'utf8';
	$opt = [];
	$dsn = "mysql:host=$host;dbname=$db;charset=$charset";

	$pdo = new PDO($dsn, $user, $pass, $opt);
	// On va preparer un statement plutot que executer directement.
	// Ca nous permet de neutraliser les entrees dangereuses en
	// demandant a la base de donnee de les nettoyer elle-meme
	// (c'est l'utilite de ':chiffre' ici)
	$stmt = $pdo->prepare(
		'SELECT texte FROM personnalites WHERE chiffre=:chiffre');
	$stmt->execute(['chiffre' => $personnalite]);
	$row = $stmt->fetch();
	return $row['texte'];
}

function personnalite($nom) {
	return reduit_nombre(converti_nom_nombre($nom, 0));
}

function intime_aspiration($nom) {
	return reduit_nombre(converti_nom_nombre(garde_voyelles($nom), 0));
}

function capacite_realisation($nom) {
	return reduit_nombre(converti_nom_nombre(garde_consones($nom), 0));
}

function chemin_de_vie($jour, $mois, $annee) {
	return reduit_nombre($jour + $mois + $annee);
}

function cette_annee_energie() {
	$cette_annee = intval(date('Y'));
	// rajout de redui_nombre_sans_11 sinon on a 10 au lieu de 1
	return reduit_nombre_sans_11(accumule_nombre($cette_annee, 0));
}

function cette_annee_ton_energie($jour, $mois) {
	$cette_annee = intval(date('Y'));
	return reduit_nombre($jour + $mois + $cette_annee);
}

function psychique($jour) {
	return reduit_nombre($jour);
}

function evolution($jour, $mois) {
	return reduit_nombre($jour + $mois);
}

/* Recursif: voir le commentaire a la fin
 * pour uncons()
 */
function converti_nom_nombre($nom, $accu) {
	if($nom == "") {
		return $accu;
	}
	else {
			
		list($head, $tail) = uncons($nom);
		return converti_nom_nombre($tail,
			$accu + converti_lettre_chiffre($head));
	}
}
// J' ai compris !!!!! on prend le code ascii de la lettre on enleve le code ascii de a et on rajoute 1 et on a la valeur de la lettre c'est dingue !!!!
function converti_lettre_chiffre($lettre) {
	return 1 + ord($lettre) - ord('A');
}

function reduit_nombre($nombre) {
	if($nombre < 10 OR $nombre == 11 OR $nombre == 22 ) {
		return $nombre;
	}
	else {
		return reduit_nombre(
			intval($nombre / 10) + $nombre % 10);
		// exemple 38 38/10=3 modulo de 38/10 =8 3+8=11 le modulo % c'est le reste de la division

	}
}

function reduit_nombre_sans_11($nombre) {
	if($nombre < 10 ) {
		return $nombre;
	}
	else {
		return reduit_nombre_sans_11(
// exemple 38 38/10=3 modulo de 38/10 =8 3+8=11 le modulo % c'est le reste de la division
			intval($nombre / 10) + $nombre % 10);
	}
}

function accumule_nombre($nombre, $accu) {
	if($nombre == 0 OR $nombre == 11 OR $nombre == 22) {
		return $accu;
	}
	else {
		return accumule_nombre(
			intval($nombre / 10),
			$accu + $nombre % 10);
	}
}
// on met tout en majuscule et on enleve les accents
function nettoie_nom($nom) {
	$nom_majuscule = strtoupper($nom);
	$nom_sans_accents = remove_accents($nom_majuscule);

	// Enleve tout ce qui n'est PAS (^) une lettre
	return preg_replace('/[^A-Z]/', '', $nom_sans_accents);
}
// la aussi j ai compris tout ce qui n'est pas aeiouy est supprimer
function garde_voyelles($nom) {
	return preg_replace(
		'/[^AEIOUY]+/',
		'',
		$nom);
}

// pareil tout ce qui est aeiouy est supprimer
function garde_consones($nom) {
	return preg_replace(
		'/[AEIOUY]+/',
		'',
		$nom);
}

/* Emprunte de Wordpress: normalement, PHP convertit a l'aide d'une command
 * 'iconv' mais en realite c'est casse sur certain serveurs, donc on
 * va utiliser la facon de wordpress
 * (bonus: elle supporte plus que l'alphabet 7-bit)
 */
function remove_accents($string) {
    if ( !preg_match('/[\x80-\xff]/', $string) )
        return $string;

    $chars = array(
    // Decompositions for Latin-1 Supplement
    chr(195).chr(128) => 'A', chr(195).chr(129) => 'A',
    chr(195).chr(130) => 'A', chr(195).chr(131) => 'A',
    chr(195).chr(132) => 'A', chr(195).chr(133) => 'A',
    chr(195).chr(135) => 'C', chr(195).chr(136) => 'E',
    chr(195).chr(137) => 'E', chr(195).chr(138) => 'E',
    chr(195).chr(139) => 'E', chr(195).chr(140) => 'I',
    chr(195).chr(141) => 'I', chr(195).chr(142) => 'I',
    chr(195).chr(143) => 'I', chr(195).chr(145) => 'N',
    chr(195).chr(146) => 'O', chr(195).chr(147) => 'O',
    chr(195).chr(148) => 'O', chr(195).chr(149) => 'O',
    chr(195).chr(150) => 'O', chr(195).chr(153) => 'U',
    chr(195).chr(154) => 'U', chr(195).chr(155) => 'U',
    chr(195).chr(156) => 'U', chr(195).chr(157) => 'Y',
    chr(195).chr(159) => 's', chr(195).chr(160) => 'a',
    chr(195).chr(161) => 'a', chr(195).chr(162) => 'a',
    chr(195).chr(163) => 'a', chr(195).chr(164) => 'a',
    chr(195).chr(165) => 'a', chr(195).chr(167) => 'c',
    chr(195).chr(168) => 'e', chr(195).chr(169) => 'e',
    chr(195).chr(170) => 'e', chr(195).chr(171) => 'e',
    chr(195).chr(172) => 'i', chr(195).chr(173) => 'i',
    chr(195).chr(174) => 'i', chr(195).chr(175) => 'i',
    chr(195).chr(177) => 'n', chr(195).chr(178) => 'o',
    chr(195).chr(179) => 'o', chr(195).chr(180) => 'o',
    chr(195).chr(181) => 'o', chr(195).chr(182) => 'o',
    chr(195).chr(182) => 'o', chr(195).chr(185) => 'u',
    chr(195).chr(186) => 'u', chr(195).chr(187) => 'u',
    chr(195).chr(188) => 'u', chr(195).chr(189) => 'y',
    chr(195).chr(191) => 'y',
    // Decompositions for Latin Extended-A
    chr(196).chr(128) => 'A', chr(196).chr(129) => 'a',
    chr(196).chr(130) => 'A', chr(196).chr(131) => 'a',
    chr(196).chr(132) => 'A', chr(196).chr(133) => 'a',
    chr(196).chr(134) => 'C', chr(196).chr(135) => 'c',
    chr(196).chr(136) => 'C', chr(196).chr(137) => 'c',
    chr(196).chr(138) => 'C', chr(196).chr(139) => 'c',
    chr(196).chr(140) => 'C', chr(196).chr(141) => 'c',
    chr(196).chr(142) => 'D', chr(196).chr(143) => 'd',
    chr(196).chr(144) => 'D', chr(196).chr(145) => 'd',
    chr(196).chr(146) => 'E', chr(196).chr(147) => 'e',
    chr(196).chr(148) => 'E', chr(196).chr(149) => 'e',
    chr(196).chr(150) => 'E', chr(196).chr(151) => 'e',
    chr(196).chr(152) => 'E', chr(196).chr(153) => 'e',
    chr(196).chr(154) => 'E', chr(196).chr(155) => 'e',
    chr(196).chr(156) => 'G', chr(196).chr(157) => 'g',
    chr(196).chr(158) => 'G', chr(196).chr(159) => 'g',
    chr(196).chr(160) => 'G', chr(196).chr(161) => 'g',
    chr(196).chr(162) => 'G', chr(196).chr(163) => 'g',
    chr(196).chr(164) => 'H', chr(196).chr(165) => 'h',
    chr(196).chr(166) => 'H', chr(196).chr(167) => 'h',
    chr(196).chr(168) => 'I', chr(196).chr(169) => 'i',
    chr(196).chr(170) => 'I', chr(196).chr(171) => 'i',
    chr(196).chr(172) => 'I', chr(196).chr(173) => 'i',
    chr(196).chr(174) => 'I', chr(196).chr(175) => 'i',
    chr(196).chr(176) => 'I', chr(196).chr(177) => 'i',
    chr(196).chr(178) => 'IJ',chr(196).chr(179) => 'ij',
    chr(196).chr(180) => 'J', chr(196).chr(181) => 'j',
    chr(196).chr(182) => 'K', chr(196).chr(183) => 'k',
    chr(196).chr(184) => 'k', chr(196).chr(185) => 'L',
    chr(196).chr(186) => 'l', chr(196).chr(187) => 'L',
    chr(196).chr(188) => 'l', chr(196).chr(189) => 'L',
    chr(196).chr(190) => 'l', chr(196).chr(191) => 'L',
    chr(197).chr(128) => 'l', chr(197).chr(129) => 'L',
    chr(197).chr(130) => 'l', chr(197).chr(131) => 'N',
    chr(197).chr(132) => 'n', chr(197).chr(133) => 'N',
    chr(197).chr(134) => 'n', chr(197).chr(135) => 'N',
    chr(197).chr(136) => 'n', chr(197).chr(137) => 'N',
    chr(197).chr(138) => 'n', chr(197).chr(139) => 'N',
    chr(197).chr(140) => 'O', chr(197).chr(141) => 'o',
    chr(197).chr(142) => 'O', chr(197).chr(143) => 'o',
    chr(197).chr(144) => 'O', chr(197).chr(145) => 'o',
    chr(197).chr(146) => 'OE',chr(197).chr(147) => 'oe',
    chr(197).chr(148) => 'R',chr(197).chr(149) => 'r',
    chr(197).chr(150) => 'R',chr(197).chr(151) => 'r',
    chr(197).chr(152) => 'R',chr(197).chr(153) => 'r',
    chr(197).chr(154) => 'S',chr(197).chr(155) => 's',
    chr(197).chr(156) => 'S',chr(197).chr(157) => 's',
    chr(197).chr(158) => 'S',chr(197).chr(159) => 's',
    chr(197).chr(160) => 'S', chr(197).chr(161) => 's',
    chr(197).chr(162) => 'T', chr(197).chr(163) => 't',
    chr(197).chr(164) => 'T', chr(197).chr(165) => 't',
    chr(197).chr(166) => 'T', chr(197).chr(167) => 't',
    chr(197).chr(168) => 'U', chr(197).chr(169) => 'u',
    chr(197).chr(170) => 'U', chr(197).chr(171) => 'u',
    chr(197).chr(172) => 'U', chr(197).chr(173) => 'u',
    chr(197).chr(174) => 'U', chr(197).chr(175) => 'u',
    chr(197).chr(176) => 'U', chr(197).chr(177) => 'u',
    chr(197).chr(178) => 'U', chr(197).chr(179) => 'u',
    chr(197).chr(180) => 'W', chr(197).chr(181) => 'w',
    chr(197).chr(182) => 'Y', chr(197).chr(183) => 'y',
    chr(197).chr(184) => 'Y', chr(197).chr(185) => 'Z',
    chr(197).chr(186) => 'z', chr(197).chr(187) => 'Z',
    chr(197).chr(188) => 'z', chr(197).chr(189) => 'Z',
    chr(197).chr(190) => 'z', chr(197).chr(191) => 's'
    );

    $string = strtr($string, $chars);

    return $string;
}

/* Cette fonction fait quelque chose de fonctionel:
 * elle retourne le premier charactere et le reste
 * d'une chaine de caracteres separement.
 * C'est beaucoup plus facile a comprendre pour
 * un debutant, a mon avis.
 */
function uncons($string) {
	return array(substr($string, 0, 1), substr($string, 1));
}
// header("Location:resultatnum.php");
?>

Content de voir que tu t'es mis au php.

Mais il y a quelques bases à revoir.
la variable $_POST est a réservé à la superglobale pour récupérè les champs de formulaire
dans une structure foreach, je te proposerai plutot cette structure
foreach($tableau as -$cle => $element)
remplacer la superglobale $_POST est une très mauvaise idée.

Mettre tes identifiants de connection sql dans tes fonction est absurde, imagine que tu change le mot de passe, le nombre d'endroit ou tu devrait le modifier est énorme alors qu'il y a moyen de tous regrouper à un seul endroit et faciliter la mise à jour en cas de modification.
Tu peux par exemple en début de code définir tes paramètres et créer ta connexion et ensuite passer en paramètres à tes fonctions cet identifiant. Cela limitera aussi le nombre de connexion à ta base et donc les resources necéssaire à ta page.

tenter d'appeler des fonctions par rapport à la valeur d'une variable ne marchera pas, des moyens éxistent mais je les déconseille surtout pour un débutant. (risque majeure de sécurité)
De plus cela semble refléter un problème de conception de code.

Dans un premier temps, à la vue de tes 2 fonctions il devrait être possible de les combiner en une seule. un paramètre en plus du nom de ta table permet d'avoir une seule fonction.

Un dernier point, lors de la conception d'une page, il serait interessant de chercher à minimiser le nombre de requète. J'ai pas lu l'entièreté de ton code, mais tu pourrais commencer à regrouper toutes les requètes vers une table en une seule requètes en regroupant tes chiffres dans un tableau et avec la syntaxe sql IN(...) tu récupère tous les textes en un coup.
Je me demande même si tu n'aurais pas interet à regrouper tes tables, avec une table texte et 3 champs chiffre, type, texte tu peux regrouper tes tables et donc encore minimiser le nombre de requète. Si le nombre de texte est limité et pas voué à grandir, tu peux aussi tous les récupèrer dans un tableau et en faire appel dynamiquement par rapport à tes valeurs. Et même si ces textes sont fixe et jamais modifié, tu peux les coder en dur dans ton code pour éviter l'utilisation de sql.

J'espère avoir été compréhensible sinon n'hésite pas à demander.

salut et merci de ta reponse
en fait j'ai finis par trouver mais ca ne me plais pas, j ai rajouter une ligne qui donnait

$_POST2=$_POST."_texte";
		echo nl2br($_POST2($resultats[$_POST]));
		echo "</td></tr></table>";

mais ca ne me plais pas.
Donc j'ai creer une nouvelle table avec 3 champs : id, chiffre et texte
id et chiffre sont les primaires associes (je sais pas si ca se dit comme ca ...) et je veux faire ma recherche sur ces 2 champs pour obtenir le texte ...
Par contre j'ai du mal

$pdo = new PDO($dsn, $user, $pass, $opt);
	// On va preparer un statement plutot que executer directement.
	// Ca nous permet de neutraliser les entrees dangereuses en
	// demandant a la base de donnee de les nettoyer elle-meme
	// (c'est l'utilite de ':chiffre' ici)
	$stmt = $pdo->prepare(
		'SELECT texte FROM definitions WHERE id=:id AND chiffre=:chiffre');
	$stmt->execute(['id' => $cle, 'chiffre' => $element]);
	$row = $stmt->fetch();
	return $row['texte'];

quand j utilise comme ca il me repond ; Notice: Undefined variable: element in F:\www\testphp\numtestbase.php on line 98
et Warning: Missing argument 2 for definitions_texte(), called in F:\www\testphp\numtestbase.php on line 51 and defined in F:\www\testphp\numtestbase.php on line 81

pourtant $element quand je le teste a le bon nom dedans ...

j ai vérifier sur le cours que j'ai et j arrive pas a voir ou est le probleme. je me doute que c'est pas grand chose mais j'arrive pas a mettre le doigt dessus.

	foreach ($resultats as $cle => $element) 
		{ 
		echo "<table><tr><td>$cle</td><td>$element</td><td>";
	//	$cle2=$cle."_texte";
		echo nl2br(definitions_texte($resultats[$cle][$element]));
		echo "</td></tr></table>";

		}

	}
}

function affiche_formulaire($texte_erreur="") {
	echo str_replace(
		"<!--TEXTE_ERREUR-->",
		$texte_erreur,
/*		file_get_contents('index.html.template'));*/
		file_get_contents('indextestbase.php'));
}

function fais_le_calcul($nom, $jour, $mois, $annee) {
	$nom_bien_propre = nettoie_nom($nom);
	return array(
		"personnalite" => personnalite($nom_bien_propre) , 
		"aspiration_intime" => aspiration_intime($nom_bien_propre),
		"capacite_realisation" => capacite_realisation($nom_bien_propre),
		"chemin_de_vie" => chemin_de_vie($jour, $mois, $annee),
		"energie_cette_annee" => cette_annee_energie(),
		"cette_annee_ton_energie" => cette_annee_ton_energie($jour, $mois),
		"psychique" => psychique($jour),
		"evolution" => evolution($jour, $mois)
	);
}

function definitions_texte($cle,$element) {
	$host    = 'localhost';
	$db      = 'test';
	$table   = 'definitions';
	$user    = 'root';
	$pass    = '';
	$charset = 'utf8';
	$opt = [];
	$dsn = "mysql:host=$host;dbname=$db;charset=$charset";

	$pdo = new PDO($dsn, $user, $pass, $opt);
	// On va preparer un statement plutot que executer directement.
	// Ca nous permet de neutraliser les entrees dangereuses en
	// demandant a la base de donnee de les nettoyer elle-meme
	// (c'est l'utilite de ':chiffre' ici)
	$stmt = $pdo->prepare(
		'SELECT texte FROM definitions WHERE id=:id AND chiffre=:chiffre');
	$stmt->execute(['id' => $cle, 'chiffre' => $element]);
	
	$row = $stmt->fetch();

	return $row['texte'];
}

la ligne 51 c'est :

echo nl2br(definitions_texte($resultats[$cle][$element]));

je pense que c'est sur $resultat le soucis mais bon ..

et la ligne 81 c'est function definitions_texte($cle,$element) {

bon je continu a chercher de toute façon je suis têtu

bon j'ai réussi a lire dans ma table unique,mais je comprends pas pourquoi ca marche et surtout j'ai ete obliger de remettre les $_POST ca me desespere... je crois que la programmation c'est pas pour moi ...

Faut pas dire cela, tu y arrivera avec un peu de persévérance.

ton appel à $resultats[$cle][$element] est incorrect. à mon avis (car j'ai pas vu comment tu crée ton tableau résultats)
tu doit appeler ta fonction avec 2 arguements
nl2br(definitions_texte($cle,$element));

ta première erreur te disais que la variable $element n'éxiste pas dans ta fonction et la seconde que ta fonction veut 2 argument mais tu n'en donne qu'un. ces 2 erreurs sont lié, vu que tu appellais incorrectement ta fonction (avec un seul argument et avec une association de tableau inexistante)

merci de me rassurer, ca fait une semaine que je lis des cours, que j'essaye de comprendre, bon c'est clair que ca fait juste mais ya des fois ca me semble insurmontable...

Pour en revenir a mon programme, j'ai fais comme tu m'avais conseiller :

j'ai mis tout dans une seule table, ca m'a permis de virer plus de 100 lignes de code
j'ai mis ma connexion a la base de donnees sur une autre page (et ca marche)
j'ai essayer de changer la variable $_POST mais la c'est mort

 if(empty($_POST['fais_le_calcul'])) {
	affiche_formulaire();
}
else {
	if(
		empty($_POST['nom']) ||
		empty($_POST['jour_naissance']) ||
		empty($_POST['mois_naissance']) ||
		empty($_POST['annee_naissance'])
	) {
		affiche_formulaire();
		echo "Vous devez entrer toute les informations !!!";
	}
	else {
		$resultats = fais_le_calcul(
			$_POST['nom'],
			$_POST['jour_naissance'],
			$_POST['mois_naissance'],
			$_POST['annee_naissance']);

		// C'est la pour afficher l'info pour verifier les resultats.
		// Le code pour afficher les resultats remplacerait celui-ci.
		echo "<p><strong>Voici le tableau qui contient les resultats:</strong></p>";
		print_r($resultats);
		
		foreach ($resultats as $_POST => $element) 
		{ 
		echo "<table><tr><td>$_POST</td><td>$element</td><td>";
		echo nl2br(definitions_texte($resultats[$_POST]));
		echo "</td></tr></table>";

		}
		
	}
}

function affiche_formulaire($texte_erreur="") {
	echo str_replace(
		"<!--TEXTE_ERREUR-->",
		$texte_erreur,
/*		file_get_contents('index.html.template'));*/
		file_get_contents('indextest2.php'));
}

function fais_le_calcul($nom, $jour, $mois, $annee) {
	$nom_bien_propre = nettoie_nom($nom);
	return array(
		"personnalite" => personnalite($nom_bien_propre) , 
		"aspiration_intime" => aspiration_intime($nom_bien_propre),
		"capacite_realisation" => capacite_realisation($nom_bien_propre),
		"chemin_de_vie" => chemin_de_vie($jour, $mois, $annee),
		"energie_cette_annee" => cette_annee_energie(),
		"cette_annee_ton_energie" => cette_annee_ton_energie($jour, $mois),
		"psychique" => psychique($jour),
		"evolution" => evolution($jour, $mois)
	);
}
// pourquoi $magic marche ??
function definitions_texte($magic) {
	include("connexion.php");
	// On va preparer un statement plutot que executer directement.
	// Ca nous permet de neutraliser les entrees dangereuses en
	// demandant a la base de donnee de les nettoyer elle-meme
	// (c'est l'utilite de ':chiffre' ici)
	$stmt = $pdo->prepare(
		'SELECT texte FROM definitions WHERE chiffre=:chiffre AND id=:id');
	$stmt->execute(['chiffre' => $magic, 'id' => $_POST]);
	$row = $stmt->fetch();
	return $row['texte'];
}

Voila une partie du code (celle ou je bosse pour le moment) et elle fonctionne, bien que je n'arrive pas a comprendre pourquoi ma variable $magic (d'ou son nom) reussi a afficher ce qui pour moi était senser être dans $element.

maintenant je voudrais appeler de cette page php une page pour pouvoir mettre tout ca en "joli". Je sais appeler un programme php depuis une page html, mais je n'arrive pas a trouver pour faire le contraire. Tu vois l’équivalent de <form action="minichat_post.php" method="post">
car maintenant que j'ai mes résultats, au lieu de me servir de cette même page avec des echo .... , je souhaiterais appeler une page htlm par exemple resultats.php qui aurait de lier avec lui (ça je sais le faire) resultats.css afin que ça ressemble a quelque chose.

J'ai beau chercher (surement mal) je ne trouve que ce que je sais deja faire : le contraire.
Je subodore que peut être utiliser une fonction comme header('Location: resultats.php'); serait peut être une piste, mais je ne sais pas temporiser, et appeler mon résultat dessus...

Merci du temps que tu m'accorde.

Au sein d'une fonction, seule les variables définies dans cette fonction éxistent. Les autres il faut les amener par les arguments de la fonction.

Pour ta variable $_POST je suis pas sur que tu comprenne comment elle fonctionne, surtout quand je vois cela 'id' => $_POST]);
Cette variable ne doit servir que pour récupèrer les infos d'un formulaire. $_POST est toujours un tableaux, donc ne pas préciser son index est absurde.

Je comprends pas trop ce que tu cherche à faire pour rendre le tout "joli" mais le pricipe générale est d'incruster du code php dans l'html

exemple:
Debut du code html
<?php echo $mavariable;?>
suite du HTML
en répétant les echo chaque fois que tu en a besoin

Bonjour
ca y est j'ai compris et j'ai réussi a virer ma variable $_POST et je n'utiliserais plus de super globale sauf pour récupérer des données d'un formulaire
Quand je parle de plus "joli" c'est faire une page séparée de mon programme, avec du css et ainsi ne pa surcharger ma page php. A moins que tu me dise que c'est mieux de laisser tout sur un même fichier plutôt que sur plusieurs ??
Pour le moment j'affiche mes résultats dans le même fichier, avec des balise echo, mais ce que j aimerais c'est avoir une page juste avec du code html et un peu de php (pour récupérer les données que j'ai obtenu dans mon programme, qui soit associer avec une page css pour pouvoir peaufiner la présentation. Donc j'avais penser a faire que mon programme une fois qu'il a finit de tout calculer et sorti de sa table sql les résultats, me renvoi sur une autres page pour afficher tout ca. Mais je sais appeler un programme php depuis une page html mais pas le contraire.

Ce que tu cherche, c'est un moteur de template, mais cela me semble très lourd pour une petite appli.

Tu peux aussi séparer ton traitement php, sauver les variable d'affichage en $_SESSION et te rediriger vers une page html qui n'aurais que des <?php echo $...;?>

Bonjour
désolé de répondre que si tard, j ai eu des soucis de sante et j’étais pas chez moi.
"Tu peux aussi séparer ton traitement php, sauver les variable d'affichage en $_SESSION et te rediriger vers une page html qui n'aurais que des <?php echo $...;?>"
c'est exactement ce que je veux faire. mais je ne sais pas comment depuis mon traitement php je peux lui dire de revenir sur une page html.

voici un exemple simpliste

fichier traitement.php

<?php
session_start();
//traitement des données
$_SESSION['data1'] = $maVariableGenereDansMonTraitement;
//appel du template
include('template.php');

fichiertemplate.php

<html>
<head>...</head>
<body><h1>TITRE</h1>
<p>Mon texte de présentation de <?php echo $_SESSION['data1'];?>.  Alors compris ?</p>
</body>
</html>