Come impedire il reinvio del modulo quando la pagina viene aggiornata (F5 / CTRL + R)

Ho un semplice modulo che invia testo alla mia tabella SQL. Il problema è che dopo che l'utente ha inviato il testo, può aggiornare la pagina e i dati vengono inviati nuovamente senza riempire nuovamente il modulo. Potrei reindirizzare l'utente su un'altra pagina dopo l'invio del testo, ma voglio che gli utenti rimangano sulla stessa pagina.

Ricordo di aver letto qualcosa su come dare a ciascun utente un ID di sessione univoco e di averlo confrontato con un altro valore che ha risolto il problema che sto riscontrando ma ho dimenticato dove si trova.

Usa il modello Pubblica / Reindirizza / Ottieni. http://en.wikipedia.org/wiki/Post/Redirect/Get

Con il mio sito Web, memorizzerò un messaggio in un cookie o in una sessione, reindirizzerò dopo il post, leggerò il cookie / la sessione e quindi cancellerò il valore di quella sessione o variabile del cookie.

Vorrei anche sottolineare che è possibile utilizzare un approccio javascript, window.history.replaceStateper impedire un reinvio sul pulsante Aggiorna e Indietro.

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

Prova del concetto qui: https://dtbaker.net/files/prevent-post-resubmit.php

Consiglierei comunque un approccio Post / Redirect / Get, ma questa è una nuova soluzione JS.

Dovresti davvero utilizzare un modello Ottieni reindirizzamento post per gestirlo, ma se in qualche modo sei finito in una posizione in cui PRG non è praticabile (ad es. Il modulo stesso è incluso, prevenendo i reindirizzamenti) puoi eseguire l'hashing di alcuni parametri della richiesta per creare una stringa in base al contenuto e quindi verificare di non averla già inviata.

//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!
    }

Uso questa riga javascript per bloccare il pop-up che richiede il reinvio del modulo al momento dell'aggiornamento del modulo.

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

Posiziona questa riga in fondo al file e osserva la magia

È possibile impedire il reinvio del modulo tramite una variabile di sessione.

Per prima cosa devi impostare rand()in una casella di testo e $_SESSION['rand']nella pagina del modulo:

<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>

Dopodiché controlla $_SESSION['rand']con il $_POST['randcheck']valore della casella di testo come questo:

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

Quando il modulo viene elaborato, reindirizza a un'altra pagina:

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

puoi anche reindirizzare alla stessa pagina.

se stai facendo qualcosa come commenti e vuoi che l'utente rimanga sulla stessa pagina, puoi usare Ajax per gestire l'invio del modulo

Ho trovato la soluzione alternativa successiva. È possibile evitare il reindirizzamento dopo l'elaborazione della POSTrichiesta manipolando l' historyoggetto.

Quindi hai il modulo HTML:

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

Quando elabori questo modulo sul tuo server invece di reindirizzare l'utente /the/result/pageimpostando l' Locationintestazione in questo modo:

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

Dopo aver elaborato i POSTdati renderli piccoli <script>e il risultato/the/result/page

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

La <script>si dovrebbe render:

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

Il risultato è:

come puoi vedere, i dati del modulo vengono modificati POSTnello process.phpscript.
Questo script ha elaborato i POSTdati e il rendering /the/result/pagecontemporaneamente con:

1. nessun reindirizzamento
2. nessun POSTdato relativo all'aggiornamento della pagina (F5)
3. no POSTquando si passa alla pagina precedente / successiva attraverso la cronologia del browser

UPD

Come altra soluzione, chiedo alla funzione di richiedere al team Mozilla FireFox di consentire agli utenti di impostare l' NextPageintestazione che funzionerà come Locationintestazione e renderà post/redirect/getobsoleto lo schema.

In breve. Quando il server elabora POSTcorrettamente i dati del modulo :

1. Imposta NextPageintestazione invece diLocation
2. Rendering del risultato dell'elaborazione dei POSTdati del modulo come verrebbe visualizzato per la GETrichiesta nel post/redirect/getmodello

Il browser a sua volta quando vedi l' NextPageintestazione:

1. Regola window.locationcon NextPagevalore
2. Quando l'utente aggiorna la pagina, il browser negozia la GETrichiesta NextPageanziché riformulare i POSTdati

Penso che questo sarebbe eccellente se implementato, no? =)

1. Usa l'intestazione e reindirizza la pagina.

   header("Location:your_page.php"); Puoi reindirizzare alla stessa pagina o pagina diversa.

2. Disinserire $ _POST dopo averlo inserito nel database.

   unset($_POST);

Un modo abbastanza sicuro è implementare un ID univoco nel post e memorizzarlo nella cache

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

Quindi nel tuo codice fai questo:

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;
}

Questo metodo funziona bene per me e penso che questo sia il più semplice per fare questo lavoro.

L'idea generale è di reindirizzare l'utente ad alcune altre pagine dopo l'invio del modulo, che interromperebbe il reinvio del modulo all'aggiornamento della pagina. Tuttavia, se è necessario mantenere l'utente sulla stessa pagina dopo l'invio del modulo, è possibile farlo in diversi modi, ma qui sto descrivendo il metodo javascript.

Metodo Javascript

Questo metodo è abbastanza semplice e blocca il pop-up che richiede il reinvio del modulo all'aggiornamento dopo l'invio del modulo. Basta posizionare questa riga di codice javascript in fondo al file e vedere la magia.

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

Javascript

Questo metodo è abbastanza semplice e blocca il pop-up che richiede il reinvio del modulo all'aggiornamento dopo l'invio del modulo. Basta posizionare questa riga di codice javascript in fondo al file e vedere la magia.

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

Basta reindirizzarlo alla stessa pagina dopo aver utilizzato i dati del modulo e funziona. L'ho provato

header('location:yourpage.php');

Una versione raffinata del post di Moob. Crea un hash del POST, salvalo come cookie di sessione e confronta gli hash in ogni sessione.

// 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
}

Fondamentalmente, è necessario reindirizzare da quella pagina, ma può comunque creare un problema mentre Internet è lenta (reindirizzamento dell'intestazione dal lato server)

Esempio di scenario di base:

Fare clic sul pulsante Invia due volte

Modo di risolvere

• Dalla parte del cliente

  • Disabilita il pulsante di invio dopo che il client ha fatto clic su di esso
  • Se si utilizza Jquery: Jquery.one
  • Modello PRG

• Lato server

  • Utilizzo di data / ora di hashing differenziate in base alla data di invio della richiesta.
  • Token di richiesta. Quando il principale si carica, assegnare una richiesta temporanea che, se ripetuta, viene ignorata.

Come prevenire il reinvio del modulo php senza reindirizzamento. Se stai usando $ _SESSION (dopo session_start) e un modulo $ _POST, puoi fare qualcosa del genere:

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

Nel modulo HTML inserisci questo:

<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;
    }
}
?>

Pertanto, ogni volta che viene inviato il modulo, viene generato un nuovo atto, archiviato in sessione e confrontato con l'atto postale.

Ps: se stai usando un modulo Get, puoi facilmente cambiare tutto il POST con GET e funziona anche.

Dopo averlo inserito nel database, chiamare il metodo unset () per cancellare i dati.

unset ($ _ POST);

Per impedire l'inserimento di dati di aggiornamento, eseguire un reindirizzamento della pagina sulla stessa pagina o su una pagina diversa dopo l'inserimento del record.

intestazione ( 'Località' $ _ SERVER [ 'PHP_SELF'].);

Usare la risposta Post / Redirect / Get pattern da Keverw è una buona idea. Tuttavia, non sei in grado di rimanere sulla tua pagina (e penso che questo fosse ciò che stavi chiedendo?) Inoltre, a volte potrebbe non riuscire :

Se un utente Web si aggiorna prima che l'invio iniziale sia stato completato a causa di un ritardo del server, il risultato è una richiesta POST HTTP duplicata in determinati agenti utente.

Un'altra opzione sarebbe quella di archiviare in una sessione se il testo dovesse essere scritto nel tuo database SQL in questo modo:

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

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

Come altri hanno già detto, non è possibile smettere di usare post / redirect / get. Ma allo stesso tempo è abbastanza facile fare ciò che vuoi sul lato server.

Nella tua pagina POST convalidi semplicemente l'input dell'utente ma non agisci su di esso, ma lo copi in un array SESSION. Quindi reindirizza nuovamente alla pagina di invio principale. La pagina di invio principale inizia controllando se esiste l'array SESSION che si sta utilizzando e, in tal caso, copiarlo in un array locale e annullarlo. Da lì puoi agire su di esso.

In questo modo fai tutto il lavoro principale una volta sola, raggiungendo ciò che vuoi fare.

Successivamente ho cercato una soluzione per impedire il reinvio in un grande progetto. Il codice funziona perfettamente con $ _GET e $ _POST e non posso modificare il comportamento degli elementi del modulo senza il rischio di bug imprevisti. Quindi, ecco il mio codice:

<!-- 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"] );

Funziona solo per evitare il reinvio di $ _POST, non $ _GET. Ma questo è il comportamento di cui ho bisogno. Il problema di reinvio non funziona con i caricamenti di file!

Ciò che funziona per me è:

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;
}

?>

E nella tua forma

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



 </form>

Questo form.phpesempio mostra come utilizzare PRG corretto (quando il modulo è valido o meno).

• Reindirizza alla stessa pagina, solo quando il modulo è valido e l'azione è stata eseguita.
• Il reindirizzamento protegge il modulo dal reinvio all'aggiornamento della pagina.
• Usa la sessione per non perdere i messaggi di successo che vuoi mostrare quando il modulo è valido.
• Esistono due pulsanti per il test: "Invio valido", "Invio non valido". Prova entrambi e aggiorna la pagina dopo.

<?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();
}

Perché non usare semplicemente la $_POST['submit']variabile come un'istruzione logica per salvare qualunque cosa sia nel modulo. Puoi sempre reindirizzare alla stessa pagina (Nel caso in cui si aggiornino e quando colpiscono go backnel browser, la variabile di invio dei post non verrebbe più impostata. Assicurati solo che il tuo pulsante di invio abbia un namee iddi submit.