Cette fonction se comporte exactement de la même manière que la fonction date() en PHP, mais traduite en français.
function date_french($format, $timestamp = null) {
$param_D = array('', 'Lun', 'Mar', 'Mer', 'Jeu', 'Ven', 'Sam', 'Dim');
$param_l = array('', 'Lundi', 'Mardi', 'Mercredi', 'Jeudi', 'Vendredi', 'Samedi', 'Dimanche');
$param_F = array('', 'Janvier', 'Février', 'Mars', 'Avril', 'Mai', 'Juin', 'Juillet', 'Août', 'Septembre', 'Octobre', 'Novembre', 'Décembre');
$param_M = array('', 'Jan', 'Fév', 'Mar', 'Avr', 'Mai', 'Jun', 'Jul', 'Aoû', 'Sep', 'Oct', 'Nov', 'Déc');
$return = '';
if(is_null($timestamp)) { $timestamp = mktime(); }
for($i = 0, $len = strlen($format); $i < $len; $i++) {
switch($format[$i]) {
case '\\' : // double.slashes
$i++;
$return .= isset($format[$i]) ? $format[$i] : '';
break;
case 'D' :
$return .= $param_D[date('N', $timestamp)];
break;
case 'l' :
$return .= $param_l[date('N', $timestamp)];
break;
case 'F' :
$return .= $param_F[date('n', $timestamp)];
break;
case 'M' :
$return .= $param_M[date('n', $timestamp)];
break;
default :
$return .= date($format[$i], $timestamp);
break;
}
}
return $return;
}
Voici sûrement l'une des astuces les plus inutiles du moment. Comment accéder aux données POST bruts en PHP ? Il suffit de lire le flux d'entrée php://input de la manière suivante :
<form action="page-input.php" method="post">
<p>
<label for="text">Zone de texte :</label>
<input type="text" name="text" id="text" />
</p>
<p><input type="submit" name="submit" value="Continuer" /></p>
</form>
<p><?php echo file_get_contents('php://input'); ?></p>
Ce qui retournera comme résultat :
text=bla+bla+bla&submit=Continuer
php://input ne fonctionnera pas si vous utilisez l'attribut enctype="multipart/form-data" dans votre balise <form action="" method="post">.
Documentation officielle : http://www.php.net/wrappers.php
Comme annoncé la semaine dernière et les vacances se terminant, il est maintenant temps de remonter (un peu) le niveau de ce blog qui sombrait doucement mais sûrement dans le grand n'importe quoi.
L'astuce du jour n'est guère facile à expliquer en quelques lignes, un exemple sera à mon avis beaucoup plus clair.
Comment utiliser un tableau comme un pur objet ? ( à la sauce Java, si je puis m'exprimer ainsi )
// Ecriture PHP classique
$array = array(); // Ligne facultative
$array['key1'] = 'value 1';
$array['key2'] = 'value 2';
$array['key3']['key31'] = 'value 31';
...
Voici une écriture qui ne fonctionne qu'en PHP 5 :
// Ecriture PHP5 objet
$array = new ClassArray(); // Ligne obligatoire !
$array['key1'] = 'value 1';
$array['key2'] = 'value 2';
...
En soit, il n'y a absolument rien de révolutionnaire, mais le new crée l'instance de l'objet ClassArray() et vous pouvez constater que l'écriture reste un tableau et non un objet
$array->key1 = 'value 1';
Une question se pose sûrement dans votre cerveau qui bouillonne d'impatience : Qui a-t-il dans cette ClassArray() ? Une simple implémentation de ArrayAccess ( PHP5 only ), ce qui nous donne :
class ClassArray implements ArrayAccess {
protected $_array = array();
public function __construct() {
$this->_array = func_get_args();
}
// En cas d'appel de la fonction isset()
public function offsetExists($offset) {
return isset($this->_array[$offset]);
}
// En cas d'appel de la valeur
public function offsetGet($offset) {
return $this->_array[$offset];
}
// En cas d'affectation de la valeur
public function offsetSet($offset, $value) {
return $this->_array[$offset] = $value;
}
// En cas d'appel de la fonction unset()
public function offsetUnset($offset) {
unset($this->_array[$offset]);
}
}
Ensuite, libre à vous de modifier cette classe pour lui ajouter de nouvelles fonctionnalités...
Remarque importante : Si vous essayez de créer un tableau sur plusieurs dimensions, un message d'erreur se produira avec l'écriture suivante :
$array = new ClassArray();
$array['key3']['key31'] = 'value 31';
// Problème : Vous n'avez pas définit $array['key3'] ! l'écriture POO est beaucoup plus stricte ;)
// Solution :
$array = new ClassArray();
$array['key3'] = new ClassArray();
$array['key3']['key31'] = 'value 31';
Documentation officielle :
http://www.php.net/~helly/php/ext/spl/interfaceArrayAccess.html
Cette fonction function array2object() n'est pas nouvelle en soit, mais voici une écriture récursive en PHP5 plus rigolote ( et surtout plus restrictive ) à utiliser.
La fonction ci-dessous ne fonctionne qu'en PHP 5 de part le typage du paramètre (array $array) ainsi on évite le contrôle is_array(). Toutefois, si vous envoyez une valeur qui n'est pas un tableau, une erreur de compilation se produira.
function array2object(array $array) {
$object = new stdClass();
foreach($array as $key => $value) {
if(is_array($value)) {
$object->$key = array2object($value);
} else {
$object->$key = $value;
}
}
return $object;
}
Exemples d'utilisation :
$tableau[0] = 'Valeur 0';
$tableau[1] = 'Valeur 1';
$tableau['deux'] = 'Valeur 2';
$tableau['trois'] = 'Valeur 3';
$objet = array2object($tableau);
echo $objet->0; // Ecriture incorrecte
echo $objet->{'1'}; // Ecriture correcte
echo $objet->deux; // Ecriture classique
echo $objet->trois; // etc...
Astuce du jour : Comment retourner plusieurs variables depuis une fonction PHP ?
Vous pouvez utiliser les tableaux array() ou les objets new stdClass() dans une variable et retourner la dite variable, toutefois cette écriture n'est pas forcément limpide lors d'une relecture de code.
Je vous propose une écriture assez souple et surtout beaucoup plus claire qui vous donnera une réelle impression de return avec X valeurs.
<?php
function retourner_plusieurs_valeurs() {
$variable_n_1 = 'One';
$variable_n_2 = 'Two';
$variable_n_3 = '333';
return array($variable_n_1, $variable_n_2, $variable_n_3);
}
list($variable_n_1, $variable_n_2, $variable_n_3) = retourner_plusieurs_valeurs();
?>
Cette astuce n'a absolument rien d'extraordinaire, mais peut être vous fera-t-elle découvrir les différentes manières de formater un nombre au format monétaire.
<?php
$number = 1234.567;
// Première méthode ( peu pratique )
echo sprintf('%.2f €', $number); // 1234.57 €
// Seconde méthode ( plus simple mais non automatique )
echo number_format($number, 2, ',', ' ') . ' €'; // 1 234,57 €
// Troisième méthode ( qui peut être automatisée )
setlocale(LC_MONETARY, 'en_US');
echo money_format('%n', $number); // $1,234.57
setlocale(LC_MONETARY, 'fr_FR');
echo money_format('%n', $number); // 1 234,57 Eu
echo money_format('%!n €', $number); // 1 234,57 €
?>
Article inspiré du livre O'Reilly PHP Cookbook, Second Edition.
Voici une petite commande PHP qui vous permettra de désactiver ou plutôt de nettoyer les magic_quotes quand ces dernières sont activées ( et accessoirement de préparer votre code si la fonction get_magic_quotes_gpc() venait à disparaître dans PHP 6 ).
if(!function_exists('get_magic_quotes_gpc')) {
// En prevision de PHP 6
function get_magic_quotes_gpc() { return 0; }
}
if(get_magic_quotes_gpc()) {
function undo_magic_quotes(&$array) {
foreach($array as $key => $value) {
if(is_array($array[$key])) {
undo_magic_quotes($array[$key]);
} else {
$array[$key] = stripslashes($value);
}
}
}
undo_magic_quotes($_GET);
undo_magic_quotes($_POST);
undo_magic_quotes($_COOKIE);
undo_magic_quotes($_REQUEST);
undo_magic_quotes($_FILES);
}
La fonction ci-dessous vous permet par l'intérmédiaire des expressions régulières de convertir automatiquement les adresses de sites internet http://www.ab-d.fr/ en lien actif avec la balise <a href="http://www.ab-d.fr/" onclick="window.open(this.href); return false;">http://www.ab-d.fr/</a>.
Accessoirement, la fonction convertit aussi les adresses emails... libre à vous de rajouter d'autres fonctionnalités de remplacement grâce à la fonction preg_replace().
function texte2url($texte) {
$patterns[0] = '/(https?:\/\/\S+)/i';
$replacements[0] = '<a href="$1" onclick="window.open(this.href); return false;">$1</a>';
$patterns[1] = '/(\S+@\S+\.\S+)/i';
$replacements[1] = '<a href="mailto:$1">$1</a>';
return preg_replace($patterns, $replacements, $texte);
}
La fonction parseInt() en Javascript tansforme une chaîne de caractères en nombre entier et renvoie la valeur numérique de celle-ci comme résultat.
Le plus proche équivalent en PHP est la fonction intval(). Toutefois, le résultat retourné me semble trop restrictif avec des chaînes de caractères ne débutant pas par un nombre.
Les expressions rationnelles (ou expressions régulières) permettent de outre passer cette limitation. Pour ce faire, on utilise la fonction preg_match() :
function parseInt($string) {
// return intval($string);
if(preg_match('/(\d+)/', $string, $array)) {
return $array[1];
} else {
return 0;
}
}
echo parseInt("2008");
echo parseInt("soit 99.90 francs");
echo parseInt("www.w3.org");
echo parseInt("300 soldats spartiates");
echo parseInt("du texte brut...");
Ce script affichera comme résultat :
- 2008
- 99
- 3
- 300
- 0
Cette faille de sécurité n'est pas nouvelle en soit, mais il est parfois bon de faire un petit rappel. De manière générale, ne faites jamais confiance aux variables $_SERVER, $_COOKIE, mais aussi, $_GET, $_POST, $_REQUEST, $_FILES...
Exemple de faille avec <?php echo $_SERVER['PHP_SELF']; ?> dans la page php suivante :
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN"
"http://www.w3.org/TR/html4/strict.dtd">
<html lang="fr">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>$_SERVER['PHP_SELF']</title>
</head>
<body>
<form action="<?php echo $_SERVER['PHP_SELF']; ?>" action="post">
<fieldset>
<legend>Ma FORM</legend>
<p><input type="submit"></p>
</fieldset>
</form>
</body>
</html>
Si vous appelez la page ci-dessus avec le lien suivant :
http://www.monsite.com/page.php/"><script>alert('Injection!');</script>
vous verrez une belle fenêtre de dialogue Javascript "Injection!" ...
Pour remédier à cette faille de sécurité, pensez à toujours sécuriser vos variables avec une fonction du type htmlentities().
La solution consiste n'ont pas à créer une variable CSS, mais à utiliser PHP pour créer des variables dans le code CSS.
Pour ce faire, nous allons utiliser l'écriture simplifiée de
<?php echo $variable_css; ?> en <?= $variable_css ?> .
Page page.html
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="fr" lang="fr">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
<title>Variable CSS - Cascading Style Sheets</title>
<link rel="stylesheet" type="text/css" href="style.php" />
</head>
<body>
<h1>Variable CSS - Cascading Style Sheets</h1>
<p class="color-1">Bloc de couleur n°1 - Variable CSS Cascading Style Sheets</p>
<p class="color-2">Bloc de couleur n°2 - Variable CSS Cascading Style Sheets</p>
<p class="color-3">Bloc de couleur n°3 - Variable CSS Cascading Style Sheets</p>
</body>
</html>
Page style.php et non style.css
<?php
header('Content-Type: text/css');
$color_0 = '#000000';
$color_1 = '#ff0000';
$color_2 = '#ff3300';
$color_3 = '#ff6600';
?>
* { font-family: sans-serif; }
h1 {
padding: 5px;
color: <?= $color_0 ?>;
border: 5px solid <?= $color_2 ?>;
background-color: <?= $color_3 ?>;
}
p.color-1 { color: <?= $color_1 ?>; }
p.color-2 { color: <?= $color_2 ?>; font-weight: bold; }
p.color-3 { color: <?= $color_3 ?>; font-style: italic; }
La nouvelle version de PHP devrait arriver durant le premier trimestre 2008 (mois de mars ?) selon son créateur Rasmus Lerdorf. L'annonce a été faite au cours du dernier Forum PHP à Paris.
Au menu, nous aurons le support Unicode et les namespaces, de meilleurs performances, toujours plus de sécurité (l'évidence même dirons certains), et... pour d'autres développeurs, une très mauvaise nouvelle: la suppression pur et simple des magic_quotes (l'utilisation de addslashes sera donc de rigueur pour vos requêtes SQL).
En attendant, la version 5.3 ne devrait pas tarder à sortir des cartons de PHP.net
Le chiffre du mois : En décembre 2007, les statistiques de diffusion de PHP 5 dans le monde ne représentaient toujours que 28 % ...
String.prototype.trim = function() {
return this.replace(/^\s*|\s*$/g, '');
};
Exemple
var v_string = ' Hello World ! ';
document.writeln('"' + v_string.trim() + '"'); // "Hello World !"
Le support de PHP4 est désormais arrêté avec la publication aujourd'hui de sa dernière version, la 4.4.8.
Cette nouvelle version, qui parait près de 8 mois après la précédente version, n'apporte pas de corrections majeures (corrections de bugs divers). A compter de ce jour, et ce jusqu'au 8 août 2008, seules des mises à jour de sécurité seront faites.
Source: PHP.net
Array.prototype.count = function() {
return this.length;
}
Exemples
var v_array = [ 5, 10, 15, 20, 25];
document.writeln(v_array.count()); // 5
