PHP.net
Compte le nombre d’occurrences de segments dans une chaîne
Cette fonction de compte pas les chaines de caractère qui ce superpose
$text = 'Ceci est un test';
echo strlen($text); // 16
echo substr_count($text, 'est'); //retourne 2
Au départ, j’étais complètement contre l’utilisation de framework. Je voulais programmer mon site web de A à Z sans intermédiaire. Je voulais garder le contrôle sur mon code en écrivant chaque ligne de code. J’avais un donc un petit système déjà bâti qui utilisait un fichier de configuration, un fichier de fonctions ainsi que mes pages PHP/HTML ensemble. Ensuite je me suis mis à apprendre l’oriente-objet pour ensuite me mettre à lire des livres sur la POO pour améliorer mes techniques de programmation. Dans les deux livres que j’ai lus sur la POO, on expliquait le design pattern MVC (Modèle-Vue-Controlleur) qui consiste a séparer l’interaction avec l’utilisateur (contrôleur), la présentation (vue) et l’interaction avec les données (modèle). Je reviendrais sur ce design pattern dans un prochain billet. Lors de mes lectures sur le sujet, je connaissais déjà cette méthode de travail sans avoir réussi à l’implémenter. Je me suis questionné sur le sujet longuement en me demandant si, un coup un tel système monté, je sauverais du temps et énergie lors de mes prochains projets.
Lors de mon apprentissage autonome en 6e session lors de mon DEC, j’avais exploré CakePHP, un des frameworks PHP5 les plus populaires. J’avais détesté mon expérience ne comprenant pas trop comment il marchait, et ce, malgré la présence de tutoriels. On me vantait ce framework comme un système qui me ferait sauver un temps fou en développement, alors que je ne voyais pas comment il pouvait y arriver. J’avais tout de même accroché sur le fait qu’il était possible de développer avec le pattern MVC.
Lors de mon questionnement sur un développement en POO, recommencer à utiliser un framework m’est revenu à l’idée. En fait, c’est un collègue scolaire et bon ami Rémi Prévost qui fait découvrir un autre framework PHP5 : Code Igniter. Il m’aura fallu quand même 8 mois avant de l’utiliser. Et maintenant, après 4 mois d’utilisation, je peux faire une bonne critique de cet outil. Les avantages et inconvénients des frameworks qui suivront sont basés sur une utilisation de Code Igniter et Kohana. Je n’ai jamais utilisé Symfony ou ZendFramework. Également, je ne peux critiquer Cake vu ma trop courte utilisation de ce framework. Également, la vue d’ensemble que je vous offre aujourd’hui ne représente que les frameworks PHP.
Le plus dur pour un programmeur est de passer de la programmation procédurale à celle orientée-objet. Une multitude de concepts s’ajoute lorsqu’on fait le saut à la POO. Les frameworks vous offrent la possibilité d’apprendre l’orienté-objet facilement. Vu que le système est déjà préconçu, il est facile d’avancer dans un petit projet pour apprendre les bases de la POO. Avec un tutoriel bien monté ainsi qu’une documentation riche, il devient facile de s’en sortir.
Un autre avantage d’utiliser la POO des frameworks et que vous pouvez le modifier sans toucher au code original du système. Il suffit d’ajouter par exemple une classe enfant pour écraser une fonction dont vous n’aimez pas le fonctionnement. Cette méthode est également valide lors de prochaine modification sur votre projet. Elle vous évitera plusieurs problèmes que la programmation procédurale peut vous causer. Vous savez sûrement de quoi je parle quand vous modifiez une fonction sur une page en particulier qui affecte une dizaine de pages sans le vouloir.
Comme je le disais plus haut, j’utilise les frameworks en partie en raison de la programmation orientée-objet et pour le pattern MVC. J’apprécie beaucoup le fait d’avoir mon contenu séparé en trois couches. Cela évite en premiers lieux d’avoir des fichiers beaucoup trop gros. Il m’est déjà arrivé d’avoir des fichiers de fonctions communes (disponible sur plusieurs pages de mon site) de plus de 3000 lignes de code. Trouver une erreur dans ce fichier gigantesque était un défi en soi. Tout étant séparé dans le pattern MVC, il devient facile de cerner une erreur et de la corriger rapidement. Par exemple, lorsque l’erreur est d’ordre HTML, il suffit de regarder dans la Vue concernée. Plus le site devient gros, plus l’utilisation du pattern MVC est utile.
Un autre avantage d’utiliser ce pattern se situe au niveau du travail d’équipe. On peut facilement se retrouver dans le travail d’un collègue, même en ayant perdu le fil du projet pendant des semaines. On peut également développer en même temps sur le même projet sans trop s’accrocher, surtout pour l’intégration CSS/HTML. Pendant qu’un intégrateur modifie l’HTML d’une page, rien n’empêche le programmeur PHP de continuer l’ajout de fonctionnalité dans les contrôleurs.
Avec la puissance de Google, il est plus qu’important d’être visible sur le web. Une des techniques utilisées pour y arriver est la réécriture d’URL. Elle permet de passer d’une URL de type : posts.php?id=1&page=2 à quelques choses du genre posts/une-nouvelle-page/2 . Cette URL est beaucoup plus significative pour un moteur de recherche que la première, vu la présence de mots-clés directement dans l’URL. C’est souvent long et pénible de réécrire des URL. Avec un framework, on commence avec 90% du travail effectué. La manière dont le système est bâti vous offre déjà l’URL réécrite. Par exemple, l’URL par défaut de Kohana est http://www.monsite.com/index.php/welcome/index. Ce qui veut dire que le framework appelle la page index.php (la pièce maîtresse du système) qui appelle le contrôleur welcome et ensuite la fonction index du contrôleur. Il ne vous reste qu’à utiliser un htaccess pour cacher le index.php pour avoir une réécriture d’URL presque parfaite. Le reste de votre travail se fera dans le routage de ces URL pour qu’elles soient peaufinées à votre goût.
Je déteste faire les validations d’un formulaire. Ce sont souvent des routines que vous avez fait des centaines de fois, mais qui vous font perdre énormément de temps de développement. Les frameworks offrent presque tous maintenant des routines de validation pour les formulaires qui vous épargne beaucoup de temps. En passant par la validation de courriel ou simplement la validation d’un champ requis tout y est. Vous pouvez sans problème ajouter des validations manuellement. La beauté de tout cela est que les messages d’erreurs sont gérés automatiquement.
Traduire un site web devient de plus en plus important, surtout pour un francophone qui veut que son site web soit lu et visité par le plus de personnes possible. Les méthodes variaient de beaucoup que ce soit un simple fichier PHP ou un XML qui contenait les lignes de texte. Un framework n’échappe pas vraiment à ces méthodes, mais c’est plus une certaine automatisation qui fait la beauté du système. Codeigniter et Kohana utilisent un peu le même système, soit un fichier dossier par langue qui contient plusieurs fichiers selon les pages du site (en fait vous décidé de la manière dont vos fichiers de langues sont gérés). Donc, il ne vous reste plus qu’à appeler la fonction lang (avec kohana) pour afficher le texte désiré. Votre site a besoin d’une deuxième langue, copier la première langue et traduisez. Ensuite il ne vous reste plus qu’à faire la validation qui détermine dans quelle langue le site se trouve.
Les frameworks contiennent encore plus que vous le pensez. On retrouve souvent un système de cache, de benchmark ou de logs. Ces trois éléments sont souvent utilisés pour améliorer les performances d’un site web. Plus votre site est gros, plus il est impératif d’avoir les meilleures performances possible. D’autres éléments viennent se greffer à tout ce que je vous ai déjà montré. Des librairies monter pour vous faire sauver du temps de développement, des classes dites “helper” qui ont les mêmes tâches que les librairies, mais plus petites. On ajoute à cela une configuration malléable pour former une recette gagnante.
La réponse est oui avec un bémol. L’utilisation d’un framework doit être justifiée. Un site de petite envergure comme une compagnie d’électricien sur la Rive-Sud de Montréal ne justifie en rien l’utilisation d’un framework. Le site doit être d’une envergure moyenne à grosse pour que l’utilisation d’un framework soit rentable. Un facebook ne devrait pas être développé avec un framework vu sa grosseur et sa complexité. Notez que plus le site devient gros et complexe, plus le temps sauvé par l’utilisation d’un framework par rapport à un site procédural devient presque inexistant. Pour ce point je parle par rapport à l’expérience vécue lors des derniers mois. Est ce que je regrette l’utilisation d’un framework pour ce projet? Non pas du temps. Si c’était à refaire, je referais la même chose.
On vous vente souvent la rapidité avec laquelle vous aller développer votre site web en utilisant un framework. Je suis ne pas vraiment d’accord avec cette affirmation. Il y a trop de facteurs à prendre en considération lors d’un développement de site web qui influence le temps de développement. Prenez simplement par exemple le temps d’apprentissage du dit framework. Il est évident que vous allez développer très vite si vous êtes un programmeur expert en POO et que c’est votre vingtième site avec votre framework. Même chose si vous êtes un habitué des sites plus traditionnels, vous aurez une vitesse de croisière supérieure comparativement à l’utilisation d’un framework. Tous ces arguments font en sorte que je n’ai même pas donné la vitesse de développement comme raison d’utiliser un framework.
Un autre désavantage de développer avec un framework est que lorsque vous avez besoin de quoi de moindrement hors-norme, il peut devenir complexe de le coder. Vous devez toujours avoir en tête que cela fonctionne avec le framework, sans le ralentir ou le détruire. Également, si vous n’aimez pas un “feature” du framework vous êtes pris avec ou vous devez changer de système. Par exemple, la classe de la gestion des bases de données. Finalement un dernier point, lorsque vous développerez une “feature” sur un framework, vous serez porté à utiliser les librairies ou helper du framework. Le problème sera lorsque vous tenterez de déplacer la classe ou fonction dans un nouveau framework ou dans un site qui n’en utilise pas. Vous perdrez beaucoup de temps à réécrire certaines parties du code pour le rendre compatible avec votre nouveau site web. Un conseil, limitez le plus possible les utilisations de librairies ou helper externe dans votre nouvelle feature.
Voilà, j’espère vous avoir éclairé sur l’utilisation d’un framework. Mon but n’est pas de vous forcer la main pour utiliser un framework ou non, mais bien de vous faire comprendre pourquoi moi j’ai utilisé un framework lors des derniers mois. À vous de juger si cela vous convient ou non.
Federico Cargnelutti a publié hier sur son blogue PHP impact une liste d’applications PHP open-sources qui selon lui, ont changé le monde du web. On retrouve dans cette liste des applications connues de tous tel que phpMyAdmin ou bien Wordpress.
Je suis d’avis que bien des applications sur cette listes n’ont pas vraiment changé le monde tel quel, mais plus des habitudes de programmation. La plupart des applications sont quasi réservé au programmeur (tel que joomla, phpmyadmin ou bien symfony). Les deux plus grandes applications open-sources sur cette liste qui ont changé le monde à mon avis sont phpBB et Wordpress vue leur utilisation mondiale et leur multitude d’applications dérivés.
http://phpimpact.wordpress.com/2008/05/22/open-source-php-applications-that-changed-the-world/
Il ne reste plus que quelques jours avant le lancement officiel de Firefox 3. Et pour l’événement, Firefox souhaite s’inscrire dans le livre des records Guinness en étant le logiciel le plus téléchargé en 24 heure. Pour réaliser l’exploit, Firefox à lancé un site web qui voua rappellera le jour du lancement de télécharger Firefox3.
Définition tiré de PHP.net
Vérifie la liste des fonctions définies par l’utilisateur afin d’y trouver function_name.
Cette fonction vous permet de vérifier si une fonction est déclaré dans votre code PHP. Très utile pour vérifier si une librairie est chargé.
if(function_exists("mcrypt_encrypt")){
echo 'La librairie MCrypt est chargé';
}else{
echo 'La librairie MCrypt n\'est pas chargé. Impossible d\'encrypter des données';
}
Une Exception est une classe d’erreur souvent disponible sur tous les langages en orienté objets. Cette classe est disponible depuis PHP5 et elle est de plus en plus utilisée pour la gestion d’erreur dans un contexte POO.
Tout d’abord, la classe à trois variables importantes accessibles par leur fonction respective. Chaque variable est typé protected ce qui veut dire qu’elles ne peuvent être modifiées ou lues de l’extérieur de la classe ou des classes parent/enfant.
Ensuite il existe 5 méthodes dans la classe Exception accessible sous le format $exception->méthode()
Utiliser une exception est fort simple. Il suffit de le voir comme la relation entre le lanceur et le receveur au baseball. Le lanceur est le programmeur alors que le receveur est PHP. Tout d’abord, le lanceur choisi qu’elle balle lancer, ensuite le receveur attrape la balle. Que cette balle soit une rapide, une courbe ou un changement de vitesse, il l’attrape. La différence entre le receveur et PHP est que PHP adapte son action en conséquence du type d’exception lancé. Mais avant de rentrer dans la partie la plus dure du sujet, utilisons une exception pour bien comprendre son fonctionnement dans le code.
throw new Exception('une erreur est survenu');
Si vous essayé ce code vous aller avoir l’erreur suivante : Fatal error: Uncaught exception. Nous devons y aller de deux étapes pour régler cette erreur. La première, essayer de lancé l’exception et ensuite l’attraper
try{
throw new Exception('une erreur est survenu');
}
catch(Exception $e){
echo $e->getMessage();
}
Ce code écrira le message d’erreur, qui dans ce cas-ci est une erreur est survenu. L’avantage de la gestion d’erreur est que nous pouvons faire a peu près n’importe quoi suite à une erreur voulu. Par erreur voulu, je veux dire une erreur déclarée par le programmeur après une validation. Voici une exception dans un contexte réelle.
function check_type($int){
if(!is_numeric($int)){
throw new Exception('Vous devez envoyer un nombre en argument.');
}
return true;
}
try{
check_type('test');
}
catch(Exception $e){
exit($e->getMessage());
}
Il est possible grâce à l’héritage de créer vos propres classes d’exception. Pourquoi? Pour vous permettre de gérer plusieurs types d’erreur de manière différente. Disons pour notre exemple que nous voulons un type d’erreur d’exécution. Le message d’erreur sera toujours la même grâce à l’héritage, ce qui veut dire que le message d’erreur ne sera pas obligatoirement passé en argument lors de l’envoi de l’exception.
class Execution_Exception extends Exception{
protected $message = 'Erreur d\'éxécution';
public function __construct(){}
}
try{
throw new Execution_Exception();
}
catch(Execution_Exception $e){
exit($e->getMessage());
}
Vous conviendrez avec moi que d’écrire la syntaxe Try/Catch à chaque Exception serait relativement pénible. Ça serait du trouble qui ferait en sorte qu’aucun programmeur n’utiliserait les Exceptions et se tournerait vers la bonne vieille fonction die(). Heureusement, PHP à créé une fonction appelé set_exception_handler() qui vous permet de dire à PHP d’appeler la fonction de votre choix s’il ne trouve pas la syntaxe Try/Catch. Cette fonction est un bijou en soit et vous ouvre la porte à une multitude d’avenu pour la gestion d’erreur. Par exemple, vous pourriez dans cette fonction ajouter un système de Log qui vous permettrait de garder la trace des erreurs survenu sur votre site web. Voici un petit bout de code qui vous montre brièvement l’utilisation de set_exception_handler().
set_exception_handler("exceptionHandler");
function exceptionHandler($exception){
echo $exception->getMessage();
}
class Execution_Exception extends Exception{
protected $message = 'Erreur d\'éxécution';
public function __construct(){}
}
throw new Execution_Exception();
Voila pour ce petit tour d’horizon rapide des Exceptions. Implémenter des Exceptions nécessite un peu plus de temps de programmation, mais un coup complété, on en sort un réelle plaisir à les utiliser.
Définition tiré de PHP.net
Analyse une URL et retourne ses composants
Cette fonction est hyper pratique lorsque vous voulez analyser une url, pour valider le host par exemple.
$url = 'http://www.plbabin.com/2008/05/fonction-de-la-semaine-parse_url/';
print_r(parse_url($url));
/*
Array (
[scheme] => http
[host] => www.plbabin.com
[path] => /2008/05/fonction-de-la-semaine-parse_url/
)
*/
Lorsque vient le temps de protéger nos données plusieurs options s’offrent à nous. En fait, plus précisément deux options. Il y a d’un côté le hachage et de l’autre l’encryption. Il existe quelques subtilité entre les deux méthodes qui font en sorte que le choix varie selon la situation.
Le hachage est le résultat d’un algorithme qui analyse une chaine de caractère pour la rendre incompréhensible à la lecture. Un algorithme de hachage génère une valeur unique à partir de l’entrée envoyé. L’avantage (ou le désavantage selon certain) du hachage c’est qu’une fois encodé, il est pratiquement impossible de retourner en arrière pour connaître la valeur de départ. Autrement dit, c’est un encryptage unidirectionnel.
Le hachage est souvent utilisé pour l’encryptage de mot de passe dans les base de données. En utilisant ce procédé, il est impossible pour un visiteur ou un administrateur de la BD de connaître les mots de passes des utilisateurs.
Il existe présentement deux fonctions de hachage disponible avec PHP soit md5 et sha1. Il est conseillé d’ajouter une chaîne unique à chaque encryptage communément appelé salt. Cette chaîne permettra de ne pas avoir deux fois le même mot de passe dans la bd. Cela augmentera donc notre protection de nos utilisateurs. Cette chaîne doit être un élément propre à chaque utilisateur. Je propose dans le code suivant d’utiliser la fonction uniqid(). On doit par contre enregistrer le salt avec notre nouvel utilisateur dans la db. Comme je le disais plus haut, cet astuce est uniquement pour éviter une duplication des mots de passes.
//un mot de passe
$mdp = '7chd90sh';
echo md5($mdp); //ab96b777b2f826b110fedffaa9d400ed
//avec un salt
$salt = uniqid();
echo md5($salt.$mdp); //94dd45698e51cfe3995eb3a26de09af3L’encryptage contrairement au hachage permet d’encoder des données et de les décoder. Cela nous permet d’emmagasiner des données tout en sachant que nous allons pouvoir les récupérer au moment opportun sans problème.
Il existe une librairie dénommée Mcrypt qui permet d’encrypter nos données. Elle utilise les différents algorithmes d’encryptage disponible. Par contre, elle n’est pas disponible sur tous les hébergeurs de site web, surtout les ceux gratuit. Je vous conseils donc de vérifier avec un phpinfo() si vous hébergeurs vous permet d’utiliser la librairie MCrypt. Pour ceux qui ont accès au php.ini de leur serveur, vous n’avez qu’à l’activer. Pour utiliser la librairie MCrypt, nous avons besoin de trois choses essentiel avant même de commencer à coder. Tout d’abord, nous avons besoin d’un algorithme d’encryptage. Ensuite nous avons besoin d’un mode d’encryptions et pour finir il nous faut une clé secrète. Cette clé sera l’élément essentiel qui vous permettra de récupérer vos données encryptés. Si vous perdez cette clé, vous données seront encrypté à jamais. Si vous vous faites voler votre clé, la barrière de sécurité est sérieusement compromise. Je vais vous présenter la classe PHP que j’utilise pour encrypter mes informations privées. Cette classe a été créée pour le livre Pro PHP Security de la maison d’édition Apress. Un livre que je conseil fortement au développeur qui souhaite en apprendre plus sur la sécurité sur le web. Pour commencer voici les déclarations de variables de la classe ainsi que le constructeur de la classe.
public function __construct( $algo='aes' ) {
switch ( $algo ) {
case 'aes':
$algorithme = MCRYPT_RIJNDAEL_256;
break;
case 'tripledes':
$algorithme = MCRYPT_TRIPLEDES;
break;
case 'blowfish':
$algorithme = MCRYPT_BLOWFISH;
break;
default:
// disallow any other algorithm
exit( "Erreur fatale. Cette classe n'accepte pas l'algorithme : $algo.
Vous devez utiliser une de ces algo : 'aes','tripledes', ou 'blowfish'." );
}
$this->algo = $algorithme;
// création d'une ressource mcrypt
$this->mcrypt = mcrypt_module_open( $this->algo, '', MCRYPT_MODE_CBC, '' );
// détermine la taile du vecteur d'initialisation selon le couple algo/mode
$this->ivsize = mcrypt_enc_get_iv_size( $this->mcrypt );
// détermine la taille maximal de la clé
$this->maxKeysize = mcrypt_enc_get_key_size( $this->mcrypt );
}Ensuite nous devons assigner une clé à notre classe. Cette clé subira plusieurs manipulations qui feront en sorte qu’elle sera encodée dans la mémoire. Elle sera tout d’abord haché pour être ensuite transformé en binaire.
public function setKey( $secret ) {
// initialize key
$key = NULL;
// Détermine le nombre de block de 32 caractère que nous aurons besoin
$keyblocks = ceil( ( $this->maxKeysize * 2 ) / 32 );
// pour chaque block, on doit généré une chaîne passé au md5 qui encodera la clé
for ( $ix = 0; $ix < $keyblocks; $ix++ ) {
$key .= md5( $ix . $secret );
}
// on "pack" ensuite la clé en mode binaire (2:1 ratio)
$key = pack( 'H*', $key );
// on coupe la clé selon la taille maximal de notre algorithme
$this->key = substr( $key, 0, $this->maxKeysize );
$this->keysize = strlen( $this->key );
}
Après il nous faut une fonction d’encodage et une autre de décodage. Lorsque la donnée sera encodée, on y glisse le vecteur d’initialisation pour permettre d’avoir exactement le même lors du décodage.
public function encrypt( $data ) {
// génère un vecteur d'initialisation
$this->iv = mcrypt_create_iv( $this->ivsize, MCRYPT_RAND );
// inititialisation
if (mcrypt_generic_init( $this->mcrypt, $this->key, $this->iv ) === -1) {
$this->__destruct();
exit( 'Erreur fatale, incapable de créer d\'initialiser l\'encryptage.' );
}
// on encrypte
$ciphertext = mcrypt_generic( $this->mcrypt, $data );
// on détruit la ressource mcrypt
mcrypt_generic_deinit( $this->mcrypt );
// prepend le vecteur d'initialisation
$out = $this->iv.$ciphertext;
// encode le text encrypté avec un base64
// on coupe le texte en block de 64 caractère pour la transmission
$out = chunk_split( base64_encode( $out ), 64 );
return $out;
}
public function decrypt( $data ) {
// la ligne doit être en base64
$input = base64_decode( $data );
// lon récupère la taille du vecteur d'initialisation contenu dans notre texte encodé
$this->iv = substr( $input, 0, $this->ivsize );
$ciphertext = substr( $input, $this->ivsize );
// initialisation
if ( mcrypt_generic_init( $this->mcrypt, $this->key, $this->iv ) === -1) {
$this->__destruct();
exit( 'Erreur fatale, incapable d\'initialiser la routine d\'encryption.' );
}
$out = mdecrypt_generic( $this->mcrypt, $ciphertext );
// destruction de la ressource
mcrypt_generic_deinit( $this->mcrypt );
// on retourne le texte
return $out;
}
Pour finir la classe, nous avons besoin d’une fonction de destruction qui détruira la ressource mcrypt et qui réécrira en mémoire la clé secrète et substituant chaque caractère par un X.
public function __destruct() {
// write over key in memory
$this->key = str_repeat( 'X', strlen( $this->key ) );
// free the mcrypt resource
mcrypt_module_close( $this->mcrypt );
}
// end of mcrypt class
}
Définition tiré de PHP.net
Récupère les arguments d’une fonction sous la forme d’un tableau.
Vous voulez avoir une fonction qui accepte des arguments dynamiques, cette fonction est pour vous. Voici une fonction qui pourrait être ajouté dans ma classe de base de donnée et qui utilise func_get_args.
public function execute()
{
$binds = func_get_args();
foreach ($binds as $index => $name) {
$this->binds[$index+1] = $name;
}
$cnt = func_num_args();
$query = $this->query;
foreach ($this->binds as $ph => $pv) {
$query = str_replace(":$ph", "'".mysql_escape_string($pv)."'", $query);
}
$this->result = mysql_query($query, $this->dbh);
if(!$this->result) {
exit("erreur d'exécution".mysql_error());
}
return $this;
}
Voici un autre exemple plus simple d’une utilisation de func_get_args()
function foo(){
$args = func_get_args();
foreach($args as $arg){
echo $arg.'‘;
}
}
foo(”variable1″,true);
/*
//output
variable1
1
*/
Ce billet aura pour but de vous faire découvrir des fonctions utiles et méconnu de PHP.
Définition tiré de PHP.net
Génère un identifiant unique basé sur la date et heure courante en microsecondes.
Cette fonction est utile si vous voulez créer un numéro unique pour par exemple un numéro de commande.
//utilisation simple de uniqid
echo uniqid(); // 4824a44040d9c
echo uniqid('COM-'); // COM-4824a457ca2e5