Foire Aux Questions PHP

Simplement en indiquant que l’on passe un tableau, ce que les champs de formulaires gèrent nativement. On indique que des champs de formulaires font partie d’un tableau en ajoutant une paire de crochets dans la valeur de l’attribut name.

<form action="" method="post">
    <p>
        <input type="checkbox" name="plop[]" value="10" />
        <input type="checkbox" name="plop[]" value="20" />
    </p>
    <p>
        <button type="submit">Test</button>
    </p>
</form>

Le résultat de print_r($_POST['plop']) sera donc un tableau et vaudra, si les deux cases ont été cochées :

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

Le résultat de print_r($_POST['plop']) vaudra, si seulement la seconde des deux cases a été cochée :

Array
(
    [0] => 20
)

Il est évidemment possible de le faire avec des champs ou l’attribut type est autre que checkbox. C’est aussi la manière de faire si vous utiliser l’attribut multiple de la balise <select>

Il est possible de spécifier des index directement dans les champs du formulaire, en les mettant entre les crochets bien entendu.

<input type="checkbox" name="questions[1][]" value="Oui" />
<textarea name="questions[commentaires]"></textarea>

Exemples

<?php
$sql = 'SELECT id, etat FROM uneTable ORDER BY id DESC';
$result = $pdo->query($sql);
echo '
<form action="" method="post">
<p>
';
while ($l = $result->fetch(PDO::FETCH_ASSOC)) {
    echo '<label for="' . $l['id'] . '">' . $l['id'] . '</label>';
    $checked = $l['etat'] == 1 ? ' checked="checked"' : '';
    echo '<input id="' . $l['id'] . '" type="checkbox" name="listeId[]"' . $checked . ' />';
}
echo '</p>
<p>
<button type="submit">Modifier les états"</button>
</p>
</form>';

<?php
if (!empty($_POST['listeId']) && is_array($_POST['listeId'])) {
    $_POST['listeId'] = array_unique(array_map('intval', $_POST['listeId']));
    // Mise à l'état actif des ids reçus
    $sql = 'UPDATE uneTable SET etat=1 WHERE id IN(' . implode(',', $_POST['listeId']) . ')';
    $result = $pdo->exec($sql);
    // Mise à l'état inactif des ids non reçus
    $sql = 'UPDATE uneTable SET etat=0 WHERE id NOT IN(' . implode(',', $_POST['listeId']) . ')';
    $result = $pdo->exec($sql);
}

<?php
$nbChamp = 5;
// Ne pas omettre l'attribut enctype
echo '<form action="" method="post" enctype="multipart/form-data">';
for ($i=0; $i<$nbChamp; $i++) {
    echo '<p><input type="file" name="image[]" /></p>';
}
echo '<p>
<button type="submit">Téléverser les images"</button>
</p>
</form>';

<?php
if (!empty($_FILES['image']) && array_filter($_FILES['image']['tmp_name'])) {
    for ($nbImg = count($_FILES['image']['tmp_name']), $i = 0; $i < $nbImg; $i++) {
        // On fait nos vérifications et actions pour chaque images
        // Soit :
        // $_FILES['image']['name'][$i]
        // $_FILES['image']['tmp_name'][$i]
        // etc…
        // Faites un print_r($_FILES) pour visualiser comment se présente le tableau
    }
}

Par étape :

• Vérifiez les options de votre navigateur : est-il configuré de façon à accepter les cookies² ?
• Toujours sur votre navigateur, vérifiez si oui ou non vos cookies y sont présents³
• Vérifiez que vous avez bien spécifié une durée de vie du cookie correcte
  Elle doit être supérieure au timestamp actuel
• Si vous créez vos cookies dans une page étant dans un sous-répertoire de votre site, et que vous en avez besoin dans une page située à sa racine, vous devez renseigner le 4ème argument de la fonction setCookie(). Dans le cas exposé, il faut y mettre un /⁴

Utilisez la classe DateTime qui, si vous avez intl et ICU disponibles et activées (ce qui est habituel), peut être utilisée en conjonction avec la classe IntlDateFormatter

<?php
/* Vous pouvez passer en paramètre une date
 * - brute de base de données MySQL
 * - comme retournée par un champ de type datetime-local
 * - au format ISO (AAAA-MM-JJ)
 */
$date = new DateTime();
$metteurEnForme = new IntlDateFormatter(
    'fr',
    IntlDateFormatter::FULL,
    IntlDateFormatter::NONE
);
echo $metteurEnForme->format($date);

mardi 27 août 2013

Vous pouvez premièrement vous tourner vers votre hébergeur pour savoir si ces tâches automatiques (appellées cron) ne sont pas déjà comprises dans votre plan d’hébergement.
Sinon, vous pouvez utiliser des services externes tels que Online Cron job (gratuit dans sa formule de base, mais imposant leur logo sur votre site) ou WebCron qui fait payer chaque exécution.

Autre possibilité, pour des tâches ne nécessitant pas trop de ressources : vous préparez un script qui sera embarqué sur toutes les pages de votre application. Ce script va vérifier s’il doit lancer la tâche selon la dernière exécution.
Ainsi, ce seront les utilisateurs qui déclencheront l’exécution de la tâche.

Cette information est contenue dans une variable superglobale : $_SERVER['HTTP_REFERER'] On peut donc faire comme ceci :

1
2

<?php
echo 'Vous venez du site : ' . htmlspecialchars($_SERVER['HTTP_REFERER']);

== effectue une comparaison "paresseuse". Cette comparaison ne tient pas compte du type de ce qui est comparé : PHP va prendre les deux parties et les convertir en deux valeurs du même type pour voir si elles correspondent. Voici un tableau qui permet de voir ce qu’il en résulterait

Avec ===, PHP va effectuer une comparaison stricte, et ne va faire aucune conversion, ce qui veut dire que le type de valeur est pris en compte. Le même tableau appliqué à === se présente ainsi :

Cas particulier des objets

Les objets se comportent un peu différemment des types dits primitifs que sont les entiers, flottants, booléens et chaînes de caractères. Si on peut les comparer avec == comme avec ===, il est important de bien comprendre comment sont effectuées les comparaisons entre deux objets.

Deux objets comparés avec == sont égaux si :

• ils sont de la même classe
• ils ont les mêmes attributs
• ces attributs ont les mêmes valeurs

En revanche, deux objets comparés avec === sont identiques s’ils sont la même instance de la même classe. Cela n’est donc possible que si l’on compare un objet avec lui-même. Deux objets ayant des attributs identiques et de valeurs identiques ne sont pas identiques, on l’a vu, c’est le cas de d’égalité mentionné ci-dessus.
C’est là la particularité des objets.

<?php
class Flag
{
    public $flag;

    function Flag($flag = true) {
            $this->flag = $flag;
    }
}

class OtherFlag
{
    public $flag;

    function OtherFlag($flag = true) {
            $this->flag = $flag;
    }
}

Le PHP ayant besoin d’être interprété par le serveur (ce qui n’est pas le cas du HTML), il faut qu’il soit quelque part où WAMP sait qu’il doit traiter du PHP, soit dans le dossier www de votre installation de WAMP. Vous devez y accéder avec une adresse commençant par http://, sans quoi vous ne passerez pas par WAMP.
Pour plus d’informations, lisez cette partie du tutoriel sur WAMP

1. Utilisez l’extension .php pour vos fichiers de code PHP, même si ceux-ci génèrent du HTML. Du code PHP dans un fichier avec l’extension .html peut soit s’afficher tel quel dans la page, soit ne pas être visible du tout

2. Utilisez bien les marques ouvrantes PHP complètes <?php. Si vous souhaitez pouvoir utiliser les versions courtes <? (et <?= sous PHP < 5.4), il vous faut activer l’option short open tag pour PHP. Pour ce faire, cliquez sur l’icône de WAMP dans la zone de notifications, et allez sur PHP > Configuration PHP > short open tag.

   Avant PHP 5.4, <?= était impacté par ce même paramètre

   Si vous avez des documents XML sur vos sites, surtout si vous les générez dynamiquement, activer cette option vous force à insérer la déclaration XML avec echo '<?xml version="1.0" encoding="utf-8" ?>'

3. La balise <?php ne doit pas contenir d’espace. En revanche, elle doit absolument être suivie d’un caractère blanc (espace ou retour à la ligne). Par exemple :

   <?phpecho $truc; // ne fonctionnera pas, echo est "collé" à <?php
   <? php echo $truc; // ne fonctionnera pas, php n'est pas "collé" à <?
   

Il faut utiliser la méthode de l’objet PDO lastInsertId()

<?php
$pdo = new PDO($dsn, $user, $passwd);
$pdo->exec("INSERT INTO ma_table (colonne1, colonne2) VALUES('$var_1', '$var_2')");
$id = $pdo->lastInsertId();

Avec l’API MySQLi, c’est la propriété mysqli#insert_id qui contient l’information.

$mysqli = new mysqli($host, $user, $password, $databaseName);
$mysqli->query("INSERT INTO ma_table (colonne1, colonne2) VALUES('$var_1', '$var_2')");
$id = $mysqli->insert_id;

// Ou, avec le style procédural
$mysqli = mysqli_connect($host, $user, $password, $databaseName);
mysqli_query($mysqli, "INSERT INTO ma_table (colonne1, colonne2) VALUES('$var_1', '$var_2')");
$id = mysqli_insert_id($mysqli);

Pour les requêtes INSERT, UPDATE et DELETE, la méthode de l’objet PDOStatement rowCount() sert à cela

$pdo = new PDO($dsn, $user, $passwd);
$stmt = $pdo->prepare('UPDATE `message` SET `view` = `view` + 1 WHERE `sujet_id` = 37690510');
$stmt->execute();
$number = $stmt->rowCount();

Avec MySQLi, il y a la propriété mysqli#affected_rows

$mysqli = new mysqli($host, $user, $password, $databaseName);
$mysqli->query('UPDATE `message` SET `view` = `view` + 1 WHERE `sujet_id` = 37690510');
$number = $mysqli->affected_rows;

// Ou, avec le style procédural
$mysqli = mysqli_connect($host, $user, $password, $databaseName);
mysqli_query($mysqli, 'UPDATE `message` SET `view` = `view` + 1 WHERE `sujet_id` = 37690510');
$number = mysqli_affected_rows($mysqli);

$mysqli = new mysqli($host, $user, $password, $databaseName);
$mysqli_result = $mysqli->query('SELECT * FROM `message` WHERE `sujet_id` = 37690510');
$number = $mysqli_result->num_rows;

// Ou, avec le style procédural
$mysqli = mysqli_connect($host, $user, $password, $databaseName);
$mysqli_result = mysqli_query($mysqli, 'SELECT * FROM `message` WHERE `sujet_id` = 37690510');
$number = mysqli_num_rows($mysqli_result);

Il faut simplement créer un dossier sessions à la racine du site, et vérifier qu’il soit accessible en lecture, écriture et exécution par l’utilisateur qui fait fonctionner le serveur.

Vous n’avez probablement pas redémarré Apache, ou pas modifié au bon endroit, ou sinon pas modifié le bon fichier.
Il se peut que vous ayez plusieurs versions de PHP sur votre machine, ou que vous ayez modifié un fichier qui n’était pas pour "le bon environnement" (le bon SAPI¹). Il y a cependant moyen de savoir quel fichier modifier rapidement.

Pour votre serveur HTTP (accès par navigateur)

Regardez dans le phpinfo (vous pouvez vous créer une page ne contenant que <?php phpinfo() si besoin) aux lignes suivantes :

• Loaded Configuration File
  Si vous êtes en local et que changer la configuration pour toutes vos applications PHP ne vous pose pas de problème, c’est le fichier à modifier.
  N’oubliez pas de redémarrer Apache après cette modification.

Pour la ligne de commandes

Hé oui, il y a parfois (et même souvent) plusieurs php.ini, un par SAPI. En général, ils ne sont pas nommés de la même manière ou ne sont pas enregistrés au même endroit.

Là, c’est très simple, il suffit de taper une commande qui va directement donner le chemin complet du fichier à modifier : la commande php --ini.
En revanche, il est extrêmement rare que les hébergeurs laissent modifier celui-ci.

Avec l’exécutable binaire symfony

Histoire de faire simple, cet exécutable utilise une version de PHP (et donc du php.ini) qu’il enregistre dans un fichier de configuration, et non pas la configuration prévue pour le terminal/l’invite de commandes. D’une part, lors du lancement de symfony check:requirements, une des premières informations qui s’affiche est le chemin du php.ini à modifier dans ce cas, et d’autre part, le fichier de configuration de l’exécutable binaire peut probablement être modifié/adapté pour que ce soit un autre php.ini qui soit utilisé.

Aussi surprenant que cela puisse paraître, c’est un souci de jeux de caractères et donc de caractères spéciaux.
Le jeu de caractères interne de PHP et celui de votre chaîne à traiter ne sont pas cohérents : vous envoyez des données dans un jeu particulier alors que ces fonctions attendent ou traitent comme s’il s’agissait d’un autre. Ne pouvant traiter la chaîne correctement, elles retournent des valeurs qui vous surprennent.

Ceci concerne les fonctions htmlentities(), html_entity_decode(), htmlspecialchars(), json_encode(), json_decode(), et la plupart des fonctions str*(), qui sont prévues pour retourner des chaînes de caractères dans un jeu précis, et n’acceptent que ce jeu précis comme entrée

En complément, regardez ce message pour d’autres éléments à vérifier en relation avec les jeux de caractères.

Il y a au moins deux possibilités pour gérer cela.

Vérifier le nombre d'occurrences existantes

L'idée est de faire une requête qui va compter dans la base de données le nombre d'occurrences de la valeur. Le test ressemblera à ceci :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

<?php
$declarationRequete = $pdo->prepare(
    'SELECT count(`id`) FROM `une_table` WHERE `la_colonne` = :la_valeur'
);
$declarationRequete->execute(array('la_valeur' => $laValeur));

if ($declarationRequete->fetchColumn() > 0) {
    // On a un ou plusieurs résultats, la valeur ne peut être enregistrée
} else {
    // On n'a aucun résultat, on va pouvoir faire INSERT
}

Notez que si vous avez plus d'un résultat ($declarationRequete->fetchColumn() retourne un nombre plus élevé que 1), vous avez un problème. 

Cette méthode vous permet, en cas de plusieurs valeurs qui doivent être uniques, de savoir exactement lesquelles le le sont pas.
En revanche, elle demande une requête supplémentaire par valeur à garder unique.

Ajouter des index d'unicité sur la ou les colonnes contenant les valeurs qui doivent être uniques

L'idée est que ce ne soit plus vous qui vérifiez l'unicité dans votre programme, mais votre moteur SQL. Ainsi, à l'insertion des données, vous vérifiez si celle-ci s'est bien passée, soit en capturant l'exception levée¹, soit en testant le retour de l'exécution de la requête.

La requête pour ajouter une contrainte d'unicité ressemble à ceci :

1

CREATE UNIQUE INDEX unique_ma_valeur ON `une_table` (`la_colonne`)

La partie PHP, elle, ne change que très peu :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

<?php
$declarationRequete = $pdo->prepare('INSERT INTO `personne` VALUES (NULL, :pseudo, :email)');
$declarationRequete->bindParam('pseudo', $_POST['pseudo']);
$declarationRequete->bindParam('email', $_POST['email']);

// PDO en mode silencieux
if ($declarationRequete->execute()) {
    /* L'insertion s'est effectuée sans problème */
} else {
   /* Il y a eu un problème à l'insertion */
}

// PDO en "mode d'erreur exceptions"
try {
    $declarationRequete->execute();
    /* Le code à partir de cette ligne et avant la 18 ne sera 
     * effectué que si la requête n'a pas généré d'erreur */
} catch(\Exception $e) {
    /* Il y a eu un problème à l'insertion */
}

Vous ne pourrez pas savoir de manière aisée quelle valeur a posé problème, donc cette méthode est plus adaptée à une seule valeur à vérifier.
Cependant, vous n'avez dans tous les cas qu'une seule requête.

Il peut y avoir beaucoup de paramètres à la base de ce problème, mais tous ont un dénominateur commun : la version et les paramètres de PHP.

Comparez un phpinfo() en local et sur le serveur pour voir les différences. Si certaines ne porteront pas nécessairement à conséquence pour votre code, une simple différence de version mineure (le second chiffre) peut poser problème, sans parler des autres paramètres.

Il arrive aussi que la casse pose problème à différents niveaux, que ce soit au niveau du nom des fichiers ou des tables/colonnes de la base de données.

Dans bien des cas, l’activation des messages d’erreur sur le serveur distant reste un bon moyen de savoir ce qu’il se passe et d’avoir des pistes.

Dans un premier temps, vous seriez tentés de l'écrire de cette façon :

1
2
3
4

<?php
$string = 'D:\\wamp\\www\\';
$foo    = preg_replace('/\\/', '/', $string); // A ne pas faire
echo $foo;

Sauf que vous aurez le droit à une erreur du type : Message: preg_replace(): No ending delimiter '/' found.

Il faut, comme indiqué dans la documentation officielle, doubler les antislashs.

1
2
3
4

<?php
$string = 'D:\\wamp\\www\\';
$foo    = preg_replace('/\\\\/', '/', $string);
echo $foo;  # D:/wamp/www/

Edit Ymox

Echappement des antislashes dans la déclaration de $string

Edit viki53

Fix typo

Allez dans le fichier de configuration de PHP php.ini et remplacez la ligne expose_php = On par expose_php = Off.

Vous pouvez utiliser la fonction path() avec le code ci-dessous sur vos liens. Elle ajoutera la partie qui peut varier d’un environnement à l’autre au besoin.

Codez tout comme si vous travailliez à la racine d’un nom de domaine. Vous pouvez ensuite utiliser la fonction path() sur tous vos liens absolus dans votre code PHP/HTML.

<?php
// On récupère les dossiers dans l'URI de la requête
$uri = preg_split('`/|\\\`', $_SERVER['REQUEST_URI'], -1, PREG_SPLIT_NO_EMPTY);

// On regarde ce qu'elle a en commun d'avec le chemin du script
$baseUrl = array_intersect(
    $uri,
    preg_split(
        '`/|\\\`',
        realpath(__DIR__),
        /* Si d'aventure vous utilisez une version de PHP avant 5.3,
         * remplacez __DIR__ ci-dessus par dirname(__FILE__) */
        -1,
        PREG_SPLIT_NO_EMPTY
    )
);
if (count($baseUrl)) {
    // S'il y a des trucs en commun, on se construit une base d'URL
    define('BASE_URL', '/' . implode('/', $baseUrl));
} else {
    // Sinon, c'est qu'on est à la racine de l'hébergement
    define('BASE_URL', '');
}

/**
 * Permet de rendre des liens absolus portables
 * @param string $link Le lien à traiter
 */
function path($link)
{
    // Si on a un URL absolu…
    if (preg_match('`^/`', $link)) {
        // … on ajoute BASE_URL devant.
        $link = BASE_URL . $link;
    }
    // On retourne le lien
    return $link;
}

Par sécurité, les liens relatifs ne devraient pas poser de problème si traités avec cette fonction, donc vous pourriez traiter tous vos liens sans réfléchir, ce que nous ne vous conseillons cependant pas. 

Certaines solutions serveur paramètrent MySQL pour qu’il écoute sur un autre port que le 3306, qui est celui par défaut.

Une des méthodes les plus simples savoir ce qu’il y a à faire est de se connecter à phpMyAdmin.
Rendez-vous sur une page de phpMyAdmin où vous voyez vos tables. Maintenant, regardez en haut de celle-ci, un peu sur la gauche, là où il y a « ← Serveur : … ». La fin de la chaîne est importante. Si vous avez deux points et un nombre (par exemple « … :3325 ») et que ce nombre n’est pas 3306, le SGBD contenant vos tables n’écoute pas sur le port "par défaut" et il faut spécifier cela à la connexion.

Spécifier le port pour le bon SGBD

Les script de connexion utilisent, par exemple :

<?php
$pdo = new PDO('mysql:host=localhost;dbname=database;', 'user', 'password');

$mysqli = new mysqli('localhost', 'user', 'password', 'database');
// Ou en procédural
$mysqli = mysqli_connect('localhost', 'user', 'password', 'database');

Pour se connecter avec un autre port que le 3306, il faut le préciser :

<?php
$pdo = new PDO('mysql:host=localhost;dbname=database'
        . ';port=' . 3325, // Notez bien le point-virgule ;
    'user', 'password');

$mysqli = new mysqli('localhost', 'user', 'password', 'database', 3325);
// Ou en procédural
$mysqli = mysqli_connect('localhost', 'user', 'password', 'database', 3325);

WampServer

Les dernières versions en date de WampServer fournissent deux SGBD : MariaDB et MySQL, et le SGBD fonctionnant sur le port par défaut peut changer. Les deux ne peuvent de toute façon pas écouter sur le même port quand ils fonctionnent en même temps, celui sur le port par défaut n’est donc pas celui où vous avez créé vos bases de données.

Remplacer MySQL par MariaDB et vice-versa

Il existe un outil pour inverser d’un seul clic le SGBD par défaut si les deux sont activés (MySQL et MariaDB), accessible au clic droit sur l’icône de WampServer dans la barre de statut > Outils > Inverser SGBD par défaut…. L’étiquette est complétée par MySQL <-> MariaDB ou MariaDB <-> MySQL selon le SGBD par défaut.

Bien sûr, il vous reste à importer vos bases de données et utilisateurs préalablement sauvegardés.

Désactiver le serveur inutile

Vous n’êtes pas obligé de conserver l’utilisation des deux gestionnaires MySQL et MariaDB, vous pouvez ne conserver que celui qui vous convient et vous pouvez même désactiver totalement les deux gestionnaires de bases de données avec un clic droit sur l’icône de WampServer dans la barre de statut > Paramètres Wamp > décocher soit Autoriser MariaDB, soit Autoriser MySQL

Ce récap est génial et super utile. Merci à tous