En utilisant la conception d'interaction de formulaire mobile de Matt Smith comme guide, nous allons créer une interaction de formulaire étonnante pour le Web, belle et accessible à l'aide de HTML, CSS et JavaScript.
La conception de formulaires et les interactions sur le Web peuvent constituer un sujet sensible. La multiplicité des problèmes d'accessibilité des formulaires et des meilleures pratiques peut rendre très difficile la conception d'une interaction de forme convaincante, par opposition à la conception de formulaire sur des plateformes natives..
Matt Smith a récemment créé une interaction de forme convaincante qu'il a publiée dans Dribbble:
Bien que conçu pour une application iOS native, cette interaction de formulaire peut être recréée pour le Web à l'aide de HTML, CSS et Javascript tout en apaisant les problèmes d'accessibilité du formulaire..
Le concept des étiquettes flottantes a suscité beaucoup d’attention, ce qui a donné lieu à des discussions et à des expériences sur le Web..
Une démo vraiment cool de @zelph http://t.co/Szw1bE2tib mettant en œuvre l'interaction de formulaire avec une étiquette flottante super géniale http://t.co/NhKfErgd2Q de @mds
- Brad Frost (@brad_frost) 23 octobre 2013
Plutôt que d'utiliser les mêmes champs de formulaire dans la conception de Matt, nous allons créer un simple formulaire de contact que vous pourriez utiliser sur votre propre site Web. Alors plongeons dans!
Premièrement, observons et enregistrons les interactions de forme créées par Matt. Cela nous permettra de prédéterminer comment notre formulaire doit être annoté. Cela nous permettra également de bien comprendre comment styliser le formulaire et créer ses interactions avec JavaScript..
Le formulaire contient les éléments suivants, nous pouvons traduire en HTML:
éléments
éléments
élémentespace réservé
les attributsEn observant les interactions créées par Matt, nous pouvons formuler des règles pour l’interaction des éléments de formulaire que nous allons créer. Ces règles seront utiles lors de la création de nos balises, règles de style et interactions JavaScript..
éléments
Et
éléments:
éléments
Et
éléments:
éléments
Et
éléments:
éléments
Et
éléments: Maintenant que nous avons déterminé la forme HTML éléments avec ses règles d'interaction, nous pouvons commencer à le créer.
Commençons par obtenir un code de démarrage de base.
Contactez moi
Créons maintenant le balisage pour notre formulaire:
Contactez moi
Ici, nous configurons un conteneur de formulaire avec un en-tête «Contactez-moi» et les éléments de formulaire correspondants structurés dans des éléments de liste. Notez que nous avons également assigné le champ email type = "email"
. Cela fournit des claviers virtuels contextuels pour les périphériques qui les prennent en charge, ainsi qu'une validation simple prise en charge par le navigateur pour les navigateurs prenant en charge les types de saisie HTML5. Pour ceux qui ne le font pas, cela devient un simple champ de texte.
Ce que nous avons maintenant, ce sont les bases d'un formulaire qui fonctionnera n'importe où et qui est correctement structuré pour une accessibilité simple..
Remarque: Nous ne couvrons pas la soumission de formulaire côté serveur dans ce didacticiel, alors n'hésitez pas à modifier la méthode de soumission du formulaire si nécessaire.
Nous avons maintenant un formulaire de travail en HTML. Maintenant, nous allons faire notre premier pas dans l'amélioration progressive: appliquer CSS modes. Créons des styles pour rendre notre formulaire plus attrayant tout en gardant notre formulaire fonctionnel et accessible..
Créons un style de base pour le conteneur de page et de formulaire. dans le de notre document, nous avons créé un lien vers un fichier nommé
styles.css
, nous allons donc créer ce fichier maintenant et l'enregistrer à la racine de notre projet.
Nous commençons par importer les styles de Eric Meyer CSS réinitialiser dans notre propre fichier. Vous pouvez saisir ces styles ici et les copier dans votre propre feuille de style.
Ensuite, créons quelques styles de page généraux:
/ * Général =================================== * / *, *: avant, *: après -moz-box-sizing: border-box; -webkit-box-dimensionnement: border-box; taille de la boîte: boîte-frontière; body background: # eaedf1; body, input, textarea font: 1em / 1.5 Arial, Helvetica, sans-serif; .container max-width: 25em; marge: 2em auto; largeur: 95%; .title font-size: 1.5em; remplissage: .5em 0; text-align: center; arrière-plan: # 323a45; Couleur blanche; border-radius: 5px 5px 0 0;
Vous remarquerez que nous utilisons l'approche suggérée par Paul Irish en ce qui concerne le modèle de boîte: taille de la boîte: boîte-frontière;
.
Maintenant, nous avons quelque chose d'un peu mieux, mais il faudra encore du travail..
Appliquons des styles à nos éléments de formulaire. Cela fera ressembler notre forme à celle de Matt.
Tout d'abord, nous allons styliser les éléments de la liste qui contiennent nos éléments de formulaire.
/ * Formulaire =================================== * / .form ul background: white; marge en bas: 1em; .form li border: 1px solid #ccc; bordure inférieure: 0; marge inférieure: 0px; position: relative; .form li: premier-enfant border-top: 0; .form li: dernier-enfant border-bottom: 1px solide #ccc;
Maintenant, tous nos éléments de formulaire sont visuellement contenus. Vous devriez avoir quelque chose comme ça:
Continuons à styler nos éléments de forme pour les faire correspondre au design de Matt tout en tenant compte des contraintes d'accessibilité du Web..
Définissez les champs de saisie comme de gros éléments de niveau bloc dans le formulaire:
label, input, textarea display: block; bordure: 0; input, textarea width: 100%; hauteur: 100%; rembourrage: 2,25em 1em 1em; contour: 0; textarea height: 16em; redimensionner: aucun;
Vous devriez avoir quelque chose comme ça:
Puis stylisez la forme les éléments doivent être positionnés à environ un tiers du sommet de chaque bloc d'entrée.
label taille de police: .8125em; / * 13/16 * / position: absolue; en haut: 1,23 m; à gauche: 1,23 m; couleur: # f1773b; opacité: 1;
Remarque: avez-vous remarqué le opacité
règle? Nous allons utiliser cette propriété (avec le Haut
propriété) pour animer le élément plus tard en utilisant JavaScript.
Vous devriez avoir quelque chose qui commence à ressembler beaucoup à la conception des formulaires de Matt.
Ensuite, besoin de styler notre bouton d'envoi de formulaire.
input [type = "submit"] background: # f1773b; marge en bas: 1em; Couleur blanche; border-radius: 3px; rembourrage: .75em; -webkit-apparence: aucun; / * supprime le navigateur par défaut
Remarquez que nous avons utilisé le sélecteur d'attribut pour cibler uniquement le bouton d'envoi. Nous avons ajouté quelques styles de base ainsi qu’une simple interaction sur le :flotter
et :actif
états (navigateurs plus anciens qui ne supportent pas CSS se transforme
n’aura tout simplement pas une interaction sophistiquée, mais la forme fonctionne toujours). Vous devriez maintenant avoir quelque chose comme ça:
Notre formulaire a été conçu de manière à ressembler au design de Matt, mais il a également été adapté pour apaiser les problèmes d'accessibilité du Web. Remarquez comment, sans JavaScript, le formulaire est toujours accessible avec les champs de formulaire affichés à tout moment. Pour les utilisateurs de navigateurs plus anciens qui ne prennent pas en charge la espace réservé
attribut, ils seront toujours en mesure de voir les champs de formulaire et de déterminer quelle information est requise d'eux.
De plus, le et
les éléments couvrent l'ensemble du bloc de champ de formulaire, de sorte que la zone cible de chaque entrée est assez grande et accessible.
Par exemple, voici à quoi ressemblerait le formulaire à ce stade d'Internet Explorer 8:
Nous devrions maintenant commencer à réfléchir à la manière de mettre en œuvre l’interaction créée par Matt en JavaScript. Nous y parviendrons en grande partie en ajoutant et en supprimant CSS Des classes.
Vous remarquerez juste avant la fermeture tag nous mettons un lien vers notre fichier JavaScript personnalisé nommé
scripts.js
. Nous pouvons créer ce fichier maintenant et dire au navigateur d’exécuter le code lorsque le DOM est prêt:
$ (document) .ready (function () // notre code ici);
espace réservé
soutienAu cas où vous ne l'auriez pas remarqué, cette interaction est fortement dépendante du support réservé. L'attribut de marque de réservation est largement pris en charge par les navigateurs modernes. Étant donné que notre interaction avec les formulaires dépend tellement de la prise en charge des paramètres de substitution, nous allons d'abord vérifier si le navigateur prend en charge le texte de substitution. Si c'est le cas, nous allons implémenter l'interaction de formulaire. Si ce n'est pas le cas (IE8 et IE9), nous fournirons simplement le formulaire de base sans interaction JavaScript. Amélioration progressive pour la victoire!
Tout d'abord, utilisons jQuery $ .support ()
pour voir si le navigateur prend en charge le texte d’espace réservé. Cela définira $ .support.placeholder
true ou false, selon la prise en charge par le navigateur du texte fictif.
// Test de prise en charge d'espace réservé $ .support.placeholder = (function () var i = document.createElement ('input'); return 'placeholder' in i;) ();
Si le texte de substitution est pris en charge, nous pouvons masquer le éléments sur le chargement de la page. Comme mentionné précédemment, le fait de masquer les étiquettes avec JavaScript après le chargement de la page garantit que les navigateurs avec JavaScript désactivé (et ceux sans prise en charge d'espace réservé) peuvent toujours utiliser le formulaire..
// Masque les libellés par défaut si les espaces réservés sont pris en charge si ($. Support.placeholder) $ ('. Form li'). Each (function () $ (this) .addClass ('js-hide-label'); ); // Code pour ajouter / supprimer des classes ici
Notez que nous avons ajouté une classe à chaque élément de la liste nommé js-hide-label
. En effet, conformément aux règles sur les interactions énoncées au début du didacticiel, l'apparence par défaut du formulaire a les étiquettes de champs de formulaire masquées. le js-hide-label
la classe sera appliquée au parent éléments lorsque le descendant
l'élément est vide du contenu de l'utilisateur.
Pour aider à la compréhension et à la maintenabilité du code, nous préfixons les classes que nous ajoutons ou supprimons avec JavaScript avec 'js-'. Ajoutons cette classe à notre feuille de style et utilisons-la pour masquer tous les descendants. étiquette
éléments de vue. Rappelez-vous comment nous allions utiliser le opacité
règle? C’est là que nous l’utilisons pour cacher le éléments:
.js-hide-label label opacité: 0; en haut: 1.5em
Remarque: le opacité
Cette propriété est prise en charge par tous les navigateurs modernes. IE8 ne le reconnaîtra pas, mais c'est correct, car IE8 ne prend pas non plus en charge les attributs d'espace réservé. Par conséquent, nous n'exécutons pas JavaScript pour appliquer la classe dans IE8. Gagnant-gagnant!
Si vous observez attentivement, le design d'interaction de Matt montre les étiquettes de champs de formulaire non seulement apparaissant et disparaissant, mais également avec un léger mouvement de haut en bas. Comme nos éléments d’étiquette sont positionnés de manière absolue, lorsque nous ajoutons une classe qui modifie son positionnement en haut (ou à gauche, à droite ou en bas), le navigateur peut effectuer la transition de cet effet. Tout ce que nous avons à faire est d’ajouter une propriété de transition à l’étiquette elle-même..
Revenons à notre étiquette
élément dans le CSS et ajouter une propriété de transition pour le Haut
et opacité
Propriétés:
label -webkit-transition: .333s au sommet, .333s au au moins opacité; transition: .333 soulage en haut, .333 assouplit l'opacité;
Cela permet aux étiquettes non seulement d'apparaître et de disparaître en douceur, mais également de faire des sautillements lorsqu'elles deviennent complètement opaques ou transparentes, comme ceci:
Vous devriez maintenant avoir quelque chose comme ça quand vous chargez la page (dans un navigateur moderne bien sûr).
Comme mentionné précédemment, nous ajoutons et supprimons des classes du éléments et en ciblant tous les enfants qui ont besoin de style. À ce stade (au chargement de la page), nous avons ajouté une classe de
js-hide-label
qui cache toutes les étiquettes dans le formulaire. Nous avons maintenant besoin d’une classe supplémentaire pour supprimer la couleur de surbrillance du éléments:
.étiquette js-unhighlight-label color: # 999
Nous avons maintenant un formulaire qui est progressivement amélioré et prêt pour certaines interactions JavaScript (dans les navigateurs modernes) lorsque l'utilisateur commence à interagir avec le formulaire..
À l'intérieur de l'espace réservé si
déclaration que nous avons écrite ci-dessus, commençons à ajouter et à supprimer notre js-
cours au bon moment. Tout d’abord, nous allons sélectionner nos éléments de formulaire et ajouter un écouteur d’événement sur la page. brouiller
, concentrer
, et keyup
événements (nous utilisons keyup
plutôt que touche Bas
ou appuyez sur la touche
comme ces événements vont se déclencher prématurément):
$ ('.form li'). find ('input, textarea'). on ('keyup blur focus', function (e) // Cache nos sélecteurs var $ this = $ (this), $ parent = $ this .parent (); // Ajouter ou supprimer des classes if (e.type == 'keyup') // code keyup ici else if (e.type == 'blur') // code flou ici else if (type == 'focus') // code de focus ici);
Voici une brève explication de ce que nous faisons ici:
$ ('. forme li')
. Ensuite, dans cette sélection, nous trouvons tous
et
des champs .find ('input, textarea')
. Cela garantit que la dernière entrée de notre marquage (le bouton d'envoi) n'est pas incluse dans notre sélection..brouiller
, concentrer
, et keyup
événements et simplement vérifier le type d'événement en utilisant e.type
pour déterminer quelles classes nous ajouterons ou supprimerons à des moments spécifiques.keyup
Selon les règles d'interaction énoncées au début, qui correspondent à la conception de Matt, lorsqu'un utilisateur commence à saisir du texte (ne pas quand ils se concentrent sur le terrain) nous voulons montrer l'étiquette.
Donc, en utilisant le keyup
événement, chaque fois que l'utilisateur entre un caractère, nous pouvons vérifier si le champ de saisie est vide (ce code va à l'intérieur if (e.type == 'keyup')
:
if ($ this.val () == ") $ parent.addClass ('js-hide-label'); autre $ parent.removeClass ('js-hide-label');
Notez que notre logique fonctionne comme ceci:
Vous devriez maintenant avoir quelque chose qui fonctionne comme ceci lorsque vous entrez ou supprimez du texte dans un champ de saisie:
brouiller
Maintenant, selon nos règles d’interaction (encore une fois), nous savons que lorsqu'un utilisateur déplace le focus d’un champ de saisie à un autre (brouiller
événement), nous devrions minimiser la couleur de la élément selon que l'utilisateur a réellement entré quoi que ce soit dans le champ.
À l'intérieur de else if (type == 'flou')
, nous allons ajouter le code suivant:
if ($ this.val () == ") $ parent.addClass ('js-hide-label'); autre $ parent.removeClass ('js-hide-label'). addClass ('js-unhighlight -label ');
Notez que notre logique fonctionne comme ceci:
js-hide-label
classe.js-hide-label
et atténuer la couleur de l'étiquette en ajoutant la classe 'js-unhighlight-label'.Vous devriez maintenant avoir quelque chose qui atténue la couleur de l'étiquette quand vous supprimez le focus, comme ceci:
concentrer
Enfin, nous devons ajouter un peu de logique lorsque l’utilisateur se concentre sur une entrée. Suivant nos règles d’interaction, utilisons le code JavaScript suivant à l’intérieur du else if (type == 'focus')
section:
if ($ this.val ()! == ") $ parent.removeClass ('js-unhighlight-label');
Notre logique fonctionne comme ceci:
Désormais, lorsqu'un utilisateur se concentre sur un champ de formulaire, s'il n'est pas vide, l'étiquette est mise en évidence avec la couleur de surbrillance, comme suit:
Nous pourrions faire beaucoup plus avec ce formulaire, notamment en ajoutant une validation côté client et côté serveur. Nous pourrions également créer quelques classes supplémentaires pour le style des valeurs de champ valides et non valides. Par exemple, nous pourrions ajouter des styles à une classe de 'js-error' qui irait au parent élément lorsque la valeur de l'entrée est invalide, comme ceci:
.js-error border-color: # f13b3b! important; / * remplace tous les cas * / .js-error + li border-top-color: # f13b3b; .js-error label color: # f13b3b;
Ces types de styles de validation pourraient rendre notre formulaire plus ressemblant à ceci:
Cependant, ce didacticiel visait à montrer comment créer une forme accessible et progressivement améliorée imitant le design de Matt. Et je dois dire que je pense que nous avons très bien réussi.
N'hésitez pas à copier, modifier ou améliorer ce formulaire de la manière que vous jugerez utile dans vos propres projets.!