Articles Tagués ‘php’

Antisèche MYSQL

Publié: 18/03/2014 dans Programmation
Tags:, ,

Voici une petite anti-sèche des commandes MySQL les plus courantes. On sait jamais, ça peut être utile…
(Surtout pour moi qui ai une ram datant de l’époque mérovingienne…)

CREATE DATABASE `maindb` /*!40100 DEFAULT CHARACTER SET utf8 */;

DROP TABLE IF EXISTS `maindb`.`log`;
CREATE TABLE  `maindb`.`log` (
`id` bigint(20) unsigned NOT NULL AUTO_INCREMENT,
`client` varchar(64) NOT NULL,
`method` varchar(16) NOT NULL,
`component` varchar(32) NOT NULL,
`timestamp` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
`freetext` varchar(256) NOT NULL,
`ack` enum(’0′,’1′) NOT NULL DEFAULT ’0′,
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8;

INSERT INTO log (client, method, component, freetext)
VALUES (‘Client01′, ‘PS’, ‘COMP01′, “”);

INSERT INTO log (client, method, component, freetext)
VALUES (‘Client01′, ‘SNMP’, ‘COMP01′, ‘No response from localhost’);

SELECT * FROM log;

SELECT * FROM log WHERE ack=’0′;

CREATE VIEW `maindb`.`not_ack` AS
SELECT id, client, method, component, timestamp, freetext FROM log WHERE ack=’0′;

UPDATE log SET ack=’1′ WHERE client=’Client01′;

DELETE FROM log WHERE client=’Client01′;

SELECT * FROM not_ack;

SELECT * FROM maindb.log WHERE DATE_SUB(CURRENT_TIMESTAMP(), INTERVAL 2 HOUR) <= timestamp;

DELETE FROM maindb.log WHERE (DATE_SUB(CURRENT_TIMESTAMP(), INTERVAL 30 DAY) > timestamp) AND (ack=’1′);

Procédures et fonctions stockées

Procédure:

DELIMITER $$

DROP PROCEDURE IF EXISTS `maindb`.`CLEAN_OLD_ACK` $$
CREATE PROCEDURE `maindb`.`CLEAN_OLD_ACK` ()
BEGIN
DELETE FROM maindb.log
WHERE (DATE_SUB(CURRENT_TIMESTAMP(), INTERVAL 30 DAY) > timestamp)
AND (ack=’1′);
END $$

DELIMITER ;

Procédure renvoyant une valeur passée en paramètre:

DELIMITER $$

DROP PROCEDURE IF EXISTS `maindb`.`NBALERTS` $$
CREATE DEFINER=`root`@`localhost` PROCEDURE `NBALERTS`(OUT result BIGINT)
BEGIN
SELECT COUNT(*) INTO result FROM log;
END $$

DELIMITER ;

On peut l’utiliser ainsi:

CALL NBALERTS(@a);
SELECT @a;

Procédure utilisant une variable utilisateur:

SELECT value INTO @age FROM config WHERE token=’age_purge’ LIMIT 1;
SELECT * FROM log WHERE (UNIX_TIMESTAMP(NOW())-UNIX_TIMESTAMP(timestamp) > (86400*@age));

Fonction:

DELIMITER $$

DROP FUNCTION IF EXISTS `maindb`.`bonjour` $$
CREATE FUNCTION `maindb`.`bonjour` (s CHAR(20)) RETURNS CHAR(50)
BEGIN
RETURN CONCAT(‘Bonjour, ‘,s,’!’);
END $$

DELIMITER ;

Elle peut s’utiliser ainsi:

SELECT bonjour(‘moi’);

Création de vue:

select
`maindb`.`user`.`Id` AS `id_user`,
concat(`maindb`.`user`.`prenom`,’ ‘,`maindb`.`user`.`nom`,’ (‘,`maindb`.`user`.`pseudo`,’)’) AS `nom`,
`maindb`.`user_objet`.`objet` AS `objet`
from (`maindb`.`user` left join `maindb`.`user_objet` on((`maindb`.`user`.`Id` = `maindb`.`user_objet`.`id_user`)))

Client MySQL en C#

Vous aurez besoin du connecteur MySQL .NET, disponible sur le site de MySQL.

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
using MySql.Data.MySqlClient;

namespace mysql
{
class MySQLConnector
{
private MySqlConnection ConnectionRessource;
private string DBName;
private string Server;
private string Login;
private string Password;
private Boolean dbUp;
private string connectionString;

private string requete;
private MySqlCommand com;
private MySqlDataReader dr;

public MySQLConnector()
{
this.DBName = “testdb”;
this.Server = “localhost”;
this.Login = “root”;
this.Password = “pass”;
this.dbUp = false;
this.connectionString = “Server=” + this.Server + “;” +
“Database=” + this.DBName + “;” +
“User ID=” + this.Login + “;” +
“Password=” + this.Password + “;”;
try
{
ConnectionRessource = new MySqlConnection(connectionString);
ConnectionRessource.Open();
this.dbUp = true;
}
catch(MySqlException e)
{
System.Console.Out.WriteLine(e.Message);
}
}

public void Close()
{
try
{
ConnectionRessource.Close();
}
catch (MySqlException e)
{
System.Console.Out.WriteLine(e.Message);
}
}

public void test()
{
requete = “SELECT * FROM table”;
com=new MySqlCommand(requete,ConnectionRessource);
dr = com.ExecuteReader();
while(dr.Read())
{
for(int i=0;i<dr.FieldCount;i++)
{
System.Console.Out.Write(dr.GetValue(i)+” “);
}
System.Console.Out.WriteLine(“”);
}
}
}
}


Si vous êtes développeur PHP, vous devez lire au moins une fois cette cinquantaine de commandements PHP !

Quelle fonction utiliser plutôt qu’une autre, comment améliorer les performances de vos scripts, les bonnes pratiques …

phpCes commandements sont une traduction du billet de chez HM2K que j’ai jugé très intéressant et que je souhaite faire partager aux développeurs non anglophones.

 

  1. echo est plus rapide que print. [Citation]
  2. Mettre ses chaines de caractères entre simple quotes ‘…’ est plus rapide qu’entre des doubles quotes « … » car PHP analyse s’il y’a des variables entre les doubles quotes. Utiliser les simple quote pour du texte pur.
  3. Utiliser sprintf au lieu de mettre des variables dans des double quotes, C’est 10x plus rapide. [Citation]
  4. Utiliser les paramètres multiples dans un echo au lieu de la concaténation des chaines. [Citation]
  5. Utiliser le plus possible des variables pour les calculs, éviter de les mettre dans les boucles. Exemple
    1.<a onclick="window.open(this.href); return false;" href="http://www.php.net/for">for</a> ($x=0; $x < count($array); $x)

    La fonction count est appelée à chaque boucle, mieux vaut utiliser $max=count($array) pour stocker le résultat du calcul avant la boucle. [Citation]

  6. Pensez à unset ou rendre null vos variables, en particulier les gros tableaux. [Citation]
  7. Eviter les méthodes magiques comme __get, __set, __autoload. [Citation]
  8. Utiliser require() au lieu de require_once() quand c’est possible. [Citation]
  9. Utilisez desz chemins complets dans vos include et require. C’est du temps gagné pour la résolution du chemin au niveau de votre OS. [Citation]
  10. require() et include() sont identiques à part que require arrete le script si le fichier n’est pas trouvé. Les performances sont quasi identiques. [Citation]
  11. Depuis PHP5, l’heure de démarrage d’un script peut être trouvé grâce à $_SERVER[’REQUEST_TIME’], à utiliser à la place de time() ou microtime(). [Citation]
  12. PCRE regex est plus rapide que EREG, mais il faut toujours regarder s’il n’est pas posssible d’utiliser une fonction native comme strncasecmp, strpbrk et stripos à la place. [Citation]
  13. Quand vous parsez du XML en PHP essayez xml2array, qui permet d’utiliser les fonctions PHP XML, pour du HTML vous pouvez essayer DOM document ou DOM XML en PHP4. [Citation]
  14. str_replace est plus rapide que preg_replace, str_replace est globalement le meilleur dans tous les cas, même si quelques fois strtr est plus rapide avec des chaines longues. Utiliser un array() dans str_replace est plus rapide que d’utiliser plusieurs str_replace. [Citation]
  15. “else if” est plus rapide qu’un case/switch. [Citation]
  16. La suppression d’erreurs avec @ est très lent. [Citation]
  17. Pour réduire l’utilisation de la bande passante, il faut activer le mode mod_deflate dans Apache2 [Citation] ou mod_gzip pour Apache1. [Citation]
  18. Fermer les connexions aux BDD après les avoir utilisé. [Citation]
  19. $row[’id’] est 7 fois plus rapide que $row[id], car si vous ne mettez pas les quotes, PHP Pense qu’il va s’agir d’une constante. [Citation]
  20. L’utilisation de tags d’un autre style ou des shorts tags pour ouvrir du code PHP est déconseillé. [Citation]
  21. L’utilisation d’un code strict permettant de supprimer toutes les erreurs, warning etc est conseillé. error_reporting(E_ALL) doit toujours être activé. [Citation]
  22. Les scripts PHP sont rendus 2 à 10 fois moins rapidement par Apache qu’une page statique. Essayez d’utiliser au maximum des pages statiques. [Citation]
  23. Les scripts PHP sont compilés à la volée (si pas de cache). Installez un système de cache PHP (comme memcached, eAccelerator ou Turck MMCache) permet d’augmenter de 25-100% les performances. [Citation]
  24. Une alternative aux systèmes de cache est de générer régulièrement le rendu en HTML statique. Essayez Smarty ou Cache Lite. [Citation]
  25. Utilisez isset où c’est possible au lieu de strlen. (ie: if (strlen($foo) < 5) { echo “Foo is too short”; } vs. if (!isset($foo{5})) { echo “Foo is too short”; } ). [Citation]
  26. ++$i est plus rapide que $ i++, donc utilisez le pre-increment quand c’est possible. [Citation]
  27. Ne réinventez pas la roue, utilisez les fonctions natives de PHP qui seront toujouts plus rapides; Si vous avez le temps de réecrire, faites le sous forme de modules C / C++. [Citation]
  28. Analysez votre code (Profiler). Utilisez Xdebug debugger pour profilker du code PHP. [Citation]
  29. Documentez  votre code. [Citation]
  30. Apprenez les différences entre du bon et du mauvais code. [Citation]
  31. Utilisez les standarts pour une meilleure compréhension de votre code par les autres. [Citation]
  32. Séparez les couches: Contenu, PHP et HTML. HTML dans un autre fichier que le PHP. [Citation]
  33. IL n’est pas obligatoire d’utiliser des systèmes de templates complexes comme Smarty, PHP en intègre déjà, regardez  ob_get_contents et extract. [Citation]
  34. Ne jamais avoir confiance en les variables utilisateurs: $_POST et $_GET. Utilisez mysql_real_escape_string quand vous utilisez MySQL, et htmlspecialchars quand vous rendez du HTML. [Citation]
  35. Pour des raisons de sécurité, ne dévoillez jamais d’infos concernant vos paths, extensions et configuration, comme utiliser display_errors ou phpinfo(). [Citation]
  36. Désactivez register_globals (Normalement désactivé par défaut, pas pour rien!). L’utiliser = risque de sécurité. Bientôt, le PHP6 supprimera complètement cette fonction ! [Citation]
  37. Ne jamais utiliser du texte clair pour stocker les mots de passe ou les comparer. Utilisez un hash md5 au minimum. [Citation]
  38. Utilisez ip2long() et long2ip() pour stocker les adresses IP en INT plutôt qu’en STRING. [Citation]
  39. Pour ne pas réinventer la roue, vous pouvez utiliser les nombreux projets PEAR souvent standarts. [Citation]
  40. Quand vous utilisez header(’Location: ‘.$url); n’oubliez pas d’y faire suivre un die(); car le script continue de tourner même après l’instruction. [Citation]
  41. En POO, si une méthode peut être static, alors déclarez la en static. Elle sera 4 fois plus rapide. [Citation].
  42. Incrémenter une variable locale dans une méthode POO est le plus rapide. [Citation]
  43. Incrémenter une propriété d’un objet (eg. $this->prop++) est 3 fois plus lent qu’une variable locale. [Citation]
  44. Incrémenter une variable indéfinie est 9-10 fois plus lent qu’une variable pré définie. [Citation]
  45. Déclarer une variable globale dans une fonction sans l’utiliser ralenti les choses. PHP doit faire une sorte de check sur la variable pour vérifier qu’elle existe. [Citation]
  46. Le nombre de méthodes dans une classe ne change rien aux performances d’appel d’une méthode. [Citation]
  47. Les méthodes d’une classe dérivée vont plus vite que celles de la classe mère. [Citation]
  48. Une fonction appelée avec un ou zéro paramètre prend environ 7-8 fois un $localvar++. 15 $localvar++ pour l’appel d’une méthode similaire. [Citation]
  49. Tout ne doit pas être objet, chaque méthode et propriété consomme de la mémoire. [Citation]
  50. Echappez les chaines provenant de l’extérieur avec mysql_real_escape_string, au lieu de mysql_escape_string ou addslashes. Si magic_quotes_gpc est activé, mieux vaut utiliser stripslashes en premier. [Citation]
  51. Attention lors de l’utilisation de mail() et de ses headers, il y’a des failles de sécurité. [Citation]
  52. Il faut unset les variables que l’on ne se sert plus après s’être connecté à la BDD

Vous n’avez plus qu’à respecter tout ces conseils pour avoir un code PHP optimisé !


Sans commentaire…


phpDocumentor est un générateur de documentation pour PHP et à pour fonction de créer une documentation de votre programme source « élément parfois négligé« . Pour y parvenir, il s’appuie sur les commentaires inclus à l’intérieur de votre code source. D’où l’importance de bien expliciter vos routines, fonctions et autres procédures.

Les caractéristiques principales de phpDocumentor sont :

  • Génération hors ligne
  • Génération en ligne
  • Templates personnalisables
  • guide, phpdoc
  • Formats de sortie en HTML, CHM, PDF, XML

Avoir recours à phpDocumentor vous permettra de pouvoir revenir sur un code après un long moment, de permettre à d’autres développeurs de voir en un clin d’oeil la structure de votre application et une meilleure maintenance du code.

phpDocumentor peut-être utilisée de deux manières : soit en mode graphique avec l’interface web, soit en ligne de commande.

Le site de phpDocumentor.

La documentation sur phpDocumentor.

Le téléchargement de phpDocumentor.

Installation rapide de PhpDocumentor :

Vous l’aurez deviné, il faut tout d’abord le télécharger C’est par ici.

Une fois décompressé vous allez mettre votre dossier PhpDocumentor dans la racine de votre dossier www.

Bravo vous avez installé PhpDocumentor

Comme vous l’imagez PhpDocumentor met un certain temps pour générer toute la documentation d’une application php. Et apache par défaut limite le traitement du script php à 30 secondes. Ce qui bien évidement ne suffit pas pour faire tourner PhpDocumentor. Pour pallier ce problème il suffit de modifier fichier php.ini :

max_execution_time = 0;
max_input_time = 0;

Comme ça on est tranquille il n’y a plus de limite

Configuration de PhpDocumentator

Il faut se rendre à la page d’administration de PhpDocumentor.

En haut à gauche vous allez voir ce menu :

C’est l’onglet Files qui va nous intéresser.

Directory to parse : C’est le chemin du dossier où se situe votre application php (celui que phpDocumentor va traiter)

Files to ignore : On doit indiquer les types de fichier à ne pas traiter (ex : *.png, *.jpg, *.css)

Passons maintenant à l’onglet Output.

Target : Nous allons indiquer l’adresse où notre documentation va être générée ( ex: C:wampwwwdoc)

Output Format : C’est la forme que prendra votre doc (vous aurez le choix entre du xml , html ou pdf)

La dernière modification sera dans l’onglet Options.

Generated Documentation Title : C’est le nom de votre documentation.

Génération de la documentation

La c’est le plus simple on a juste à cliquer sur un bouton :

La il faut attendre un peu que le script se génère. La durée est relative à la taille de votre application.

Si vous voyez ça, c’est que votre doc est bien généré :

Oui, ma doc est bien formée, mais j’ai pratiquement pas d’information dessus.
Mais comment cela se fait-il ?

Si vous avez une documentation appauvrie, c’est que vous avez mal commenté vos fonctions dans votre code source php.

Voici un exemple qui devrait faire une documentation assez complète :

01
02
03
04
05
06
07
08
09
10
11
12
/**
* @author Roul
* @access public
* @param float $fNombre
* @todo double le nombre entré en paramètre
* @return float
*/
public function double(float $fNombre)
{
return $fNombre*2;
}

Si vous voulez plus d’indications sur le formatage des commentaires je vous conseille de lire ceci

Ester egg dans PHP

Publié: 16/02/2011 dans Geek world
Tags:,

Les programmeurs de PHP ont soigneusement pris soin de placer un Easter Egg au sein du langage. Ajouter ?=PHPE9568F36-D428-11d2-A769-00AA001ACF42 à la fin de l’URL de la page PHP pour découvrir un chien. C’est assez ordinaire comme Easter Egg mais bon
Il suffit de s’essayer sur plusieurs sites web