A lieu de les activer dans mon php.ini, je préfère les laisser désactivés par défaut, je les active au cas par cas (tous les projets n’en ont pas la nécessité).

Voici donc la ligne que j’ajoute aux .htaccess concernés :

php_flag short_open_tag on 

Et les shorts tags sont ainsi disponibles (sans relancer mon serveur Apache ^^)

Je souhaitais obtenir les informations suivantes :

• N° dans la voie + éventuellement la mention bis ou ter
• Nom de la voie
• Code Postal
• Ville

Au lieu de passer à la main sur la liste, j’ai codé un petit bout de PHP pour le faire à ma place
Pour cela, je me suis servi des expressions régulières grâce à la fonction preg_match();

Le code PHP :

preg_match('/^([\d\/-]+?[\h]?(bis|ter)?)[\h]*([\D]{3}.*),[\h]*([\d]{5})[\h]*(.*)$/i', $adresse, $aMatch);
$numero = $aMatch[1];
$voie = $aMatch[3];
$code_postal = $aMatch[4];
$ville = $aMatch[5];

Analyse :

Analysons cette (magnifique, avouons-le) expression régulière :

^([\d\/-]*[\h]?(bis|ter)?)[\h]*([\D]{3}.*),[\h]*([\d]{5})[\h]*(.*)$

Dans l’ordre :

• ^ : début du texte à analyser
• ([\d\/-]*[\h]?(bis|ter)?) : capture d’une série de chiffres (pouvant comprendre un -, genre 5-7 rue ….) suivi ou non d’un espace puis de la mention “bis” ou “ter” (ou pas)
• [\h]* : aucun, un ou plusieurs espaces
• ([\D]{3}.*) : 3 caractères qui ne sont pas numériques, suivi (ou non) de divers caractères (le nom de la voie)
• , : la virgule qui sépare le nom de la voie du code postal
• [\h]* : encore aucun, un ou plusieurs espaces
• ([\d]{5}) : 5 caractères numériques (le code postal)
• [\h]* : encore aucun, un ou plusieurs espaces
• (.*) : une série de n’importe quel caractère (le nom de la ville)
• $ : fin du texte à analyser

J’ai utilisé le modificateur “i” en fin d’expression régulière pour que le traitement soit insensible à la case uniquement pour “bis” et “ter”).

Cette expression fonctionne sur ces adresses :

• 12 bis rue du 18 Mai 1945, 78000 Versailles
• 5-7 avenue de Paris, 84000 Avignon
• Place d’Arme, 75001 Paris
• Certainement d’autres…

Si j’ai omis quoi que ce soit, ou que l’expression ne fonctionne pas sur certaines adresses, n’hésitez pas à me le signaler dans les commentaires, je ferai évoluer ce bout de code

Voici donc un snippet permettant de rétablir l’ordre dans sa variable $_GET :

Le principe :

Le principe est simple, on reprend l’URL de base, stockée dans $_SERVER['REQUEST_URI'], puis on va la découper pour récupérer les paramètres qui lui sont passés.

Le code :

preg_match_all('/[\&\?]([^\&]+)=([^\&]+)/', $_SERVER['REQUEST_URI'], $matches);//Découpage de l'URL
foreach($matches[1] as $k => $v) {
    if (!isset($_GET[$v]))
        $_GET[$v] = $matches[2][$k];//Injection dans la variable $_GET
}

Nous voici désormais avec un variable $_GET complète

Edit : Godefroy me précise qu’on peut simplement utiliser le paramètre [QSA] en face de sa règle de réécriture ^^ (il me suffisait de lire la doc du mod_rewrite)

L’installation se fait par cette simple commande :

sudo apt-get install lamp-server^

Ce package vous permettra d’installer Apache 2, PHP 5.3, MySQL 5.1 ainsi que SQLite et PERL.

Comme vous le voyez, tout n’est pas indispensable (je regrette même qu’il n’ai pas inclus phpMyAdmin), mais l’essentiel est là. On installe un LAMP sans avoir à se souvenir du nom exact  de chaque paquet.

Crédit photo : kudumomo

Conditions du test

Cet ensemble de tests a été réalisés sur un Pentium 4 double coeur, abreuvé par 3Go de RAM, faisant tourner Apache 2 et PHP 5.3.

Pour réaliser les tests, j’ai crée 500 scripts PHP ayant cette tête :

<?php
  class me_1{
    public function __construct(){
    }
  }
?>

enregistré sous le nom includeme_1.php

Le script “incluant” réalise une simple boucle for() et tente d’inclure les fichiers un à un.
Une seconde version du script tente d’instancier la classe me_1, l’inclusion étant traitée par la fonction autoload() .

Résultats

Trêve de blabla technique, passons au résultats :

Légende :

1. fonction : la fonction utilisée (sisi)
2. chemine : le type de chemin employé pour l’inclusion
3. () : appel de la fonction PHP include(‘toto.php’)
4. ” : appel de la fonction native include ‘toto.php’ (réputée plus rapide …)
5. autoload : résultats obtenus avec le second script (sachant que j’ai utililisé les fonctions natives)

Code de test

Vous trouverez dans ce zip les codes utilisés pour réaliser les tests : Benchmark

Conclusion

J’étais parti avec à l’a-priori que include était plus rapide que require, car require bloque le script dans le cas où il ne trouve pas le fichier à inclure, hors cette séance de benchmarking nous montre que les deux fonctions jouent à égalité.
Egalement, les versions “_once” me semblait plus lentes car elles vérifient que le script n’a pas déjà été inclus, et les résultats m’ont donné raison (ouf ^^).
Je pensais également que la fonction “autoload” rajoutait du temps d’exécution, et, à mon grand étonnement, ce n’est pas le cas. Du coup, ça en fait une fonction encore plus intéressante.

Ce test reste synthétique et ne peut correspondre à une utilisation en condition réelle car les scripts à inclure sont vides et assez petits. Toutefois, la répétition par 500x permet, à mon avis, de pallier à cette lacune.

Crédit photo : shaggy359

Mais toutes ces fonctions ne se valent pas en terme de performance. Pour en avoir le coeur net et constater les différences, j’ai fait un mini-benchmark de ces 3 boucles :

Le test :

Le test consiste à parcourir un tableau d’un million d’éléments allant de 1 à 1.000.000 . Chaque boucle se contente de parcourir les valeurs, et ne fait rien d’autre.

$array = range(1,1000000);//Création du tableau

La machine utilisée pour ce test est un Pentium 4 double coeur épaulé par 3Go de RAM sur lequel est installé Apache 2 accompagné de PHP5.3

Les résultats :

foreach($array as $a){} :0.106s
foreach($array as &$a){} :0.101s
for($i=0;$i < count($array);$i++){} : 1.874s
for($i=0;$i < count($array);++$i){} : 1.901s
for($i=0;$i<$c;$i++){} : 0.281s
for($i=0;$i<$c;++$i){} : 0.264s
for($i=0;isset($array[$i]);$i++){} : 0.286s
for($i=0;isset($array[$i]);++$i){} : 0.279s
while(isset($array[$i])){++$i;} : 0.256s
while($elm = next($array)){} : 1.638s
while(next($array)){current($array);}  : 3.349s

Conclusion :

On constate que la boucle foreach est bien plus rapide que ces “collègues”, vient ensuite la boucle while, suivie de la boucle for. Personnellement, je ne m’attendais pas à ce que la boucle foreach soit plus performante que les autres. Dans mon esprit le classement aurait été while,for puis foreach…

Désormais, nous connaissons la performance des unes par rapport aux autres.

$country = file_get_contents('http://api.hostip.info/country.php?ip='.$ip);

Le pays est retourné dans sa forme “courte” (FR, US, UK, etc …).

L’API de hostip.info permet d’obtenir plus d’informations telles que les coordonnées GPS ou la ville.

Il existe des solutions pour définir les jointures entre les classes. Par exemple dans Symfony, il existe des fichiers de configuration (en yml). On définit son modèle, on lance un p’tit script et “HOP !”, voici de belles classes de bases prêtes à être héritées.
Autrement, il existe la solution de Kohana, qui consiste à indiquer les relations dans chaque classe, manuellement.

Bref, les solutions existent, toutefois le truc que je trouve lourdingue, c’est de faire coller en permanence les classes avec les tables en bases de données. En cours de développement, mes tables et leurs champs bougent beaucoup. Du coup, il faut systématiquement que je reporte chaque modification dans la classe qui va bien…

Partant du principe que la base de données comporte déjà toutes les infos nécessaires. Je me suis dit qu’il serait possible d’extraire les informations inclues dans chaque tables, et de reporter ces infos dans des classes en PHP. C’est déjà un premier pas : lister les champs de la table… En fouillant un peu, je détermine les champs primaires, et je peux même typer mes variables (en quelque sorte …).

Tout ça c’est bien, mais en m’imposant une convention de nommage, j’arriverai même à esquisser des jointures et des tables pivots détectables facilement depuis un script.
Par exemple :

p_table1_table2 est la table pivot entre table1 et table2.

Le résultat, c’est une petite classe, composée de quelques méthodes statiques qui :

• Analyse une base de données, donnée
• Détermine les relations entre les tables
• Génère un script PHP par table (hors pivots)

Désormais, quand je développe :

1. Modifs dans la base de données
2. Exécution de mon script
3. Mes classes sont à jours ^^

J’offre ce code à qui en a besoin. Le tout est livré sous licence BeerWare, car si mon code vous plait et qu’on se croise, libre à vous de me payer un boc

Le zip ci-joint contient la classe, ainsi qu’un petit exemple et ma méthode d’écriture des scripts PHP (libre à vous de la changer ^^).

db_2_classes.zip

/^(#?)([0-9\.]+)[\s]+([a-z0-9\._-]+)/

En PHP, ça donne :

$contenu_du_host = file_get_contents("c:\windows\system32\drivers\etc\hosts");

preg_match_all('/^(#?)([0-9\.]+)[\s]+([a-z0-9\._-]+)/im',$contenu_du_host,$result);

Le résultat :

Array
(
    [0] => Array
        (
            [0] => 127.0.0.1       localhost
            [1] => 127.0.0.1		dev.murl.fr
        )

    [1] => Array
        (
            [0] =>
            [1] =>
        )

    [2] => Array
        (
            [0] => 127.0.0.1
            [1] => 127.0.0.1
        )

    [3] => Array
        (
            [0] => localhost
            [1] => dev.murl.fr
        )

)

La semaine dernière, j’ai configuré l’envoi de mail via sSMTP pour pouvoir utiliser mon compte GMail depuis ma console SSH ou depuis mes scripts PHP. sSMTP est une mini-application qui permet (après configuration) d’utiliser la fonction sendmail avec un compte GMail, ce qui me procure un système d’envoi de mails efficaces, spacieux, autogéré et surtout je ne voulais pas m’amuser à configurer un serveur de mail complet (du type posix, exim, etc …) uniquement pour envoyer quelques mails depuis PHP…

Trêve de clavardage, on se remonte les manches et on ouvre le capot (ou un terminal, ça fera tout aussi bien l’affaire).
(la procédure d’installation/configuration se fait en SuperUtilisateur – su).

Tout d’abord, installons le dénommé sSMTP :

apt-get install ssmtp

Ensuite, il va falloir configurer la bête , ça se passe dans /etc/ssmtp/ssmtp.conf :

nano /etc/ssmtp/ssmtp.conf

y coller tout ceci (en prenant soin de remplacer moimoimoi et monmotdepassesecret par les bonnes infos …) :

root=moimoimoi@gmail.com
mailhub=smtp.gmail.com:587
rewriteDomain=
hostname=moimoimoi@gmail.com
UseSTARTTLS=YES
AuthUser=moimoimoi
AuthPass=monmotdepassesecret
FromLineOverride=YES

un Ctrl+X pour fermer nano, puis un Y (pour yes), puis on passe aux aliases, qui se trouvent dans /etc/ssmtp/revaliases :

nano /etc/ssmtp/revaliases

y coller tout ceci (en remplaçant “monlogindemamachine” par votre vrai login):

root:moimoimoi@gmail.com:smtp.gmail.com:587
monlogindemamachine:moimoimoi@gmail.com:smtp.gmail.com:587

Et voilà, c’est fini. Vous pouvez vous essuyer les mains et tester l’envoi de mail depuis votre serveur ^^

Source : Delodder.be