The form element formally defines a form and attributes that determine the form's behavior. Each time you want to create an HTML form, you must start it by using this element, nesting all the contents inside. Many assistive technologies and browser plugins can discover form elements and implement special hooks to make them easier to use.
We already met this in the previous article.
It's always possible to use a form control outside of a form element. If you do so, by default that control has nothing to do with any form unless you associate it with a form using its form attribute. This was introduced to let you explicitly bind a control with a form even if it is not nested inside it.
Let's move forward and cover the structural elements you'll find nested in a form.
and \ elements
The fieldset element is a convenient way to create groups of widgets that share the same purpose, for styling and semantic purposes. You can label a fieldset by including a legend element just below the opening fieldset tag. The text content of the legend formally describes the purpose of the fieldset it is included inside.
Many assistive technologies will use the legend element as if it is a part of the label of each control inside the corresponding fieldset element. For example, some screen readers such as Jaws and NVDA will speak the legend's content before speaking the label of each control.
Here's an example:
```html live-sample___fieldset-legend
Fruit juice size
Small
Medium
Large
This renders as follows:
100%
When reading the above form, a screen reader will speak "Fruit juice size small" for the first radio button label, "Fruit juice size medium" for the second, and "Fruit juice size large" for the third.
Each time you have a set of radio buttons, you should nest them inside a fieldset element. There are other use cases, and in general the fieldset element can also be used to section a form. Ideally, long forms should be spread across multiple pages, but if a form is getting long and must be on a single page, putting the different related sections inside different fieldsets improves usability.
Because of its influence over assistive technology, the fieldset element is one of the key elements for building accessible forms; however, it is your responsibility not to abuse it. If possible, each time you build a form, try to [listen to how a screen reader](/docs/Learn_web_development/Core/Accessibility/Tooling#screen_readers) interprets it. If it sounds odd, try to improve the form structure.
## The \<label> element
As we saw in the previous article, the label element is the formal way to define a label for an HTML form widget. This is the most important element if you want to build accessible forms — when implemented properly, screen readers will speak a form element's label along with any related instructions, as well as it being useful for sighted users. Take this example, which we saw in the previous article:
```html
<label for="name">Name:</label> <input type="text" id="name" name="user_name" />
With the <label> associated correctly with the <input> via its for attribute (which contains the <input> element's id attribute), a screen reader will read out something like "Name, edit text".
There is another way to associate a form control with a label — nest the form control within the <label>, implicitly associating it.
<label for="name">
Name: <input type="text" id="name" name="user_name" />
</label>
Even in such cases however, it is considered best practice to set the for attribute to ensure all assistive technologies understand the relationship between label and widget.
If there is no label, or if the form control is neither implicitly nor explicitly associated with a label, a screen reader will read out something like "Edit text blank", which isn't very helpful at all.
Labels are clickable, too!
Another advantage of properly set up labels is that you can click or tap the label to activate the corresponding widget. This is useful for controls like text inputs, where you can click the label as well as the input to focus it, but it is especially useful for radio buttons and checkboxes — the hit area of such a control can be very small, so it is useful to make it as easy to activate as possible.
For example, clicking on the "I like cherry" label text in the example below will toggle the selected state of the taste_cherry checkbox:
```html live-sample___checkbox-label
I like cherry
I like banana
Try it out:
100%
### Multiple labels
Strictly speaking, you can put multiple labels on a single widget, but this is not a good idea as some assistive technologies can have trouble handling them. In the case of multiple labels, you should nest a widget and its labels inside a single label element.
Let's consider this example:
```html
<p>Please complete all required (*) fields.</p>
<!-- So this: -->
<!--<div>
<label for="username">Name:</label>
<input id="username" type="text" name="username" required />
<label for="username">*</label>
</div>-->
<!-- would be better done like this: -->
<!--<div>
<label for="username">
<span>Name:</span>
<input id="username" type="text" name="username" required />
<span>*</span>
</label>
</div>-->
<!-- But this is probably best: -->
<div>
<label for="username">Name *:</label>
<input id="username" type="text" name="username" required />
</div>
120
The paragraph at the top states a rule for required elements. The rule must be included before it is used so that sighted users and users of assistive technologies (AT) such as screen readers can learn what it means before they encounter a required element.
Beyond the structures specific to web forms, it's good to remember that form markup is just HTML. This means that you can use all the power of HTML to structure a web form.
As you can see in the examples, it's common practice to wrap a label and its widget with a li element within a ul or ol list. p and div elements are also commonly used. Lists are recommended for structuring multiple checkboxes or radio buttons.
In addition to the fieldset element, it's also common practice to use HTML titles (e.g., h1, h2) and sectioning (e.g., section) to structure complex forms.
Above all, it is up to you to find a comfortable coding style that results in accessible, usable forms. Each separate section of functionality should be contained in a separate section element, with fieldset elements to contain radio buttons.
Let's put these ideas into practice and build a slightly more involved form — a payment form. This form will contain a number of control types that you may not yet understand. Don't worry about this for now; you'll find out how they work in the next article (Basic native form controls ). For now, read the descriptions carefully as you follow the below instructions, and start to form an appreciation of which wrapper elements we are using to structure the form, and why.
To start with, make a local copy of our blank template file in a new directory on your computer.
Next, create your form by adding a form element:
```html-nolint
```
```css hidden
h1 {
margin-top: 0;
}
ul {
margin: 0;
padding: 0;
list-style: none;
}
form {
margin: 0 auto;
width: 400px;
padding: 1em;
border: 1px solid #cccccc;
border-radius: 1em;
}
div + div {
margin-top: 1em;
}
label span {
display: inline-block;
text-align: right;
}
input,
textarea {
font: 1em sans-serif;
width: 250px;
box-sizing: border-box;
border: 1px solid #999999;
}
input[type="checkbox"],
input[type="radio"] {
width: auto;
border: none;
}
input:focus,
textarea:focus {
border-color: black;
}
textarea {
vertical-align: top;
height: 5em;
resize: vertical;
}
fieldset {
width: 250px;
box-sizing: border-box;
border: 1px solid #999999;
}
button {
margin-top: 20px;
}
label {
display: inline-block;
}
p label {
width: 100%;
}
```
We applied some extra CSS to the finished form below. If you'd like to make changes to the appearance of your form, you can copy styles from [the example](/docs/Learn_web_development/Extensions/Forms/How_to_structure_a_web_form/Example) or visit [Styling web forms](/docs/Learn_web_development/Extensions/Forms/Styling_web_forms).
```js hidden
document.querySelector("form").addEventListener("submit", (event) => {
event.preventDefault();
});
```
100%
## Summary
You now have all the knowledge you'll need to properly structure your web forms. We will cover many of the features introduced here in the next few articles, with the next article looking in more detail at using all the different types of form widgets you'll want to use to collect information from your users.
## See also
- [A List Apart: _Sensible Forms: A Form Usability Checklist_](https://alistapart.com/article/sensibleforms/)
Learn_web_development/Extensions/Forms/Basic_native_form_controls