AJAX

Представляю Вам третью статью из серии jQuery для начинающих. В этот раз я постараюсь рассказать о реализации AJAX запросов...
Что такое AJAX я думаю рассказывать не стоит, ибо с приходом веб-два-нуля большинство пользователей уже воротят носом от перезагрузок страниц целиком, а с появлением jQuery реализация упростилась в разы...
Примечание: Во всех примерах используется сокращенный вариант вызова jQuery методов, используя функцию $(знак доллара)

jQuery(..).load

Начнем с самого простого — загрузка HTML кода в необходимый нам DOM элемент на странице. Для этой цели нам подойдет метод load. Данный метод может принимать следующие параметры:
  1. url запрашиваемой страницы
  2. передаваемые данные (необязательный параметр)
  3. функция которой будет скормлен результат (необязательный параметр)
Приведу пример JavaScript кода:
// по окончанию загрузки страницы
$(document).ready(function(){
// вешаем на клик по элементу с id = example-1
$('#example-1').click(function(){
// загрузку HTML кода из файла example.html
$(this).load('ajax/example.html');
})
});
Пример подгружаемых данных (содержимое файла example.html):
Example<br/>
Data Loaded By AJAX<br/>
Bye-Bye

jQuery.ajax

Это самый основной метод, а все последующие методы лишь обертки для метода jQuery.ajax. У данного метода лишь один входной параметр — объект включающий в себя все настройки (выделены параметры которые стоит запомнить):
  • async — асинхронность запроса, по умолчанию true
  • cache — вкл/выкл кэширование данных браузером, по умолчанию true
  • contentType — по умолчанию «application/x-www-form-urlencoded»
  • data— передаваемые данные — строка иль объект
  • dataFilter — фильтр для входных данных
  • dataType— тип данных возвращаемых в callback функцию (xml, html, script, json, text, _default)
  • global — тригер — отвечает за использование глобальных AJAX Event'ов, по умолчанию true
  • ifModified — тригер — проверяет были ли изменения в ответе сервера, дабы не слать еще запрос, по умолчанию false
  • jsonp — переустановить имя callback функции для работы с JSONP (по умолчанию генерируется на лету)
  • processData — по умолчанию отправляемые данный заворачиваются в объект, и отправляются как «application/x-www-form-urlencoded», если надо иначе — отключаем
  • scriptCharset — кодировочка — актуально для JSONP и подгрузки JavaScript'ов
  • timeout — время таймаут в миллисекундах
  • type— GET либо POST
  • url— url запрашиваемой страницы
Локальные AJAX Event'ы:
  • beforeSend — срабатывает перед отправкой запроса
  • error — если произошла ошибка
  • success — если ошибок не возникло
  • complete — срабатывает по окончанию запроса
Для организации HTTP авторизации (О_о):
  • username — логин
  • password — пароль
Пример javaScript'а:
$.ajax({
url: '/ajax/example.html', // указываем URL и
dataType : "json", // тип загружаемых данных
success: function (data, textStatus) { // вешаем свой обработчик на функцию success
$.each(data, function(i, val) { // обрабатываем полученные данные
/* ... */
});
}
});

jQuery.get

Загружает страницу, используя для передачи данных GET запрос. Может принимать следующие параметры:
  1. url запрашиваемой страницы
  2. передаваемые данные (необязательный параметр)
  3. callback функция, которой будет скормлен результат (необязательный параметр)
  4. тип данных возвращаемых в callback функцию (xml, html, script, json, text, _default)

jQuery.post

Данный метод аналогичен предыдущему, лишь передаваемые данные уйдут на сервер посредством POST'а. Может принимать следующие параметры:
  1. url запрашиваемой страницы
  2. передаваемые данные (необязательный параметр)
  3. callback функция, которой будет скормлен результат (необязательный параметр)
  4. тип данных возвращаемых в callback функцию (xml, html, script, json, text, _default)
JavaScript:
$(document).ready(function(){ // по завершению загрузки страницы
$('#example-3').click(function(){ // вешаем на клик по элементу с id = example-3
$.post('ajax/example.xml', {}, function(xml){ // загрузку XML из файла example.xml
$('#example-3').html('');
$(xml).find('note').each(function(){ // заполняем DOM элемент данными из XML
$('#example-3').append('To: ' + $(this).find('to').text() + '<br/>')
.append('From: ' + $(this).find('from').text() + '<br/>')
.append('<b>' + $(this).find('heading').text() + '</b><br/>')
.append( $(this).find('body').text() + '<br/>');
});
}, 'xml'); // указываем явно тип данных
})
});
Файл example.xml:
<?xml version="1.0" encoding="UTF-8"?>
<note>
<to>Tove</to>
<from>Jani</from>
<heading>Reminder</heading>
<body>Don't forget me this weekend!</body>
</note>

jQuery.getJSON

Загружает данные в формате JSON (удобней и быстрее нежели XML). Может принимать следующие параметры:
  1. url запрашиваемой страницы
  2. передаваемые данные (необязательный параметр)
  3. callback функция, которой будет скормлен результат (необязательный параметр)
JavaScript:
$(document).ready(function(){ // по завершению загрузки страницы
$('#example-4').click(function(){ // вешаем на клик по элементу с id = example-4
$.getJSON('ajax/example.json', {}, function(json){ // загрузку JSON данных из файла example.json
$('#example-4').html('');
// заполняем DOM элемент данными из JSON объекта
$('#example-4').append('To: ' + json.note.to + '<br/>')
.append('From: ' + json.note.from + '<br/>')
.append('<b>' + json.note.heading + '</b><br/>')
.append( json.note.body + '<br/>');
});
})
});
Файл example.json:
{
note:{
to:'Tove',
from:'Jani',
heading:'Reminder',
body:'Don\'t forget me this weekend!'
}
}

jQuery.getScript

данная функция загружает и выполняет локальный JavaScript. Может принимать следующие параметры:
  1. url запрашиваемого скрипта
  2. callback функция, которой будет скормлен результат (необязательный параметр)
JavaScript:
$(document).ready(function(){ // по завершению загрузки страницы
$('#example-5').click(function(){ // вешаем на клик по элементу с id = example-5
$.getScript('ajax/example.js', function(){ // загрузку JavaScript'а из файла example.js
testAjax(); // выполняем загруженный JavaScript
});
})
});
Файл example.js:
function testAjax() {
$('#example-5').html('Test completed'); // изменяем элемент с id = example-5
}

Отправка Формы

Для отправки формы посредством jQuery можно использовать любой из перечисленных способов, а вот для удобства «сбора» данных из формы лучше использовать плагин jQuery Form

Примеры использования JSONP

Отдельно стоит отметить использование JSONP— ибо это один из способов осуществления кросс-доменной загрузки данных. Если немного утрировать — то это подключение удаленного JavaScript'a, содержащего необходимую нам информациию в формате JSON, а так же вызов нашей локальной функции, имя которой мы указываем при обращении к удаленному серверу (обычно это параметр callback). Чуть более наглядно это можно продемонстрировать следующая диаграмма (кликабельно):
При работе с jQuery имя callback функции генерируется автоматически для каждого обращения к удаленному серверу, для этого достаточно использовать GET запрос ввида:
http://api.domain.com/?type=jsonp&query=test&callback=?
Вместо последнего знака вопроса (?) будет подставлено имя callback функции. Если же Вы не хотите использовать данный способ, то Вам необходимо будет явно указать имя callback функции, используя опцию jsonp при вызове метода jQuery.ajax().

События

Для удобства разработки, на AJAX запросах висит несколько event'ов, их можно задавать для каждого AJAX запроса в отдельности, либо глобально. На все event'ы можно повесить свою функцию.
Пример для отображения элемента с id=«loading» во время выполнения любого AJAX запроса:
$("#loading").bind("ajaxSend", function(){
$(this).show(); // показываем элемент
}).bind("ajaxComplete", function(){
$(this).hide(); // скрываем элемент
});
Для локальных событий — вносим изменения в опции метода ajax():
$.ajax({
beforeSend: function(){
// Handle the beforeSend event
},
complete: function(){
// Handle the complete event
}
// ...
});
Для большей наглядности, приведу следующую диаграмму (кликабельно):
Ну и собственно список всех event'ов:
  • ajaxStart— Данный метод вызывается в случае когда побежал AJAX запрос, и при этом других запросов нету
  • beforeSend— Срабатывает до отправки запроса, позволяет редактировать XMLHttpRequest. Локальное событие
  • ajaxSend— Срабатывает до отправки запроса, аналогично beforeSend
  • success— Срабатывает по возвращению ответа, когда нет ошибок ни сервера, ни вернувшихся данных. Локальное событие
  • ajaxSuccess— Срабатывает по возвращению ответа, аналогично success
  • error— Срабатывает в случае ошибки. Локальное событие
  • ajaxError— Срабатывает в случае ошибки
  • complete— Срабатывает по завершению текущего AJAX запроса (с ошибкои или без — срабатывает всегда).Локальное событие
  • ajaxComplete— Глобальное событие, аналогичное complete
  • ajaxStop— Данный метод вызывается в случае когда больше нету активных запросов

Bootstrap 5.3. Закрыть cворачиваемое содержимое при клике вне элемента

Сворачиваемое содержимое создаётся с помощью Bootstrap 5.3.3.
Добавляем к нопке класс .show-element, если сворачиваемых блоков несколько или #showElement, если блок один.
<button class="btn btn-primary show-element" type="button" data-bs-toggle="collapse" data-bs-target="#collapseExample" aria-expanded="false" aria-controls="collapseExample">
    Кнопка с data-target
  </button>

<div class="collapse" id="collapseExample">
  <div class="card card-body">
    Кстати, диаграммы связей, вне зависимости от их уровня, должны быть рассмотрены исключительно в разрезе маркетинговых и финансовых предпосылок. Каждый из нас понимает очевидную вещь: высокотехнологичная концепция общественного уклада в значительной степени обусловливает важность существующих финансовых и административных условий. И нет сомнений, что некоторые особенности внутренней политики лишь добавляют фракционных разногласий и объявлены нарушающими общечеловеческие нормы этики и морали. Банальные, но неопровержимые выводы, а также независимые государства формируют глобальную экономическую сеть и при этом — подвергнуты целой серии независимых исследований.
  </div>
</div>
Блок сворачивается только при повторном клике на кнопку. В большинстве случаев это неудобно. Можно написать отдельный Javascript для данной задачи, но когда у тебя уже подгружаются библиотеки jQuery и Bootstrap, то их и будем использовать.
Итак, добавляем небольшой код, который будет закрывать наше выпадающее содержимое, при клике в любом месте страницы, кроме самого выпадающего блока и его элементов. Комментарии дают понять, что делается.
    $(document).mouseup( function(e){  // событие клика по веб-документу
		var div = $( "#collapseExample.show" );  // здесь указываем сворачиваемое содержимое
		if ( !div.is(e.target)  // если клик был не по нашему сворачиваемому содержимому
		    && div.has(e.target).length === 0 ) {  // и не по его дочерним элементам
			$('.show-element').addClass('collapsed');  // добавляем кнопке класс .collapsed
            $('.propertyInput.show').removeClass('show');  // удаляем у сворачиваемого содержимого класс .show
		}
	});

Slick Slider в модальном окне Bootstrap

При загрузке страницы сайта все Slick Slider, находящиеся в модальных окнах, не будут инициализированы, т.к. модальное окно имеет стиль display:none.
Чтобы решить эту проблему добавляем небольшой код на jQuery, который инициализирует Slick Slider в момент открытия модального окна и наоборот, отменит инициализацию после закрытия окна.
В примере
    $('#modal').on('shown.bs.modal', function() {  // запускаем модальное окно
      $('#modal .slick-slider').not('.slick-initialized').slick();   // если slick slider не инициализирован, то делаем это
      $('#modal .slick-slider').slick('refresh');
    });

    $('#modal').on('hidden.bs.modal', function() {  // закрываем модальное окно
      $('#modal .slick-slider').slick('unslick').empty();   // после закрытия модального окна отменяем инициализацию slick slider
    });

Slick Slider. Подключение файла скрипта

Подключение файла скрипта и задание параметров слайдеру Slick с помощью jQuery
$.getScript("/js/slick.min.js", function(){// подключаем скрипт slick-слайдера
$('.slider-for').slick({
infinite: false,
slidesToShow: 1,
slidesToScroll: 1,
fade: true,
arrows: true,
nextArrow: '',
prevArrow: '',
asNavFor: '.thumb-slider'
});

Время прочтения статьи на jQuery и чистом JavaScript

Время прочтения (или просто чтения) — это оценка, сколько времени потребуется среднему человеку, чтобы прочитать текст. Обычно оно рассчитывается на основе количества слов в статье, а также учитывает такие факторы, как:

  • Длина текста. Чем длиннее текст, тем больше времени потребуется на его прочтение.
  • Сложность текста. Сложные тексты с большим количеством технических терминов и сложных предложений требуют больше времени для понимания.
  • Размер шрифта. Крупный шрифт облегчает чтение, а мелкий, наоборот, усложняет его.
  • Наличие изображений. Изображения могут сделать текст более привлекательным, но они также могут замедлить чтение, если их слишком много.

Реализация на jQuery

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

За настройки отвечают параметры (находятся в последних строках):

images — время в секундах, которое уходит на просмотр одного изображения;

wpm — среднее количество слов, которое человек читает в минуту.

(function($) {
    $.fn.readtime = function(options) {
        // Значения по умолчанию
        var defaults = {
            format:  '#',
            wrapper: 'time',
            images: 7,     // Время на одно изображение (в секундах)
            wpm: 250       // Скорость чтения (слов в минуту)
        };

        // Объединяем переданные параметры с настройками по умолчанию
        options = $.extend(defaults, options);

        return this.each(function() {
            // Получаем текстовое содержимое элемента
            var text = this.textContent || this.innerText || '';

            // Подсчитываем количество слов в тексте
            var words = text.replace(/(^\s*)|(\s*$)/gi, '')
                            .replace(/[ ]{2,}/gi, ' ')
                            .replace(/\n /, '\n')
                            .split(' ').length;

            // Рассчитываем время на основе количества слов
            var time = (words / options.wpm) * 60;

            // Добавляем время на изображения
            if (options.images) {
                time += ($(this).find('img').length * options.images);
            }

            // Округляем до ближайшего целого числа и переводим в минуты
            time = Math.round(time / 60);

            // Форматируем выводимое значение
            time = options.format.replace(/#/, time);

            // Создаем элемент для отображения времени
            var element = document.createElement(options.wrapper);

            // Функция для склонения слова "минута"
            function declOfNum(number, titles) {
                cases = [2, 0, 1, 1, 1, 2];
                return titles[(number % 100 > 4 && number % 100 < 20) ? 2 : cases[(number % 10 < 5) ? number % 10 : 5]];
            }

            var title = declOfNum(time, ['минута', 'минуты', 'минут']);

            // Вставляем результат в элемент с классом .time_read
            $('.time_read').html(time + ' ' + title);
        });
    };
}(jQuery));

// Используем плагин с настройками
$(".text_read").readtime({
    images: 7,
    wpm: 250
});
  • Значения по умолчанию. Определяем значения по умолчанию для скорости чтения и времени на изображение.
  • Подсчет слов. Извлекаем текст из элемента и подсчитываем количество слов.
  • Добавление времени на изображения. Если в элементе есть изображения, добавляем к общему времени чтения дополнительные секунды.
  • Форматирование результата. Используем функцию declOfNum для правильного склонения слова «минута» в зависимости от значения.
  • Вывод результата. Вставляем результат в элемент с классом .time_read.

Если на странице текст будет меньше среднего количества слов указанных в параметре wpm, то скрипт будет выводить время прочтения 0. Чтобы исправить это найдите в скрипте строчку: title=declOfNum(time,['минута','минуты','минут']); и над ней вставьте: if(time == 0) { var time = 1; }.

Реализация на чистом JavaScript

Теперь посмотрим, как можно реализовать тот же функционал, но уже без jQuery.

(function() {
    function readtime(selector, options) {
        // Значения по умолчанию
        const defaults = {
            format: '#',
            wrapper: 'time',
            images: 7,    // Время на каждое изображение (в секундах)
            wpm: 250      // Скорость чтения (слов в минуту)
        };

        // Объединяем параметры с настройками по умолчанию
        options = Object.assign({}, defaults, options);

        // Функция для склонения слова "минута" в зависимости от числа
        function declOfNum(number, titles) {
            const cases = [2, 0, 1, 1, 1, 2];
            return titles[(number % 100 > 4 && number % 100 < 20) ? 2 : cases[(number % 10 < 5) ? number % 10 : 5]];
        }

        // Получаем все элементы, соответствующие переданному селектору
        const elements = document.querySelectorAll(selector);

        elements.forEach(element => {
            // Получаем текстовое содержимое элемента
            const text = element.textContent || element.innerText || '';

            // Считаем количество слов в тексте
            const words = text.trim().replace(/[ ]{2,}/g, ' ').split(' ').length;

            // Расчет времени на основе количества слов
            let time = (words / options.wpm) * 60;

            // Добавляем время на изображения, если есть
            if (options.images) {
                time += (element.querySelectorAll('img').length * options.images);
            }

            // Округляем и преобразуем в минуты
            time = Math.round(time / 60);

            // Форматируем выводимое значение
            const formattedTime = options.format.replace(/#/, time);

            // Создаем элемент для отображения времени
            const timeElement = document.createElement(options.wrapper);
            const title = declOfNum(time, ['минута', 'минуты', 'минут']);

            // Добавляем текст с временем и склонением
            timeElement.textContent = `${formattedTime} ${title}`;

            // Вставляем время чтения в элемент с классом .time_read
            const timeReadElement = document.querySelector('.time_read');
            if (timeReadElement) {
                timeReadElement.innerHTML = ''; // Очищаем перед вставкой
                timeReadElement.appendChild(timeElement);
            }
        });
    }

    // Используем функцию readtime с нужным селектором и параметрами
    readtime(".text_read", {
        images: 7,
        wpm: 250
    });
})();
  1. Настройки по умолчанию. Как и в jQuery-версии, заданы значения по умолчанию для скорости чтения и времени на изображение.
  2. Подсчет слов. Используется textContent или innerText, чтобы извлечь текст и посчитать количество слов.
  3. Добавление времени для изображений. Время увеличивается в зависимости от количества изображений в элементе.
  4. Форматирование результата. Результат округляется и форматируется с правильным склонением слова «минута».
  5. Отображение результата. Вставляем результат в элемент .time_read.

Использование jQuery Validate для проверки форм

Рабочая валидация с проверкой captcha
<script>
      $(function() {
            $(".validate").validate({
            focusInvalid: true,
            errorClass: "input_error",
            onkeyup: false,
            onfocusout: false,
            rules: {
            captcha: {
            required: true,
            remote: '/forms/'
            },
            author: "required",
             text: "required",
             email: {
                   required: true,
                   email: true
                  }
               },
               messages: {
                       author: "Пожалуйста, укажите своё Имя!",
                       text: "Пожалуйста, напишите свой комментарий!",
                       captcha: "Вы не вписали контрольное число!",
                       email: {
                       required: "Введите свой email",
                       email: "E-mail должен быть в формате name@domain.com"
                         }
            }});
        });
   </script>
Проверьте, подключен ли в макете файл jquery.validate.min.js, в системе управления он расположен в hostcmsfiles/jquery/jquery.validate.min.js
Core_Page::instance()
// jQuery
->js('/hostcmsfiles/jquery/jquery.min.js')
...
// Validate
->js('/hostcmsfiles/jquery/jquery.validate.min.js')
...
->showJs();

Указание валидации формы

Валидация конкретной формы или форм с классом validate указывается следующим образом:
<script>
$(".validate").validate();
</script>
Валидация всех форм:

<script>
$("form").validate();
</script>

Способы валидации форм

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

Тем полям, которые нужно проверять, добавляете атрибут class="required"
<form action="." method="post" class="validate">
    <input type="text" name="name" value="" class="required" />
    <input type="submit" value="Submit" />
</form>

С помощью метод addClassRules вы можете расширить и добавить условие валидации:
<form action="." method="post" class="validate">
    <input type="text" name="name" value="" class="name" />
    <input type="text" name="zip" value="" class="zip" />
    <input type="submit" value="Submit" />
</form>
Проверка скриптом
<script >
$.validator.addClassRules("name", {
    required: true,
    minlength: 2
});
</script >
или сразу для нескольких полей:
<script >
$.validator.addClassRules({
name: {
required: true,
minlength: 2
},
zip: {
required: true,
digits: true,
minlength: 5,
maxlength: 5
}});
</script >

Передача опций при инициализации validate()

Методу validate() передаем объекты rules и messages которые состоят из пар ключ/значение. В rules в качестве ключа указываем атрибут name поля, значением указываем правило проверки. В messages в качестве ключа так же идет атрибут name поля, а в качестве значения указываем предупреждающее сообщение.
<script >
$(".validate").validate({
rules: {
name: "required",
email: {
required: true,
email: true
}
},
messages: {
name: "Please specify your name",
email: {
required: "Введите свой email",
email: "E-mail должен быть в формате name@domain.com"
}
}});
</script >
Список правил:
  • required — поле обязательное для заполнения (true или false);
  • remote — указывается файл для проверки поля (например: "check.php");
  • email — проверяет корректность e-mail адреса (true или false);
  • url — проверяет корректность url адреса (true или false);
  • date — проверка корректности даты (true или false);
  • dateISO — проверка корректности даты ISO (true или false);
  • number — проверка на число (true или false);
  • digits — только цифры (true или false);
  • creditcard — корректность номера кредитной карты (true или false);
  • equalTo — равное чему-то (например другому полю equalTo: "#pswd");
  • accept — проверка на правильное расширение (accept: "xls|csv");
  • maxlength — максимальное кол-во символов;
  • minlength — минимальное кол-во символов;
  • rangelength — кол-во символов от скольких и до скольких (rangelength: [2, 5]);
  • range — число должно быть в диапазоне от и до (range: [2, 12]);
  • max — максимальное значение числа;
  • min — минимальное значение числа.

Пример использования в XSL-шаблоне

Указываем форме класс например validate, и далее в XSL-шаблоне формы добавляем код проверки формы (пример взят из формы быстрого заказа в адаптивном шаблоне):
<script >
$(".validate").validate({
rules: {
surname: "required",
name: "required",
email: {
required: true,
email: true
}
},
messages: {
surname: "Введите фамилию!",
name: "Введите имя!",
email: {
required: "Введите e-mail!",
email: "Адрес должен быть вида name@domain.com"
}
},
focusInvalid: true,
errorClass: "input_error"
});
</script>
Проверка валидации и заблокированного E-mail нежелательного Пользователя
<SCRIPT>
            $(document).ready(function() {
            $('.select2').addClass('required');
            $("#form<xsl:value-of select="@id" />").submit(function (event) {
            event.preventDefault();
            var eml = $('input[name=email]').val();
            if(eml =='svinya.svintus@yandex.ru') {
            alert ('Вы не можете отправлять нам письма');
            $(location).attr('href', '/');
            }else{
            
            $(this).validate({
            focusInvalid: true,
            errorClass: "input_error"
            });
            }
            });
            });
        </SCRIPT>

Модальное окно с формой подписки и сохранением куки на jQuery

Добавляем в макет код показа формы:

<?php
        // add ФОРМА ПОДПИСКА ЗА СКИДКУ
     $oForm = Core_Entity::factory('Form', 49);  // заменить ID формы
      
     $Form_Controller_Show = new Form_Controller_Show($oForm);
      
     if (!is_null(Core_Array::getPost($oForm->button_name)))
     {
     $Form_Controller_Show
     ->values($_POST + $_FILES)
     // 0 - html, 1- plain text
     ->mailType(0)
     ->mailXsl(
     Core_Entity::factory('Xsl')->getByName('ПисьмоКураторуФормыВФорматеHTML')
     )
     ->mailFromFieldName('email')
     ->process();
     }
      
     $Form_Controller_Show
     ->xsl(
     Core_Entity::factory('Xsl')->getByName('ОтобразитьФормуВМодальномОкне')
     )
      ->show();
?>

Подключаем в макете скрипт jquery.cookie.min.js:

<script src="/js/jquery.cookie.min.js"></script>

Проверяем куки:

<script>
$(document).ready(function($) {
if ($.cookie('was') == null) {
// Покажем всплывающее окно
setTimeout(function(){$('#popupModal').modal('show');}, 36000);
}
// Запомним в куках, что посетитель к нам уже заходил
$.cookie('was', 'value', { expires: 2, path: '/' });
});
</script>

JavaScript / jQuery . jquery.cookie.min.js

jQuery.cookie=function(b,j,m){if(typeof j!="undefined"){m=m||{};if(j===null){j="";m.expires=-1}var e="";if(m.expires&&(typeof m.expires=="number"||m.expires.toUTCString)){var f;if(typeof m.expires=="number"){f=new Date();f.setTime(f.getTime()+(m.expires*24*60*60*1000))}else{f=m.expires}e="; expires="+f.toUTCString()}var l=m.path?"; path="+(m.path):"";var g=m.domain?"; domain="+(m.domain):"";var a=m.secure?"; secure":"";document.cookie=[b,"=",encodeURIComponent(j),e,l,g,a].join("")}else{var d=null;if(document.cookie&&document.cookie!=""){var k=document.cookie.split(";");for(var h=0;h<k.length;h++){var c=jQuery.trim(k[h]);if(c.substring(0,b.length+1)==(b+"=")){d=decodeURIComponent(c.substring(b.length+1));break}}}return d}};

Работа плагина jQuery validate изнутри

Как валидировать форму

Есть 2 основных способа, чтобы валидировать форму.
1. Использовать имена классов как правила
Как это работает
Мы добавляем к полю, которое нужно провалидировать, html атрибут «class», и это подключит валидацию.
Итак, если нам нужно, чтобы текстовое поле было обязательным мы добавляем в элемент input значение атрибута class = «required»
Html
<form action="/" method="post">
  <input id="Name" type="text" name="Name" value="" class ="required"  />
  <input type="submit" value="Submit" />
</form>
Так вы можете добавить к определенным классам несколько правил.
Плюсы и минусы такого подхода:
Работает только с правилами, которые не принимают аргументов.
Мы используем 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
<input class="zip" type="text" name="zipCode" />
Информация: Чтобы использовать собственное сообщение для определенного правила requires в составном правиле, нам нужно придумать псевдоним для правила «required», создать новое правило с этим псевдонимом и установить для него сообщение по умолчанию.
JavaScript
$.validator.addMethod("newrequired", $.validator.methods.required, "new name is required");
Или мы можем использовать html атрибут «title», его значение будет сообщением об ошибке для составного правила.
Заметка: Валидация по имени класса работает только для правил валидации, не принимающих никаких аргументов.
2. Добавление правил как JSON объекта к методу validate()
По названию, вы должны были догадаться, что этот метод валидации принимает объект json, поэтому мы можем определить поля, которые нам нужно валидировать и правила валидации для них.
Html
<form>
  <input id="something" type="text" name="userEmail" />
  <input id="submit" type="submit" value="submit" />
</form>
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
<input id="Email" title="you have to enter a value" type="text" name="Email" />
3. Использовать сообщение по умолчанию. Когда определяется правило валидации, есть встроенные сообщения по умолчанию для встроенных правил.
Заметка: Эти три способа переопределяют друг друга, основываясь на приоритетности, самый приоритетный — переданный объект «messages», а наименее приоритетный — сообщение по умолчанию.

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

Когда мы хотим добавить больше правил валидации, чем определены по умолчанию, мы используем метод
JavaScript
$.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 !/[0-9]*/.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
});

Сенсорный эффект прокрутки полной страницы - ScrollingMagic.js

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

Пользователи могут перемещаться между блоками прокрутки с помощью колесика мыши, клавиш со стрелками и сенсорных жестов.
Как его использовать:
1. Добавьте блоки прокрутки (разделы содержимого) на страницу.
<sections class="scrolling-block">

	  Section 1

	</sections>

	<sections class="scrolling-block">

	  Section 2

	</sections>

	<sections class="scrolling-block">

	  Section 3

	</sections>

	...
2. Скрыть полосу прокрутки браузера.
html {

	  width:100%;

	  scrollbar-width:none;

	  /* Also needed to disable scrollbar Firefox */

	  -ms-overflow-style:none;

	  /* Disable scrollbar IE 10+ */

	}

	@-moz-document url-prefix() {

	  /* Disable scrollbar Firefox */

	  html {

	      scrollbar-width:none;
	  }

	}

	html::-webkit-scrollbar {

	  /* Disable scrollbar Chrome/Safari/Webkit */

	  width:0px;

	  background:transparent;

	}
3. Пример стилей CSS для блоков прокрутки.
.scrolling-block {

	  display: flex;

	  justify-content:center;

	  align-items:center;

	  background-color: rgba(0,0,0,0.5);

	  width:100%;

	  min-height: fit-content;

	  height:100vh;

	  position:relative;

	}

	.scrolling-block img {

	  width:auto;

	  max-width:100%;

	  height:100%;

	  object-fit: cover;

	}

	.scrolling-block.invise {

	  opacity:0;

	  transition: opacity0.5s ease-in;

	}

	.scrolling-block.active {

	  opacity:1;

	  transition: opacity0.5s ease-in;

	}
4. Импортируйте как библиотеку jQuery, так и ScrollingMagic.js в документ. Вот и все.
<script src="/path/to/cdn/jquery.min.js"></script>
<script src="/path/to/scrollingMagic.js"></script>
5. Переопределите задержки по умолчанию в миллисекундах.
let delayWheel = 400;

let delayTouch = 400;

let delayKey = 700;
6. По умолчанию плагин автоматически отключает сенсорные жесты, если размер видового экрана меньше 320px. Вы можете переопределить точку останова непосредственно в JavaScript следующим образом:
	window.addEventListener('scroll',
	  (e) => {

	    e.preventDefault()

	    if (counter !== sections.length - 1) {

	      if ((document.documentElement.clientWidth >= 320)) {

	        window.scrollTo(0,

	          sections[counter].offsetTop - (

	          document.documentElement.clientHeight - (sections[counter].clientHeight)) / 2

	        )
	      }
	    }
	  })

	function InitTouchScroll() {

	  if (document.documentElement.clientWidth >= 320) {

	    window.addEventListener('touchmove', touchmove,

	      {passive:false})

	    window.addEventListener('touchstart', touchstart, {passive:false})

	    window.addEventListener(

	      "touchend",

	      touchend,

	      {passive:false}
	    );
	  }else {
	    window.removeEventListener('touchmove', touchmove,)

	    window.removeEventListener('touchstart', touchstart,)

	    window.removeEventListener('touchend', touchend,)
	  }
	}
Демо-версия
https://www.jqueryscript.net/demo/touch-fullpage-scrolling-magic/

События и их обработка в jQuery

В этой статье мы рассмотрим методы jQuery, которые предназначены для обработки различных событий, возникающих на странице.
Событие– это «сигнал», возникающий в браузере, который сообщает вам, что что-то произошло для того, чтобы вы могли с ним взаимодействовать.
Например, событие click возникает при клике пользователем на DOM-элементе. Кроме click, в браузере генерируются множество других событий. Здесь же мы остановимся на рассмотрение методов, которые предоставляет библиотека jQuery для работы с ними.

Обработка событий с помощью методов jQuery

jQuery - Синтаксис функции on
Перед тем как переходить к добавлению элементам обработчиков событий, эти элементы сначала необходимо получить. 
В jQuery повесить событие (слушатель событий) на определённый элемент можно с помощью функций on и one, а также кратких записей on.
// функция on
.on(events,handler);
// функция one
.one(events,handler);

// events - событие или список событий через пробел, при наступлении которых необходимо выполнить обработчик (handler)
// handler - функция (обработчик события)

// краткая запись функции on
.event(handler);

// event - название события (можно использовать для обработки только тех событий, для которых в jQuery создана такая краткая запись)
Функция one отличается от on только тем, что она выполняет обработчик при наступлении указанного события только один раз.
Например, добавим с помощью функции onсобытие clickдля всех элементов с классом btn:
// использование в качестве обработчика анонимной функции
$('.btn').on('click', function() {
// действия, которые будут выполнены при наступлении события...
console.log($(this).text());
});

// использование обычной функции в качестве обработчика
var myFunction = function() {
console.log($(this).text());
}
$('.btn').on('click', myFunction);
Вышеприведённый код, записанный с использованием короткой записи функции on:
$('.btn').click(function() {
// действия, которые будут выполнены при наступлении события...
console.log($(this).text());
});

Дополнительная информация о событии

При обработке события вы можете узнать некоторую дополнительную информацию о нём. Передача этой информации, а именно объекта Event в обработчик события осуществляется всегда посредством первого аргумента.
$('#demo').on('click', function(e){
// e – объект Event, содержащий дополнительную информацию о произошедшем событии
// часто используемые свойства объекта Event
e.preventDefault(); //отменить выполнение действия по умолчанию
e.stopPropagation(); //остановить дальнейшее всплытие события
// e.type – получить тип события
// e.target – ссылка на элемент, на котором произошло событие
// e.currentTarget - ссылка на текущий элемент (для которого сработал обработчик). Это свойство, как правило, равно функции this.
// e.currentTarget === this
// e.which – код клавиши (для мыши), код кнопки или символа (для клавиатуры)
//e.pageX, e.pageY – координаты курсора, относительно левого верхнего угла документа
});

Пространство имён

В jQuery после указания имени события вы можете ещё дополнительно указать пространство имён.
Например:
// событие click в пространстве имён first
$('#demo').on('click.first',function(){
console.log('1 обработчик события click');
});
// событие click в пространстве имён second
$('#demo').on('click.second',function(){
console.log('2 обработчик события click');
});
Пространство имён - это очень удобная вещь. Она используется, например, когда вам необходимо вызвать не все события, а только с определённым именем.
// вызвать событие click в пространстве имён first
$('#demo').trigger('click.first');


// вызвать событие click в пространстве имён second
$('#demo').trigger('click.second');
Также с его помощью очень просто удалять определённые события:
//удалить обработчики события click в пространстве имён first
$('#demo').off('click.first');


//удалить обработчики события click в пространстве имён second
$('#demo').off('click.second');
Описание и примеры использования функций triggerи offрассматриваются в статье немного ниже.

Передача дополнительных данных в обработчик

При необходимости вы можете передать данные в обработчик события (посредством указания дополнительного аргумента в функции on). Доступ к переданным данным внутри обработчика осуществляется через объект Event.
Осуществляется это так (пример):
<div id="content"></div>
<button id="showContent1">Показать контент 1</button>
<button id="showContent2">Показать контент 2</button>
...


<script>
$('#showContent1').on('click', {title:'Заголовок 1', content: 'Содержимое 1...'}, function(e){
var output = '<b>'+e.data.title+': </b>' + e.data.content;
$('#content').html(output);
});
$('#showContent2').on('click', {title:'Заголовок 2', content: 'Содержимое 2...'}, function(e){
var output = '<b>'+e.data.title+': </b>' + e.data.content;
$('#content').html(output);
});
</script>

Как повесить несколько событий на один элемент

Пример использования одного обработчика для нескольких (2 или более) событий:
$('#id').on('keyup keypress blur change', function(e) {
console.log(e.type); // тип события
});


// или так
var myFunction = function() {
...
}


$('#id')
.keyup(myFunction)
.keypress(myFunction)
.blur(myFunction)
.change(myFunction);
Для каждого события своя функция:
$("#id").on({
mouseenter: function() {
// обработчик события mouseenter...
},
mouseleave: function() {
// обработчик события mouseleave...
},
click: function() {
// обработчик события click...
}
});
Пример использования в jQuery несколько обработчиков (функций) на одно событие:
$("#demo").click(function(){
console.log('1 обработчик события click');
});
$("#demo").click(function(){
console.log('2 обработчик события click');
});
Например, узнать в какой очерёдности будут выполняться события можно так:
var eventList = $._data($('#demo')[0], 'events');
console.log(eventList);

Программный вызов события

Для вызова события из кода в jQuery есть 2 метода:
trigger- вызывает указанное событие у элемента.
triggerHandler- вызывает обработчик события, при этом само событие не происходит.
$('#header').on('click',
function() {
console('Произошёл клик на элементе #header');
}
});


// программный вызов события click элемента
$('#header').trigger('click');
// короткая запись данного вызова
$('#header').click();
// вызов обработчика события click у выбранного элемента
$('#header').triggerHandler('click');

jQuery - Событие загрузки страницы (ready)

Процесс добавления к некоторому элементу обработчика события обычно осуществляется после загрузки страницы, т.е. когда DOM дерево документа уже построено. Иначе при написании обработчиков, вы можете обратиться к элементам, которых ещё нет на странице.
Самая короткая запись события загрузки страницы в jQuery выглядит так:
$(function(){
// действия, которые необходимо выполнить после загрузки документа...
});
Но, можно использовать и более длинную запись:
$(document).ready(function(){
// действия, которые необходимо выполнить после загрузки документа...
});

jQuery - Событие загрузки (load)

Событие load браузер генерирует элементу, когда он и все вложенные в него элементы были полностью загружены. Данное событие предназначено только для элементов, в которых присутствует URL: image, script, iframe и window.
Например, выполнить функцию, когда страница будет полностью загружена (включая картинки):
$(window).on('load', function() {
// действия после полной загрузки страницы...
});
Например, выведем сообщение в консоль, когда указанное изображение будет загружено:
<img id="image" src="image.png">
...
<script>
$('#image').on('load', function() {
console.log('Изображение загружено');
});
</script>

jQuery - События мыши

В jQuery для отслеживания действий мыши наиболее часто используют следующие события:
  • mousedown
  • mouseup
  • click
  • mousemove
  • wheel
  • hover
  • mouseenter
  • mouseover
  • mouseleave
  • mouseout

jQuery - Событие клик (click)

Событие click является сложным событием, оно возникает после генерирования событий mousedown и mouseup. Событие mousedownвозникает, когда указатель находится над элементом и кнопка мыши нажата. Событие mouseupпроисходит, когда указатель находится над элементом и кнопка мыши отпущена. Событие click генерируется, когда курсор находится над элементом, и клавиша мыши нажата и отпущена. Эти события могут получать любые HTML элементы.
Например, повесим обработчик на событие onclickэлемента window. При наступлении данного события обработчик будет выводить номер нажатой клавиши и координаты курсора:
$(window).on('click', function(e) {
// обработка события click...
console.log('Нажата кнопка: ' + e.which); //1 - левая кнопка, 2 - средняя кнопка, 3 - правая
console.log('Координаты курсора: x = ' + e.pageX + ' ; y = ' + e.pageY);
});
Например, повесим событие onclickна все элементы с классом btn:
$('.btn').on('click', function(){
// код обработчика события нажатия кнопки
...
});
Краткая запись события по клику:
$('.btn').click(function(){
...
});
Например, разберем, как можно скрыть блок через некоторое время после события click:
<div class="message">
...<a class="hide-message" href="#">Скрыть блок через 5 секунд</a>...
</div>
...
<script>
$('.hide-message').click(function(e){
e.preventDefault();
var _this = this;
setTimeout(function(){
$(_this).closest('.message').hide();
}, 5000);
});
</script>

jQuery - Событие при наведении (hover)

jQuery - Событие hover
Событие при поднесении курсора является сложным и состоит из 2 событий:
  • вхождения (mouseenter, mouseover);
  • покидания (mouseleave, mouseout).
События mouseenter и mouseleave в jQuery отличаются от mouseoverи mouseoutтолько тем, что они не возникают когда курсор соответственно входит и покидает внутренние элементы прослушиваемого элемента. Другими словами события mouseover и mouseoutвсплывают, а mouseenter и mouseleave– нет.
Например, изменим цвет элемента списка при поднесении к нему курсора:
<ul id="list">
<li>Ручка</li>
<li>Карандаш</li>
<li>Линейка</li>
</ul>
...
<script>
$('ul>li').
mouseenter(function(){
// при вхождении в элемент
$(this).css('color','orange');
}).
mouseleave(function(){
// при покидании элемента
$(this).css('color','black');
});
</script>
Те же самые действия, но использованиям mouseoverи mouseout:
$('ul>li').
mouseover(function(){
// при вхождении в элемент
$(this).css('color','orange');
}).
mouseout(function(){
// при покидании элемента
$(this).css('color','black');
});
Данные методы необязательно использовать вместе, их можно также применять по отдельности.
Например, подсчитаем количество посещений элемента при наступлении события "Навести мышью":
<div id="count">Количество: <span>0</span></div>
...
<script>
$('#count').mouseenter(function(){
var count = parseInt($(this).find('span').text());
count++;
$(this).find('span').text(count);
});
</script>
Вместо использования mouseenter и mouseleave можно использовать событие hover.
Например, перепишем вышеприведённый пример, используя hover:
$('ul>li').hover(
function(){
// при вхождении в элемент
$(this).css('color','orange');
},
function(){
// при покидании элемента
$(this).css('color','black');
}
);
При использовании события hover в jQuery, первый обработчик используется для задания действий при вхождении курсора в элемент (mouseenter), а второй - при покидании (mouseleave).
Если указать событию hover один обработчик, то он будет выполняться как для обработки наведения мыши, так и для её покидания.
Например:
$('h1').hover(function(){
console.log('Произошло события входа в элемент или выхода из него');
});

jQuery - Событие движения мыши

Событие mousemove посылается элементу, когда указатель мыши перемещается внутри него. Любой HTML элемент может получать это событие.
$('.target').mousemove(function(e) {
console.log('Вызван обработчик для события mousemove.');
console.log('Координаты относительно левого верхнего угла документа: ' + e.pageX + ', ' + e.pageY);
console.log('Координаты курсора внутри цели: ' + e.offsetX + ', ' + e.offsetY);
});

jQuery - Событие колёсика мыши (wheel)

Прослушивание события прокрутки колёсика (wheel) мышки можно осуществить так:
$(window).on('wheel', function(e) {
// код обработчика (например)...
console.log('Количество прокрученных пикселей: ' + e.originalEvent.deltaY);
if (e.originalEvent.deltaY < 0){
console.log('Прокручиваем вверх');
} else {
console.log('Прокручиваем вниз');
}
});
Данное событие в отличие от scroll генерируется браузером только для колёсика мышки, при этом неважно прокручивается элемент или нет, т.е. с ним можно работать на элементах с overflow, равным hidden. Еще одно отличие заключается в том, что wheel генерируется до прокрутки, а scroll- после неё.

jQuery – События клавиатуры

При нажатии клавиши клавиатуры браузер генерирует события в следующем порядке:
keydown -> keypress -> keyup


keydown(клавиша нажата, но ещё не отпущена);
keypress(событие генерируется для букв, цифр и других клавиш, за исключением управляющих) – предназначено для того чтобы получить код символа (события keydownи keyupпозволяют узнать только о коде клавиши, но не символа);
keyup(генерируется браузером при отпускании клавиши).
Например, напишем обработчик для прослушивания всех событий, которые происходят при нажатии клавиши:


<input id="target" type="text" value="">
...
<script>
$('#target').on('keydown keypress keyup', function(e) {
console.log('Тип события: ' + e.type); // keydown, keypress, keyup
console.log('Код нажатой клавиши или символа: ' + e.which); // код символа позволяет получить только keypress
console.log('Нажата клавиша Alt: ' + e.altKey);
console.log('Нажата клавиша Ctrl: ' + e.ctrlKey);
console.log('Нажата клавиша Shift: ' + e.shiftKey);
console.log('Нажата клавиша Cmd (osMac): ' + e.metaKey);
});
</script>
Пример, в котором показано, как можно прослушать событие keypress и узнать, нажато ли указанное сочетание клавиш:
$(document).keypress("c",
function(e) {
if(e.ctrlKey) {
console.log('Нажато сочетание клавиш Ctrl+c');
}
});
Пример, как можно прослушать сочетание клавиш Ctrl+Enter:
$(document).keydown(function(e) {
// с поддержкой macOS X
if ((e.ctrlKey || e.metaKey) && (e.keyCode == 13 || e.keyCode == 10)) {
// ваши действия...

}
}
Пример, с использованием событий keydown и keyup:
<input id="name" type="text">
...
<script>
$('#name').
keydown(function(){
$(this).css('background-color', 'yellow');
}).
keyup(function(){
$(this).css('background-color, 'pink');
});
</script>

jQuery – События элементов формы

В jQuery можно выделить следующие события для элементов формы и не только:
  • focus (focusin)
  • blur (focusout)
  • change
  • input (для текстовых элементов формы)
  • select
  • submit

jQuery - События получения и потери фокуса

Событие focus посылается элементу, когда он получает фокус. Данное событие генерируется для элементов input, selectи ссылок (a href="..."), а также любых других элементов, у которых установлено свойство tabindex. Получение элементом фокуса обычно осуществляется посредством клика или нажатия клавиши Tab на клавиатуре. Событие focus не всплывает.
Кроме focus есть ещё похожее событие, называется оно focusin. В отличие от focusданное событие всплывает, и оно может, например, использоваться для обнаружения события фокуса родительскими элементами.
Событие blur посылается элементу, когда он теряет фокус. Так же как и focus, событие blurимеет похожее событие focusout. Данное событие отличается от blur тем, что оно может всплывать. Это возможность можно использовать, например, для получения его на родительских элементах, а не только на том элементе, который его вызвал (target).
Например, при получении элементом divсобытия фокуса установим ему фон оранжевого цвета:
<div id="demo"><input type="text"></div>
...
<script>
$('#demo').
focusin(function(){
$(this).css('background-color','orange');
})
.focusout(function(){
$(this).css('background-color','inherit');
});
</script>
Точно такое же выполнить с помощью событий focus и blur не получится, т.к. они не всплывают:
$('#demo input').
focus(function(){
$(this).parent().css('background-color','orange');
})
.blur(function(){
$(this).parent().css('background-color','inherit');
});

jQuery - Событие изменения (change)

Событие change предназначено для регистрации изменения значения элементов input, textarea и select. Для элементов select, checkboxes, и radi oкнопок данное событие возникает сразу (т.е. как только пользователь делает какой-то выбор). Но для других элементов данное событие не будет происходить до тех пор, пока этот элемент не потеряет фокус.
Пример использования события changeдля слежения за состоянием элемента checkbox. Доступность кнопки будет определять в зависимости от того в каком состоянии (checked или нет) находиться флажок:
<input type="checkbox" id="agree">
<button type="submit" id="send" disabled>Отправить</button>
...
<script>
$(function() {
$('#agree').on('change', function(){
if (this.checked) {
$('#send').prop('disabled',false);
} else {
$('#send').prop('disabled',true);
}
});
});
</script>
Пример, в котором рассмотрим, как получить значение элемента selectпри его изменении:
<p id="result"></p>
<select id="list">
<option value="1">Первое значение</option>
<option value="2">Второе значение</option>
<option value="3">Третье значение</option>
</select>
...
<script>
$(function() {
$('#list').on('change', function(){
var value = $(this).val();
$('#result').text(value);
});
});
</script>
Пример, в котором рассмотрим, как получить все выбранные элементы select при его изменении:
<select name="colors" multiple="multiple">
<option>Зелёный</option>
<option>Красный</option>
<option>Синий</option>
<option>Коричневый</option>
<option>Фиолетовый</option>
<option>Серый</option>
</select>
...
<script>
$('select[name="colors"]')
.change(function () {
var colors = [];
$('select[name="colors"] option:selected').each(function() {
colors.push($(this).text());
});
console.log('Выбранные цвета: ' + colors.join());
})
.change();
</script>
Пример программного вызова события changeдля элемента select:
// list - id элемента change
$('#list').trigger('change');
// краткая запись
$('#list').change();
// вызов только обработчика события change
$('#list').triggerHandler('change');
Пример использования события изменения change для получения значения элемента input:
<input type="text" name="name">
...
<script>
$(function() {
// событие изменения значения input (возникает только после потери фокуса)
$('input[name="name"]').on('change',
function(){
var value = $(this).val();
console.log(value);
});
});
</script>
Но кроме события change есть ещё событие input для текстовых элементов. Данное событие в отличие от change генерируется сразу, а не после того как данный элемент потеряет фокус.
Пример, использования события ввода для получения значения элемента input:
$('input[name="name"]').on('input',function(){
var value = $(this).val();
console.log(value);
});
Пример, в котором представлен один из способов получения значения элемента textarea:
<textarea name="text"></textarea>
...
<script>
$('textarea[name="text"]').on('input',function(){
var value = $(this).val();
console.log(value);
});
</script>
Пример, в котором рассмотрим, как с помощью события changeполучить значение выбранного элемента inputс type, равным radio:
<input type="radio" name="platform" checked="checked" value="windows">Windows
<input type="radio" name="platform" value="linux">Linux
<input type="radio" name="platform" value="macos">macOS
...
<script>
$(function() {
$('input[name="platform"]').on('change', function(){
var value = $(this).val();
console.log(value);
});
});
</script>

jQuery - Событие выбора (select)

Событие выбора select генерируется браузером, когда пользователь внутри элементов input с type="text" или textarea выделяет текст.
$( "#target" ).select(function() {
console.log('Вызван обработчик события select');
});

jQuery – Событие отправки формы (submit)

Событие submitвозникает у элемента, когда пользователь пытается отправить форму. Данное событие может быть добавлено только к элементам form.
Пример, использования события submit:
<form id="feedback" action="action.php">
...
</form>
...
<script>
$('#feedback').submit(function(e) {
// отменить отправку формы
e.preventDefault();
// другие действия, например, для отправки формы по ajax...

});
</script>
Программный вызов отправки формы:
$('#feedback').submit();
$('#feedback').trigger('submit');

jQuery - Событие прокрутки (scroll)

Для отслеживания состояния скроллинга в jQuery используется событие scroll.
Например, повесим на событие прокрутки страницы функцию, которая будет отображать элемент с классом scrollup, если величина прокрутки больше 200px и скрывать его, если значение прокрутки меньше этой величины.
// краткая запись функции
$(window).scroll(function() {
// действия при скроллинге страницы...
if ($(this).scrollTop()>200) {
$('.scrollup').fadeIn();
} else {
$('.scrollup').fadeOut();
}
});

jQuery - Событие изменения размеров окна (resize)

Для прослушивания события изменения окна браузера используется resize:
Например, создадим обработчик, который будет при изменении окна браузера выводить в конец страницы её ширину и высоту:
$(window).resize(function() {
$('body').append('<p>Ширина x Высота = ' + window.innerWidth + ' x ' + window.innerHeight + '</p>');
});

jQuery - Отмена стандартного поведения события

Некоторые элементы в HTML имеют стандартное поведение. Например, когда пользователь нажимает на ссылку, он переходит по адресу указанному в атрибуте href. Если вам это действие не нужно, то его можно отменить. Для отмены стандартного поведения необходимо вызвать в обработчике этого события метод preventDefault объекта event.
Например, отменим стандартное поведение всех ссылок на странице, имеющих класс service:
$('a.service').on('click',function(e){
//отменяем стандартное действие браузера
e.preventDefault();
// действия, которые будет выполнять ссылка
...
});

Что такое всплытие и как его остановить

jQuery - Как работает метод stopPropagation
Кроме отмены стандартного действия, в механизме событий есть ещё такое понятие как всплытие. Оно заключается в том, что когда браузер генерирует событие, то он это делает не только для текущего элемента (цели), но и для всех его потомков включая родителя:
текущий элемент (цель) -> родительский элемент цели -> прародительский элемент -> ... -> document -> window
В jQuery бывают сценарии, когда в представленной цепочке у какого-нибудь элемента то же есть обработчик для этого события, который выполнять не нужно. И чтобы это событие не распространилось на этот элемент, его необходимо остановить. Для этого в обработчике нужного элемента необходимо вызвать метод stopPropagationобъекта event. После вызова этого метода событие остановится, и не будет всплывать.
Например, необходимо чтобы при поднесении курсора к элементу с классом mark, его содержимое становилось оранжевым цветом.
<div class="mark">Некоторый текст...<span class="mark">фрагмент...</span>...продолжение...</div>
...
<script>
$('.mark').on('hover',
function(e){
e.stopPropagation();
$(this).css('color',orange);
},
function(e){
e.stopPropagation();
$(this).css('color',black);
}
});
</script>
В данном случае если не указывать метод stopPropagation, то при поднесении курсора к элементу span с классом mark данное событие возникнет не только у него, но и у всех его родительских элементов. А это в этом примере приведёт к тому, что изменится цвет не только текста, заключенного в span, но и всего абзаца.

Если вам необходимо отменить стандартное поведение браузера и остановить всплытие события, то в jQuery вместо вызова двух этих методов можно просто вернуть в качестве результата функции значение false.
$('a').on('click', function(e){
//e.preventDefault();
//e.stopPropagation();
...
return false;
});

Добавление событий к динамически созданным объектам

Для того чтобы повесить событие на элемент, которого ещё нет, можно использовать следующую конструкцию функции on:
$(document).on(eventName, selector, handler);


// document или любой другой существующий родительский элемент
// eventName - имя события
// selector - селектор, осуществляющий фильтрацию потомков, для которых необходимо запустить обработчик события
// handler - обработчик события
Это действие можно осуществить благодаря тому, что событие всплывает, и, следовательно, возникает у всех предков этого элемента. А объект, до которого всплывают все события на странице, является document. Поэтому в большинстве случаев выбирают именно его. После этого зная селектор, функция onможет программно отобрать среди элементов (элемента, который вызвал это событие (target) и всех его предков включая родителя) те, которые соответствуют ему. И затем для всех отобранных элементов выполнить указанный в функции onобработчик. Действия, посредством которых обработка события переносится на другой элемент (предок), называется в jQuery ещё процессом делегирования события.
Например, добавим событие к элементу, которого ещё нет на странице:
<button id="addButton" type="button">Добавить кнопку</button>


<script>
// при нажатии на элемент с id="addButton" добавить в начало страницы новую кнопку
$('#addButton').on('click', function(e) {
$('body').prepend('<button class="deleteMe" type="button">Удалить меня</button>');
});
// добавить событие click, которое будет выполнено для элементов, которых ещё нет на странице
$(document).on('click','.deleteMe', function() {
$(this).remove();
});
</script>
Делегирование может применяться не только для обработки событий динамически созданных объектов, но и для того чтобы не привязывать к каждому элементу (если их на странице может быть очень много) обработчик.
Например, запретим в комментариях переходить по внешним ссылкам (такие действия будем перенаправлять на страницу away):
$(document).on('click','#comment a',function(e) {
if(!(location.hostname === this.hostname || !this.hostname.length)) {
e.preventDefault();
location.href='away?link='+encodeURIComponent($(this).attr('href'));
}
});

jQuery - Удалить обработчик события

Удаление обработчиков события осуществляется с помощью метода off. При этом с помощью него можно удалить только те обработчики, которые добавлены посредством метода on.
Вызов метода off без аргументов снимет у указанных элементов все добавленные к ним обработчики событий.
Например, отключим все обработчики у элементов с классом link:
$('.link').off();
Например, удалим событие clickу всех элементов с классом link:
$('.link').off('link');
Специальный селектор (**) позволяет удалить только делегированные события с сохранением не делегированных:
$('.link').off('click','**');
Удалить только указанные делегированные события (с помощью селектора):
// добавление делегированного события
$('ul').on('click','li', function(){
// выводим в консоль контент элемента li
console.log($(this).text());
});


// удаление делегированного события
$('ul').off('click','li');
Удалить все обработчики openModal делегированного события click в пространстве имён modalдля элементов с классом show:
$('body').on('click.modal', '.show', openModal);

Создание пользовательского события

Для создания пользовательских событий в jQuery используются методы onи trigger.
Принцип создания специального события jQuery рассмотрим посредством следующего примера:
<div class="module">
<p>...</p>
<button class="success" type="button">Вызвать пользовательское событие highlight (цвет зелёный)</button>
<button class="error" type="button">Вызвать пользовательское событие highlight (цвет красный)</button>
</div>
...
<script>
// добавляем ко всем элементам p пользовательское событие, которое будет изменять цвет текста и его содержимое
// получения данных, переданных методом trigger, осуществим посредством аргументов color и title
$('.module p').on('highlight', function(e, color, title) {
$(this).css('color',color);
$(this).text('Вызвано пользовательское событие highlight ' +title);
});
// при нажатии на элемент с классом success вызвать кастомное событие highlight и передать ему параметры
$('.success').click(function(){
// используя второй аргумент передадим данные в обработчик события
$(this).closest('.module').find('p').trigger('highlight',['green','(цвет зелёный)']);
});
// при нажатии на элемент с классом error вызвать кастомное событие highlight и передать ему параметры
$('.error').click(function(){
// используя второй аргумент передадим данные в обработчик события
$(this).closest('.module').find('p').trigger('highlight',['red','(цвет красный)']);
});
</script>

Создаем iframe с видео

Модальное окно с запуском видео при открыти
<div class="modal fade" id="myModalVideo" tabindex="-1" role="dialog">
     <div class="modal-dialog">
       <div class="modal-content">
                <div class="modal-header"><button class="close" type="button" data-dismiss="modal">x</button>
          </div>
        <div class="modal-body">
         <object width="1" height="1" classid="clsid:d27cdb6e-ae6d-11cf-96b8-444553540000" codebase="//download.macromedia.com/pub/shockwave/cabs/flash/swflash.cab#version=6,0,40,0" data="" type="application/x-shockwave-flash"><param name="src" value="/video/Egeria.mp4" /><embed width="1" height="1" type="application/x-shockwave-flash" src="/video/Egeria.mp4" /></object>
        </div>
    </div>
  </div>
</div>
Кнопка вызова модальноно окна
<button type="button" id="toggleModalVideoYoutube" data-bs-toggle="modal" data-bs-target="#myModalVideo">
  Запустить модальное окно
</button>

JavaScript / jQuery

<script>
$(function() {
/*создаем iframe с видео*/
var videoIframe = $("<iframe/>", {
"class": "embed-responsive-item",
"src": "https://www.youtube.com/embed/cNLJB-giaVo?autoplay=1&enablejsapi=1&playerapiid=ytplayer",
"width": "96%",
"height": "400px",
"frameborder": "0",
"allowfullscreen": ""
});
/*по клику на кнопку .toggleModalVideoYoutube аттачим iframe с видео в модалку*/
$('.toggleModalVideoYoutube').click(function () {
$('#myModalVideo').modal('show');
videoIframe.appendTo('#myModalVideo .modal-body');
});
/*по закрытию модалки убираем iframe */
$('#myModalVideo').on('hidden.bs.modal', function () {
videoIframe.detach();
});
});
</script>

Удаление атрибута тега с помощью jQuery

При загрузке страницы удалим стили из тегов <p> и <span>. 
$(function () {

$(".item-attr p").each(function()
      {
         $(this).removeAttr("style");
     });
     $(".item-attr p span").each(function()
      {
         $(this).removeAttr("style");
     });
  
});