È molto comodo sapere sempre quale versione specifica è questo o quell'assieme del progetto. Questo di solito viene fatto inserendo un numero di versione composto da più cifre. Sono un sostenitore di una struttura a 4 cifre come:
Insieme, questo forma la denominazione della versione completa (Major.Minor.Pathch.Build):
Alcune persone usano un valore numerico univoco come build, che viene incrementato ogni volta, ad esempio, durante una build notturna. Credo che non abbia senso in questo: è molto più conveniente associare questo numero a una revisione nel repository. Uso Subversion e CMake, quindi dimostrerò come è possibile automatizzare la pubblicazione di una versione build con questi strumenti.
Innanzitutto, devi aggiungere un file di intestazione al progetto (ad esempio, version.h):
| #includere |
Ecco una semplice interfaccia attraverso la quale è possibile ottenere il numero di versione completo del programma in forma di testo o come identificatore intero univoco.
Ora darò il contenuto di version.cpp:
| #includere |
Qui tutto è banale e, credo, non necessita di commenti. L'ultima cosa rimasta è il meccanismo per cambiare il valore BUILD con il numero di revisione nel repository. CMake lo gestirà bene, basta aggiungere il seguente codice a CMakeLists.txt:
| set (VERSION_FILE ../ common/sources/version.cpp) find_package (Subversion REQUIRED) Subversion_WC_INFO ($ (PROJECT_SOURCE_DIR) Repo) file (READ $ (VERSION_FILE) OLD_CODE) foreach (LINE $ (OLD_CODEX)) "string = (+) "BUILD_NUMBER $ (LINE)) if (BUILD_NUMBER) string (REGEX REPLACE" + $ "$ (Repo_WC_REVISION) LINE $ (LINE)) endif () set (NEW_CODE $ (NEW_CODE) $ (LINE)) endforeach ( LINE) file ( SCRIVI $ (VERSION_FILE) " $ (NEW_CODE) ") |
L'unica sottigliezza nello script è nell'ultima riga e, più specificamente, le virgolette in "$ (NEW_CODE)", senza di esse tutte ";" verranno rimosse.
Abbiamo bisogno delle seguenti pagine:
- Pagina di registrazione con modulo di registrazione
- Pagina di attivazione dell'account
- Pagina di recupero password
- Pagina di reimpostazione della password
Il modulo di accesso al sito verrà posizionato su tutte le pagine del sito (ad esempio, nell'intestazione).
Questa è la pagina di registrazione che vogliamo ricevere:
Qui, il tipo di account determinerà con quale gruppo registriamo l'utente. Inoltre, il campo per l'identificazione (nome utente) sarà e-mail.
Aggiungi uno snippet di chiamata alla pagina Registrati:
[[! Registrati? & submitVar = `register-btn` &activationResourceId =` 27` &activateEmailTpl = `Email.Activation` &activateEmailSubject =` Sei registrato su example.com` & placeholderPrefix = `reg.` & successMsg =`
Si prega di notare che tutti i tag di registrazione devono necessariamente chiamare non memorizzato nella cache. Le stesse regole si applicano quando si elaborano i moduli con lo snippet FormIt.
Analizziamo i parametri di chiamata:
& submitVar = `register-btn`- specifica l'attributo del nome del tag ingresso... Cioè, lo snippet funzionerà solo se il modulo viene inviato da un pulsante con un nome specifico.
&activationResourceId = `42`- guardando avanti, 42 è l'identificativo della pagina su cui attiveremo l'utente.
&activationEmailTpl = `Email.Activation`- pezzo con una lettera di attivazione, a riguardo in seguito.
& placeholderPrefix = `reg.`- indica che tutti i segnaposto, con rare eccezioni (ne parleremo più avanti), che vengono creati in questo frammento, devono iniziare con "reg."
& successoMsg- il messaggio che verrà visualizzato dopo l'avvenuto invio del modulo. Nota che puoi specificare i valori dal modulo e qualsiasi altro tag al suo interno. Questo messaggio verrà scritto nel segnaposto [[! + messaggio.errore]]. Un nome piuttosto strano e al momento c'è un errore nella documentazione. È scritto lì [[! + reg.error.message]], ma dal codice del componente risulta che non è così.
& usernameField = `email`- indica che il campo email verrà utilizzato come nome utente.
& usergroupsField = `reg_type`- definisce il campo che definisce il gruppo al quale verrà aggiunto il nuovo utente.
& customValidators = `valueIn`- indica validatori aggiuntivi da creare manualmente.
e convalida- i validatori sono impostati separati da virgole per ogni campo, e se sono richiesti più validatori per un campo, allora sono separati anche da due punti. Analizziamoli separatamente:
nome utente: vuotoÈ una semplice trappola per spam, il che significa che il campo del nome utente deve essere lasciato vuoto.
reg_type: valueIn = ^ lettori; scrittori; fannulloni ^- limitiamo i possibili gruppi ai tre indicati. Nella consegna iniziale, questo non è il caso e gli hacker malvagi possono registrarsi, ad esempio, nel gruppo Administrator (se non lo hai rinominato).
nome completo: richiesto: minLength = ^ 6 ^- il campo nome completo non deve essere vuoto e contenere almeno 6 caratteri.
password: richiesta: minLength = ^ 6 ^- analogamente per la password.
password_confirm: password_confirm = ^ password ^- Le password devono essere identiche.
e-mail: obbligatorio: e-mail- l'e-mail non deve essere vuota ed essere la posta stessa.
Design [[! + error.message: default = `[[! $ Register.Form]]`]] visualizza un messaggio sull'invio riuscito del modulo o sul blocco del modulo se hai appena visitato la pagina o l'hai compilata in modo errato.
Creiamo il validatore sopra valoreIn... Per fare ciò, crea uno snippet con il nome valoreIn e il seguente codice:
$ valueIn = esplodi (";", $ param); return in_array ($ valore, $ valoreIn);
Ora devi creare un pezzo Modulo.Registrati ... In questo caso, sarà il seguente (usando Bootstrap 3):
In questo modulo, noterò alcune cose su MODX:
Impostare il valore tra quelli ricevuti dal form in modo che in caso di errore l'utente non debba inserire nuovamente tutto.
[[! + reg.error.email: notempty = `[[! + reg.error.email]]`]]- anche in questo caso, in caso di guasto, verrà visualizzato un messaggio di errore sotto il campo.
- assicurati di indicare il nome del pulsante se hai precedentemente impostato la proprietà & inviaVar.
Ora resta da creare un pezzo Email.Attivazione con la lettera che il sito invia all'utente:
Grazie per la registrazione! Per attivare il tuo account, segui il seguente link:
Attiva il tuo account su Example.Com
Dopo l'attivazione, potrai accedere inserendo email e password:
Login:[[+ email]]
Parola d'ordine:[[+ password]]
Qui puoi utilizzare i segnaposto con i nomi dei campi del modulo. Nota che sono già scritti senza "reg." Viene aggiunto anche un segnaposto [[+ confermaUrl]], in cui il link di attivazione è già stato generato, non devi nemmeno fare nulla.
Il tocco finale all'arte di registrare un nuovo account utilizzando un componente Login creerà una pagina di attivazione. Usiamo un modello vuoto per questa pagina e nel contenuto della pagina dobbiamo solo specificare una chiamata al tag:
[[! ConfermaRegistrati? & redirectTo = `1`]]
dove 1 è l'identificativo della pagina alla quale l'utente verrà reindirizzato in caso di attivazione avvenuta con successo. In questo caso, sarà già loggato.
Iniziamo a configurare il login al profilo utente. Il modulo di autorizzazione sarà semplice:
Aggiungiamolo chiamandolo nel posto giusto:
[[! Login? & loginTpl = `Auth.Login` & logoutTpl =` Auth.Logout` & errTpl = `Auth.Login.Error` & actionKey =` action` & loginKey = `login` & redirectToPrior =` 1` & logoutResourceId = `1` ]]
Qui specifichiamo un pezzo con il modulo di accesso mostrato sopra ( & loginTpl = `Auth.Login`), un pezzo con un codice mostrato agli utenti autorizzati ( & logoutTpl = `Auth.Logout`), un piccolo pezzo con l'output di un errore di accesso ( & errTpl = `Auth.Login.Error`). I parametri seguono:
& actionKey = `action` e & loginKey = `login`- i principali identificatori per l'elaborazione della richiesta. Il primo indica il nome del parametro nella richiesta POST e il secondo indica il suo valore. Cioè, il modulo deve passare il valore $ _POST ["action"] = "login" in modo che lo snippet Login l'ha elaborato.
& redirectToPrior = `1`- significa che dopo aver effettuato l'accesso, verremo reindirizzati alla stessa pagina da cui abbiamo effettuato l'accesso.
& logoutResourceId = `1`- quando usciamo dal profilo, andremo alla pagina con l'identificatore 1.
Chunk Auth.Login :
[[! + errori]]
Il modulo viene elaborato nella stessa pagina. Se si verifica un errore, verrà visualizzato sotto il modulo nel segnaposto [[! + errori]].È inoltre necessario ricordare i collegamenti alle risorse con Registrazione e recupero password. Nota che nel campo per il nome e-mail = "nome utente" - è stato in questo campo che lo snippet ha duplicato la posta Registrati ed è unico per gli utenti.
Chunk Auth.Logout:
[] `& tpl =` User.HeaderBadge` & innerJoin = `(" modUserGroupMember ":(" alias ":" modUserGroupMember "," on ":" modUser.id = modUserGroupMember.member ")," modUserGroup ":(" alias " : "modUserGroup", "on": "modUserGroupMember.user_group = modUserGroup.id")) `& select =` ("modUserGroup" :( "group_name": "modUserGroup.name")) `]]
Questa parte è facoltativa se tutti gli utenti sono nello stesso gruppo. Ma per visualizzare un gruppo di utenti, gli snippet standard inclusi nel componente Login non sono sufficienti. Puoi scrivere un semplice frammento per ottenere il nome del gruppo xPDO, oppure puoi usare uno snippet già pronto pdoUsers incluso nel pacchetto pdoTools... Parametri specificati in questo frammento:
& utenti = `[[+ modx.user.id]]`- selezioniamo solo l'attuale utente autorizzato.
& tpl = `User.HeaderBadge`- un pezzo in cui verranno visualizzate brevi informazioni sull'utente.
& innerUnisci- JSON con join di tabelle di gruppi di utenti, la descrizione esula dallo scopo di questo articolo. La cosa principale è che funziona J.
& Selezionare- JSON aggiungendo il campo modUserGroup.name con l'alias group_name alla selezione.
Chunk con il badge dell'utente User.HeaderBadge :
Se non avessimo bisogno di un gruppo di utenti, il contenuto di questo blocco potrebbe essere inserito direttamente nel blocco Aut.Logout ... Qui puoi visualizzare i segnaposto con qualsiasi campo modUser e modUserProfile più usando pdoUsers aggiunto un campo nome del gruppo.
In un pezzo Auth.Login.Error output di errore semplice:
Abbiamo finito con il login. A questo punto, l'utente può registrarsi ed effettuare il login con successo. Ma cosa succede se ha dimenticato la password? In questo caso, clicca sul link "Hai dimenticato la password?" e va alla pagina di recupero della password, che abbiamo pre-creato e chiamato lì:
[[! Ha dimenticato la password? & tpl = `Auth.ForgotPass.Form` & submitVar =` forgotpass` & errTpl = `Auth.Login.Error` & sentTpl =` Auth.ForgotPass.Sent` & emailTpl = `Email.ForgotPass` & emailSubject =` Ripristino dell'account accesso su Esempio. Com` & resetResourceId = `29`]]
Analizziamo i parametri di questa chiamata:
& tpl = `Auth.ForgotPass.Form`- parte del modulo in cui l'utente inserisce la sua email.
& submitVar = `forgotpass`- nel caso dello snippet ForgotPassword, è sufficiente che il parametro con questo nome venga passato al server, indipendentemente da quale valore non vuoto.
& errTpl = `Auth.Login.Error`- l'output dell'errore è simile allo snippet di accesso
& sentTpl = `Auth.ForgotPass.Sent`- questo blocco contiene contenuti che verranno visualizzati in caso di invio riuscito di una lettera per modificare la password.
& emailTpl = `Email.ForgotPass`- la lettera stessa è contenuta qui.
& oggetto dell'email= `Ripristino dell'accesso a un account sul sito Example.Com` - intestazione del messaggio.
& resetResourceId = `29`- identificatore di risorsa su cui la password verrà reimpostata su una nuova.
Pezzo Auth.ForgotPass.Form:
La novità qui è solo un altro modo di visualizzare gli errori nel segnaposto [[+ loginfp.errors]] e passando un parametro che è questo modulo che reimposta la password: .
Auth.ForgotPass.Sent:
Le informazioni per il recupero dell'account sono state inviate all'indirizzo email specificato: [[+ email]].
Qui puoi utilizzare i dati del modulo sopra.
Email.ForgotPass:
[[+ nome completo]],
Per attivare la tua nuova password, visita il seguente link:
Voglio una nuova password
Se tutto è andato bene, potrai accedere al tuo profilo con le seguenti informazioni:
Login:[[+ nome utente]]
Parola d'ordine:[[+ password]]
Grazie,
Esempio di amministrazione del sito.Com
Tutto è molto simile al pezzo della lettera di attivazione, solo la password viene generata qui nello snippet.
Il tocco finale resta quello di creare una risorsa alla quale l'utente andrà dalla lettera per aggiornare la password. In questa risorsa, abbiamo bisogno di una chiamata:
[[! ResetPassword: vuoto = `
Non hai ordinato la reimpostazione della password. Forse hai sbagliato indirizzo. Puoi andare alla pagina principale del sito o utilizzare il menu in alto.
`? & tpl = `Auth.ForgotPass.Reset`]]
Questo codice visualizzerà un messaggio se improvvisamente qualcuno vaga di nuovo in questa pagina o semplicemente per errore. E se la password viene reimpostata con successo, verrà visualizzato un messaggio dal blocco Auth.ForgotPass.Reset:
La tua password è stata reimpostata con successo con quella specificata nella lettera. Ora puoi accedere con questa password. Non dimenticare di cambiarlo nel tuo profilo.
Ora abbiamo un sistema di autorizzazione e registrazione degli utenti completamente funzionante. La modifica del profilo degli utenti autorizzati verrà lasciata al di fuori dello scopo dell'articolo.
1. Crea una pagina di registrazione e aggiungi una chiamata snippet ad essa Registrati.
2. Crea blocchi con un modulo di registrazione Modulo.Registrati
e lettera di attivazione Email.Attivazione.
3. Crea una pagina di conferma della registrazione e fai una chiamata snippet su di essa ConfermaRegistrati.
4. Aggiungi uno snippet di chiamata Login dove vogliamo inserire il form di login e il badge dell'utente autorizzato.
5. Crea un blocco con un modulo di accesso Aut.Login
, blocco con informazioni sull'utente autorizzato Aut.Logout
, pezzo con messaggio di errore Auth.Login.Error
.
6. Crea una pagina di recupero della password e fai una chiamata snippet su di essa Ha dimenticato la password.
7. Crea un pezzo Auth.ForgotPass.Form
con un modulo di recupero password, chunk Auth.ForgotPass.Sent
con un messaggio sull'avvenuto invio della lettera, chunk Email.ForgotPass
con una lettera per reimpostare la password.
8. Crea una risorsa con una reimpostazione finale della password e inserisci una chiamata snippet in essa Resetta la password.
9. Crea un pezzo Auth.ForgotPass.Reset
con un messaggio sulla reimpostazione della password riuscita.
È tutto. Sarò lieto di eventuali aggiunte e commenti.
Foolproof è un insieme di misure per impedire l'inserimento di informazioni errate in un modulo. Ad esempio, se è necessario immettere un numero positivo compreso tra 0 e 10 in un campo, è necessario verificare che l'utente non immetta testo o un numero che non rientri nell'intervallo specificato, ad es. il numero non deve essere inferiore a zero né superiore a dieci.
Perché vengono inserite informazioni errate? Ciò è dovuto principalmente a tre ragioni.
- L'utente ha commesso un errore accidentale, ad esempio, leggendo distrattamente ciò che deve indicare.
- In una pagina Web, viene chiesto loro di inserire dati in modo ambiguo, quindi l'utente deve indovinare e fare un'ipotesi su ciò che vuole veramente da lui. In questo caso, le opinioni dello sviluppatore e dell'utente non sempre coincidono.
- Ci sono un certo numero di persone che prendono le istruzioni come una sfida e cercano di fare il contrario. Tali utenti ragionano in questo modo: “Sì, mi viene chiesto di inserire un numero. Cosa succede se indico le lettere?" Dopodiché, chiedono informazioni ovviamente errate e vedono a cosa porterà.
Dovrebbe essere chiaro che formulazioni precise e corrette, sebbene riducano la probabilità di errori, non ti salvano in alcun modo da essi. Solo i mezzi tecnici lato server consentono di ottenere il risultato desiderato ed evitare di inserire informazioni errate. Tuttavia, la revisione o, come viene anche chiamata, la convalida lato client consente di verificare rapidamente la correttezza dei dati inseriti dall'utente, senza dover inviare il modulo al server. Ciò consente di risparmiare tempo all'utente e riduce il carico sul server. Dal punto di vista dell'usabilità, ci sono anche dei vantaggi: l'utente riceve immediatamente un messaggio su quali informazioni ha indicato in modo errato e può correggere il suo errore.
Campo obbligatorio
Alcuni campi del modulo devono essere compilati prima di inviarli al server. Questo, ad esempio, vale per il modulo di registrazione, dove viene richiesto di inserire un nome utente e una password. L'attributo obbligatorio viene utilizzato per specificare i campi obbligatori, come mostrato nell'esempio 1.
Esempio 1. L'attributo richiesto
HTML5 IE 10+ Cr Op Sa Fx
Campo obbligatorio
I campi obbligatori devono essere compilati prima di inviare il modulo, altrimenti il modulo non verrà inviato al server e il browser emetterà un avviso al riguardo. Il tipo di messaggio dipende dal browser; ad esempio, Chrome visualizza un tooltip, come mostrato in Fig. uno.
Riso. 1. Il campo obbligatorio non è compilato
Correttezza dei dati
Inizialmente sono presenti due campi in cui i dati inseriti dall'utente vengono verificati automaticamente. Questo è l'indirizzo web e l'indirizzo email. Il browser Chrome controlla anche la validità del campo dei dati del calendario, ma solo perché non dispone di un'interfaccia del calendario clicca per selezionare. Questi elementi sono caratterizzati dalle seguenti regole.
- Indirizzo Web ( ) deve contenere il protocollo (http: //, https: //, ftp: //).
- Indirizzo email ( ) deve contenere lettere o numeri prima del simbolo @, dopo di esso, quindi un punto e un dominio di primo livello.
I browser hanno criteri leggermente diversi per la convalida dei dati utente. Ad esempio, Opera sostituisce automaticamente il protocollo http: // davanti al testo inserito, mentre altri browser se lo aspettano dall'utente. Chrome e Opera richiedono un punto nell'indirizzo di posta, è facoltativo per Firefox.
L'esempio 2 mostra un modulo con campi obbligatori in cui due campi vengono convalidati dal browser.
Esempio 2. Correttezza dei dati
HTML5 IE 10+ Cr Op Sa Fx
Correttezza dei dati
Opera convalida un elemento del form solo se è presente l'attributo name.
Quello che succede in Opera quando si inseriscono dati errati è mostrato in Fig. 2.
Riso. 2. Avvertenza sui dati errati
Modello di input
Alcuni dati non possono essere classificati come un tipo di elemento del modulo, quindi è necessario utilizzare una casella di testo. Inoltre, il loro input avviene secondo un certo standard. Quindi, l'indirizzo IP contiene quattro numeri separati da un punto (192.168.0.1), il codice postale della Russia è limitato a sei cifre (124007), il telefono contiene un codice di città e un numero specifico di cifre spesso separate da un trattino ( 391 555-341-42), ecc. Il browser deve specificare un modello di input in modo che convalidi l'input dell'utente in base ad esso. Per questo, viene utilizzato l'attributo pattern e il suo valore è un'espressione regolare. Alcuni valori tipici sono elencati in tabella. uno.
L'esempio 3 richiede un valore di colore esadecimale (# ffcc00) e se non è compreso in questo intervallo, il browser visualizza un messaggio di errore.
Esempio 3. Modello di input
HTML5 IE 10+ Cr Op Sa Fx
Inserimento colore
Nella fig. 3 mostra un avviso nel browser Chrome.
Riso. 3. I dati inseriti non corrispondono al modello
Annullamento della convalida
La convalida non è sempre richiesta per un modulo, ad esempio, uno sviluppatore desidera utilizzare una soluzione universale in JavaScript e non ha bisogno di una convalida duplicata da parte del browser. In questi casi, è necessario disabilitare la convalida in linea. Per questo, viene applicato l'attributo novalidate del tag.
Per uno scopo simile, viene utilizzato l'attributo formnovalidate, che viene aggiunto al pulsante per l'invio del modulo, in questo caso al tag ... In questo caso, il modulo dell'esempio 4 sarà simile a questo.
Per qualsiasi sviluppatore web, non esiste ancora un problema più serio della completa compatibilità cross-browser del suo prodotto. Probabilmente, questo è uno dei compiti principali di un buon specialista: assicurarsi che il suo sito venga sempre visualizzato correttamente in tutti i browser.
Parametro necessario che a volte viene utilizzato per l'input non funziona nell'antico IE, che semplicemente non può essere lasciato in quel modo. Gli utenti in pensione che utilizzano ancora IE6 dovrebbero essere altrettanto facili sul tuo sito come gli utenti dell'ultima versione di Google Chrome. Chi oltre agli sviluppatori web può prendersi cura di loro.
Sul doloroso, su Internet Explorer
Per i normali browser come Firefox, Opera e Google Chrome, questa operazione è relativamente semplice. Anche le versioni precedenti di questi browser rendono ugualmente bene il codice html, a meno che, ovviamente, non venga utilizzata una nuova tecnologia. Ma per raggiungere questo obiettivo nei browser della famiglia Internet Explorer, ci vuole uno sforzo enorme.
Ogni versione del browser Internet Exlorer ha la sua stupidità unica. Ciò che funziona in IE6 potrebbe non funzionare correttamente in IE7 e viceversa. Questo zoo di Microsoft non è stato in grado di superare anche nell'ultima versione del suo browser.
Non riesco a capire perché gli sviluppatori di browser non possano semplicemente aprire e leggere gli standard W3C per la creazione di siti.
Pertanto, come sviluppatore web, devo agire come una sorta di "strato" tra browser capricciosi e visitatori del sito che richiedono conoscenza e spettacolo. Ed è fantastico che gli sviluppatori web ci siano riusciti finora.
Quindi, come ti viene richiesto di lavorare nelle versioni precedenti di IE?
JS viene in nostro soccorso. In precedenza, non potevo sopportarlo, ma ora non vedo un'ulteriore via senza di essa nella vastità del WEB "corretto".
Non ho inventato la soluzione sotto di me, ma l'ho presa da un blog borghese. Dato che sono avido, e il blog è borghese, non mi collegherò ad esso.
La funzione sarà responsabile di tutto. fnCheckFields ()... Inserisci il codice JS sul tuo sito web:
Di solito si consiglia di inserirlo tra i tag html TESTA all'inizio della pagina, ma consiglierei comunque di posizionarlo in fondo alla pagina prima del tag di chiusura CORPO... Pertanto, JS ha un impatto minore sulla velocità di caricamento della pagina.
La finestra di input, dove deve essere inserito il parametro richiesto, dovrebbe apparire così in linguaggio html:
Questo script funziona in modo molto semplice: dopo aver fatto clic sul pulsante Inviare, lo script controlla tutti gli input per la presenza del parametro richiesto e, se lo trova, controlla di conseguenza il valore inserito in questo campo. Se non viene immesso nulla in tale input, viene visualizzata una finestra di avviso sulla necessità di input. Di conseguenza, i dati non vengono inviati da nessuna parte.
È anche bello che se disponi di un normale browser che ha già imparato a comprendere questo parametro come previsto, tale finestra di avviso non verrà visualizzata e gli strumenti standard per l'elaborazione del parametro richiesto per il tuo browser funzioneranno.
Condividi sui social reti
