Overview
Frontend form validation
Parsley is a javascript form validation. It helps you providing your users feedbacks on their form submission before sending it to your server. It saves you bandwidth, server load and it saves time for your user.
This javascript form validation is not necessary, and if used, this do not replace a strong backend server validation.
That's why Parsley is here: to let you define your general form validation, implement it on the backend side, and simply port it frontend-side, with maximum respect to user experience best practices.
Parsley 1.x versions
Parsley current stable and supported versions are 2.x. If you still use a 1.x version, here is the related doc. But don't forget to upgrade!
Data attributes
Parsley use a specific DOM API that allow to configure pretty much everything directly from your DOM, without writing a single javascript configuration line ou custom function. Parsley default DOM API is data-parsley-
. That means that if in config you see a foo
property, it could be set/modified via DOM with data-parsley-foo="value"
.
More on Parsley DOM API
- For composed property names, Parsley uses camelization, like jQuery
$.data()
does. That means thatdata-parsley-composed-property
will correspond in code tocomposedProperty
, and reciprocally. - Every property set in DOM will be stored in
this.options
for each Parsley instance. - You can change the DOM API namespace directly in DOM (inception), by doing
data-parsley-namespace="data-my-namespace-"
and then your Parsley DOM attributes will look likedata-my-namespace-property="value"
. - Special chars: if you are facing referencing names with special chars, like
id="this:is:a:special:id"
, you'll need in DOM API to use this syntax:data-parsley-errors-container='div[id="this:is:a:special:id"]'
otherwise it won't work.
Configuration
You'll see along this documentation and through examples various available configuration options. You can also view here all Parsley's default configuration options.
Installation
Basic installation
Parsley rely on jQuery (>= 1.6) that would need to be called before including Parsley.
Then, you can either use parsley.js
unminified file or parsley.min.js
minified one. These files and other builds (Remote, Extras..) are available here.
Finally, add data-parsley-validate
to each <form>
you want to be validated.
That would look pretty much like this:
<script src="jquery.js"></script>
<script src="parsley.min.js"></script>
<form data-parsley-validate>
...
</form>
Parsley CSS
Parsley adds many classes and elements in the DOM when it validates. You are strongly encouraged to customize them in your own stylesheets, but here is the "standard" Parsley css file that is used here on the documentation and examples, if you want to use it to bootstrap your projects with Parsley.
Javascript installation
Like for Basic installation, manage to require jQuery and Parsley. Then, simply use $('#form').parsley(options);
or new Parsley('#form', options);
(where options
is an optional configuration object) to manually bind Parsley to your forms.
That would look pretty much like this:
<script src="jquery.js"></script>
<script src="parsley.min.js"></script>
<form id="form">
...
</form>
<script type="text/javascript">
$('#form').parsley();
</script>
Do not add data-parsley-validate
to your forms
Please be aware that parsley looks on document load at all data-parsley-validate
occurrences in DOM and automatically bind them if valid.
Once a form or field instance is binded by Parsley, default instantiation options could not be easily updated, only the ones defined in the DOM. That means that if this DOM validation attribute is present, doing $('#form').parsley(options);
would just return the automatically already binded instance, and not the one you would expect with the options
you wanted to set.
Localization
Parsley comes with various error messages for its built-in validators. They are shipped in English by default, but many other languages are available, thanks to the awesome international Parsley community. See the available localizations here.
To load a different locale and its messages, you have two possibilities:
-
Load your needed localization before parsley, then select the one you need then once Parsley is loaded and if you want to switch from the English default one. In this example, we'll load both French and Italian translations, and use French:
<script src="jquery.js"></script> <script src="i18n/fr.js"></script> <script src="i18n/it.js"></script> <script src="parsley.min.js"></script> <script type="text/javascript"> window.ParsleyValidator.setLocale('fr'); </script>
-
Load your needed localization after parsley. Last loaded file will automatically set the messages locale for ParsleyValidator. In this example, we'll load both French and Italian translations, and use Italian:
<script src="jquery.js"></script> <script src="parsley.min.js"></script> <script src="i18n/fr.js"></script> <script src="i18n/it.js"></script>
Plugins
Parsley strive to be well decoupled and modular. It uses events and inheritance, that allows various plugins.
Current available plugins are:
- Parsley Remote: provide an ajax validator and an asynchronous validation
- Parsley Extras: provide some extras useful validators
Usage
Overview
Parsley is a decoupled library that uses differents classes to do the heavy work. You'll see here the different protagonists involved and how you can configure them to fit your desired validation.
$ API | Return |
---|---|
$('#existingForm').parsley(options) |
parsleyFormInstance |
$('#existingInput').parsley(options) |
parsleyFieldInstance |
$('#notExistingDOMElement').parsley(options) |
undefined |
$('.multipleElements').parsley(options) |
Array[Instances] |
Look at the source code!
Of course, this documentation strive to be the most exhaustive possible and relatively easy to understand. This documentation also provide the complete annotated source. Please take 5 minutes of your time to have a quick glance at it, and at least understand the architecture (Parsley, ParsleyForm, ParsleyField, ParsleyValidator, ParsleyUI, Utils, Pub/Sub..), it will heavily ease the lecture below.
Form
When doing $('#target').parsley()
or new Parsley('#target');
on a <form id="target">
element, it will bind the whole form and its various inputs and return you a ParsleyForm
instance.
Field options inheritance
All the options you pass through DOM or constructor for a form will be inherited by every ParsleyField
input instance that belongs to the form. This is a handy way to configure all your form's inputs in a row by passing their config through form.
Options
Property | Default | Description |
---|---|---|
data-parsley-namespace |
data-parsley- |
Namespace used by Parsley DOM API to bind options from DOM. See more |
data-parsley-validate |
Auto bind your form with Parsley validation on document load. | |
data-parsley-priority-enabled |
true |
Either validate higher priority constraints first and stop on first failure (true ), or validate all constraints simultaneously and show all failing ones (false ). |
data-parsley-excluded |
input[type=button], input[type=submit], input[type=reset] |
Form fields that won't be validated by Parsley. If you want for example to add disabled fields to the existing list, use data-parsley-excluded="input[type=button], input[type=submit], input[type=reset], [disabled]" |
Methods
Method | Returns | Description |
---|---|---|
isValid(group, force) |
boolean |
Returns if the Form is valid or not. Does not affect UI nor fires events. If group given, only validate fields that belongs to this group. If force given, force validation even on non required fields (See example) |
validate(group, force) |
boolean
|
Validate form. Prevent submission if not valid. Fires events and affect UI.. You can only validate a certain group of fields by specifying optional group string parameter. If group given, only validate fields that belongs to this group. If force given, force validation even on non required fields (See example) |
reset() |
Reset UI for this form and for its fields. | |
destroy() |
Disable and destroy Parsley for this form and its fields. |
UI
See UI for Form section.Field
When doing $('#target').parsley()
or new Parsley('#target');
on a <input id="target">
element (or <textarea>
, <select>
), it will bind the field and return you a ParsleyField
instance. Exception made for inputs type radio and checkbox that does not have a name
attribute or a data-parsley-multiple
attribute, they won't be binded (ignored) and would eventually raise a warning in console.
Options
Property | Description |
---|---|
data-parsley-value |
Set a specific field value for Parsley validation, dissociated from the real one. eg: data-parsley-value="foo" |
data-parsley-group |
Assign a group to a field for specifig group validation. eg: data-parsley-group="signup" . That way, you could only valid a portion on a form and not the whole fields. |
data-parsley-multiple |
You can add this attribute to radio / checkboxes elements like that data-parsley-multiple="mymultiplelink" to link them together if they don't share the same name. |
data-parsley-validate-if-empty |
A field is by default not validated if not required and empty. By adding data-parsley-validate-if-empty , validation will be done even if field is empty. Useful if you need some custom validators that check something particular when field is empty. |
data-parsley-trim-value |
Trim field value only for Parsley validation (and not inside the input itself, data sent by your form won't be trimmed). Useful if your backend already do so and if trailing spaces could unnecessarily mess with your validation. Use data-parsley-trim-value="true" . |
data-parsley-ui-enabled |
If set to false , Parsley will not affect UI for this field. |
data-parsley-errors-messages-disabled |
Add parsley-success and parsley-error classes on field, but no error message. |
Checkbox, radio and select multiple
These fields are a bit different than regular input
, textarea
or simple select
. They need to have either a name
or an id
attribute to be correctly binded and validated by Parsley. Otherwise, they would be ignored and a warning will be put in the console.
Methods
Method | Returns | Description |
---|---|---|
isValid(force) |
boolean |
Returns if the Field is valid or not. Does not affect UI nor fires events. If force given, force validation even on non required fields (See example) |
validate(force) |
true if all ok[] if empty optional field[Violation [, Violation..]] if fails
|
Validate Field. Fires events and affect UI. If force given, force validation even on non required fields (See example) |
reset() |
Reset UI for this field. | |
destroy() |
Disable and destroy Parsley for this field. |
UI
See UI for Field section.Built-in validators
Overview
Parsley 2.x is now based on validator.js that ships usual validators and ease a lot group and priority validation. That way, Parsley mutualize validators with validators.js and define new ones using the Callback()
Assert.
Use Validator.js in your Parsley projects
Parsley let you use validator.js in window.ParsleyValidator.Validator
Validators list
These validators are shipped in parsley.js
. Have a look at Parsley Remote plugin and Parsley Extras for more validators.
Craft yours!
Of course, Parsley built-in validators are well used and usual validators, and you'll need some more that fit your specific forms and validations. That's why Parsley let you easily create your own validators.
Here again, like localizations, configuring your custom validators and error messages comes with two flavors:
- By registering them in some globals before calling
parsley.js
:<input type="text" data-parsley-multiple="3" /> [...] <script type="text/javascript"> window.ParsleyConfig = { validators: { multiple: { fn: function (value, requirement) { return 0 === value % requirement; }, priority: 32 } }, i18n: { en: { multiple: 'This value should be a multiple of %s' }, fr: { multiple: 'Cette valeur doit ĂȘtre un multiple de %s' } } }; </script>
- By registering them in
ParsleyValidator
after thatparsley.js
is loaded:<input type="text" data-parsley-multiple="3" /> [...] <script type="text/javascript"> window.ParsleyValidator .addValidator('multiple', function (value, requirement) { return 0 === value % requirement; }, 32) .addMessage('en', 'multiple', 'This value should be a multiple of %s') .addMessage('fr', 'multiple', 'Cette valeur doit ĂȘtre un multiple de %s'); </script>
UI/UX
Overview
Parsley ships a UI/UX component that is the only one responsible for classes, error messages, focus or trigger events that alterate your page. It strives to be the most UX friendly. Here are the main motto for ParsleyUI:
- Min char validation: Parsley by default does not proceed with field validation when less than 3 chars have been input. Do not assault your users with error messages too soon!.
- One error at the time: constraints are prioritized in Parsley, and if many of them are not met for a field on validation, only show the most important one.
- Quick error removal: when a field is detected and shown as invalid, further checks are done on each keypress to try to quickly remove error messages once the field is ok.
- Control focusing on error: on form submission, the first error field is focused to allow the user to easily start fixing errors.
Naturally, all this is absolutely customizable, you'll see below how to configure your desired UX behavior.
Classes and templates
Parsley adds its share of classes and elements. to be continued..
UI for form
Name | API | Description |
---|---|---|
UI Enabled |
data-parsley-ui-enabled="false" |
Activate or deactivate UI |
Focus |
data-parsley-focus="first" |
Focus failing field on form validation. Possible values: 'first' | 'last' | 'none' |
UI for field
Name | API | Description |
---|---|---|
Trigger |
data-parsley-trigger="change" |
Specify one or many javascript events that will trigger item validation. To set multiple events, separate them by a space data-parsley-trigger="focusin focusout" . See the various events supported by jQuery. |
No focus |
data-parsley-no-focus |
If this field fails, do not focus on it (if first focus strategy is on, next field would be focused, if last strategy is on, previous field would be focused) |
Validation threshold |
data-parsley-validation-threshold="10" |
Used with trigger option above, for all key - events, do not validate until field have a certain number of characters. Default is 3 |
Class handler |
data-parsley-class-handler="#element" |
Specify the existing DOM container where ParsleyUI should add error and success classes. It is also possible to configure it with a callback function from javascript, see the annotated source. |
Errors container |
data-parsley-errors-container="#element" |
Specify the existing DOM container where ParsleyUI should put the errors. It is also possible to configure it with a callback function from javascript, see the annotated source. |
Error message |
data-parsley-error-message="my message" |
Customize an unique global message for the field. |
Validator error message |
data-parsley-`constraint`-message="my message" |
Customize the error message for the field constraint. eg: data-parsley-required-message="this field is required" |
UI for javascript
Name | Method | Description |
---|---|---|
Add error |
window.ParsleyUI.addError(parsleyInstance, name, message); |
Manually add an error message. | Update error |
window.ParsleyUI.updateError(parsleyInstance, name, message); |
Manually edit an error message. | Remove error |
window.ParsleyUI.removeError(parsleyInstance, name); |
Manually remove an error message. |
Events
Overview
Parsley comes with a tiny pub/sub mechanism that allows ParsleyUI to work. Further more, it could allow you to do some powerful magic if you listen properly to the right events!
Events List
Name | Instance | Fired by | Description |
---|---|---|---|
parsley:form:init |
ParsleyForm |
new Parsley() |
Fired when a Form is binded for the first time. |
parsley:form:validate |
ParsleyForm |
.validate() |
Fired when a form validation is triggered, before its validation. |
parsley:form:validated |
ParsleyForm |
.validate() |
Fired when a form validation is triggered, after its validation. |
parsley:field:init |
ParsleyField |
new Parsley() |
Fired when a Field is binded for the first time. |
parsley:field:validate |
ParsleyField |
.validate() |
Fired when a field validation is triggered, before its validation. |
parsley:field:success |
ParsleyField |
.validate() |
Fired when a field validation went well. |
parsley:field:error |
ParsleyField |
.validate() |
Fired when a field validation failed. |
Usage
Method | Description |
---|---|
$.listen('name', callback) |
Listen a specific event. Fire a callback function. |
$.listen('name', context, callback) |
Listen a specific event. Fire a callback function that would have a specific context. |
.subscribe('name', callback) |
On a ParsleyField , it would only be fired if the specific event is fired by the specific field. On a ParsleyForm , it would be fired if the event is fired by the form, or by any of its fields. |
.unsubscribe('name') |
Unsubscribe all callbacks subscribed to an event name. |
$.emit('name') |
Emit an event for listeners and subscribers. |
Parsley Remote
Parsley remote is a handy plugin that adds an unique ajax asynchronous validator: data-parsley-remote="http://url.ext"
. It adds these asynchronous methods to Parsley: .asyncIsValid()
and .asyncValidate()
.
By default, it will make a GET
request to the url given in the DOM, and send as parameter the field's value within its name or id. Standard jQuery $.ajax
options could be passed with data-parsley-remote-options
.
<input name="q" type="text" data-parsley-remote-reverse="true" data-parsley-remote="http://myapi.com" data-parsley-remote-options='{ method: "POST", dataType: "jsonp", "data": { "anothervar": "value" } }' value="foo" />
The above code will make a POST
querry to http://myapi.com
sending q='foo'
and anothervar=value
. By default, a non 2xx ajax response is considered as a failure, but sometimes (when a call is needed to see if an email, a pseudo is available) a 404 API answer could be the right answer, that's why the reverse
option is here, to throw an error if the request is a success.
To use this plugin, either load parsley.remote.js
before loading parsley.js
, either directly load parsley+remote.js
.
Parsley Extras
You'll find in the src/extra/
directory in Parsley .zip or Github projects many more or less useful validators crafted by the community. A doc here is coming.