Comment empêcher une nouvelle soumission de formulaire lorsque la page est actualisée (F5 / CTRL + R)

J'ai un formulaire simple qui soumet du texte à ma table SQL. Le problème est qu'après que l'utilisateur a soumis le texte, il peut actualiser la page et les données sont à nouveau soumises sans remplir à nouveau le formulaire. Je pourrais rediriger l'utilisateur vers une autre page une fois le texte soumis, mais je souhaite que les utilisateurs restent sur la même page.

Je me souviens avoir lu quelque chose sur le fait de donner à chaque utilisateur un identifiant de session unique et de le comparer avec une autre valeur qui a résolu le problème que je rencontre, mais j'ai oublié où il se trouve.

Utilisez le modèle Post / Redirection / Get. http://en.wikipedia.org/wiki/Post/Redirect/Get

Avec mon site Web, je vais stocker un message dans un cookie ou une session, rediriger après la publication, lire le cookie / session, puis effacer la valeur de cette session ou variable de cookie.

Je tiens également à souligner que vous pouvez utiliser une approche javascript, window.history.replaceStatepour empêcher une nouvelle soumission sur le bouton d'actualisation et de retour.

<script>
    if ( window.history.replaceState ) {
        window.history.replaceState( null, null, window.location.href );
    }
</script>

Preuve de concept ici: https://dtbaker.net/files/prevent-post-resubmit.php

Je recommanderais toujours une approche Post / Redirection / Get, mais il s'agit d'une nouvelle solution JS.

Vous devriez vraiment utiliser un modèle Post Redirect Get pour gérer cela, mais si vous vous êtes retrouvé dans une position où PRG n'est pas viable (par exemple, le formulaire lui-même est dans un include, ce qui empêche les redirections), vous pouvez hacher certains des paramètres de la requête pour créer une chaîne basée sur le contenu, puis vérifiez que vous ne l'avez pas déjà envoyée.

//create digest of the form submission:

    $messageIdent = md5($_POST['name'] . $_POST['email'] . $_POST['phone'] . $_POST['comment']);

//and check it against the stored value:

    $sessionMessageIdent = isset($_SESSION['messageIdent'])?$_SESSION['messageIdent']:'';

    if($messageIdent!=$sessionMessageIdent){//if its different:          
        //save the session var:
            $_SESSION['messageIdent'] = $messageIdent;
        //and...
            do_your_thang();
    } else {
        //you've sent this already!
    }

J'utilise cette ligne javascript pour bloquer la fenêtre contextuelle demandant une nouvelle soumission de formulaire lors de l'actualisation une fois le formulaire soumis.

if ( window.history.replaceState ) {
  window.history.replaceState( null, null, window.location.href );
}

Placez simplement cette ligne au pied de votre fichier et voyez la magie

Vous pouvez empêcher la nouvelle soumission de formulaire via une variable de session.

Vous devez d'abord définir rand()dans une zone de texte et $_SESSION['rand']sur la page du formulaire:

<form action="" method="post">
  <?php
   $rand=rand();
   $_SESSION['rand']=$rand;
  ?>
 <input type="hidden" value="<?php echo $rand; ?>" name="randcheck" />
   Your Form's Other Field 
 <input type="submit" name="submitbtn" value="submit" />
</form>

Après cela, vérifiez $_SESSION['rand']avec la $_POST['randcheck']valeur de la zone de texte comme ceci:

if(isset($_POST['submitbtn']) && $_POST['randcheck']==$_SESSION['rand'])
{
    // Your code here
}

Lorsque le formulaire est traité, vous redirigez vers une autre page:

... process complete....
header('Location: thankyou.php');

vous pouvez également rediriger vers la même page.

si vous faites quelque chose comme des commentaires et que vous voulez que l'utilisateur reste sur la même page, vous pouvez utiliser Ajax pour gérer la soumission du formulaire

J'ai trouvé la prochaine solution de contournement. Vous pouvez échapper à la redirection après le traitement de la POSTdemande en manipulant l' historyobjet.

Vous avez donc le formulaire HTML:

<form method=POST action='/process.php'>
 <input type=submit value=OK>
</form>

Lorsque vous traitez ce formulaire sur votre serveur, vous au lieu de rediriger l'utilisateur vers /the/result/pageen configurant l'en- Locationtête comme ceci:

$cat process.php
<?php 
     process POST data here
     ... 
     header('Location: /the/result/page');
     exit();
?>

Après avoir traité les POSTdonnées ed, vous rendez petit <script>et le résultat/the/result/page

<?php 
     process POST data here
     render the <script>         // see below
     render `/the/result/page`   // OK
?>

Le <script>vous devriez rendre:

<script>
    window.onload = function() {
        history.replaceState("", "", "/the/result/page");
    }
</script>

Le résultat est:

comme vous pouvez le voir, les données du formulaire sont POSTéditées en process.phpscript.
Ce script a traité les POSTdonnées et le rendu /the/result/pageà la fois avec:

1. pas de redirection
2. pas de POSTdonnées lorsque vous actualisez la page (F5)
3. non POSTlorsque vous accédez à la page précédente / suivante dans l'historique du navigateur

UPD

Comme autre solution, je demande à l' équipe Mozilla FireFox de demander aux utilisateurs de configurer un en- NextPagetête qui fonctionnera comme un en- Locationtête et rendra le post/redirect/getmodèle obsolète.

En bref. Lorsque le serveur traite POSTcorrectement les données du formulaire :

1. En- NextPagetête de configuration au lieu deLocation
2. Rendre le résultat du traitement des POSTdonnées du formulaire comme il le rendrait pour la GETdemande dans le post/redirect/getmodèle

Le navigateur à son tour quand voir l'en- NextPagetête:

1. Ajuster window.locationavec NextPagevaleur
2. Lorsque l'utilisateur actualise la page, le navigateur négocie la GETdemande au NextPagelieu de reformuler les POSTdonnées

Je pense que ce serait excellent si mis en œuvre, n'est-ce pas? =)

1. Utilisez l'en-tête et redirigez la page.

   header("Location:your_page.php"); Vous pouvez rediriger vers la même page ou une page différente.

2. Désélectionnez $ _POST après l'avoir inséré dans la base de données.

   unset($_POST);

Un moyen assez sûr est d'implémenter un identifiant unique dans la publication et de le mettre en cache dans le

<input type='hidden' name='post_id' value='".createPassword(64)."'>

Ensuite, dans votre code, procédez comme suit:

if( ($_SESSION['post_id'] != $_POST['post_id']) )
{
    $_SESSION['post_id'] = $_POST['post_id'];
    //do post stuff
} else {
    //normal display
}

function createPassword($length)
{
    $chars = "abcdefghijkmnopqrstuvwxyz023456789";
    srand((double)microtime()*1000000);
    $i = 0;
    $pass = '' ;

    while ($i <= ($length - 1)) {
        $num = rand() % 33;
        $tmp = substr($chars, $num, 1);
        $pass = $pass . $tmp;
        $i++;
    }
    return $pass;
}

Cette méthode fonctionne bien pour moi, et je pense que c'est la plus simple pour faire ce travail.

L'idée générale est de rediriger l'utilisateur vers d'autres pages après la soumission du formulaire, ce qui arrêterait la nouvelle soumission du formulaire lors de l'actualisation de la page. Néanmoins, si vous devez maintenir l'utilisateur sur la même page après l'envoi du formulaire, vous pouvez le faire de plusieurs manières, mais je décris ici la méthode javascript.

Méthode Javascript

Cette méthode est assez simple et bloque la fenêtre contextuelle demandant une nouvelle soumission du formulaire lors de l'actualisation une fois le formulaire soumis. Placez simplement cette ligne de code javascript au pied de votre fichier et voyez la magie.

<script>
if ( window.history.replaceState ) {
  window.history.replaceState( null, null, window.location.href );
}
</script>

Javascript

Cette méthode est assez simple et bloque la fenêtre contextuelle demandant une nouvelle soumission du formulaire lors de l'actualisation une fois le formulaire soumis. Placez simplement cette ligne de code javascript au pied de votre fichier et voyez la magie.

<script>
    if ( window.history.replaceState ) {
        window.history.replaceState( null, null, window.location.href );
    }
</script>

Redirigez-le simplement vers la même page après avoir utilisé les données du formulaire, et cela fonctionne. J'ai essayé.

header('location:yourpage.php');

Une version raffinée du post de Moob. Créez un hachage du POST, enregistrez-le en tant que cookie de session et comparez les hachages à chaque session.

// Optionally Disable browser caching on "Back"
header( 'Cache-Control: no-store, no-cache, must-revalidate' );
header( 'Expires: Sun, 1 Jan 2000 12:00:00 GMT' );
header( 'Last-Modified: ' . gmdate('D, d M Y H:i:s') . 'GMT' );

$post_hash = md5( json_encode( $_POST ) );

if( session_start() )
{
    $post_resubmitted = isset( $_SESSION[ 'post_hash' ] ) && $_SESSION[ 'post_hash' ] == $post_hash;
    $_SESSION[ 'post_hash' ] = $post_hash;
    session_write_close();
}
else
{
    $post_resubmitted = false;
}

if ( $post_resubmitted ) {
  // POST was resubmitted
}
else
{
  // POST was submitted normally
}

Fondamentalement, vous devez rediriger hors de cette page, mais cela peut toujours poser un problème lorsque votre connexion Internet ralentit (rediriger l'en-tête depuis le serveur)

Exemple de scénario de base:

Cliquez deux fois sur le bouton Soumettre

Façon de résoudre

• Côté client

  • Désactiver le bouton de soumission une fois que le client a cliqué dessus
  • Si vous utilisez Jquery: Jquery.one
  • Modèle PRG

• Du côté serveur

  • Utilisation de l'horodatage / horodatage de hachage basé sur la différenciation lorsque la demande a été envoyée.
  • Jetons de requête utilisateur. Lorsque le principal se charge, attribuez un jeton de demande temporaire qui, s'il est répété, est ignoré.

Comment empêcher une nouvelle soumission de formulaire php sans redirection. Si vous utilisez $ _SESSION (après session_start) et un formulaire $ _POST, vous pouvez faire quelque chose comme ceci:

if ( !empty($_SESSION['act']) && !empty($_POST['act']) && $_POST['act'] == $_SESSION['act'] ) {
  // do your stuff, save data into database, etc
}

Dans votre formulaire html, mettez ceci:

<input type="hidden" id="act" name="act" value="<?php echo ( empty($_POST['act']) || $_POST['act']==2 )? 1 : 2; ?>">
<?php
if ( $_POST['act'] == $_SESSION['act'] ){
    if ( empty( $_SESSION['act'] ) || $_SESSION['act'] == 2 ){
        $_SESSION['act'] = 1;
    } else {
        $_SESSION['act'] = 2;
    }
}
?>

Ainsi, à chaque fois que le formulaire est soumis, un nouvel acte est généré, stocké en session et comparé au post acte.

Ps: si vous utilisez un formulaire Get, vous pouvez facilement modifier tous les POST avec GET et cela fonctionne aussi.

Après l'avoir inséré dans la base de données, appelez la méthode unset () pour effacer les données.

unset ($ _ POST);

Pour empêcher l'insertion de données d'actualisation, effectuez une redirection de page vers la même page ou une page différente après l'insertion de l'enregistrement.

header ('Location:'. $ _ SERVER ['PHP_SELF']);

L'utilisation du modèle Post / Redirection / Get de Keverw est une bonne idée. Cependant, vous ne parvenez pas à rester sur votre page (et je pense que c'est ce que vous demandiez?) De plus, cela peut parfois échouer :

Si un utilisateur Web s'actualise avant la fin de la soumission initiale en raison d'un retard du serveur, ce qui entraîne une demande HTTP POST dupliquée dans certains agents utilisateurs.

Une autre option serait de stocker dans une session si le texte doit être écrit dans votre base de données SQL comme ceci:

if($_SERVER['REQUEST_METHOD'] != 'POST')
{
  $_SESSION['writeSQL'] = true;
}
else
{
  if(isset($_SESSION['writeSQL']) && $_SESSION['writeSQL'])
  {
    $_SESSION['writeSQL'] = false;

    /* save $_POST values into SQL */
  }
}

Comme d'autres l'ont dit, il n'est pas possible de ne plus utiliser post / redirect / get. Mais en même temps, il est assez facile de faire ce que vous voulez faire côté serveur.

Dans votre page POST, vous validez simplement l'entrée utilisateur mais n'agissez pas dessus, vous la copiez dans un tableau SESSION. Vous redirigez ensuite vers la page de soumission principale à nouveau. Votre page de soumission principale commence par vérifier si le tableau SESSION que vous utilisez existe, et si c'est le cas, copiez-le dans un tableau local et désactivez-le. À partir de là, vous pouvez agir en conséquence.

De cette façon, vous ne faites tout votre travail principal qu'une seule fois, réalisant ce que vous voulez faire.

J'ai cherché une solution pour empêcher une nouvelle soumission dans un énorme projet par la suite. Le code fonctionne très bien avec $ _GET et $ _POST et je ne peux pas changer le comportement des éléments de formulaire sans risque de bogues imprévus. Alors, voici mon code:

<!-- language: lang-php -->
<?php

// Very top of your code:

// Start session:
session_start();

// If Post Form Data send and no File Upload
if ( empty( $_FILES ) && ! empty( $_POST ) ) {
    // Store Post Form Data in Session Variable
    $_SESSION["POST"] = $_POST;
    // Reload Page if there were no outputs
    if ( ! headers_sent() ) {
        // Build URL to reload with GET Parameters
        // Change https to http if your site has no ssl
        $location = "https://" . $_SERVER['HTTP_HOST'] . $_SERVER['REQUEST_URI'];
        // Reload Page
        header( "location: " . $location, true, 303 );
        // Stop any further progress
        die();
    }
}

// Rebuilt POST Form Data from Session Variable
if ( isset( $_SESSION["POST"] ) ) {
    $_POST = $_SESSION["POST"];
    // Tell PHP that POST is sent
    $_SERVER['REQUEST_METHOD'] = 'POST';
}

// Your code:
?><html>
    <head>
        <title>GET/POST Resubmit</title>
    </head>
    <body>

    <h1>Forms:</h1>
    <h2>GET Form:</h2>
    <form action="index.php" method="get">
        <input type="text" id="text_get" value="test text get" name="text_get"/>
        <input type="submit" value="submit">
    </form>
    <h2>POST Form:</h2>
    <form action="index.php" method="post">
        <input type="text" id="text_post" value="test text post" name="text_post"/>
        <input type="submit" value="submit">
    </form>
    <h2>POST Form with GET action:</h2>
    <form action="index.php?text_get2=getwithpost" method="post">
        <input type="text" id="text_post2" value="test text get post" name="text_post2"/>
        <input type="submit" value="submit">
    </form>
    <h2>File Upload Form:</h2>
    <form action="index.php" method="post" enctype="multipart/form-data">
        <input type="file" id="file" name="file">
        <input type="submit" value="submit">
    </form>

    <h1>Results:</h1>
    <h2>GET Form Result:</h2>
    <p>text_get: <?php echo $_GET["text_get"]; ?></p>
    <h2>POST Form Result:</h2>
    <p>text_post: <?php echo $_POST["text_post"]; ?></p>
    <h2>POST Form with GET Result:</h2>
    <p>text_get2: <?php echo $_GET["text_get2"]; ?></p>
    <p>text_post2: <?php echo $_POST["text_post2"]; ?></p>
    <h2>File Upload:</h2>
    <p>file:
    <pre><?php if ( ! empty( $_FILES ) ) {
            echo print_r( $_FILES, true );
        } ?></pre>
    </p>
    <p></p>
    </body>
    </html><?php
// Very Bottom of your code:
// Kill Post Form Data Session Variable, so User can reload the Page without sending post data twice
unset( $_SESSION["POST"] );

Cela fonctionne uniquement pour éviter la nouvelle soumission de $ _POST, pas de $ _GET. Mais c'est le comportement dont j'ai besoin. Le problème de nouvelle soumission ne fonctionne pas avec les téléchargements de fichiers!

Ce qui fonctionne pour moi est:

if ( !refreshed()) {
   //Your Submit Here
        if (isset( $_GET['refresh'])) {
            setcookie("refresh",$_GET['refresh'], time() + (86400 * 5), "/");
        }

    }    
}


function refreshed()
{
    if (isset($_GET['refresh'])) {
        $token = $_GET['refresh'];
        if (isset($_COOKIE['refresh'])) {
            if ($_COOKIE['refresh'] != $token) {
                return false;
            } else {
                return true;
            }
        } else {
            return false;
        }
    } else {
        return false;
    }
}  


function createToken($length) {
    $characters = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
    $charactersLength = strlen($characters);
    $randomString = '';
    for ($i = 0; $i < $length; $i++) {
        $randomString .= $characters[rand(0, $charactersLength - 1)];
    }
    return $randomString;
}

?>

Et dans votre forme

 <form  action="?refresh=<?php echo createToken(3)?>">



 </form>

Cet form.phpexemple montre comment utiliser PRG correctement (lorsque le formulaire est valide ou non).

• Il redirige vers la même page, uniquement lorsque le formulaire est valide et qu'une action a été effectuée.
• La redirection empêche le formulaire d'être resoumis lors de l'actualisation de la page.
• Il utilise la session pour ne pas perdre les messages de réussite que vous souhaitez afficher lorsque le formulaire est valide.
• Il y a deux boutons pour tester: "Soumettre valide", "Soumettre invalide". Essayez les deux et actualisez la page après cela.

<?php
session_start();

function doSelfRedirect()
{
  header('Location:'.$_SERVER['PHP_SELF']);
  exit;
}

function setFlashMessage($msg)
{
  $_SESSION['message'] = $msg;
}

function getFlashMessage()
{
  if (!empty($_SESSION['message'])) {
    $msg = $_SESSION['message'];
    unset($_SESSION['message']);
  } else {
    $msg = null;
  }

  return $msg;
}

if ($_SERVER['REQUEST_METHOD'] === 'POST') {
  // Validation primitive example.
  if (empty($_POST['valid'])) {
    $formIsValid = false;
    setFlashMessage('Invalid form submit');
  } else {
    $formIsValid = true;
  }

  if ($formIsValid) {
    // Perform any actions here.
    // ...

    // Cool!
    setFlashMessage('Form is valid. Action performed.');

    // Prevent form resubmission.
    doSelfRedirect();
  }
}
?>
<h1>Hello form</h1>

<?php if ($msg = getFlashMessage()): ?>
  <div><?= $msg ?></div>
<?php endif; ?>

<form method="post">
  <input type="text" name="foo" value="bar"><br><br>
  <button type="submit" name="invalid" value="0">Invalid submit</button>
  <button type="submit" name="valid" value="1">Valid submit</button>
</form>

if (($_SERVER['REQUEST_METHOD'] == 'POST') and (isset($_SESSION['uniq']))){
    if($everything_fine){
        unset($_SESSION['uniq']);
    }
}
else{
    $_SESSION['uniq'] = uniqid();
}

Pourquoi ne pas simplement utiliser la $_POST['submit']variable comme une instruction logique afin de sauvegarder tout ce qui se trouve dans le formulaire. Vous pouvez toujours rediriger vers la même page (au cas où ils s'actualiseraient et lorsqu'ils frapperaientgo back au navigateur, la variable d'envoi de message ne serait plus définie. Assurez-vous simplement que votre bouton d'envoi a un nameet idde submit.