PHP – alternative à eval, comment et pourquoi s’en passer ?

3 raisons de ne pas utiliser eval

1) Risque d’insertion de code

Étant donné que c’est une chaine qui va être exécutée par PHP, il se peut que, d’une manière ou d’une autre, une personne mal intentionnée puisse insérer du code dans votre eval. Il suffit d’une simple configuration spécifique au niveau du serveur comme « register_globals » pour qu’une variable puisse être modifiée par un utilisateur, ce qui se répercutera sur votre eval  .

2) Un suivi des erreurs difficile

Les alternatives pour remplacer eval (PHP)

Modification d’une variable avec un nom variable

Parfois, on doit modifier une variable dont on ne connait pas le nom. En utilisant eval, on peut créer une chaine qui génère dynamiquement le nom de la variable à partir du contenu d’une autre (Oui, oui  ). Cependant, sans eval, c’est aussi possible  ! Pour cela il suffit de faire :

1. // Variable dont on ne connait pas le nom  
2. $article = "test";  
3.   
4. // Le nom de la variable est stocké dans celle-ci  
5. $nomDeLaVariable = "article";  
6.   
7. // On va modifier la variable qui a un nom variable  
8. $$nomDeLaVariable = "test2";  
9.   
10. // On affiche le resultat : "test2" !  
11. echo $article;  

Effectivement, en utilisant un double dollar « $$ », on remplace le nom de la variable par le contenu de la variable « nomDeLaVariable ».

Appel d’une fonction avec un nom variable

Tout comme le point précédent, on va utiliser une méthode relativement similaire ; voici l’exemple :

1. // Définition d'une fonction avec un nom que l'on ne connait pas  
2. function plop() {  
3.     echo "test";  
4. }  
5.   
6. // Nom de la fonction stockée dans cette variable  
7. $nomDeLaFonction = "plop";  
8.   
9. // Appel de la fonction avec le nom stocké dans $nomDeLaFonction  
10. $nomDeLaFonction();  

Et voilà ! La fonction « plop() » sera exécutée ! Il faut savoir qu’il vous est aussi possible d’utiliser call_user_func de php. Vous pouvez aussi consulter call-user-func-array pour manipuler plus facilement les paramètres à envoyer à votre fonction.

Créer une instance d’une classe avec un nom variable

Comme pour les deux points précédents, vous pouvez faire :

1. $Objet = new $nomObjet();  

Optimisation de vos requêtes MySQL

Réduisez le nombre de colonnes dans vos SELECT

Si vous êtes adeptes du SELECT *, soyez attentif à la quantité de données que vous retournent vos requêtes. Si votre script n’utilise que deux champs, utilisez plutot SELECT champ1, champ2 [...].

Limitez l’utilisation des jointures et préférerez les sous-requêtes

Installez des Index sur les colonnes qui font l’objet de tris (MySQL)

Les champs des tables volumineuses qui font l’objet de conditions, filtrages ou tris (par exemple des « WHERE », « ORDER BY », etc…) doivent disposer d’un Index pour accroitre la rapidité d’execution des requêtes.

En quelque sorte un Index fonctionne comme le sommaire d’un livre. Il permet à MySQL d’avoir à portée de main toutes les valeurs sur lesquelles portes la recherche.

Optimisation de la structure de vos tables MySQL

Créez une clé primaire (simple ou multiple) pour chaque table

On ne le répètera jamais assez, pour identifier un enregistrement de façon unique, une table doit disposer d’une clé primaire. 

MySQL – Quelques règles simples d’optimisation

Lorsque l’on conçoit la base de données d’un site web, on ne pense pas toujours à son évolution dans le temps. 

JSON : Retourner une variable d’état à javascript

En complément avec l’arobase @, vous pouvez utiliser une chaine de retour qui spécifiera comment s’est passé l’exécution en arrière plan de votre script.

Personnellement j’ai l’habitude de stocker la chaîne de retour dans le tableau JSON à la clé « state » du tableau retourné. Lorsqu’il n’y a pas d’erreur, je retourne simplement « ok », sinon la chaine d’erreur à afficher. Voici un petit script d’exemple :

Appel ajax avec jQuery :

Cacher simplement les erreurs spécifiques

Si toutefois vous ne souhaitez pas mettre en place un système compliqué de suivi d’erreurs, vous pouvez simplement cacher la génération d’erreurs de certaines fonctions à l’aide de « @ » ; par exemple :

1. $handle = @fopen("fichier.txt", "r");  

… ou bien cacher toutes les erreurs de votre script en utilisant :

1. error_reporting(0);  

Si vous voulez savoir si une fonction peut générer des erreurs ou non, consultez la documentation PHP à la section « Erreurs / Exceptions » de votre fonction. Par exemple, pour fopen : « Si l’ouverture échoue, une alerte E_WARNING sera générée. Vous pouvez utiliser le caractère @ pour supprimer cette alerte. ».

Gérer et prévoir les différentes erreurs PHP

Si vous effectuez un retour JSON et qu’une erreur PHP est affichée, jQuery ne pourra pas parser les données de retour et il vous affichera notre erreur « alert ». Cependant, il est quand même plus pratique d’éviter que ce type d’erreur ne survienne en gérant les erreurs de vos fonctions PHP.

Cacher et enregistrer les erreurs survenues

Afficher une erreur à l’internaute

La première des choses est d’afficher une erreur claire à l’internaute étant donné qu’il n’a aucun moyen de voir l’état d’avancement de votre requête (à part peut-être un petit loader en gif animé que vous aurez installé préalablement). Avouez que vous non plus vous n’aimez pas les temps d’attentes où vous ne savez pas si le chargement est planté ou non.

Voici donc une fonction callback d’erreur pour votre requête jQuery :

Les cas d’erreurs ajax

Généralement, les erreurs surviennent dans deux cas :

• Une erreur de connexion (coupure internet, données invalides de retour etc…)
• Une chaîne JSON mal formatée par une erreur PHP affichée avant ou après votre retour de données

(Tuto) PHP & jQuery – Gérer les erreurs Ajax en arrière plan

Il arrive que dans nos applications web on utilise Ajax pour dynamiser les pages afin de rendre l’utilisation de notre interface plus simple et plus facile. Cependant, tout ce qui se passe en Ajax est exécuté en arrière plan. Il n’est donc pas possible d’afficher les erreurs directement sur la page  (par exemple si vous utilisez un parsage JSON).

Les graphes

La théorie des graphes est aujourd'hui un outil majeur de modélisation et de résolution de problèmes dans un très grand nombre de domaines, des sciences fondamentales aux applications technologiques les plus concrètes. Un graphe est défini par ses sommets et ses arcs. Les sommets forment un ensemble S quelconque (quoique fini en pratique), et les arcs un sous-ensemble A de  ; autrement dit, un graphe est le graphe d'une relation binaire. Si , on dit que a est un arc d'extrémité initiale u et d'extrémité finale v, on le note  ; on dit aussi que v est un sommet adjacent à u, ou est un successeur de u.

Implémentation des graphes

Deux implémentations des graphes sont couramment utilisées ; le choix se fait en fonction des opérations que l'on veut faire, et de la densité du graphe, c'est-à-dire du rapport entre le nombre d'arcs et le nombre de sommets.
La matrice d'adjacence  M_G d'un graphe G est une matrice carrée, indicée par les sommets (donc de dimension ), dont les éléments indiquent l'existence d'un arc : M_G[u][v] est différent de null si et seulement si . La représentation d'un graphe par sa matrice d'adjacence est préférée quand le graphe est dense (beaucoup d'arcs), car elle comporte toujours les |S|² éléments d'un tableau bidimensionnel ; elle est bien adaptée aux algorithmes qui s'expriment à l'aide d'opérations matricielles.

public class GrapheParMatrice implements Graphe {
  private Arc[][] adjacence;

  public GrapheParMatrice(int taille) {
    adjacence = new boolean[taille][taille];
  }
  // ...
}