Tutorial zur Implementierung monatlicher Datenaktualisierungsbeschränkungen

In diesem Tutorial wird im Detail erläutert, wie die Funktionalität von Benutzerdaten (z. B. Benutzername) in einer Webanwendung implementiert wird, die nur im Monat Änderungen ermöglicht. Wir werden das Design von Datenbankdatumfeldern untersuchen, die datierten Funktion von SQL oder das DateTime -Objekt von SQL verwenden, um Datumsunterschiede zu berechnen, und stellen eine sichere PHP -Code -Implementierung bereit, um sicherzustellen, dass Benutzervorgänge den Geschäftsregeln entsprechen und gleichzeitig Sicherheitsrisiken wie SQL -Injektion verhindern.

Anforderungenanalyse: Implementieren Sie monatliche Änderungsbeschränkungen

In vielen Webanwendungen, um die Datenkonsistenz aufrechtzuerhalten, böswillige und häufige Vorgänge zu verhindern oder die Benutzererfahrung sicherzustellen, müssen Zeitintervallbeschränkungen für bestimmte kritische Vorgänge festgelegt werden (z. B. Änderungen von Benutzernamen, Avataren oder Senden bestimmter Nachrichten). In diesem Tutorial werden "Benutzer nur einmal im Monat nur einmal im Monat geändert" und erläutern ausführlich, wie diese Funktion über die Datenbankdatumfeld- und Datumsvergleichslogik implementiert wird.

Die Kernanforderung lautet: Wenn ein Benutzer versucht, den Benutzernamen zu ändern, muss das System das Datum seiner letzten Änderung überprüfen. Wenn die letzte Änderung weniger als einen Monat beträgt (normalerweise als 30 Tage berechnet), wird die Modifikation abgelehnt. Andernfalls ist die Änderung und das letzte Änderungsdatum zulässig.

Datenbankdesign: NAME_CHANGED -Feld

Um das Datum zu verfolgen, das der Benutzer zuletzt geändert hat, müssen wir der Benutzertabelle ein Datumstyp hinzufügen. In der Tabelle Benutzer- (oder user_db) können Sie beispielsweise ein Datum oder ein DateTime -Feld mit dem Namen namens_Changed hinzufügen.

• Feldname: name_changed
• Datentyp: Datum (nur Speicherdaten) oder DateTime (Speicherdaten und Uhrzeiten mit höherer Genauigkeit)
• Standardwert: Es wird empfohlen, auf NULL oder 0000-00-00 einzustellen. Null ist normalerweise eine bessere Wahl, weil es explizit "nie modifiziert" bedeutet. 0000-00-00 hat in einigen Datenbanksystemen besondere Bedeutungen, wird aber auch häufig als Platzhalter in der Praxis verwendet.

Probentischstruktur (vereinfacht):

 Tabellen Benutzer erstellen (
    ID int auto_increment Primärschlüssel,
    E -Mail Varchar (255) Einzigartige Nicht -NULL,
    Nennen Sie Varchar (255) nicht null,
    Name_Changed Datum Standard NULL - Zeichnen Sie das Datum der Änderung des Nachnamens auf);

Kernlogik: Datumsdifferenzberechnung

Um festzustellen, ob der Benutzer den Namen innerhalb der angegebenen Zeit geändert hat, besteht der Schlüssel darin, die Differenz in der Anzahl der Tage zwischen dem aktuellen und dem zuletzt geänderten Datum zu berechnen. Der einfache Vergleich von Monaten (z. B. $ current_month - $ last_modified_month) ist ungenau, da es die Grenzsituationen des Neujahrs oder des frühen/Ende des Monats nicht bewältigen kann (zum Beispiel wird es am 30. Januar geändert und es darf am 1. Februar erneut geändert werden, aber es ist tatsächlich nur zwei Tage später).

Die richtige Art und Weise besteht darin, die Gesamtzahl der Tage zwischen zwei Daten zu berechnen.

Methode 1: Verwenden Sie die SQL -Datediff -Funktion (empfohlen)

Datenbanksysteme wie MySQL bieten die Funktion des datierten (Datums1, Datums2), mit dem die Differenz in der Anzahl der Tage zwischen zwei Daten berechnet wird. Datediff (Now (), name_Changed) gibt die Anzahl der Tage zwischen dem aktuellen Datum und dem Datum name_Changed zurück.

• Logik:
  • Wenn Name_Changed null oder 0000-00-00 ist, bedeutet dies, dass es nie geändert wurde und eine Änderung zulässig ist.
  • Wenn das Ergebnis von datediff (now (), name_changed) größer oder gleich 30 (oder der Anzahl der Tage zwischen Monaten, die Sie definieren) ist, ist eine Änderung zulässig.
  • Andernfalls Weigerung zu ändern.

Methode 2: PHP DateTime -Objekt führt Datumsberechnung durch

Obwohl SQL -datediff einfach und effizient ist, können auch Datumsberechnungen an der PHP -Anwendungsschicht durchgeführt werden. Dadurch wird das Datum name_changed aus der Datenbank abgerufen und dann mithilfe des DateTime -Objekts von PHP verarbeitet.

• Logik:
  1. Holen Sie sich die Zeichenfolge name_Changed in der Datenbank.
  2. Erstellen Sie ein DateTime -Objekt: $ lastModifiedDate = new DateTime ($ namechangedfromdb);
  3. Erstellen Sie das aktuelle Datum DateTime -Objekt: $ currentDate = new DateTime ();
  4. Berechnen Sie die Datumsdifferenz: $ intervall = $ currentDate-> diff ($ lastModifiedDate);
  5. Erhalten Sie den Unterschied in der Anzahl der Tage: $ Days = $ Intervall-> Tage;
  6. Ein Urteil fällen, das auf Tagen basiert.

PHP -Code -Implementierung

Hier ist ein PHP -Code -Beispiel, das Sicherheitspraktiken und Datumsurteillogik kombiniert. Wir werden PDO für Datenbankvorgänge verwenden, um die SQL -Injektion zu verhindern.

  Php
Session_Start (); // Stellen Sie sicher, dass die Sitzung gestartet wird // Datenbankverbindungskonfiguration $ host = 'localhost';
$ db = 'your_database_name';
$ user = 'your_username';
$ pass = 'your_password';
$ charset = 'utf8mb4';

$ dsn = "MySQL: host = $ host; dbname = $ db; charset = $ charset";
$ options = [
    Pdo :: attr_errmode => pdo :: errmode_exception,
    Pdo :: attr_default_fetch_mode => pdo :: fetch_assoc,
    Pdo :: attr_emulate_prepares => false,
];

versuchen {
    $ pdo = new pdo ($ dsn, $ user, $ pass, $ options);
} catch (\ pdoException $ e) {
    Wurf neu \ pdoException ($ e-> getMessage (), (int) $ e-> getCode ());
}

$ fehler = [];
$ success_message = '';

if (isset ($ _ post ['name']) &&! leer ($ _ post ['name'])) {
    $ newname = trim ($ _ post ['name']);
    $ useremail = $ _Session ['E -Mail'] ?? Null; // Angenommen, die Benutzer -E -Mail wird in der Sitzung gespeichert, wenn (! $ Useremail) {
        $ fehler [] = "Der Benutzer ist nicht angemeldet oder die Sitzung ist abgelaufen.";
    } elseif (strlen ($ newname)  20) {
        $ fehler [] = "Der Name muss zwischen 2 und 20 Zeichen lang sein.";
    } anders {
        // 1. Holen Sie sich das aktuelle Name des Benutzers name_changed $ STMT = $ PDO-> PREPET ("NAME_CHANGED VON UNSERE WOHEN, Wobei E-Mail =: E-Mail");
        $ stmt-> execute ([': mail' => $ useremail]);
        $ userInfo = $ stmt-> fetch ();

        if ($ userInfo) {
            $ lastChangedDate = $ userInfo ['name_changed'];

            // 2. Bestimmen Sie, ob $ canchange = false zulässig ist;
            if (leer ($ last changedDate) || $ lastChangedDate === '0000-00-00') {
                // nie geändert, $ canchange = true;
            } anders {
                // Datumsunterschiede berechnen (mit SQL -Datediff)
                $ stmt = $ pdo-> vorbereiten ("SELECT DATIFT (NOW (),: LastChangedDate) als DAY_DIFF");
                $ stmt-> execute ([': lastChangedDate' => $ lastChangedDate]);
                $ result = $ stmt-> fetch ();
                $ DAYDIFF = $ result ['Days_diff'];

                if ($ DaysDiff> = 30) {// Änderung von $ canchange = true nach 30 Tagen oder mehr;
                } anders {
                    $ fehler [] = "Sie können Ihren Namen nur einmal im Monat ändern. Bitte versuchen Sie es erneut in". (30 - $ DaysDiff). "Diremen versuchen es erneut.";
                }

                /*
                // oder verwenden Sie PHP DateTime, um $ lastModifiedDatetime = new DateTime ($ lastChangedDate) zu berechnen;
                $ currentDateTime = new DateTime ();
                $ intervall = $ currentDatetime-> diff ($ lastModifiedDatetime);
                $ DAYDIFFPHP = $ Intervall-> Tage;

                if ($ DAYDIFFPHP> = 30) {
                    $ canchange = true;
                } anders {
                    $ fehler [] = "Sie können Ihren Namen nur einmal im Monat ändern. Bitte versuchen Sie es erneut in". (30 - $ DaysDiffphp). "Diremen versuchen es erneut.";
                }
                */
            }

            // 3.. Führen Sie die Änderungsoperation durch, wenn ($ canchange) {
                $ stmt = $ pdo-> vorbereiten ("Benutzer set name =: name, name_changed = curdate () wobei E-Mail =: E-Mail");
                $ updateresult = $ stmt-> execute ([
                    ': name' => $ newname,
                    ': E -Mail' => $ useremail
                ]);

                if ($ updateresult) {
                    $ success_message = "Namensänderung war erfolgreich!";
                } anders {
                    $ fehler [] = "Namensänderung fehlgeschlagen, bitte versuchen Sie es später erneut.";
                }
            }
        } anders {
            $ fehler [] = "Benutzerinformationen nicht gefunden.";
        }
    }
}
?>



<kopf>
    <meta charset="utf-8">
    <title> Name des Namens </title>
    <styles>
        .Error {Farbe: rot; }
        .Success {Farbe: grün; }
    


    <h1> Namen </h1> ändern

     php if (! leer ($ fehler):?>
        <div class="error">
             php foreach ($ fehler als $ error):?>
                <p>  Php echo htmlSpecialChars ($ error); ?> </p>
             Php Endforeach; ?>
        </div>
     Php Endif; ?>

     php if (! leer ($ success_message):?>
        <div class="success">
            <p>  php echo htmlspecialChars ($ success_message); ?> </p>
        </div>
     Php Endif; ?>

    <form action="" method="post">
        <label f> Neuer Name: </label>
        <eingabe type="text" id="name" name="name" erforderlich minlength="2" maxlength="20">
        <br> <br>
        <eingabe type="surug" name="name" value="Name modifizieren">
    </eingabe></eingabe>
</form>

</styles></kopf>

Das obige ist der detaillierte Inhalt vonTutorial zur Implementierung monatlicher Datenaktualisierungsbeschränkungen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!