Informazioni utente senza cervello php. Array globale $_SERVER in PHP. Salviamo le informazioni sugli Utenti nel database

Nella seconda lezione scriveremo altre due lezioni e finiremo completamente la parte interna dello script.

Piano

L'obiettivo di questa serie di tutorial è creare una semplice applicazione che consenta agli utenti di registrarsi, accedere, disconnettersi e modificare le impostazioni. La classe che conterrà tutte le informazioni sull'utente si chiamerà User e sarà definita nel file User.class.php. La classe che sarà responsabile dell'input/output si chiamerà UserTools (UserTools.class.php).

Qualcosa sulla denominazione delle classi

L'etichetta corretta è nominare i file che descrivono una classe con lo stesso nome della classe stessa. Ciò semplifica la determinazione dello scopo di ciascun file nella cartella delle classi.

È anche comune aggiungere .class o .inc alla fine del nome del file della classe. In questo modo definiamo chiaramente lo scopo del file e possiamo utilizzare .htaccess per limitare l'accesso a questi file.

Classe utente (User.class.php)

Questa classe definirà ciascun utente. Man mano che questa applicazione cresce, la definizione di "Utente" potrebbe cambiare in modo significativo. Fortunatamente, la programmazione OOP semplifica l'aggiunta di ulteriori attributi utente.

Costruttore

In questa classe utilizzeremo un costruttore: questa è una funzione che viene chiamata automaticamente quando si crea la copia successiva della classe. Questo ci consente di pubblicare automaticamente alcuni attributi dopo la creazione del progetto. In questa classe, il costruttore accetterà un unico argomento: un array associativo che contiene una riga della tabella users del nostro database.

require_once "DB.class.php"; class Utente ( public $id; public $nomeutente; public $hashedPassword; public $email;
public $joinDate;
//Il costruttore viene chiamato quando viene creato un nuovo oggetto//Prende un array associativo con la riga del DB come argomento. funzione __construct($data) ( $this->id = (isset($data["id"])) ? $data["id"] : ""; $this->nomeutente = (isset($data[" nomeutente"])) ? $dati["nomeutente"] : ""; $questo->hashedPassword = (isset($dati["password"])) ? $dati["password"] : ""; $questo- >email = (isset($data["email"])) ? $data["email"] : ""; $this->joinDate = (isset($data["join_date"])) $data[" join_date "]: ""; )
public function save($isNewUser = false) ( //crea un nuovo oggetto database. $db = new DB(); //se l'utente è già registrato e stiamo //aggiornando solo le sue informazioni. if(!$isNewUser ) ( //imposta l'array di dati $data = array("username" => ""$this->username"", "password" => ""$this->hashedPassword"",
"email" => ""$questo->email"");
//aggiorna la riga nel database $db->update($data, "users", "id = ".$this->id); )else ( //se l'utente viene registrato per la prima volta. $data = array("username" => ""$this->username"", "password" => ""$this->hashedPassword"" , "email" => ""$questo->email"", "join_date" => """.date("Y-m-d H:i:s",time()).""" id = $db ->inserisci($dati, "utenti"); $questo->joinDate = ora(); ) ) ?>

Spiegazione

La prima parte del codice, all'esterno della zona della classe, garantisce che la classe sia connessa al database (poiché la classe Utente ha una funzione che richiede questa classe).

Invece delle variabili della classe “protetta” (usate nella 1a lezione), le definiamo “pubbliche”. Ciò significa che qualsiasi codice esterno alla classe ha accesso a queste variabili quando lavora con l'oggetto Utente.

Il costruttore accetta un array in cui le colonne della tabella sono chiavi. Definiamo una variabile di classe utilizzando $this->variablename. Nell'esempio di questa classe, controlliamo prima se esiste il valore di una determinata chiave. Se sì, impostiamo la variabile di classe su quel valore. Altrimenti, la stringa vuota. Il codice utilizza la forma abbreviata di notazione se:

$valore = (3 == 4) ? "A": "B";

In questo esempio stiamo controllando se 3 è uguale a quattro! Se sì, allora $valore = "A", no - $valore = "B". Nel nostro esempio, il risultato è $valore = “B”.

Salviamo le informazioni sugli Utenti nel database

La funzione di salvataggio viene utilizzata per apportare modifiche alla tabella del database con i valori correnti nell'oggetto Utente. Questa funzione utilizza la classe del database che abbiamo creato nel primo tutorial. Utilizzando le variabili di classe, viene impostato l'array $data. Se i dati utente vengono salvati per la prima volta, $isNewUser viene passato come $true (false per impostazione predefinita). Se $isNewUser = $true viene chiamata la funzione insert() della classe DB. Altrimenti, viene chiamata la funzione update(). In entrambi i casi, le informazioni dell'oggetto utente verranno archiviate nel database.

Classe UserTools.class.php

Questa classe conterrà funzioni correlate agli utenti: login(), logout(), checkUsernameExists() e get(). Ma con l'espansione di questa applicazione puoi aggiungerne molte altre.

//UserTools.class.php require_once "User.class.php"; require_once "DB.class.php";
classe StrumentiUtente(
//Accedi all'utente. Per prima cosa controlla se //il nome utente e la password corrispondono a una riga nel database. //Se ha esito positivo, imposta le variabili di sessione //e memorizza l'oggetto utente al suo interno.
accesso alla funzione pubblica ($ nome utente, $ password)
{
$hashedPassword = md5($password); $risultato = mysql_query("SELECT * FROM utenti WHERE nome utente = "$nomeutente" AND password = "$hashedPassword""); if(mysql_num_rows($result) == 1) ( $_SESSION["user"] = serialize(new User(mysql_fetch_assoc($result))); $_SESSION["login_time"] = time(); $_SESSION["logged_in "] = 1; return true; )else( return false; ) )
//Disconnette l'utente. Distruggi le variabili di sessione. public function logout() ( unset($_SESSION["user"]); unset($_SESSION["login_time"]); unset($_SESSION["logged_in"]); session_destroy(); ) //Controlla se esiste un nome utente. //Questo viene chiamato durante la registrazione per assicurarsi che tutti i nomi utente siano univoci. funzione pubblica checkUsernameExists($nomeutente) ( $risultato = mysql_query("seleziona id dagli utenti dove nomeutente="$nomeutente""); if(mysql_num_rows($risultato) == 0) ( return false; )else( return true; )
}
//ottieni un utente //restituisce un oggetto Utente. Prende l'id dell'utente come input public function get($id) ( $db = new DB(); $result = $db->select("users", "id = $id"); restituisce new User($result );) )
?>

funzione login()

La funzione login() è chiara già dal nome. Prende gli argomenti utente $ nomeutente e $ password e controlla che corrispondano. Se tutto corrisponde, crea un oggetto Utente con tutte le informazioni e lo salva nella sessione. Tieni presente che stiamo utilizzando solo la funzione PHP serialize(). Crea una versione memorizzata dell'oggetto che può essere facilmente deserializzata utilizzando unserialize(). Inoltre, l'ora di accesso verrà salvata. Questo può essere utilizzato successivamente per fornire agli utenti informazioni sulla durata della permanenza sul sito.

Potresti anche notare che abbiamo impostato $_SESSION["logged_in"] su 1. Questo ci consente di verificare facilmente su ogni pagina se l'utente ha effettuato l'accesso. È sufficiente controllare solo questa variabile.

funzione logout()

Anche una funzione semplice. La funzione PHP unset() cancella le variabili in memoria, mentre session_destroy() eliminerà la sessione.

funzione checkUsernameExists()

Chiunque conosca l'inglese capirà facilmente la funzione. Chiede semplicemente al database se è stato utilizzato o meno un login simile.

get() funzione

Questa funzione prende l'ID univoco dell'utente ed effettua una query al database utilizzando la classe DB, ovvero la funzione select(). Prenderà un array associativo con una serie di informazioni utente e creerà un nuovo oggetto Utente, passando l'array al costruttore.

Dove posso usarlo? Ad esempio, se crei una pagina che deve visualizzare profili utente specifici, dovrai recuperare queste informazioni in modo dinamico. Ecco come puoi farlo: (diciamo che l'URL è http://www.website.com/profile.php?userID=3)

//nota: dovrai prima aprire una connessione al database. //vedere la Parte 1 per ulteriori informazioni su come farlo. // Dovrai anche assicurarti di aver incluso i file della classe.
$strumenti = nuovi StrumentiUtente(); $utente = $strumenti->get($_REQUEST["userID"]); echo "Nome utente: ".$utente->nome utente.""; echo "Iscrizione il: ".$user->joinDate."";

Facilmente! È vero?

Il tocco finale sul lato server: global.inc.php

global.inc.php è richiesto per ogni pagina del sito. Perché? In questo modo posizioneremo sulla pagina tutte le consuete operazioni che ci serviranno. Ad esempio, inizieremo session_start(). Si aprirà anche la connessione al database.

require_once "classes/UserTools.class.php";
require_once "classes/DB.class.php";
//connettiti al database $db = new DB(); $db->connetti();
//inizializza l'oggetto UserTools $userTools = new UserTools(); //avvia la sessione
inizio_sessione();
//aggiorna le variabili di sessione se sei loggato if(isset($_SESSION["logged_in"])) ( $user = unserialize($_SESSION["user"]); $_SESSION["user"] = serialize($userTools-> get($utente->id) ) ?>

Cosa sta facendo?

Ci sono molte cose che accadono qui. Innanzitutto apriamo una connessione al database.

Dopo la connessione, avviamo la funzione session_start(). La funzione crea una sessione o continua quella corrente se l'utente è già loggato. Poiché la nostra applicazione è progettata per consentire agli utenti di accedere/disconnettersi, questa funzionalità è richiesta su ogni pagina.

Successivamente, controlliamo se l'utente ha effettuato l'accesso. In tal caso, aggiorneremo $_SESSION["utente"] per riflettere le informazioni utente più recenti. Ad esempio, se un utente cambia la sua email, quella vecchia verrà memorizzata nella sessione. Ma con l'aggiornamento automatico ciò non accadrà.

Questo conclude la seconda parte! Domani troverai la lezione finale su questo argomento.

Ti auguro il meglio!

Quelli che hanno studiato più o meno seriamente PHP sappi che esiste un array globale molto utile in PHP che è chiamato $_SERVER. E in questo articolo vorrei analizzare le chiavi più popolari e i loro valori in questo array, poiché la loro conoscenza è semplicemente obbligatoria anche per un principiante Programmatore PHP.

Prima che inizi array globale $_SERVER in PHP, ti do subito un piccolo suggerimento. C'è una grande funzionalità integrata PHP, che è chiamato phpinfo(). Facciamo subito un esempio del suo utilizzo:

phpinfo();
?>

Come risultato dell'esecuzione di questo semplice script, vedrai una tabella enorme con vari Impostazioni dell'interprete PHP, incluso, verso la fine ci sarà una tabella di valori array globale $_SERVER. Elencherà tutte le chiavi e tutti i loro valori corrispondenti. Come può aiutarti? E il fatto è che se hai bisogno di questo o quel valore e dimentichi come si chiama la chiave, allora usa la funzione phpinfo() Puoi sempre ricordare il suo nome. In generale, eseguirai questo script e mi capirai immediatamente.

Passiamo ora a quelli più popolari alle chiavi dell'array $_SERVER:

• HTTP_USER_AGENT- questa chiave permette di conoscere le caratteristiche del cliente. Nella maggior parte dei casi si tratta sicuramente del browser, ma non sempre. E ancora, se si tratta di un browser, quale, puoi scoprirlo in questa variabile.
• HTTP_REFERER- contiene il percorso assoluto di quel file ( Scritto PHP, Pagina HTML), da cui siamo passati a questo script. In parole povere, da dove veniva il cliente.
• SERVER_ADDR - indirizzo IP server.
• REMOTE_ADDR - indirizzo IP cliente.
• DOCUMENT_ROOT- percorso fisico alla directory principale del sito. Questa opzione viene impostata tramite File di configurazione del server Apache.
• SCRIPT_NOMEFILE- percorso fisico allo script chiamato.
• STRINGA DELLA DOMANDA- un valore molto utile che ti consente di ottenere una stringa con una richiesta e quindi puoi analizzare questa stringa.
• RICHIESTA_URI- un valore ancora più utile che contiene non solo la richiesta stessa, ma anche il percorso relativo allo script richiamato dalla root. Questo è molto spesso utilizzato per rimuovere la duplicazione indice.php, cioè, quando ne abbiamo URL: "http://miosito.ru/index.php" E " http://miosito.ru/" porta a una pagina e URL diversi, quindi duplicati, che avranno un effetto negativo sull'ottimizzazione dei motori di ricerca. E con l'aiuto RICHIESTA_URI possiamo determinare: con indice.php o no, lo script è stato chiamato. E possiamo fare un reindirizzamento con indice.php(se fosse presente RICHIESTA_URI) acceso senza indice.php. Di conseguenza, quando si invia tale richiesta: " http://miosito.ru/index.php?id=5", avremo un reindirizzamento a URL: "http://miosito.ru/?id=5". Cioè, ci siamo sbarazzati della duplicazione rimuovendo from URL Questo indice.php.
• SCRIPT_NAME- percorso relativo allo script richiamato.

Forse questi sono tutti gli elementi array globale $_SERVER in PHP che vengono utilizzati regolarmente. Bisogna conoscerli ed essere in grado di usarli quando necessario.

$HTTP_SERVER_VARS [eliminato]

(PHP 4 >= 4.1.0, PHP 5, PHP 7)

$_SERVER -- $HTTP_SERVER_VARS [eliminato] — Informazioni sul server e sull'ambiente di esecuzione

Descrizione

La variabile $_SERVER è un array contenente informazioni quali intestazioni, percorsi e posizioni degli script. Le voci in questo array vengono create dal server web. Non vi è alcuna garanzia che ogni server web ne fornisca qualcuno; il server potrebbe ometterne alcuni o fornirne altri non elencati qui. Tuttavia, molte di queste variabili sono presenti nella specifica »CGI/1.1, quindi puoi aspettarti che siano implementate nel tuo particolare server web.

La variabile $HTTP_SERVER_VARS contiene le stesse informazioni iniziali, ma non lo è superglobale. (Nota che $HTTP_SERVER_VARS e $_SERVER sono variabili diverse, quindi PHP le tratta di conseguenza). Tieni inoltre presente che gli "array lunghi" sono stati rimossi in PHP 5.4.0, quindi $HTTP_SERVER_VARS non esiste più.

Indici

Potresti (o meno) trovare uno dei seguenti elementi nell'array $_SERVER. Tieni presente che pochi elementi, se non nessuno, saranno disponibili (o contano davvero) se PHP è in esecuzione riga di comando.

"PHP_SELF" Il nome del file di script attualmente in esecuzione, relativo alla radice del documento. Ad esempio, $_SERVER["PHP_SELF"] nello script su http://example.com/foo/bar.php sarebbe /foo/bar.php . Costante __FILE__ contiene il percorso completo e il nome file del file corrente (ovvero connesso). Se PHP è in esecuzione sulla riga di comando, questa variabile contiene il nome dello script, a partire da PHP 4.3.0. Prima non era disponibile. "argv " Una serie di argomenti passati allo script. Quando lo script viene eseguito sulla riga di comando, fornisce un accesso simile a C alle opzioni della riga di comando. Quando chiamato tramite il metodo GET, questo array conterrà la stringa di query. "argc " Contiene il numero di parametri passati allo script (se lanciato da riga di comando)."GATEWAY_INTERFACE" Contiene la versione della specifica CGI utilizzata dal server; Per esempio" CGI/1.1". "SERVER_ADDR" Indirizzo IP del server su cui è in esecuzione lo script corrente."NOME DEL SERVER" Il nome dell'host su cui è in esecuzione lo script corrente. Se lo script è in esecuzione su un host virtuale, conterrà il nome definito per quell'host virtuale."SERVER_SOFTWARE" La stringa di identificazione del server specificata nelle intestazioni quando si verifica una risposta a una richiesta."SERVER_PROTOCOL" Il nome e la versione del protocollo informativo attraverso il quale è stata richiesta la pagina; Per esempio " HTTP/1.0"; "REQUEST_METHOD" Quale metodo è stato utilizzato per richiedere la pagina; Per esempio " OTTENERE", "TESTA", "INVIARE", "METTERE".

Commento:

Lo script PHP termina dopo aver inviato le intestazioni (ovvero, dopo aver eseguito qualsiasi output senza bufferizzare l'output), se la richiesta è stata effettuata utilizzando il metodo TESTA.

Commento: Tieni presente che quando utilizzi ISAPI con IIS il valore sarà spento, se la richiesta non è stata effettuata tramite HTTPS.

Commento: Il tuo server web deve essere configurato per creare questa variabile. Ad esempio in Apache è necessaria la presenza della direttiva Ricerche nome host attivate nel file httpd.conf in modo che questa variabile venga creata. Guarda anche gethostbyaddr() .

Il percorso assoluto dello script attualmente in esecuzione.

Commento:

Se lo script viene eseguito sulla riga di comando (CLI) utilizzando un percorso relativo come file.php o ../file.php , la variabile $_SERVER["SCRIPT_FILENAME"] conterrà il percorso relativo specificato dall'utente.

Commento: Per ottenere una porta fisica (reale) in Apache 2, è necessario installare UseCanonicalName = attivato E UsaCanonicalPhysicalPort = Attivato, altrimenti questo valore potrebbe essere sostituito e non restituire il valore reale della porta fisica. Fare affidamento su questo valore non è sicuro nel contesto di applicazioni che richiedono una maggiore sicurezza.

Commento: A partire da PHP 4.3.2, la variabile PATH_TRANSLATED non è più impostata implicitamente nella SAPI di Apache 2, rispetto ad Apache versione 1 dove era impostata sullo stesso valore della variabile SCRIPT_FILENAME quando non era utilizzata da Apache. Questa modifica è stata apportata per conformarsi alla specifica CGI, dove la variabile PATH_TRANSLATED dovrebbe esistere solo quando è definito PATH_INFO. Gli utenti di Apache 2 possono utilizzare la direttiva AcceptPathInfo = attivato nel file di configurazione httpd.conf per impostare la variabile PATH_INFO.

Il risultato dell'esecuzione di questo esempio sarà qualcosa di simile.