Валидация полей произвольных форм и контейнеров на jQuery.

Эта очень неприятная тема для любого программиста. Чем больше полей в форме, тем больше и сложнее скрипт для валидации формы jquery . Были времена когда программисты делали валидацию на PHP. Подобная валидация довольно громоздко выглядела. Недостаток такой валидации PHP в том, что постоянно нужно использовать сессии или куки. В этом случае постоянно перегружается страница, что делает лишние запросы к базе данных.

Валидацию на jquery сделать намного проще. Существуют несколько плагинов jquery для проверки полей формы. Я покажу вам очень простой способ. Вы сможете его видоизменить и добавить свои фирменные проверки. Образно говоря, в один массив будут помещены ошибки. Затем этот массив превратится в сплошную строку. Вы увидите на выводе сразу несколько ошибок.

Вставьте следующий код в документ html. Обратите внимание на то, что у вас одна кнопка и 3 поля.

form { margin:10px; border: 1px solid gray; } input { margin:5px; border: 1px solid gray; }


// validation form jquery $("input").click(function (){ // собираем данные в один массив var title = $("input").val().trim(); var text = $("input").val().trim(); var cat = $("input").val().trim(); //обрабатываю данные var error_arr = ; if(title.length == 0) error_arr.push("описание"); if(text.length == 0) error_arr.push("текст"); if(cat.length == 0) error_arr.push("категорию"); // проверка на наличие ошибок if(error_arr.length > 0){ alert("Вы не заполнили следующие поля:\n" + error_arr.join(", ")); // блокировка перехода на другую страницу return false; }else{ console.log("Ошибок нет!"); } });

Давайте рассмотрим сам скрипт для валидации формы. Сначала собираются данные в переменные. Обязательно сделайте очистку данных от пробелов. " " - это тоже символ. Далее происходит проверка данных на наличие символов. Вы можете добавить свои фирменные проверки. Даже можете использовать регулярные выражения. Всё зависит от поставленной задачи. Затем происходит финальная проверка на наличие ошибок. Если есть хотя бы одна ошибка, то алерт выведет ошибку. Обратите внимание на join(). Эта функция собирает все элементы массива и выводит их в виде строки через разделитель. Читайте о массивах на странице массивы в javascript . Я не использую циклы и функцию each(). Так проще)). Если ошибок нет, то скрипт переместит вас на новую страницу и данные отправятся. В случае ошибки валидации перехода на другую страницу не будет. Вы увидите предупреждение и вывод всех ошибок (Вы не заполнили следующие поля: описание, текст, категорию).

Есть 2 основных способа, чтобы валидировать форму:

1. Использовать имена классов как правила

Как это работает

Мы добавляем к полю, которое нужно провалидировать, html атрибут «class», и это подключит валидацию.
Итак, если нам нужно, чтобы текстовое поле было обязательным мы добавляем в элемент input значение атрибута class = «required»
Html
JavaScript
$(document).ready(function() { $("form").validate(); });

Так вы можете добавить к определенным классам несколько правил.

Плюсы и минусы такого подхода:
Работает только с правилами, которые не принимают аргументов.
Мы используем html атрибут «class» для того, для чего он не предназначен.
Но его легко установить.
Использование метода «addClassRules»

Использование функции «addClassRules» дает нам возможность использовать составное правило для одного класса.

JavaScript
$.validator.addClassRules({ name: { required: true, minlength: 2 }, zip: { required: true, digits: true, minlength: 5, maxlength: 5 } });
Этот код добавляет 2 новых правила для класса «name» и «zip», и, если у нас есть элемент «input», у которого класс «zip», то к нему применяются правила: его значение является обязательным, пользователь может вводить только цифры и длина должна быть точно 5 символов.

Html

Информация: Чтобы использовать собственное сообщение для определенного правила requires в составном правиле, нам нужно придумать псевдоним для правила «required», создать новое правило с этим псевдонимом и установить для него сообщение по умолчанию.

JavaScript
$.validator.addMethod("newrequired", $.validator.methods.required, "new name is required");

Или мы можем использовать html атрибут «title», его значение будет сообщением об ошибке для составного правила.

Заметка: Валидация по имени класса работает только для правил валидации, не принимающих никаких аргументов.

2. Добавление правил как JSON объекта к методу validate()

По названию, вы должны были догадаться, что этот метод валидации принимает объект json, поэтому мы можем определить поля, которые нам нужно валидировать и правила валидации для них.

Html
JavaScript
$("form").validate({ rules: { userEmail: { email: true, required: true } } });

Заметка: Когда мы передаем объект «rules» функции «validate» ключом должно быть значение атрибута «name», а не значение «id». Как можно увидеть в примере: ключ -это «userEmail», значение атрибута «name», а у атрибута «id» другое значение.

Плюсы и минусы этого подхода:
Этот подход дает нам возможность использовать больше правил валидации, которые принимают аргументы, такие как minlength, remote, equalTo и т.д.
Отличный и настраиваемый вручную контроль над всем.
Но пользователь должен делать отдельную функцию «validate» с разными опциями для каждой формы.

Добавление или удаление динамических правил.

Чтобы добавить правило мы должны использовать метод «rules» для элементов jQuery после того как форма провалидирована и передавать как первый параметр строку «add» и как второй параметр - объект правил, которые мы хотим добавить к этому элементу (также мы можем передавать объект «сообщение» для правил, которые мы добавили).

JavaScript
$(".input").rules("add", { required: true, messages: { required: true } }) Если мы хотим удалить правило или набор правил, мы передаем строку «remove», как первый параметр для метода «rules», а вторым параметром будет строка, которая содержит правила, которые мы хотим удалить, отделенные пробелом.JavaScript $(".input").rules("remove", "min max"); Подход настройки вручнуюJavaScript
var validator = $("form").data("validator"); validator.settings.rules.objectName = { required: true }

Этот подход очень полезен, если у вас есть созданные правила и объекты сообщений, вы можете расширить правила валидатора своими собственными:

JavaScript
$.extend(validator.settings, { rules: rules, messages: messages }); Сообщения валидации и как они работают

Есть три способа настроить сообщение валидации

1. Передать объект «messages» методу «validate». Объект «messages» состоит из пар ключзначение. Ключ - это значение атрибута «name» элемента. Значение - объект, содержащий каждое правило и его сообщение.

JavaScript
$("form").validate({ rules: { userEmail: { email: true, required: true } }, messages: { userEmail: { email: "Please enter your email", required: "*" } } });

2. Определить значение атрибута «title» элемента

Html

3. Использовать сообщение по умолчанию. Когда определяется правило валидации, есть встроенные сообщения по умолчанию для встроенных правил.
Заметка: Эти три способа переопределяют друг друга, основываясь на приоритетности, самый приоритетный - переданный объект «messages», а наименее приоритетный - сообщение по умолчанию.

Добавление собственных правил валидации

Когда мы хотим добавить больше правил валидации, чем определены по умолчанию, мы используем метод $.validator.addMethod

Этот метод принимает как параметры следующее:

• имя правила;
• функцию, которая осуществляет валидацию;
• сообщение по умолчанию.

Функция, которая производит валидацию, может быть с двумя или тремя параметрами

JavaScript
function validationMethod (value, element) // OR function validationMethod (value, element, params)

Давайте объясню эти параметры.

Значение: значение DOM элемента, который будет валидироваться
Элемент: сам элемент DOM
Параметры: то, что мы передаем как значение. Для этого примера правила валидации - это то, чему должен равняться params.
JavaScript
$("form").validate({ rules: { firstname: { compare: { type: "notequal", otherprop: "lastname" } } } });

в этом примере params будет равен {type:«notequal», otherprop: «lastname»}

Пример добавления собственного правила:

JavaScript
$.validator.addMethod("notnumbers", function(value, element) { return !/*/.test(value); }, "Please don"t insert numbers.") Что именно происходит, когда мы вызываем метод «validate»

Когда мы вызваем метод validate на форме, за кулисами происходит много разных вещей:

Создается объект «validator» со всеми правилами и опциями, присоединенными к форме.

Метод «validate» присоединяет «validator» используя "$.data". Мы можем получить его выбрав форму и вызвав функцию jQuery "$.data" и передать ее «validator». Объект «vaidator» - это все метаданные для валидации, которые дают нам возможность доступа к опциям валидации в любое время жизненного цикла страницы.

Используя этот объект, мы можем изменить во время выполнения опции, которые мы передали методу валидации, такие как добавление или удаление правил, изменение поведения, если поле валидное или невалидное, или даже введение селектора игнорирования.

JavaScript
//getting the validator var validator = $("selector").data("validator")

Заметка: Когда вы вызываете метод «validate» на форме, которая уже провалидирована, он вернет только объект «validator», используется также $.data, и все предыдущие опции, переданные методом «validate», будут стерты.

JavaScript
var validator = $(".selector").validate(/* rules will be omitted */)

Присоединение событий формы

Что произойдет, когда мы нажмем submit(отправить форму), и в форме будет введено неверное значение для поля, к которому мы присоединили валидацию. Если одно из полей невалидное, то плагин валидации будет присматриваться к нему более пристально, чтобы проверять, валидное оно или нет, по событиям на этом поле.

Сообытия формы, на которые подписывается плагин - это «click», «focusin», «focusout», «keyup», «submit».

Заметка: Вы можете отключить валидацию по определенным событиям, передав их как ключи в методе validate, и false в качестве значений.

JavaScript
$(".selector").validate({ onfocusout: false, onkeyup: false, onclick: false, onsubmit: false });

Главной причиной прерывания и предотвращения отправки браузером данных на сервер, является то, что вы хотите валидировать значения, которые пользователь вводит в форму. В какой-то момент, любой веб программист понимает, что пользователь может ввести в элемент input все, что угодно. Есть бесчисленное число различных значений, которые, возможно, вы должны обработать, но по моему опыту есть только несколько причин, почему пользователь вводит в форму что-то неожиданное.

Первая причина заключается в том, что пользователь не понимает, каких данных вы ожидаете. Например, вы могли попросить название кредитной карты, а пользователь мог ввести ее номер.

Вторая причина заключается в том, что пользователь не желает давать вам данные, которые вы запросили, и просто пытается заполнить форму как можно быстрее. Такие пользователи пишут в форме все, что угодно, лишь бы побыстрее перейти к следующему этапу. Если у вас есть много пользователей, чей e-mail адрес выглядит вот так [email protected] , тогда вы понимаете, что это проблема.

Третья причина состоит в том, что вы запрашиваете информацию, которой пользователь не обладает. Например, вы спрашиваете гражданина Великобритании, в каком штате он живет. (У нас тут нет штатов, идиот. Не получишь от меня ни гроша.)

И, наконец, пользователь может действительно сделать ошибку, обычно описку. Например, я быстро, но не особо аккуратно набираю текст, и часто я набираю мою фамилию как Freman , вместо Freeman , пропуская одну е.

С опечатками, в принципе, ничего сделать нельзя, но что касается трех других причин, то все зависит от вас, сделаете ли вы приятное и четкое приложение или нечто, что будет раздражать и злить пользователей.

Я не хочу произносить длинную и напыщенную речь о дизайне веб форм, но я хочу сказать, что лучший способ решить эту задачу – это сосредоточиться на том, что хочет получить пользователь. И если все идет не так, попытайтесь увидеть проблему (и пути ее решения) глазами пользователя. Ваши пользователи не знают, как вы выстроили свою систему, они ничего не знают о вашем бизнес процессе; они просто хотят, чтобы что-то у них получилось. Любой будет рад и счастлив, если вы сфокусируетесь на задаче, которую пользователь пытается выполнить, вместо того, чтобы бессмысленно пугать его, если он не предоставит требуемые вами данные.

jQuery предоставляет все средства, которые вам нужны, чтобы создать свою собственную систему для валидации значений данных, но я рекомендую другой подход. Один из наиболее популярных jQuery плагинов называется Validation, и как вы поняли из названия, он работает с валидацией форм.

Внимание

В этой главе я обсуждаю валидацию на стороне клиента . Это дополнение, а не замена валидации на стороне сервера , когда вы проверяете данные, полученные сервером. Валидация на стороне клиента – это благо для пользователя : таким образом вы не даете пользователю отправлять повторяющиеся запросы на сервер, чтобы обнаружить и исправить ошибку в данных. Валидация на стороне сервера – это благо для приложения , она гарантирует, что плохие данные не вызовут проблем. Вы должны использовать оба способа. Правда вы можете пренебречь валидацией на стороне клиента, и это не скажется на защите вашего приложения.

Плагин Validation можно загрузить с http://bassistance.de/jquery-plugins/jquery-plugin-validation или использовать версию, которую я включил в исходный код для этой книги (доступный на Apress.com). В показано использование этого плагина.

Совет

Для плагина валидации существует много различных опций конфигурации. В этой главе я сфокусировался на тех, которые наиболее часто используются и которые покрывают наиболее широкий спектр различных ситуаций. Если они вам не подходят, я предлагаю вам использовать другие опции, которые описаны в документации, доступной при загрузке плагина.

Листинг 13-7: Использование плагина валидации формы Example div.errorMsg { color: red; } .invalidElem { border: medium solid red; } $("form").validate({ }, }, errorElement: "div", errorClass: "errorMsg" }); $.validator.addClassRules({ flowerValidation: { min: 0 } }) $("input").addClass("flowerValidation").change(function (e) { $("form").validate().element($(e.target)); }); }); ${name}: Jacqui"s Flower Shop Place Order

Примечание

HTML5 включает в себя поддержку базовой валидации форм. Это хорошее начало, но все же это очень базово, и до сих пор существуют значительные различия в том, как браузеры интерпретируют спецификацию. Пока не будут реализованы полные, масштабные и последовательные возможности HTML5, я рекомендую работать с валидацией форм jQuery.

Импортирование файла JavaScript

Первая вещь, которую нам нужно сделать, это вставить плагин валидации в документ, вот таким вот образом:

Я использовал отладочную версию файла, но доступна также и минимизированная версия и некоторые, но не все, сервисы CDN, потому что этот файл очень популярен.

Конфигурация валидации

Следующий шаг – это конфигурация валидации элемента form , которую вы делаете, вызвав метод validate для элементов form , для которых вы хотите провести валидацию. Аргументом метода validate является объект-карта, который содержит настройки конфигурации, как показано в.

Листинг 13-8: Конфигурация валидации $("form").validate({ highlight: function (element, errorClass) { $(element).add($(element).parent()).addClass("invalidElem"); }, unhighlight: function (element, errorClass) { $(element).add($(element).parent()).removeClass("invalidElem"); }, errorElement: "div", errorClass: "errorMsg" });

Я указал значения для четырех опций (highlight , unhighlight , errorElement и errorClass); позже я вернусь и объясню их значения.

Определение правил валидации

Гибкость плагина валидации во многом обусловлена способом, которым вы быстро и просто можете указать правила для тестирования правильности ввода данных. Есть много различных путей связывания правил с элементами. Один, которым я стараюсь пользоваться, работает через классы. Вы определяете набор правил и связываете его с классом, и когда форма валидируется, правила применяются ко всем элементам form , которые являются членами указанного класса. Я создал только одно правило в примере, как показано в .

Листинг 13-9: Определение правил валидации $.validator.addClassRules({ flowerValidation: { min: 0 } })

В данном случае я создал новое правило, которое будет применяться ко всем элементам form , которые являются членами класса flowerValidation . Правило заключается в том, что значение должно быть равно или больше 0 . Я выразил в правиле условие, используя min . Это только один из множества удобных стандартных правил валидации, которые предоставляет плагин валидации, и я опишу все из них позже в этой главе.

Применение правил валидации

Вы свяжете правила валидации с элементами в форме, если добавите элементу класс, который вы указали на предыдущем этапе. Это дает вам возможность "подогнать" валидацию для различных видов элементов в форме. Для этого примера все элементы будут обрабатываться одинаково, поэтому я использую jQuery, чтобы выбрать все элементы ввода данных и добавить класс flowerValidation , как показано в .

Листинг 13-10: Добавление элементов input классу, связанному с валидацией $("input").addClass("flowerValidation").change(function (e) { $("form").validate().element($(e.target)); });

Я также использовал функцию, связанную с событием change , чтобы напрямую валидировать элемент, чье значение поменялось. Это гарантирует, что пользователь получит немедленный ответ, если исправит ошибку. Результат работы плагина валидации можно увидеть на . Чтобы получить этот рисунок, я ввел -1 в поле ввода и нажал кнопку Place Order.

Рисунок 13-5: Использование плагина валидации

Совет

Текст сообщения, показанный пользователю, сгенерирован плагином валидации. Я покажу вам, как создавать собственные сообщения далее в этой главе.

Как и при "доморощенной" валидации, которую я показывал вам ранее, пользователь не сможет отправить форму, пока не исправит ошибку, но на этот раз пользователь видит, какое значение или значения ошибочны, и получает рекомендацию, как это исправить.

Использование правил валидации

Плагин валидации поддерживает большой набор правил, которые можно использовать, чтобы проверить значения формы. В предыдущем примере вы видели правило min . Оно гарантирует, что значение будет больше либо равно указанному числовому значению. В описаны правила валидации.

Таблица 13-3: Правила плагина Validation

Правила	Описание
creditcard: true	Значение должно содержать номер кредитной карты
date: true	Значение должно быть текущей JavaScript датой
digits: true	Значение должно содержать только цифры
email: true	Значение должно быть действительным e-mail адресом
max: maxVal	Значение должно быть не больше чем maxVal
maxlength: length	Значение должно содержать символов не более, чем length
min: minVal	Значение должно быть не меньше чем minVal
minlength: length	Значение должно содержать символов не менее, чем length
number: true	Значение должно быть десятичным числом
range:	Значение должно находиться в пределах minVal и maxVal
rangelength:	Значение должно содержать символом минимум minLen и не более, чем maxLen
required: true;	Требуемое значение
url: true	Значение должно быть URL

Вы можете объединить несколько правил в одно. Это позволит вам провести комплексную валидацию быстро и качественно.

Совет

В дистрибутив плагина валидации входит файл с названием additional-methods.js . Этот файл определяет некоторые дополнительные правила, включая номера телефонов США и Великобритании, адреса IPv4 и IPv6, некоторые дополнительные форматы данных, e-mail и URL.

Эти правила можно применить к элементам различными путями. Каждое из них я опишу в следующих разделах.

Примечание

Плагин Validation также поддерживает удаленную валидацию , когда данные, введенные пользователем, проверяются через удаленный сервер. Это полезно, когда данные не могут быть распределены на клиентскую сторону, потому что это может быть небезопасно или непрактично (например, проверка на то, что имя пользователя не было до сих пор использовано). Я покажу удаленную валидацию в главе 16 , после того, как мы изучим возможности, которые она использует, в главах 14 и .

Применение правил валидации через классы

Как оказалось, наиболее часто я провожу валидацию через классы. Этот подход я применяю и в примере. Кстати, вы не ограничены одним правилом. Можно применять несколько правил вместе, чтобы провести валидацию различных аспектов значения, которое предоставляет пользователь, как показано в .

Листинг 13-11: Объединение нескольких правил в одно $.validator.addClassRules({ flowerValidation: { required: true, digits: true, min: 0, max: 100 } })

В этом примере я объединил правила required , digits , min и max , чтобы убедиться, что пользователь добавит значение, которое содержит только цифры, расположенные в диапазоне от 0 до 100 .

Обратите внимание, что я связываю правило с классом, используя метод addClassRules . Аргументами этого метода являются один или несколько наборов правил и имя класса, к которому они будут применяться. Как показано в примере, вы вызываете метод addClassRules для свойства validator главной jQuery $ функции.

Каждый валидированный элемент form обрабатывается индивидуально, что обозначает, что пользователь может увидеть различные сообщения для разных ошибок, как показано на .

Рисунок 13-6: Применение нескольких правил валидации для элементов form

Я ввел различные значения, которые "провалят" одно из правил. Важно отметить, что правила выполняются в том порядке, в котором вы их объединили в одном правиле. Если вы посмотрите на сообщение об ошибке для товара Rose, вы заметите, что он провалился на проверке digits . Если вы поменяете порядок правил, вы можете получить другую ошибку. В показан измененный порядок правил.

Листинг 13-12: Изменение порядка применения правил $.validator.addClassRules({ flowerValidation: { required: true, min: 0, max: 100, digits: true } })

В этом примере я переместил проверку digits в конец правила. Если я введу в поле формы -1 , тогда провалится проверка min , как показано на .

Рисунок 13-7: Изменения порядка применения правил во время проведения валидации
Применение правил валидации напрямую к элементам

Следующая технология позволяет применять правила валидации к отдельным элементам, как показано в .

Листинг 13-13: Применение правил валидации к элементам в выборке $(document).ready(function () { var data = [ { name: "Astor", product: "astor", stocklevel: "10", price: "2.99" }, { name: "Daffodil", product: "daffodil", stocklevel: "12", price: "1.99" }, { name: "Rose", product: "rose", stocklevel: "2", price: "4.99" }, { name: "Peony", product: "peony", stocklevel: "0", price: "1.50" }, { name: "Primula", product: "primula", stocklevel: "1", price: "3.12" }, { name: "Snowdrop", product: "snowdrop", stocklevel: "15", price: "0.99" }, ]; var templResult = $("#flowerTmpl").tmpl(data); templResult.slice(0, 3).appendTo("#row1"); templResult.slice(3).appendTo("#row2"); $("form").validate({ highlight: function (element, errorClass) { $(element).add($(element).parent()).addClass("invalidElem"); }, unhighlight: function (element, errorClass) { $(element).add($(element).parent()).removeClass("invalidElem"); }, errorElement: "div", errorClass: "errorMsg" }); $.validator.addClassRules({ flowerValidation: { required: true, min: 0, max: 100, digits: true, } }) $("#row1 input").each(function (index, elem) { $(elem).rules("add", { min: 10, max: 20 }) }); $("input").addClass("flowerValidation").change(function (e) { $("form").validate().element($(e.target)); }); });

Обратите внимание, что вы вызываете метод правил для объекта jQuery , передавая ему строку add и объект-карту с правилами проверки, которые вы хотите применить, и их аргументами. Метод rules работает только с первым элементом в выборке, поэтому нужно использовать метод each , если вы хотите более широко применить правила. В данном примере я выбрал все элементы input , которые являются потомками элемента row1 , и применил к ним набор правил.

Совет

Можно удалить правила для элемента, если заменить add на remove при вызове метода rules .

Правила, которые применяются к элементам с использованием метода rules , оцениваются раньше правил, применяемых с использованием класса. Для моего примера это обозначает, что элементы input в верхнем ряду будут проверяться с использованием значения min равном 10 и значением max равном 20 , в то время как другие элементы input будут, соответственно, использовать значения от 0 до 100 . Результат можно увидеть на .

Рисунок 13-8: Применение правил напрямую к элементам

Поскольку вы работаете с каждым элементом в отдельности, вы можете подгонять проверку под свои нужды. В показан пример.

Листинг 13-14: Корректировка правил для элементов $(document).ready(function () { var data = [ { name: "Astor", product: "astor", stocklevel: "10", price: "2.99" }, { name: "Daffodil", product: "daffodil", stocklevel: "12", price: "1.99" }, { name: "Rose", product: "rose", stocklevel: "2", price: "4.99" }, { name: "Peony", product: "peony", stocklevel: "0", price: "1.50" }, { name: "Primula", product: "primula", stocklevel: "1", price: "3.12" }, { name: "Snowdrop", product: "snowdrop", stocklevel: "15", price: "0.99" }, ]; var templResult = $("#flowerTmpl").tmpl(data); templResult.slice(0, 3).appendTo("#row1"); templResult.slice(3).appendTo("#row2"); $("form").validate({ highlight: function (element, errorClass) { $(element).add($(element).parent()).addClass("invalidElem"); }, unhighlight: function (element, errorClass) { $(element).add($(element).parent()).removeClass("invalidElem"); }, errorElement: "div", errorClass: "errorMsg" }); $("input").each(function (index, elem) { var rules = { required: true, min: 0, max: data.stocklevel, digits: true } if (Number(data.price) > 3.00) { rules.max--; } $(elem).rules("add", rules); }); $("input").change(function (e) { $("form").validate().element($(e.target)); }); });

В этом примере я подогнал значение правила max , используя объект данных, который я добавил в документ, чтобы сгенерировать элементы с использованием шаблона. Значение правила max устанавливается с использованием свойства stocklevel и корректируется вниз, если цена больше $3 . Если у вас есть данные наподобие этих, вы можете провести гораздо более полезную валидацию. Результат этого изменения можно увидеть на .

Рисунок 13-9: Установление различных значений для правил валидации на основании данных
Применение правил валидации через атрибут элемента name

Можно применить правила валидации к элементам, основываясь на значении атрибута name . Спецификация HTML не требует, чтобы значение атрибута name было уникальным, и одно значение часто используется для категоризации группы элементов form . В моем примере документа цветочного магазина все имена разные, и каждое из них соответствует отдельному продукту. В любом случае, вы можете создать правила, которые соответствуют значению атрибута name , и правила, которые применяются ко всем элементам с этим значением. В показан пример.

Листинг 13-15: Применение правил валидации на основании имени элемента $(document).ready(function () { var data = [ { name: "Astor", product: "astor", stocklevel: "10", price: "2.99" }, { name: "Daffodil", product: "daffodil", stocklevel: "12", price: "1.99" }, { name: "Rose", product: "rose", stocklevel: "2", price: "4.99" }, { name: "Peony", product: "peony", stocklevel: "0", price: "1.50" }, { name: "Primula", product: "primula", stocklevel: "1", price: "3.12" }, { name: "Snowdrop", product: "snowdrop", stocklevel: "15", price: "0.99" }, ]; var templResult = $("#flowerTmpl").tmpl(data); templResult.slice(0, 3).appendTo("#row1"); templResult.slice(3).appendTo("#row2"); var rulesList = new Object(); for (var i = 0; i < data.length; i++) { rulesList.product] = { min: 0, max: data[i].stocklevel, } } $("form").validate({ highlight: function (element, errorClass) { $(element).add($(element).parent()).addClass("invalidElem"); }, unhighlight: function (element, errorClass) { $(element).add($(element).parent()).removeClass("invalidElem"); }, errorElement: "div", errorClass: "errorMsg", rules: rulesList

Вы добавляете правила, которые основываются на именах элементов, используя свойство rules объекта конфигурации, который вы передаете методу validate , когда проводите валидацию для form . Обратите внимание, что я просто использовал объект данных, чтобы создать набор правил (также обратите внимание, что свойство product в объекте данных используется для генерирования атрибута name в элементах input). Я стараюсь не использовать такой подход, поскольку мне больше нравится работать напрямую с элементами в документе; но это технология может пригодиться, если у вас есть объект данных и вы хотите провести валидацию, прежде чем элементы формы будут добавлены в документ.

Применение правил валидации с использованием атрибутов элементов

И наконец, вы можете применять правила валидации, используя атрибуты элементов. Плагин валидации проверяет элементы form , чтобы увидеть, определяют ли они атрибуты, которые соответствуют имени встроенных правил проверки; таким образом считается, что для элемента, который определяет атрибут required , требуется обязательная проверка. В показан пример.

Листинг 13-16: Приведение валидации с использованием атрибута элемента $("input").change(function (e) { $("form").validate().element($(e.target)); }); }); ${name}:

Мне нравится эта технология, когда она используется в связке с шаблоном данных; но я считаю, что она загромождает документ, если применяется к статически определенным элементам, потому что одни и те же атрибуты применяются к элементам снова и снова.

Указание сообщений валидации

Плагин валидации определяет сообщения об ошибке по умолчанию для всех встроенных правил, но они довольно общие и не всегда полезны пользователю. Вот простой пример: если вы укажете для проверки max значение 10 , а пользователь введет в поле 20 , тогда сообщение об ошибке будет следующим:

Please enter a value less than or equal to 10

Это сообщение описывает ограничение, которое вы применили к элементу, но оно не дает никаких разъяснений пользователю, почему тут вообще есть лимит. К счастью, вы можете менять эти сообщения, чтобы добавить дополнительный контекст и скорректировать их для своих нужд. Метод, который вы используете для изменения сообщений, зависит, в первую очередь, от того, как вы создавали правила валидации. Вы не можете менять сообщения, если вы применяли правила, используя класс, но в следующих разделах я расскажу, как менять сообщения, еcли были использованы другие технологии.

Указание сообщений для атрибутивной и именной валидации

Если вы используете атрибут name или проверочные атрибуты, чтобы связать правила с элементами, вы можете изменить сообщения, если добавите свойство messages в объект options , который вы передаете методу validate , когда настраиваете валидацию. В показан пример.

Листинг 13-17: Использование свойства messages объекта оbject $(document).ready(function () { var data = [ { name: "Astor", product: "astor", stocklevel: "10", price: "2.99" }, { name: "Daffodil", product: "daffodil", stocklevel: "12", price: "1.99" }, { name: "Rose", product: "rose", stocklevel: "2", price: "4.99" }, { name: "Peony", product: "peony", stocklevel: "0", price: "1.50" }, { name: "Primula", product: "primula", stocklevel: "1", price: "3.12" }, { name: "Snowdrop", product: "snowdrop", stocklevel: "15", price: "0.99" }, ]; var templResult = $("#flowerTmpl").tmpl(data); templResult.slice(0, 3).appendTo("#row1"); templResult.slice(3).appendTo("#row2"); $("form").validate({ highlight: function (element, errorClass) { $(element).add($(element).parent()).addClass("invalidElem"); }, unhighlight: function (element, errorClass) { $(element).add($(element).parent()).removeClass("invalidElem"); }, errorElement: "div", errorClass: "errorMsg", messages: { rose: { max: "We don"t have that many roses in stock!" }, peony: { max: "We don"t have that many peonies in stock!" } } }); $("input").change(function (e) { $("form").validate().element($(e.target)); }); });

Вы можете рассматривать структуру объекта, который вы предоставляете, как значение свойства messages . Вы указываете свойство, используя имя элемента, в котором вы заинтересованы, и указываете, чтобы значение этого свойства было объектом-картой между проверкой и новым сообщением, которое вы хотите использовать. В данном примере я изменил сообщение для правила max для элементов с именами rose и peony . Результат можно увидеть на . Оба эти элемента показаны со скорректированным сообщением валидации.

Рисунок 13-10: Изменение сообщение через объект options

Синтаксис для настройки этих сообщений может быть очень дублирующим, поэтому я стараюсь создать объект с нужными мне сообщениями программно, как показано в .

Листинг 13-18: Определение пользовательских сообщений программно $(document).ready(function () { var data = [ { name: "Astor", product: "astor", stocklevel: "10", price: "2.99" }, { name: "Daffodil", product: "daffodil", stocklevel: "12", price: "1.99" }, { name: "Rose", product: "rose", stocklevel: "2", price: "4.99" }, { name: "Peony", product: "peony", stocklevel: "0", price: "1.50" }, { name: "Primula", product: "primula", stocklevel: "1", price: "3.12" }, { name: "Snowdrop", product: "snowdrop", stocklevel: "15", price: "0.99" }, ]; var templResult = $("#flowerTmpl").tmpl(data); templResult.slice(0, 3).appendTo("#row1"); templResult.slice(3).appendTo("#row2"); var customMessages = new Object(); for (var i = 0; i < data.length; i++) { customMessages.product] = { max: "We only have " + data[i].stocklevel + " in stock" } } $("form").validate({ highlight: function (element, errorClass) { $(element).add($(element).parent()).addClass("invalidElem"); }, unhighlight: function (element, errorClass) { $(element).add($(element).parent()).removeClass("invalidElem"); }, errorElement: "div", errorClass: "errorMsg", messages: customMessages }); $("input").change(function (e) { $("form").validate().element($(e.target)); }); });

В этом примере я использую свойство stocklevel из объекта данных, чтобы предоставить пользователю более точное и имеющее нужный смысл сообщение.

Изменение сообщений для валидации каждого элемента

Когда вы применяете правила к отдельным элементам, вы можете использовать объект messages , который определит желаемые сообщения. В показано, как это делается.

Листинг 13-19: Указание сообщений для правил, применяемых к каждому элементу $(document).ready(function () { var data = [ { name: "Astor", product: "astor", stocklevel: "10", price: "2.99" }, { name: "Daffodil", product: "daffodil", stocklevel: "12", price: "1.99" }, { name: "Rose", product: "rose", stocklevel: "2", price: "4.99" }, { name: "Peony", product: "peony", stocklevel: "0", price: "1.50" }, { name: "Primula", product: "primula", stocklevel: "1", price: "3.12" }, { name: "Snowdrop", product: "snowdrop", stocklevel: "15", price: "0.99" }, ]; var templResult = $("#flowerTmpl").tmpl(data); templResult.slice(0, 3).appendTo("#row1"); templResult.slice(3).appendTo("#row2"); $("form").validate({ highlight: function (element, errorClass) { $(element).add($(element).parent()).addClass("invalidElem"); }, unhighlight: function (element, errorClass) { $(element).add($(element).parent()).removeClass("invalidElem"); }, errorElement: "div", errorClass: "errorMsg", }); $("input").each(function (index, elem) { $(elem).rules("add", { min: 10, max: 20, messages: { max: "You only have " + data.stocklevel + " in stock" } }) }).change(function (e) { $("form").validate().element($(e.target)); }); });

Еще раз, я использовал свойство stockvalue для указания сообщения. Для простоты я взял за предположение, что элементы input расположены в том же порядке, что и единицы данных. Результат использования этого сообщения можно увидеть на .

Рисунок 13-11: Указание сообщений, полученных из объекта данных
Создание пользовательской проверки

Можно создать пользовательские правила валидации, если встроенные не соответствует нашим требованиям. Это довольно простой процесс, что обозначает, что вы можете тесно связать валидацию со структурой и природой вашего веб приложения. В представлен пример.

Листинг 13-20: Создание пользовательской валидации $(document).ready(function () { var data = [ { name: "Astor", product: "astor", stocklevel: "10", price: "2.99" }, { name: "Daffodil", product: "daffodil", stocklevel: "12", price: "1.99" }, { name: "Rose", product: "rose", stocklevel: "2", price: "4.99" }, { name: "Peony", product: "peony", stocklevel: "0", price: "1.50" }, { name: "Primula", product: "primula", stocklevel: "1", price: "3.12" }, { name: "Snowdrop", product: "snowdrop", stocklevel: "15", price: "0.99" }, ]; var templResult = $("#flowerTmpl").tmpl(data); templResult.slice(0, 3).appendTo("#row1"); templResult.slice(3).appendTo("#row2"); $("form").validate({ highlight: function (element, errorClass) { $(element).add($(element).parent()).addClass("invalidElem"); }, unhighlight: function (element, errorClass) { $(element).add($(element).parent()).removeClass("invalidElem"); }, errorElement: "div", errorClass: "errorMsg", }); return Number(value) < Number(args); }, "We don"t have that many in stock"); $("input").each(function (index, elem) { $(elem).rules("add", { min: 0, stock: data.stocklevel }) }).change(function (e) { $("form").validate().element($(e.target)); }); });

Вы указываете пользовательское правило, используя метод addMethod , который вызывается для свойства validator функции $ . Аргументами этого метода являются имя, которым вы хотите обозначить правило, функция, которая используется для проведения валидации, и сообщение, которое будет показано, если валидация не прошла. В этом примере я определил правило с именем stock .

Определение функции валидации

Аргументами пользовательской функции валидации являются значение, введенное пользователем, объект HTMLElement , представляющий элемент формы, и любые аргументы, которые были указаны, когда правило применяется к элементу для валидации, например, вот так:

$(elem).rules("add", { min: 0, stock: data.stocklevel })

Когда я применил правило, я указал значение свойства stocklevel в качестве аргумента для проверки. И это передано пользовательской функции валидации.

function(value, elem, args ) { return Number(value) Example 2: First Name: Last Name: Email: Password:

Добавьте следующий JavaScript- код в функцию $(document).ready(function() {}) после блока$(‘#first_form’).submit(function(e) {}) .

$("form").validate({ rules: { fname: "required", lname: "required", user_email: { required: true, email: true, }, psword: { required: true, minlength: 8, } }, messages: { fname: "This field is required", lname: "This field is required", user_email: "Enter a valid email", psword: { minlength: "Password must be atleast 8 characterslong" } }, submitHandler: function(form) { form.submit(); } });

Мы применили правило required ко всем полям формы. Для поля адреса электронной почты добавили правило email . А к полю пароля- правило, которое проверяет минимальную длину в 8 символов.

Перевод статьи “Form Validation Using Jquery Examples” был подготовлен дружной командой проекта

Вам когда-нибудь приходилось искать скрипты и плагины для валидации произвольных форм и контейнеров? Когда тэг "form" не используемая конструкция? И когда необходимо проверять корректность полей в любое время, а не по зашитым концептуальным механизмам? Можно долго спорить о необходимости соблюдать стандартны и поддерживать отправку данных через полную перезагрузку страницы. Тем не менее, сегодня, большинство web-приложений уже не возможно представить без поддержки javascript-a. Отключите javascript - и сервисы станут бесполезными, несмотря на то, что вы сможете зарегистрироваться, войти и пройтись по нескольким страницам.

Примечание : Речь идет о том, что тег form предназначен для отправки данных методом POST и требует перезагрузки страницы или фрейма. Тем не менее, чем дальше, тем реже используется этот метод, и тем чаще те же самые данные отправляются ajax-ом, которому в общем все равно, какие теги использовались перед формированием данных.

Примечание : Конечно, существуют интернет-гиганты, которым в обязательном порядке необходимо поддерживать разные способы и режимы. Но, в их случае даже самый маленький процент подразумевает миллионы пользователей.

Рассмотрим существующие плагины для валидации форм на jQuery

Сноска: Название плагинов умышленно не приводится в статье, так как задачей является не критика конкретных приложений, а создание простого инструмента, который можно применить к произвольным формам .

Большинство существующих скриптов для валидации форм имеют несколько серьезных ограничений, которые далеко не всегда можно обойти простыми заглушкам или которые потребуют от вас длительной рутины.

• Жесткая привязка к тэгу "form" . Поэтому если у вас есть несколько десятков форм, построенных на div-ах или таблицах, и вы твердо решили использовать популярные решения, то готовьтесь потратить кучу времени на ручное добавление тегов и корректировку скриптов и стилей.
• Привязка к именам полей . Некоторые валидаторы привязываются к названиям полей, а это значит написание простыней javasript-а для каждого случая. Если для пары форм это не страшно, то для коллекции это уже означает длительную ручную генерацию кода.
• Отсутствие валидации по требованию , без необходимости инициализации плагина. Вы не можете взять и один раз вручную проверить форму. Нужно правильно составить форму (правда, это везде нужно, но суть не в этом), затем инициализировать движок плагина, который в обязательном порядке привяжет кучу скриптов к элементам формы. И уже после этого вызвать метод isValid, который не всегда доступен в явном виде. Иногда, этот метод еще нужно "как-то" вытащить из внутренних механизмов.

Примечание : С одной стороны, вполне логично, что привязка идет к тегу форм, так как плагины появились "после". С другой стороны, сегодня скрипты позволяют быстро создавать и собирать данные из любых произвольных форм. При определенном уровне любопытства и настойчивости, вы можете легко создать форму только на тэгах "span"(div) и "input", при этом выглядеть она будет точно так же, как и все другие.

Разумеется, большинство плагинов имеют много приятных моментов. Но, по большому счету, они сводятся к:

• Наличию преднастроенных валидаторов . По сути, готовых регулярных выражений
• Проверкам различных типов . Включая проверку данных нескольких полей (например, подтверждение пароля и т.п.)
• Возможности создания собственных валидаторов
• Красивой анимации со всплывающими окошками и появляющимися подсказками

Если раньше красивая анимация и навороченный механизм сами по себе были достаточно вескими аргументами в пользу использования того или иного плагина, то сегодня это уже не совсем так. Найти готовые регулярные выражения для проверок большинства известных типов полей - задача не очень сложная. Большое число разнотипных проверок уже не столь актуально, как раньше. Стремление к минимализму форм ведет к уменьшению количества проверок. Попробуйте вспомнить, когда вы в последний раз встречали проверки, которые бы отличались от валидации текста, исключая повторение пароля? Необходимость в создании собственных валидаторов, при обилии уже готовых регулярных выражений, встречается все реже и реже. Красивая анимация и всплывающие подсказки в окошках когда-то будоражили фантазию и придавали приложениям очарование и неповторимость. Тем не менее, сегодня, достаточно пометить красным цветом хорошо известные всем поля, и большинство пользователей сами поймут, что именно необходимо исправить.

Примечание : Не стоит считать, что плагины не имеют смысла и что их не стоит использовать. Существует достаточно много ситуаций, когда написание кода с нуля обойдется намного дороже, чем использование готовых плагинов. В данной статье речь идет о тех ситуациях, когда ограничения плагинов либо создают препятствия, либо их плюсы не сильно превышают затраты по времени и силам.

Пишем скрипт для валидации произвольных форм на jQuery

Сноска: Вам совершенно не обязательно писать приложение с нуля, пример с готовым скриптом и стилями можно скачать по ссылке в конце статьи .

Прежде, чем реализовывать свой механизм, необходимо определиться с его возможностями и ограничениями:

• . Это может быть span, div, table и так далее. Важно то, что форма это отдельный элемент DOM. Сохранение данных с 15 разных контейнеров - это уже не обычная форма, с любой точки зрения.
• Скрипт должен поддерживать как валидацию на лету , так и произвольную проверку любых форм или даже отдельных полей, без каких-либо привязок скриптов или других ограничений.
• Плагин должен быть простым как с точки зрения настройки и запуска, так и с точки зрения организации и кода.
• Необходимо, чтобы его можно было расширить в любое время . Добавить валидаторы. Встроить всплывающие сообщения. И многое другое.
• Настройка валидаторов полей должна быть не только универсальной, но и простой

И первым делом, переходим к самому важному, к определению основного механизма - вызова проверок для полей. Ведь, выбранный алгоритм будет напрямую влиять не только на сложность настройки, но и на количество букв, которое вам придется набирать, чтобы его корректно запустить. Исходя из составленных требований, самым простым механизмом будет вызов валидаторов по наличию классов стилей в атрибуте "class". Во-первых, стили легко задаются и не накладывают серьезных ограничений. Во-вторых, их можно добавлять и убирать в любой момент. В-третьих, если какие-то классы стилей вы уже используете в своем проекте, то их переименование, как в скрипте валидации, так и в полях, решается простой заменой одной строки на другую, без кардинального изменения кода.

Примечание : К сожалению, даже обилие javascript проверок и обработчиков событий не уберегут ни одно приложение от необходимости валидации данных на серверной стороне. Помните, что можно без особых усилий составить и вызвать отправку данных практически на любом браузере.

Составим тестовый проект

Теперь, составим тестовый проект со следующей структурой:

• css - каталог со стилями
  • template.css - файл стилей
• images - каталог для картинок для стилей валидации
  • icon-fail.png - иконка для некорректно заполненного поля
  • icon-ok.png - иконка для правильно заполненного поля
• js - каталог для скриптов
  
  • jquery-validate.js - скрипт валидации произвольных форм
• index.html - тестовая форма

Примечание : При составлении структуры тестового проекта, старайтесь максимально приблизить ее к структуре настоящего проекта. Это поможет вам отловить проблемы, связанные со структурой, еще на этапе разработке.

Файл стилей - template.css

Большую часть файла стилей занимают стили самой формы, что бы демонстрационный пример выглядел привлекательно. Для самого же плагина нужны только первые два правила ".field-input.input-ok" и ".field-input.input-error"

Примечание : Старайтесь добавлять даже к тестовым формам хотя бы минимальны дизайн. Чем ближе тестовый проект будет к реальному, тем больше шансов отловить ошибки и скрытые проблемы. Например, картинка в "background" для проверенных полей будет занимать часть поля. Это означает, что для полей с большим объемом текста необходимо предусматривать отступы в стилях.

Field-input.input-ok{ background: url(../images/icon-ok.png) no-repeat right center #e3ffe5; border: 1px solid #96b796;line-height: 19px; } .field-input.input-error{ background: url(../images/icon-fail.png) no-repeat right center #ffebef; border: 1px solid red;line-height: 19px; } .clear{clear:both;}body{width: 1000px;margin:auto;} .form{float: left;width: 490px;margin-right: 5px;} .form .header{color: blue;font-size: 20px;font-family: georgia;margin-bottom: 10px} .form .label{padding: 5px;padding-left: 0px;font-size: 18px;} .form .field{margin-bottom: 10px;} .form .field-input{padding: 5px;font-size: 15px;width: 400px;} .form .save-button{cursor: pointer;margin-top: 10px;color: white;background: green;border: 1px solid #ddd;padding: 5px 10px;} .form .save-button:hover{background: rgb(60, 176, 60);}

Файл скрипта валидации произвольных форм на jQuery - jquery-valiate.js

Так как скрипт достаточно простой и в самих комментариях подробно описана вся необходимая информация, то файл приводится целиком:

(function (parentObject) { // Проверяем на повторную инициализацию if (parentObject.validation) return; //////////////////////////////////////////////// // Создаем общий интерфейс для валидации форм //////////////////////////////////////////////// parentObject.validation = { _defaultOptions: { // Контейнер. Может быть селектором или элементом container: "", // Селектор для поиска полей fieldSelector: ".field-input", // Проверка в режиме онлайн liveCheck: true, // Селектор для кнопок сабмита submitSelector: ".save-button", // Обработчик, который вызывается после успешной валидации submitHandler: null, // Класс полей с ошибками errorClass: "input-error", // Класс верных полей okClass: "input-ok", // Список валидаторов // Примечание: так как валидатор пустых полей вынесен отдельно, // то пустые строки в других валидаторах считаются как прошедшие validators: { "required": function (str) { return str.length > 0; }, "numeric": function (str) { var regExp = new RegExp("\\-?\\d+((\\.|\\,)\\d{0,})?"); return regExp.test(str) || !str; }, "alpha": function (str) { var regExp = new RegExp("^[а-яА-ЯёЁa-zA-Z\\s]+$"); return regExp.test(str) || !str; }, "alphanumeric": function (str) { var regExp = new RegExp("^[а-яА-ЯёЁa-zA-Z0-9\\s]+$"); return regExp.test(str) || !str; }, "date": function (str) { var regExpISO = new RegExp("(19|20)\\d\\d-((0|1)-(0|\\d)|(0|1)-30|(0|1)-31)"), regExpRU = new RegExp("((0|\\d)\\.(0|1)|30\\.(0|1)|31\\.(0|1))\\.(19|20)\\d\\d"); return (regExpISO.test(str) | regExpRU.test(str)) || !str; }, "datetime": function (str) { var regExpISO = new RegExp("(19|20)\\d\\d-((0|1)-(0|\\d)|(0|1)-30|(0|1)-31) (\\d+):(\\d+)"), regExpRU = new RegExp("((0|\\d)\\.(0|1)|30\\.(0|1)|31\\.(0|1))\\.(19|20)\\d\\d (\\d+):(\\d+)"); return (regExpISO.test(str) | regExpRU.test(str)) || !str; }, "time": function (str) { var regExp = new RegExp("(\\d+):(\\d+)"); return regExp.test(str) || !str; }, "digit": function (str) { var regExp = new RegExp("^+$"); return regExp.test(str) || !str; }, "password": function (str) { var regExp = new RegExp("^[а-яА-ЯёЁa-zA-Z0-9\\s]+$"); return regExp.test(str) || !str; }, "email": function (str) { var regExp = new RegExp("^(+\\.)* +(\\.+)*\\.{2,6}$"); return regExp.test(str) || !str; }, "url": function (str) { var regExp = new RegExp("^((https?|ftp)\\:\\/\\/)?({1})((\\.)|())*\\.({2,6})(\\/?)$"); return regExp.test(str) || !str; } } }, // Функция инициализации // Создает каркас для форм init: function (_options) { var options = $.extend({}, this._defaultOptions, (_options || {})), self = this; // Если указан контейнер (или его селектор), // а так же селектор для полей, // то создаем каркас if (options.container && options.fieldSelector) { // Если есть селектор для кнопок, // то вещаем обработчик на щелчек if (options.submitSelector) { $(options.container).find(options.submitSelector).on("click", function () { if (self.isValid(options)) { // Если указан обработчик, после успешной валиадции, // то вызываем его if (typeof (options.submitHandler) === "function") options.submitHandler(); return true; } else { return false; } }); } // Если нужна проверка в режиме онлайн if (options.liveCheck) { // Проходимся по всем полям и вешаем проверку валидности $(options.container).find(options.fieldSelector).each(function (cnt, item) { $(item).on("click", function () { self.validItem($(item), options) }).on("blur", function () { self.validItem($(item), options) }).on("change", function () { self.validItem($(item), options) }).on("keyup", function () { self.validItem($(item), options) }); }); } } }, // Функция для валидации отдельного элемента validItem: function (item, _options) { var options = $.extend({}, this._defaultOptions, (_options || {})), classList = $(item).attr("class").split(/\s+/), validResult = true; // Проходимся по всем классам в атрибуте "class", // и если находим класс с именем валидатора, то вызываем его $.each(classList, function (index, cl) { // Проверка для повторяющихся полей, // имя поля, которое должно повториться указывается в атрибуте "confirm-field" if (cl === "confirmfield") { validResult &= ($(options.container).find("").val() == $(item).val()); } // Иначе обычная проверка else if (typeof (options.validators) === "function") { validResult &= options.validators(item.val()); } }); // Если поле не прошло валидацию if (!validResult) $(item).addClass(options.errorClass).removeClass(options.okClass); // Поле прошло валидацию else $(item).addClass(options.okClass).removeClass(options.errorClass); // Возвращаем результат return validResult; }, // Проверка всех полей произвольной формы isValid: function (_options) { var options = $.extend({}, this._defaultOptions, (_options || {})), validResult = true, self = this; // Если указан контейнер (или его селектор), а так же селектор для полей, // то проверяем все поля if (options.container && options.fieldSelector) { $(options.container).find(options.fieldSelector).each(function (cnt, item) { validResult &= self.validItem($(item), options); }); } // Возвращаем результат проверки return validResult; }, // Очищаем поля от всех классов стилей, которые были добавлены во время проверки clear: function (_options) { var options = $.extend(true, {}, this._defaultOptions, (_options || {})); if (options.container && options.fieldSelector) { $(options.container).find(options.fieldSelector) .removeClass(options.errorClass).removeClass(options.okClass); } } } })(window);

Тестовая страница с формами - index.html

Тестовая страница достаточно проста. Ее основное пространство занимает html-код самих форм демонстрационного примера. Сам же вызов плагина для создания валидации на лету, а так же запуск ручной валидации по нажатию на кнопку, занимают всего несколько строк.

$(function () { // Валидация через механизм window.validation.init({ container: ".form-1", submitHandler: function () { alert("Валидация первой формы прошла успешно!"); } }); // Ручная валидация, доступная в любой момент $(".form-2 .save-button").on("click", function () { if(window.validation.isValid({ container: ".form-2" })) { alert("Валидация второй формы прошла успешно!"); } }); });


Валидации формы в режиме реального времени Имя Email Подтверждение пароля URL Отправить форму Пример ручной валидации формы Имя Email Пароль (цифры, буквы и пробел) Подтверждение пароля URL Дата форматы ГГГГ-ММ-ДД и ДД.ММ.ГГГГ Отправить форму

Теперь, сохраняем все файлы в проекте, открываем index.html в любом браузере и переходим к первичному тестированию результата.

Смотрим результат выполнения скрипта валидации на jQuery в тестовом проекте

После того как вы откроете файл, перед вами должна появится следующего вида страница:

Как видно, на экране будут отображаться две формы. Форма следа будет проверяться на валидацию в режиме реального времени, т.е. при каждом вводе в текстовые поля, а так же при нажатии на кнопку "отправить форму". Форма справа будет проверяться вручную, только при нажатии на кнопку "Отправить форму". В остальное время форма останется нетронутой.

Теперь, убедимся, что валидация происходит в те моменты, когда это необходимо, и что формы никак не влияют друг на друга. Выглядеть это будет примерно так:

Как видно, в форма слева проводилась валидация на лету. А в форме слева валидация происходила только по нажатию на кнопку "Отправить форму."

Закончив, первичное тестирование, необходимо снова пройтись по возможностям и ограничениям составленным в самом начале:

• Форма хранится в одном произвольном контейнере . - Выполнено . Форма не зависит от конкретного элемента. Обрабатывает произвольный контейнер
• Валидация как на лету, так и вручную . - Выполнено . Валидацию можно производить как на лету, так и вручную
• Плагин должен быть простым - Выполнено . Код очень простой. Настройка форм заняла не более 5 минут. Для запуска плагина понадобилось всего пара строчек
• Можно было расширить в любое время - Выполнено . Добавление валидаторов элементарное. Можно добавить как в опции по умолчанию, так и во время запуска плагина. Так как код простой, то добавить функциональность то же просто.
• Настройка валидаторов должна быть универсальной и простой - Выполнено . Валидаторы указываются через классы стилей.

Теперь, у вас есть легкий и простой плагин на jQuery, который можно применять для валидации произвольных форм как на лету, так и в ручном режиме. При этом, плагин легко расширяется как с точки зрения количества проверок, так и с точки зрения дополнительной функциональности.