Usando come guida il design di interazione di moduli mobili di Matt Smith, creeremo un'interessante interazione tra moduli per il web che è sia bella che accessibile utilizzando HTML, CSS e JavaScript.
La progettazione di moduli e l'interazione sul web possono essere un argomento delicato. Una molteplicità di preoccupazioni sull'accessibilità alla forma e le migliori pratiche possono rendere molto difficile la progettazione di un'interazione di forme convincenti, al contrario della progettazione di moduli su piattaforme native.
Matt Smith ha recentemente creato un'interessante interazione tra i moduli che ha pubblicato su Dribbble:
Sebbene sia progettato per un'applicazione iOS nativa, questa interazione con il modulo può essere ricreata per il web utilizzando HTML, CSS e Javascript, mentre anche i problemi legati all'accessibilità dei moduli.
Il concetto di etichetta fluttuante ha suscitato una certa attenzione, portando a discussioni ed esperimenti in tutto il web.
Demo davvero interessante di @zelph http://t.co/Szw1bE2tib che implementa l'interazione con il modulo di etichetta float super-fantastico http://t.co/NhKfErgd2Q di @mds
- Brad Frost (@brad_frost), 23 ottobre 2013
Anziché utilizzare gli stessi campi modulo nel design di Matt, creeremo un semplice modulo di contatto che potresti utilizzare sul tuo sito web. Quindi tuffiamoci dentro!
Per prima cosa, osserviamo e registriamo le interazioni tra i moduli che Matt ha creato. Questo ci permetterà di predeterminare in che modo la nostra forma dovrebbe essere marcata. Ci darà anche una buona comprensione di come modellare il modulo e creare le sue interazioni con JavaScript.
Il modulo ha i seguenti elementi che possiamo tradurre HTML:
elementi
elementi
elementosegnaposto
attributiOsservando le interazioni che Matt ha creato, possiamo formulare regole per l'interazione degli elementi del modulo che creeremo. Queste regole saranno utili per creare il nostro markup, le regole di stile e le interazioni JavaScript.
elementi
&
elementi:
elementi
&
elementi:
elementi
&
elementi:
elementi
&
elementi: Ora che abbiamo determinato il modulo HTML elementi insieme alle sue regole di interazione, possiamo iniziare a crearlo.
Iniziamo prendendo un codice base di base.
Contattami
Ora creiamo il markup per il nostro modulo:
Contattami
Qui impostiamo un contenitore di moduli con un'intestazione di "Contact Me" e gli elementi di modulo corrispondenti strutturati all'interno di elementi di elenco. Notiamo che abbiamo anche assegnato il campo email type = "email"
. Ciò fornisce tastiere virtuali contestuali per i dispositivi che li supportano e una semplice convalida supportata dal browser per i browser che supportano i tipi di input HTML5. Per quelli che non lo fanno, diventa un semplice campo di testo.
Quello che abbiamo ora sono le basi di un modulo che funzionerà ovunque ed è adeguatamente strutturato per una semplice accessibilità.
Nota: Non trattiamo l'invio di moduli lato server in questo tutorial, quindi sentiti libero di cambiare il metodo di invio del modulo, se necessario.
Ora abbiamo una forma di lavoro in HTML. Ora faremo il nostro primo passo verso il miglioramento progressivo: l'applicazione CSS stili. Creiamo stili per rendere la nostra forma visivamente più accattivante, ricordando anche di mantenere la forma funzionale e accessibile.
Creiamo alcuni stili di base per la pagina e il contenitore dei moduli. Nel del nostro documento abbiamo creato un collegamento a un file chiamato
styles.css
, quindi creeremo quel file ora e lo salveremo nella radice del nostro progetto.
Iniziamo importando gli stili da Eric Meyer CSS ripristinare nel nostro file. Puoi prendere questi stili qui e copiarli nel tuo foglio di stile.
Successivamente, creiamo alcuni stili di pagina generali:
/ * Generale ==================================== * / *, *: prima, *: dopo -moz-box-dimensionamento: border-box; -webkit-box-dimensionamento: border-box; dimensionamento della scatola: border-box; body background: # eaedf1; body, input, textarea font: 1em / 1.5 Arial, Helvetica, sans-serif; .container larghezza massima: 25em; margine: 2em auto; larghezza: 95%; .title font-size: 1.5em; riempimento: .5em 0; allineamento del testo: centro; sfondo: # 323a45; colore bianco; border-radius: 5px 5px 0 0;
Noterai che usiamo l'approccio suggerito da Paul Irish per il modello box quando si disegnano le forme: dimensionamento della scatola: border-box;
.
Ora abbiamo qualcosa di meglio, ma avremo bisogno di altro lavoro.
Applichiamo alcuni stili ai nostri elementi del modulo. Questi renderanno la nostra forma più simile a quella di Matt.
Innanzitutto, modificheremo gli elementi della lista che contengono i nostri elementi del modulo.
/ * Modulo ==================================== * / .form ul background: bianco; margin-bottom: 1em; . form li border: 1px solid #ccc; border-bottom: 0; margin-bottom: 0px; posizione: relativa; . forma li: first-child border-top: 0; . forma li: last-child border-bottom: 1px solid #ccc;
Ora abbiamo tutti i nostri elementi di forma visivamente contenuti. Dovresti avere qualcosa di simile a questo:
Continuiamo a disegnare i nostri elementi di forma per abbinare il design di Matt tenendo conto anche dei vincoli di accessibilità del web.
Modella i campi di input come grandi elementi a livello di blocco nel modulo:
etichetta, input, textarea display: block; confine: 0; input, textarea width: 100%; altezza: 100%; imbottitura: 2.25em 1em 1em; contorni: 0; textarea height: 16em; ridimensionamento: nessuno;
Dovresti avere qualcosa di simile a questo:
Quindi modellare il modulo gli elementi da sedersi posizionati a circa un terzo del percorso dalla parte superiore di ciascun blocco di input.
label font-size: .8125em; / * 13/16 * / posizione: assoluta; superiore: 1.23em; a sinistra: 1.23em; colore: # f1773b; opacità: 1;
Nota: hai notato il opacità
regola? Useremo quella proprietà (insieme al superiore
proprietà) per animare il elemento più avanti utilizzando JavaScript.
Dovresti avere qualcosa che sta iniziando a somigliare molto al design del modulo di Matt.
Successivamente, è necessario personalizzare il pulsante di invio del modulo.
input [type = "submit"] background: # f1773b; margin-bottom: 1em; colore bianco; border-radius: 3px; imbottitura: .75em; -webkit-apparenza: nessuno; / * rimuovi il browser predefinito
Si noti che abbiamo utilizzato il selettore dell'attributo per scegliere come target solo il pulsante di invio. Abbiamo aggiunto alcuni stili di base insieme a una semplice interazione su : hover
e :attivo
stati (browser più vecchi che non supportano CSS trasforma
semplicemente non avrà un'interazione elegante, ma la forma funziona ancora). Ora dovresti avere qualcosa di simile a questo:
La nostra forma è stata disegnata in un modo simile al design di Matt, ma anche adattata per soddisfare i problemi di accessibilità del web. Si noti come, senza JavaScript, il modulo è ancora accessibile con i campi modulo visualizzati in ogni momento. Per gli utenti con browser meno recenti che non supportano il segnaposto
attributo, saranno comunque in grado di vedere i campi del modulo e accertare quali informazioni sono richieste da loro.
Inoltre, il e
gli elementi coprono l'intero blocco del campo modulo, quindi l'area di destinazione per ciascun input è abbastanza grande e accessibile.
Ad esempio, questo è come dovrebbe apparire il modulo a questo punto in Internet Explorer 8:
Adesso pensiamo a come implementare l'interazione che Matt ha creato usando JavaScript. Lo faremo in gran parte aggiungendo e rimuovendo CSS classi.
Noterai subito prima della chiusura tag abbiamo messo un link al nostro file JavaScript personalizzato chiamato
scripts.js
. Possiamo creare quel file ora e dire al browser di eseguire il codice quando il file DOM è pronto:
$ (document) .ready (function () // Il nostro codice qui);
segnaposto
supportoNel caso in cui non l'avessi notato, questa interazione dipende fortemente dal supporto dei segnaposto. L'attributo segnaposto è ampiamente supportato nei browser moderni. Poiché la nostra interazione con i moduli è così dipendente dal supporto dei segnaposto, prima verificheremo se il browser supporta il testo segnaposto. Se lo fa, implementeremo l'interazione del modulo. In caso contrario (IE8 e IE9) forniremo semplicemente il modulo di base senza interazione JavaScript. Miglioramento progressivo per la vittoria!
Per prima cosa, usiamo jQuery $ .Support ()
per vedere se il browser supporta il testo segnaposto. Questo verrà impostato $ .support.placeholder
a vero o falso, a seconda del supporto del browser per il testo segnaposto.
// Test per il supporto segnaposto $ .support.placeholder = (function () var i = document.createElement ('input'); return 'placeholder' in i;) ();
Se il testo segnaposto è supportato, possiamo nascondere il elementi sul caricamento della pagina. Come accennato in precedenza, nascondendo le etichette con JavaScript dopo il caricamento della pagina garantisce che i browser con JavaScript disattivato (e quelli senza supporto segnaposto) possano ancora utilizzare il modulo.
// Nascondere le etichette per impostazione predefinita se i segnaposto sono supportati se ($. Support.placeholder) $ ('. Form li'). Each (function () $ (this) .addClass ('js-hide-label'); ); // Codice per aggiungere / rimuovere classi qui
Si noti che abbiamo aggiunto una classe a ciascun elemento della lista denominato js-nasconde-label
. Questo perché, secondo le regole di interazione all'inizio del tutorial, l'aspetto predefinito del modulo ha le etichette dei campi modulo nascoste. Il js-nasconde-label
la classe sarà applicata al genitore elementi quando il discendente
l'elemento è vuoto del contenuto dell'utente.
Per facilitare la comprensione e la manutenibilità del codice, stiamo anteponendo le classi che aggiungiamo o rimuoviamo con JavaScript con 'js-'. Aggiungiamo quella classe al nostro foglio di stile e usiamola per nascondere tutti i discendenti etichetta
elementi dalla vista. Ricorda come avremmo usato il opacità
regola? Questo è dove lo usiamo per nascondere il elementi:
.etichetta js-hide-label opacity: 0; inizio: 1.5em
Nota: Il opacità
la proprietà è supportata in tutti i browser moderni. IE8 non lo riconoscerà, ma va bene perché IE8 non supporta gli attributi segnaposto, quindi non stiamo eseguendo JavaScript per applicare la classe in IE8. Win-win!
Se osservi da vicino, il design dell'interazione di Matt mostra le etichette dei campi dei moduli non solo apparendo e scomparendo, ma facendo così un piccolo movimento su e giù. Poiché i nostri elementi dell'etichetta sono posizionati in modo assoluto, quando aggiungiamo una classe che modifica il suo posizionamento in alto (o sinistra, destra o in basso) il browser può passare a quell'effetto. Tutto quello che dobbiamo fare è aggiungere una proprietà di transizione all'etichetta stessa.
Torniamo al nostro etichetta
elemento nel CSS e aggiungere una proprietà di transizione per il superiore
e opacità
proprietà:
label -webkit-transition: .333s eas top, .333s facilitano l'opacità; transizione: .333s facilità top, .333s facilità opacità;
Ciò consente alle etichette non solo di apparire e scomparire senza problemi, ma di ruzzolare su e giù quando diventano completamente opache o trasparenti, in questo modo:
Ora dovresti avere qualcosa di simile quando carichi la pagina (ovviamente in un browser moderno).
Come accennato in precedenza, stiamo aggiungendo e rimuovendo classi dal elementi e targeting per bambini che hanno bisogno di stile. A questo punto (sul caricamento della pagina) abbiamo aggiunto una classe di
js-nasconde-label
che nasconde tutte le etichette nel modulo. Ora abbiamo bisogno di un'altra classe per rimuovere il colore di evidenziazione dal elementi:
.etichetta js-unhighlight-label color: # 999
Ora abbiamo un modulo che è progressivamente migliorato e pronto per alcune interazioni JavaScript (nei browser moderni) quando l'utente inizia a interagire con il modulo.
All'interno del segnaposto Se
dichiarazione che abbiamo scritto sopra, iniziamo ad aggiungere e rimuovere il nostro js-
classi al momento giusto. In primo luogo, selezioneremo i nostri elementi del modulo e aggiungeremo un listener di eventi sul sfocatura
, messa a fuoco
, e keyup
eventi (noi usiamo keyup
piuttosto che keydown
o pressione di un tasto
poiché tali eventi spareranno prematuramente):
$ ('. form li'). find ('input, textarea'). on ('keyup blur focus', function (e) // Cache i nostri selettori var $ this = $ (this), $ parent = $ this .parent (); // Aggiungi o rimuovi classi if (e.type == 'keyup') // codice keyup qui else else (e.type == 'blur') // sfoca codice qui else if (e.type == 'focus') // codice focus qui);
Ecco una breve spiegazione di ciò che stiamo facendo qui:
$ ('. form li')
. Quindi, all'interno di quella selezione, troviamo tutto
e
i campi .trova ('input, textarea')
. Questo assicura che l'ultimo input nel nostro markup (il pulsante di invio) non sia incluso nella nostra selezione.sfocatura
, messa a fuoco
, e keyup
eventi e semplicemente controllare il tipo di evento usando tipo e
per determinare quali classi aggiungere o rimuovere in momenti specifici.keyup
In base alle regole di interazione stabilite all'inizio che corrispondono al design di Matt, quando un utente inizia a inserire il testo (non quando si concentrano sul campo) vogliamo mostrare l'etichetta.
Quindi, usando il keyup
evento, ogni volta che l'utente inserisce un carattere, possiamo verificare se il campo di input è vuoto (questo codice va all'interno if (e.type == 'keyup')
:
if ($ this.val () == ") $ parent.addClass ('js-hide-label'); else $ parent.removeClass ('js-hide-label');
Notate che la nostra logica funziona così:
Ora dovresti avere qualcosa che funzioni in questo modo quando inserisci o cancelli del testo da un campo di input:
sfocatura
Ora, secondo le nostre regole di interazione (di nuovo), sappiamo che quando un utente sposta lo stato attivo da un campo di input a quello successivo (sfocatura
evento), dovremmo de-enfatizzare il colore del elemento a seconda che l'utente abbia effettivamente inserito qualcosa nel campo.
Dentro il else if (e.type == 'blur')
, aggiungeremo il seguente codice:
if ($ this.val () == ") $ parent.addClass ('js-hide-label'); else $ parent.removeClass ('js-hide-label'). addClass ('js-unhighlight -label ');
Notate che la nostra logica funziona così:
js-nasconde-label
classe.js-nasconde-label
e de-enfatizzare il colore dell'etichetta aggiungendo la classe 'js-unhighlight-label'.Ora dovresti avere qualcosa che de-enfatizza il colore dell'etichetta quando rimuovi lo stato attivo, in questo modo:
messa a fuoco
Infine, dobbiamo aggiungere una piccola logica per quando un utente si concentra su un input. Seguendo le nostre regole di interazione, utilizziamo il seguente codice JavaScript all'interno di altrimenti se (e.type == 'focus')
sezione:
if ($ this.val ()! == ") $ parent.removeClass ('js-unhighlight-label');
La nostra logica funziona così:
Ora, quando un utente si concentra su un campo modulo, se non è vuoto, l'etichetta sarà enfatizzata con il colore di evidenziazione, in questo modo:
C'è molto di più che potremmo fare in questo modulo, inclusa l'aggiunta di validazione lato client e lato server. Potremmo anche creare altre classi per lo styling di valori di campi validi e non validi. Ad esempio, potremmo aggiungere stili a una classe di 'js-error' che andrebbe sul genitore elemento quando il valore dell'input non è valido, in questo modo:
.js-error border-color: # f13b3b! important; / * sovrascrive tutti i casi * / .js-error + li border-top-color: # f13b3b; .js-error label color: # f13b3b;
Questi tipi di stili di convalida potrebbero rendere la nostra forma un aspetto più simile a questo:
Tuttavia, questo tutorial intendeva mostrare come creare una forma accessibile e progressivamente migliorata che imitasse il design di Matt. E, devo dire, penso che abbiamo fatto abbastanza bene.
Sentiti libero di copiare, modificare o migliorare questo modulo in qualsiasi modo tu ritenga opportuno nei tuoi progetti!