3. Göm "Snabbtangenterna".

I den andra lektionen kommer vi att skriva ytterligare två klasser och avsluta den interna delen av manuset helt.

Planen

Målet med denna handledningsserie är att skapa en enkel applikation som låter användare registrera sig, logga in, logga ut och ändra inställningar. Klassen som kommer att innehålla all information om användaren kommer att kallas User och den kommer att definieras i User.class.php-filen. Klassen som kommer att ansvara för in-/utgången kommer att heta UserTools (UserTools.class.php).

Lite om klassnamn

Den korrekta tonen är att namnge klassfiler med samma namn som själva klassen. På så sätt är det lätt att avgöra syftet med varje fil i klassmappen.

Det är också vanligt att lägga till .class eller .inc i slutet av klassfilnamnet. Därför definierar vi tydligt syftet med filen och kan använda .htaccess för att begränsa åtkomsten till dessa filer.

Användarklass (User.class.php)

Denna klass kommer att definiera varje användare. När denna applikation växer kan definitionen av "användare" ändras avsevärt. Lyckligtvis gör OOP-programmering det enkelt att lägga till ytterligare användarattribut.

Konstruktör

I den här klassen kommer vi att använda konstruktorn - det här är en funktion som automatiskt anropas när nästa kopia av klassen skapas. Detta gör att vi automatiskt kan publicera vissa attribut efter att projektet har skapats. I den här klassen kommer konstruktorn att ta ett enda argument: en associativ array som innehåller en rad från användartabellen i vår databas.

require_once "db.class.php"; class User ( public $id; public $username; public $hashedPassword; public $email;
public $joinDate;
//Konstruktör anropas när ett nytt objekt skapas//Tar en associativ array med DB-raden som argument. funktion __construct($data) ( $this->id = (isset($data["id"])) ? $data["id"] : ""; $this->username = (isset($data[" användarnamn"])) ? $data["användarnamn"] : ""; $this->hashedPassword = (isset($data["lösenord"])) ? $data["lösenord"] : ""; $this- >email = (isset($data["email"])) ? $data["email"] : ""; $this->joinDate = (isset($data["join_date"])) ? $data[" join_date"] : ""; )
public function save($isNewUser = false) ( //skapa ett nytt databasobjekt. $db = new DB(); //om användaren redan är registrerad och vi //bara uppdaterar deras information. if(!$isNewUser ) ( //ställ in datamatrisen $data = array("username" => ""$this->användarnamn", "lösenord" => ""$this->hashedPassword",
"email" => ""$this->e-post"");
//uppdatera raden i databasen $db->update($data, "users", "id = ".$this->id); )else ( //om användaren registreras för första gången. $data = array("username" => ""$this->username"", "password" => ""$this->hashedPassword"" , "email" => ""$this->email"", "join_date" => """.date("Y-m-d H:i:s",time())."""); $this-> id = $db->insert($data, "users"); $this->joinDate = time(); ) return true; ) ) ?>

Förklaring

Den första delen av koden, utanför klasszonen, tillhandahåller anslutningen av klassen till databasen (eftersom det finns en funktion i klassen User som kräver denna klass).

Istället för "skyddade" klassvariabler (används i lektion 1), definierar vi dem som "offentliga". Det betyder att vilken kod som helst utanför klassen har tillgång till dessa variabler när man arbetar med User-objektet.

Konstruktorn tar en array där kolumnerna i tabellen är nycklarna. Vi definierar klassvariabeln med $this->variablename. I exemplet med denna klass kontrollerar vi först och främst om värdet på en viss nyckel finns. Om så är fallet sätter vi klassvariabeln till det värdet. Annars en tom sträng. Koden använder den korta formen av omsättningsnotationen om:

$värde = (3 == 4) ? "A" : "B";

I det här exemplet kontrollerar vi om 3 är lika med fyra! Om ja - då $value = "A", nej - $value = "B". I vårt exempel är resultatet $värde = "B".

Spara information om användare i databasen

Spara-funktionen används för att göra ändringar i databastabellen med de aktuella värdena i User-objektet. Den här funktionen använder DB-klassen vi skapade i den första handledningen. Med hjälp av klassvariabler sätts $datamatrisen. Om detta är första gången användaren lagras, skickas $isNewUser som $true (standard är false). Om $isNewUser = $true anropas funktionen insert() för DB-klassen. Annars anropas update()-funktionen. I båda fallen kommer informationen från användarobjektet att lagras i databasen.

Klass UserTools.class.php

Den här klassen kommer att innehålla funktioner relaterade till användare: login(), logout(), checkUsernameExists() och get(). Men med expansionen av denna applikation kan du lägga till många fler.

//UserTools.class.php require_once "User.class.php"; require_once "db.class.php";
klass Användarverktyg(
//Logga in användaren. Kontrollerar först om //användarnamnet och lösenordet matchar en rad i databasen. //Om det lyckas, ställ in sessionsvariablerna //och lagra användarobjektet inom.
offentlig funktionsinloggning ($användarnamn, $password)
{
$hashedPassword = md5($lösenord); $result = mysql_query("SELECT * FROM users WHERE username = "$username" AND password = "$hashedPassword""); if(mysql_num_rows($result) == 1) ( $_SESSION["user"] = serialisera(ny användare(mysql_fetch_assoc($result))); $_SESSION["login_time"] = tid(); $_SESSION["logged_in" "] = 1; return true; )else( return false; ) )
//Logga ut användaren. Förstör sessionsvariablerna. public function logout() ( unset($_SESSION["användare"]); unset($_SESSION["login_time"]); unset($_SESSION["logged_in"]); session_destroy(); ) //Kontrollera om ett användarnamn finns. //Detta anropas under registreringen för att säkerställa att alla användarnamn är unika. offentlig funktion checkUsernameExists($username) ( $result = mysql_query("välj id från användare där användarnamn="$användarnamn""); if(mysql_num_rows($result) == 0) (retur false; )else( return true;)
}
//skaffa en användare //returnerar ett användarobjekt. Tar användar-id som en offentlig ingångsfunktion get($id) ( $db = new DB(); $result = $db->select("användare", "id = $id"); returnera ny användare($result ); ) )
?>

login() funktion

Login()-funktionen är självförklarande. Den tar användarargumenten $username och $password och kontrollerar om de matchar. Om allt stämmer, skapar ett användarobjekt med all information och lagrar det i sessionen. Observera att vi endast använder PHP serialize()-funktionen. Det skapar en beständig version av objektet som enkelt kan unserializes med unserialize(). Även inloggningstiden kommer att sparas. Detta kan användas senare för att ge användarna information om hur länge deras vistelse på webbplatsen varar.

Du kanske också märker att vi sätter $_SESSION["logged_in"] till 1. Detta gör att vi enkelt kan kontrollera på varje sida om användaren är inloggad. Det räcker att bara kontrollera denna variabel.

logout() funktion

Också en enkel funktion. PHP:s unset()-funktion rensar variabler i minnet, medan session_destroy() tar bort sessionen.

checkUsernameExists() funktion

Vem kan engelska kommer lätt att förstå funktionen. Den frågar helt enkelt databasen om en sådan inloggning används eller inte.

get() funktion

Denna funktion tar ett unikt användar-ID och frågar databasen med DB-klassen, nämligen select()-funktionen. Det kommer att ta en associativ array med viss användarinformation och skapa ett nytt användarobjekt som skickar arrayen till konstruktorn.

Var kan den användas? Om du till exempel skapar en sida som behöver visa specifika användarprofiler måste du ta denna information dynamiskt. Så här kan du göra det: (låt oss säga att webbadressen är http://www.website.com/profile.php?userID=3)

//notera: du måste först öppna en databasanslutning. //se del 1 för ytterligare information om hur du gör det. //Du måste också se till att du har inkluderat klassfilerna.
$tools = new UserTools(); $user = $tools->get($_REQUEST["användar-ID"]); echo "Användarnamn: ".$user->användarnamn.""; echo "Joined On: ".$user->joinDate."";

Lätt! Sanning?

Efterbehandling på serversidan: global.inc.php

global.inc.php krävs för varje sida på webbplatsen. Varför? På så sätt kommer vi att placera alla vanliga operationer som vi behöver på sidan. Till exempel kommer vi att starta session_start(). Databasanslutningen öppnas också.

require_once "classes/UserTools.class.php";
require_once "classes/DB.class.php";
//anslut till databasen $db = new DB(); $db->anslut();
//initiera UserTools-objekt $userTools = new UserTools(); //starta sessionen
session_start();
//uppdatera sessionsvariabler om inloggad if(isset($_SESSION["logged_in"])) ( $user = unserialize($_SESSION["user"]); $_SESSION["user"] = serialize($userTools-> get($user->id)); ) ?>

Vad gör han?

Det är flera saker på gång här. Först och främst öppnar vi en anslutning till databasen.

Efter anslutning startar vi session_start()-funktionen. Funktionen skapar en session eller fortsätter den nuvarande om användaren redan är inloggad. Eftersom vår applikation är designad för användare att logga in/ut, krävs denna funktion på varje sida.

Därefter kontrollerar vi om användaren är inloggad. Om så är fallet kommer vi att uppdatera $_SESSION["användare"] för att visa den senaste användarinformationen. Till exempel, om en användare ändrar sin e-post, kommer sessionen fortfarande att lagra den gamla. Men med hjälp av automatisk uppdatering kommer detta inte att hända.

Detta avslutar den andra delen! I morgon väntar den sista lektionen om detta ämne.

Med vänliga hälsningar!