In HTML, basic constraints are declared in two ways:

• By choosing the most semantically appropriate value for thetype attribute of the<input> element, e.g., choosing theemail type automatically creates a constraint that checks whether the value is a valid email address.
• By setting values on validation-related attributes, allowing basic constraints to be described without the need for JavaScript.

The intrinsic constraints for thetype attribute are:

For both of these input types, if themultiple attribute is set, several values can be set, as a comma-separated list. If any of these do not satisfy the condition described here, theType mismatch constraint violation is triggered.

Note that most input types don't have intrinsic constraints, as some are barred from constraint validation or have a sanitization algorithm transforming incorrect values to a correct default.

In addition to thetype attribute described above, the following attributes are used to describe basic constraints:

Constraint validation is done through the Constraint Validation API either on a single form element or at the form level, on the<form> element itself. The constraint validation is done in the following ways:

• By a call to thecheckValidity() orreportValidity() method of a form-associated DOM interface, (HTMLInputElement,HTMLSelectElement,HTMLButtonElement,HTMLOutputElement orHTMLTextAreaElement), which evaluates the constraints only on this element, allowing a script to get this information. ThecheckValidity() method returns a Boolean indicating whether the element's value passes its constraints. (This is typically done by the user-agent when determining which of the CSS pseudo-classes,:valid or:invalid, applies.) In contrast, thereportValidity() method reports any constraint failures to the user.
• By a call to thecheckValidity() orreportValidity() method on theHTMLFormElement interface.
• By submitting the form itself.

CallingcheckValidity() is calledstatically validating the constraints, while callingreportValidity() or submitting the form is calledinteractively validating the constraints.

Using JavaScript and the Constraint API, it is possible to implement more complex constraints, for example, constraints combining several fields, or constraints involving complex calculations.

Basically, the idea is to trigger JavaScript on some form field event (likeonchange) to calculate whether the constraint is violated, and then to use the methodfield.setCustomValidity() to set the result of the validation: an empty string means the constraint is satisfied, and any other string means there is an error and this string is the error message to display to the user.

The postal code format varies from one country to another. Many countries allow an optional prefix with the country code (likeD- in Germany,F- in France, andCH- in Switzerland). Some countries use only a fixed number of digits in postal codes, while others, like the UK, have more complex formats that allow letters at some specific positions.

As an example, we will add a script checking the constraint validation for a form:

<form>  <label for="postal-code">Postal Code: </label>  <input type="text" />  <label for="country">Country: </label>  <select>    <option value="ch">Switzerland</option>    <option value="fr">France</option>    <option value="de">Germany</option>    <option value="nl">The Netherlands</option>  </select>  <input type="submit" value="Validate" /></form>

This displays the following form:

First, we write a function checking the constraint itself:

function checkPostalCode() {  // For each country, defines the pattern that the postal code has to follow  const constraints = {    ch: [      "^(CH-)?\\d{4}$",      "Swiss postal codes must have exactly 4 digits: e.g. CH-1950 or 1950",    ],    fr: [      "^(F-)?\\d{5}$",      "French postal codes must have exactly 5 digits: e.g. F-75012 or 75012",    ],    de: [      "^(D-)?\\d{5}$",      "German postal codes must have exactly 5 digits: e.g. D-12345 or 12345",    ],    nl: [      "^(NL-)?\\d{4}\\s*([A-RT-Z][A-Z]|S[BCE-RT-Z])$",      "Dutch postal codes must have exactly 4 digits, followed by 2 letters except SA, SD and SS",    ],  };  // Read the country id  const country = document.getElementById("country").value;  // Get the NPA field  const postalCodeField = document.getElementById("postal-code");  // Build the constraint checker  const constraint = new RegExp(constraints[country][0], "");  console.log(constraint);  // Check it!  if (constraint.test(postalCodeField.value)) {    // The postal code follows the constraint, we use the ConstraintAPI to tell it    postalCodeField.setCustomValidity("");  } else {    // The postal code doesn't follow the constraint, we use the ConstraintAPI to    // give a message about the format required for this country    postalCodeField.setCustomValidity(constraints[country][1]);  }}

Then we link it to theonchange event for the<select> and theoninput event for the<input>:

window.onload = () => {  document.getElementById("country").onchange = checkPostalCode;  document.getElementById("postal-code").oninput = checkPostalCode;};

Another common constraint is to limit the size of a file to be uploaded. Checking this on the client side before the file is transmitted to the server requires combining the Constraint Validation API, and especially thefield.setCustomValidity() method, with another JavaScript API, here the File API.

Here is the HTML part:

<label for="fs">Select a file smaller than 75 kB: </label><input type="file" />

This displays:

The JavaScript reads the file selected, uses theFile.size() method to get its size, compares it to the (hard coded) limit, and calls the Constraint API to inform the browser if there is a violation:

function checkFileSize() {  const fs = document.getElementById("fs");  const files = fs.files;  // If there is (at least) one file selected  if (files.length > 0) {    if (files[0].size > 75 * 1000) {      // Check the constraint      fs.setCustomValidity("The selected file must not be larger than 75 kB");      fs.reportValidity();      return;    }  }  // No custom constraint violation  fs.setCustomValidity("");}

Finally, we hook the method with the correct event:

window.onload = () => {  document.getElementById("fs").onchange = checkFileSize;};

Apart from setting constraints, web developers want to control what messages are displayed to the users and how they are styled.

The look of elements can be controlled via CSS pseudo-classes.

:required and :optional CSS pseudo-classes

The:required and:optionalpseudo-classes allow writing selectors that match form elements that have therequired attribute, or that don't have it.

:placeholder-shown CSS pseudo-class

See:placeholder-shown.

:valid :invalid CSS pseudo-classes

The:valid and:invalidpseudo-classes are used to represent <input> elements whose content validates and fails to validate respectively according to the input's type setting. These classes allow the user to style valid or invalid form elements to make it easier to identify elements that are either formatted correctly or incorrectly.

The following items can help with controlling the text of a constraint violation:

• ThesetCustomValidity(message) method on the following elements:

  • <fieldset>. Note: Setting a custom validity message on fieldset elements will not prevent form submission in most browsers.
  • <input>
  • <output>
  • <select>
  • Submit buttons (created with either a<button> element with thesubmit type, or aninput element with thesubmit type. Other types of buttons do not participate in constraint validation.
  • <textarea>

• TheValidityState interface describes the object returned by thevalidity property of the element types listed above. It represents various ways that an entered value can be invalid. Together, they help explain why an element's value fails to validate, if it's not valid.