Элемент HTML form (<form>) представляет (собой) раздел документа, содержащий интерактивные элементы управления, которые позволяют пользователю отправлять информацию на веб-сервер.
Можно использовать :valid и :invalid CSS псевдоклассы для стилизации <form> элемента, в зависимости от того, валиден или нет конкретный элемент elements внутри формы.
Как и все HTML-элементы, этот элемент поддерживает глобальные атрибуты (en-US).
accept HTML 4 Этот API вышел из употребления и его работа больше не гарантируется.
Список типов содержимого, разделённых запятой, которые принимает сервер.> Примечание:Примечание об использовании: Этот атрибут был удалён в HTML5 и его не следует больше использовать. Взамен, используйте accept атрибут заданного <input> элемента.
accept-charset
Разделённые пробелами символьные кодировки, которые принимает сервер. Браузер использует их в том порядке, в котором они перечислены. Значение по умолчанию означает ту же кодировку что и у страницы.
(В предыдущей версии HTML, различные кодировки могли быть разделены запятыми.)
action
URI-адрес программы, которая обрабатывает информацию переданную через форму. Это значение может быть переписано с помощью атрибута formaction на <button> или <input> элементе.
autocomplete HTML5
Указывает, могут ли элементы управления автоматически быть дописаны в форме браузером. Эта настройка может быть переписана с помощью атрибута autocomplete на элементе формы. Возможные значения:* off: Пользователь должен явно ввести значение в каждое поле или документ предоставит свой собственный метод автодополнения; браузер автоматически не дополняет записи.
on: Браузер может автоматически дополнить значения, основанные на значениях, которые пользователь уже вводил, в течение предыдущего использования формы. > **Примечание:**Если вы установили значение offдляautocomplete атрибута формы, из-за того, что документ предоставляет своё собственное автодополнение, то вам следует также установить значение off для autocomplete каждого <input> элемента формы, которые документ может автоматически дополнить. Подробнее, смотрите Google Chrome notes.
enctype
Когда значение атрибута method равно post, атрибут — MIME тип содержимого, которое используется, чтобы передать форму на сервер. Возможные значения:*
application/x-www-form-urlencoded: Значение по умолчанию, если атрибут не задан.
multipart/form-data: Используйте это значение, если пользуетесь элементом <input> атрибутом type установленным в «file».
text/plain (HTML5)Это значение может быть переписано атрибутом formenctype на элементе <button> или <input>.
method
HTTP (en-US) метод, который браузер использует, для отправки формы. Возможные значения:* post: Соответствует HTTP POST методу ; данные из формы включаются в тело формы и посылаются на сервер.
get: Соответствует GET методу; данные из формы добавляются к URI атрибута action, их разделяет ‘?’, и полученный URI посылается на сервер. Используйте этот метод, когда форма содержит только ASCII символы и не имеет побочного эффекта.Это значение может быть переписано атрибутом formmethod на <button> или <input> элементе.
name
Имя формы. В HTML 4 его использование запрещено (id следует использовать взамен). Оно должно быть уникальным и не пустым среди всех форм в документе в HTML 5.
novalidate HTML5
Это Boolean атрибут показывает, что форма не проверяется на валидность, когда отправляется серверу. Если атрибут пропущен (и поэтому форма проверяется), эта настройка по умолчанию, может быть переписана атрибутом
formnovalidate на <button> или <input> элементе, принадлежащем форме.
target
Имя или ключевое слово, показывающее где отображать ответ, который будет получен, после отправки формы. В HTML 4, это имя или ключевое слово для фрейма. В HTML5, это имя или ключевое слово, контекстапросмотра (например, вкладка, окно, или линейный фрейм). Следующие ключевые слова имеют специальное значение:* _self: Загружает ответ в том же самом фрейме HTML 4 (или HTML5 контексте просмотра) как текущий. Это значение по умолчанию, если атрибут не указан.
_blank: Загружает ответ в новом безымянном окне HTML 4 или HTML5 контексте просмотра.
_parent: Загружает ответ HTML 4 в родительском наборе фрейма для текущего фрейма или HTML5 родительский контекст просмотра для текущего просмотра. Если нет предка, эта опция действует точно так же как as _self.
_top: HTML 4: Загружает ответ в полное, оригинальное окно, закрывая все другие фреймы. HTML5: Загружает ответ в верхний уровень контекста просмотра (т.е., контекст просмотра это предок текущего и не имеет других предков). Если нет предка, эта опция действует точно так же как as _self.HTML5: Это значение может быть перезаписано formtarget атрибутом на <button> или <input> элементе.
Этот элемент реализует HTMLFormElement интерфейс.
<!-- Простая форма, которая пошлёт GET запрос -->
<form action="">
<label for="GET-name">Name:</label>
<input type="text" name="name">
<input type="submit" value="Save">
</form>
<!-- Простая форма, которая пошлёт POST запрос -->
<form action="" method="post">
<label for="POST-name">Name:</label>
<input type="text" name="name">
<input type="submit" value="Save">
</form>
<!-- Форма с fieldset, legend, и label -->
<form action="" method="post">
<fieldset>
<legend>Title</legend>
<input type="radio" name="radio"> <label for="radio">Click me</label>
</fieldset>
</form>
BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.
Другие элементы, которые используются для создания форм: <button>, <datalist>, <fieldset>, <input>,<keygen> (en-US), <label>, <legend> , <meter>, <optgroup>, <option>, <output>, <progress>, <select>, <textarea> (en-US).
Атрибут / параметр method (от англ. «method» ‒ «метод») указывает метод отправки данных формы на сервер.
Поддержка браузерами
Chrome
Поддерж.
Firefox
Поддерж.
Opera
Поддерж.
Maxthon
Поддерж.
IExplorer
Поддерж.
Safari
Поддерж.
iOS
Поддерж.
Android
Поддерж.
Спецификация
Верс.
Раздел
HTML
2.0
Form: FORM
Перевод
3.2
FORM
4.01
17.3 The FORM element method = get|post [CI]… DTD:Transitional
Strict
Frameset
5.0
4.10.19. 6 Form submission The method and…
5.1
4.10.19.6. Form submission The method and…
XHTML
1.0
Extensible HyperText Markup Language DTD:Transitional
Strict
Frameset
1.1
Extensible HyperText Markup Language
Значения
get
Объединяет данные формы в одну строку, после чего присоединяет полученную строку к URL-адресу обработчика формы (указывается в атрибуте «action» или «formaction») и с помощью полученного URL-адреса передаёт данные формы на сервер.
>
<p><label>Фамилия: <input type="text" name="family"></label></p>
<!-- Введено значение ivanov -->
<p><label>Имя: <input type="text" name="name"></label></p>
<!-- Введено значение ivan -->
<button type="submit"> Отправить </button>
</form>
В итоге получится: http://www.example.com/script/index.php?family=ivanov&name=ivan
Плюсы метода:
Позволяет быстро получать результаты передачи форм с небольшим количеством коротких полей.
Минусы метода:
Некоторые сервера ограничивают длину URL-адреса с аргументами;
Передача личных данных (пароли, номера кридитных карт и так далее) с помощью данного метода является небезопасной, так как данные передаваемые этим методом могут быть легко перехвачены.
post
Браузер устанавливает связь с сервером, на котором находится обработчик данных формы (URL-адрес обработчика указывается в атрибуте «action» или «formaction») и после установки связи передаёт (в отдельном сеансе связи) данные на сервер.
Плюсы метода:
В отличие от метода «get» данный метод является более безопасным методом передачи личных данных;
Может передавать на сервер большие объёмы данных формы.
Минусы метода:
Требуется определённый опыт в создании соответствующих обработчиков формы.
dialog
Предполагает, что форма с данными находится в диалоговом окне (элемент dialog), которое должно быть закрыто после отправки данных на сервер.
Одним из основных способов передачи данных веб-сайту является обработка форм. Формы представляют специальные элементы разметки HTML, которые содержат
в себе различные элементы ввода — текстовые поля, кнопки и т.д. И с помощью данных форм мы можем ввести некоторые данные и отправить их на сервер. А сервер уже обрабатывает эти данные.
Создание форм состоит из следующих аспектов:
Создание элемента <form><form> в разметке HTML
Добавление в этот элемент одно или несколько поле ввода
Установка метода передачи данных. Чаще всего используются методы GET или POST
Установка адреса, на который будут отправляться введенные данные
POST-запросы
Итак, создадим новую форму. Для этого определим новый файл form.php, в которое поместим следующее содержимое:
Атрибут action="user.php" элемента form указывает, что данные формы будет обрабатывать скрипт user.php,
который будет находиться с файлом form. php в одной папке. А атрибут method="POST" указывает, что в качестве метода передачи данных будет применяться метод POST.
Теперь определим файл user.php, который будет иметь следующее содержание:
Для обработки запросов типа POST в PHP используется встроенная глобальная переменная $_POST.
Она представляет ассоциативный массив данных, переданных с помощью метода POST. Используя ключи, мы можем получить отправленные
значения. Ключами в этом массиве являются значения атрибутов name у полей ввода формы.
Например, так как атрибут name поля ввода возраста имеет значение age (<input type="number" name="age" />),
то в массиве $_POST значение этого поля будет представлять ключ «age»: $_POST["age"]
И поскольку возможны ситуации, когда поле ввода будет не установлено, то в этом случае желательно перед обработкой данных проверять
их наличие с помощью функции isset(). И если переменная установлена, то функция isset() возвратит значение true.
Теперь мы можем обратиться к скрипту form.php и ввести в форму какие-нибудь данные:
И по нажатию кнопки введенные данные методом POST будут отправлены скрипту user.php:
Необязательно отправлять данные формы другому скрипту, можно данные формы обработать в том же файле формы. Для этого изменим файл form.php
следующим образом:
Поскольку в данном случае мы отправляем данные этому же скрипту — то есть по тому же адресу, то у элемента форма можно не устанавливать
атрибут action.
Стоит отметить, что в принципе мы можем отправлять формы и запросом GET, в этом случае для получения тех же значений формы
применяется массив $_GET, который был рассмотрен в прошлой теме:
HTTP методы GET и POST используются для отправки данных на сервер.
Чаще всего методы используются в HTML формах, гиперссылках и AJAX запросах.
POST и GET запросы можно отправить на сервер с помощью любого программного обеспечения, работающего с протоколом HTTP.
Обработка запросов может отличаться в зависимости от типа сервера.
Большинство действующих сайтов работают с языком программирования PHP. В этом случае передаваемые данные попадают в суперглобальные массивы $_GET и $_POST.
Массивы $_GET и $_POST являются ассоциативными. Таким образом, переданный на сервер параметр с именем «user_name», будет доступен как $_GET[‘user_name’] или $_POST[‘user_name’] в зависимости от используемого метода.
Какой метод использовать GET или POST, чем отличаются методы
Основное отличие метода GET от POST в способе передачи данных.
Запрос GET передает данные в URL в виде пар «имя-значение» (другими словами, через ссылку), а запрос POST передает данные в теле запроса (подробно показано в примерах ниже). Это различие определяет свойства методов и ситуации, подходящие для использования того или иного HTTP метода.
Страница, созданная методом GET, может быть открыта повторно множество раз. Такая страница может быть кэширована браузерами, проиндексирована поисковыми системами и добавлена в закладки пользователем. Из этого следует, что метод GET следует использовать для получения данных от сервера и не желательно в запросах, предполагающих внесений изменений в ресурс.
Например, можно использовать метод GET в HTML форме фильтра товаров: когда нужно, исходя из данных введенных пользователем, переправить его на страницу с отфильтрованными товарами, соответствующими его выбору.
Запрос, выполненный методом POST, напротив следует использовать в случаях, когда нужно вносить изменение в ресурс (выполнить авторизацию, отправить форму оформления заказа, форму обратной связи, форму онлайн заявки). Повторный переход по конечной ссылке не вызовет повторную обработку запроса, так как не будет содержать переданных ранее параметров. Метод POST имеет большую степень защиты данных, чем GET: параметры запроса не видны пользователю без использования специального ПО, что дает методу преимущество при пересылке конфиденциальных данных, например в формах авторизации.
HTTP метод POST поддерживает тип кодирования данных multipart/form-data, что позволяет передавать файлы.
Также следует заметить, что методы можно комбинировать. То есть, при необходимости вы можете отправить POST запрос на URL, имеющий GET параметры.
В каких случаях использовать POST и когда нужно использовать GET
В таблице ниже показаны распространенные варианты использования HTTP запросов с объяснением в чем разница между GET и POST запросами в конкретной ситуации.
Ситуация
GET
POST
Фильтр товаров
Пользователь получит страницу с подходящими ему товарами, сможет сохранить ее в закладки, переслать ссылку на страницу с параметрами другим и вернуться к странице позже без повторного заполнения формы фильтра.
Для повторного посещения страницы пользователь должен будет повторно заполнить форму фильтра, страницей с параметрами нельзя будет поделиться, сохранить в закладки и вернуться к странице позже без повторного заполнения формы фильтра.
Форма авторизации
Отсутствует защита конфиденциальной информации. Введенный пароль будет виден в адресной строке браузера, будет сохранен в истории посещенных сайтов.
Хотя данные могут передаваться в незашифрованном виде, увидеть их можно только через инструменты разработчика или с помощью другого специального программного обеспечения.
Онлайн заявка
Оформления заказа
Форма обратной связи
При повторном обращении по конечной ссылке на сервере будет произведена повторная обработка, например, будет создана повторная заявка, оформлен еще один заказ, создан еще один запрос на обратную связь.
Повторное обращение по конечной ссылке не приведет к повторной обработке запроса с введенными ранее параметрами.
Через гиперссылку
Переход по гиперссылке с параметрами равнозначен отправке запроса через HTML форму.
Нет технической возможности поместить POST запрос в гиперссылку.
AJAX запросы
Используются оба метода. Выбор зависит от контекста. Принципы выбора метода такие же, как и для HTML форм.
Сравнительная таблица HTTP методов GET и POST
В таблице ниже приведены основные свойства и отличия GET и POST методов.
Свойство
GET
POST
Способ передачи данных
Через URL
В теле HTTP запроса
Защита данных
Данные видны всем в адресной строке браузера, истории браузера и т. п.
Данные можно увидеть только с помощью инструментов разработчика, расширений браузера, специализированных программ.
Длина запроса
Не более 2048 символов
Не ограничена
Примечание: ограничения могут быть установлены сервером.
Сохранение в закладки
Страница с параметрами может быть добавлена в закладки
Страница с параметрами не может быть добавлена в закладки.
Кэширование
Страница с параметрами может быть кэширована
Страница с параметрами не может быть кэширована
Индексирование поисковыми системами
Страница с параметрами может быть индексирована
Страница с параметрами не может быть индексирована
Возможность отправки файлов
Не поддерживается
Поддерживается
Поддерживаемые типы кодирования
application/x-www-form-urlencoded
application/x-www-form-urlencoded
multipart/form-data
text/plain
Использование в гиперссылках <a>
Да
Нет
Использование в HTML формах
Да
Да
Использование в AJAX запросах
Да
Да
Пример использования GET запроса
В примере показана простая HTML форма фильтра по нескольким параметрам.
Ссылка содержит URL документа, отвечающего за обработку и блок параметров. Знак «?» отмечает начало блока параметров GET запроса. Далее находятся пары «имя-значение», разделенные знаком «&». Имена параметров отделены от значений знаком «=».
Переход по ссылке, приведенной выше, будет равнозначен отправке формы с указанными параметрами.
Пример использования POST запроса
В примере показана простая HTML форма авторизации.
После отправки формы браузер переведет пользователя по ссылке:
http://example.com/profile.php
Для того, чтобы увидеть переданные параметры, воспользуемся инструментами разработчика.
Запрос состоит из области заголовков и тела запроса.
В заголовках указана служебная информация: URL обработчика, тип кодирования, параметры браузера и т. д.
В теле запроса содержатся передаваемые параметры. Формат тела запроса может отличаться в зависимости от выбранного типа кодирования.
by Lebedev
Форма отправки данных в PHP (POST, GET)
Чтобы организовать передачу данных на сервер с помощью формы, потребуется реализовать HTML форму, в которую посетители сайта будут вводить свою информацию и PHP код, назначение которого в принятии и обработке полученных данных на сервере.
HTML форма отправки данных
Форма на странице формируется тегами <form>…</form>, внутри которых помещаются теги полей для ввода текстовой информации, теги специальных компонентов (например, поле со списком), теги для поля выбора и загрузки файла.
Для HTML5 так же существует возможность размещать теги полей формы не внутри тегов формы, а в любом месте на странице. При этом для каждого такого поля нужно указывать атрибут «form», чтобы определить с какой формой отправки он должен взаимодействовать.
Итак, простейшая форма отправки может содержать следующий код:
<form action="myform.php" method="post"> Значение А: <input type="text" name="data1"> Значение Б: <input type="text" name="data2"> <input type="submit" value="Отправить"> </form>
Элементы формы и их параметры:
action=»myform.php» – атрибут «action» определяет, какой php-файл будет обрабатывать отправляемые данные. В этом примере, данные будут отправлены в файл «myform.php», находящийся в той же директории что и страница с формой. Если этот атрибут не указать явно, данные формы будут отправлены по адресу страницы самой формы.
method=»post» – параметр method определяет метод передачи данных POST или GET. Более подробно об этом в статье «Отличия методов POST или GET». Если не указывать атрибут явно, по умолчанию будет использоваться метод GET.
Текст «Значение А:» и «Значение Б:» добавлен только с целью оформления и понятности формы для пользователя. Добавлять это для передачи данных не обязательно, но для того, чтобы пользователю стало понятно, что вводить, стоит указывать.
Теги <input> используются для формирования различных управляющих элементов формы.
type=»text» – атрибут «type» определяет вид поля. В зависимости от того, какой тип указан, меняется и внешний вид элемента, и его назначение. Значение атрибута «text» указывает, что в браузере элемент будет отображаться однострочным текстовым полем, куда пользователь сможет ввести свою строку.
name=»data1″ – атрибут «name», указывает имя, вернее индекс данных в массиве, полученных сервером. Это обязательный параметр, по которому в php-обработчике можно будет затем получить доступ переданному значению. Имя может быть выбрано произвольно, однако, удобнее когда это значение имеет какой-то понятный смысл.
type=»submit» – тег <input> с таким значением параметра «type» будет отображаться на странице как кнопка. На самом деле на форме можно обойтись и без кнопки. Если, например, в форме есть текстовые поля, то отправку можно осуществить, просто нажав «Ввод» на клавиатуре. Но наличие кнопки делает форму более понятной.
value=»Отправить» – в данном случае (для type=»submit») определяет только надпись на кнопке. Для type=»text», например, это будет текст, который будет выведен в текстовом поле.
В итоге, на странице этот код будет выглядеть приблизительно так:
Обработка отправленных HTML формой данных в PHP
Отправленные описанным способом данные, помещаются в суперглобальные массивы $_POST, $_GET и $_REQUEST. $_POST или $_GET будут содержать данные в зависимости от того, каким методом осуществлялась отправка. $_REQUEST содержит отправленные данные любым из указанных методов.
$_POST, $_GET и $_REQUEST – это ассоциативные массивы, поля-индексы которых совпадают с атрибутами «name» тегов <input>. Соответственно, для работы с данными в файле myform. php можно присвоить переменным значения элементов такого массива указав в качестве индекса имя поля:
// для метода GET $a = $_GET['data1']; $b = $_GET['data2'];
// для метода POST $a = $_POST['data1']; $b = $_POST['data2'];
// при любом методе $a = $_REQUEST['data1']; $b = $_REQUEST['data2'];
Проверка заполнения полей формы
Иногда при получении данных нужно проверить, не отправил ли пользователь пустую форму. Для этого можно использовать функцию empty.
if (empty($_REQUEST['data1'])) { echo 'Поле не заполнено'; } else { echo 'Поле было заполнено'; $a = $_REQUEST['data1']; }
Обычно этого решения достаточно. Если нужно вводить текст, то будет понятно, введен он или нет. Однако, если пользователь намеренно для вычислений введет ноль, то функция empty покажет, что значения нет. Поэтому для таких ситуаций лучше использовать функцию isset. Она будет явно проверять, заданно ли значение или нет.
if (isset($_REQUEST['data1'])) { echo 'Поле было заполнено'; $a = $_REQUEST['data1']; } else { echo 'Поле не заполнено'; }
HTML-формы
❮ Назад
Далее ❯
HTML-форма используется для сбора пользовательского ввода. Пользовательский ввод
чаще всего отправляются на сервер для обработки.
Пример
Имя:
Фамилия:
Попробуйте сами »
Элемент
. элементы формы .
Элемент
представляет собой контейнер для различных типов элементов ввода,
такие как: текстовые поля, флажки, радио
кнопки, кнопки отправки и т. д.
Все
в этой главе рассматриваются различные элементы формы:
HTML-элементы формы.
Элемент
Элемент HTML является наиболее
используемый элемент формы.
Элемент может отображаться в
много способов, в зависимости от тип атрибут.
Вот несколько примеров:
Тип
Описание
Отображает однострочное поле ввода текста
<тип ввода = "радио">
Отображает переключатель (для выбора одного из множества вариантов)
Отображает флажок (для выбора нуля или более из множества вариантов)
Отображает кнопку отправки (для отправки формы)
<тип ввода = "кнопка">
Отображает нажимаемую кнопку
В этой главе рассматриваются все различные типы входов:
Типы ввода HTML.
Текстовые поля
определяет однострочное поле ввода для
ввод текста.
Пример
Форма с полями ввода текста:
Попробуйте сами »
Вот как приведенный выше HTML-код будет отображаться в браузере:
Имя:
Фамилия:
Примечание: Сама форма не видна. Также обратите внимание, что ширина по умолчанию
поля ввода составляет 20 символов.
Элемент
JavaScript
Попробуйте сами »
Вот как приведенный выше HTML-код будет отображаться в браузере:
Выберите ваш любимый веб-язык:
HTML CSS JavaScript
Флажки
определяет флажок .
Флажки позволяют пользователю выбрать НОЛЬ или БОЛЬШЕ вариантов из ограниченного числа вариантов.
Пример
Форма с флажками:
У меня есть велосипед
У меня есть машина
У меня есть лодка
Попробуйте сами »
Вот как приведенный выше HTML-код будет отображаться в браузере:
У меня есть велосипед У меня есть машина У меня есть лодка
Кнопка отправки
определяет кнопку для отправки данных формы обработчику формы.
Обработчик формы обычно представляет собой файл на сервере со сценарием для обработки
входные данные.
Обработчик формы указан в действии формы атрибут.
Пример
Форма с кнопкой отправки:
First
имя:
Фамилия:
Попробуйте сами »
Вот как приведенный выше HTML-код будет отображаться в браузере:
Имя:
Фамилия:
Атрибут имени для
Обратите внимание, что каждое поле ввода должно иметь атрибут name для отправки.
Если атрибут name опущен, значение поля ввода вообще не будет отправлено.
Пример
В этом примере не будет отправлено значение поля ввода «Имя»:
First
имя:
Попробуйте сами »
HTML-упражнения
Проверьте себя с помощью упражнений
Упражнение:
В форму ниже добавьте поле ввода с типом «кнопка» и значением «ОК».
<форма> <>
Начать упражнение
❮ Предыдущий
Далее ❯
: Элемент Form — HTML: Язык гипертекстовой разметки
HTML-элемент представляет собой раздел документа, содержащий интерактивные элементы управления для отправки информации.
Можно использовать :valid и :invalid Псевдоклассы CSS для стилизации элемента
в зависимости от того, допустимы ли элементы внутри формы.
Этот элемент включает глобальные атрибуты.
принять Устаревший
Типы контента, разделенные запятыми, которые принимает сервер.
Примечание: Этот атрибут устарел и не должен использоваться. Вместо этого используйте атрибут accept для элементов .
принять кодировку
Кодировки символов, разделенные пробелами, которые принимает сервер. Браузер использует их в том порядке, в котором они перечислены. Значение по умолчанию означает ту же кодировку, что и страница.
(В предыдущих версиях HTML кодировки символов также могли быть разделены запятыми.)
автокапитализация Нестандартный
Нестандартный атрибут, используемый iOS Safari, который управляет тем, как текстовые элементы формы должны автоматически начинаться с прописной буквы. autocapitalize атрибутов в элементах формы переопределяет его на
. Возможные значения:
нет : Без автоматического использования заглавных букв.
предложений (по умолчанию): Делайте первую букву каждого предложения заглавной.
слов : Сделать заглавной первую букву каждого слова.
символов : Сделать все символы прописными, то есть заглавными.
автозаполнение
Указывает, могут ли значения элементов ввода по умолчанию автоматически заполняться браузером. атрибуты автозаполнения в элементах формы переопределяют его на
. Возможные значения:
выкл. : Браузер может не заполнять записи автоматически. (Браузеры, как правило, игнорируют это для подозрительных форм входа; см. Атрибут автозаполнения и поля входа.)
на : Браузер может автоматически заполнять записи.
имя
Имя формы. Значение не должно быть пустой строкой и должно быть уникальным среди элементов формы в коллекции форм, в которой оно находится, если таковая имеется.
отн.
Создает гиперссылку или аннотацию в зависимости от значения, подробности см. в атрибуте rel .
Атрибуты для отправки формы
Следующие атрибуты управляют поведением во время отправки формы.
Действие
URL-адрес, который обрабатывает отправку формы. Это значение может быть переопределено формацией в элементе , или . Этот атрибут игнорируется, если установлено method="dialog" .
enctype
Если значение атрибута method равно post , enctype — это MIME-тип отправки формы. Возможные значения:
приложение/x-www-form-urlencoded : Значение по умолчанию.
multipart/form-data : Используйте это, если форма содержит элементов с type=file .
text/plain : Полезно для целей отладки.
Это значение может быть переопределено атрибутами formenctype для элементов , или элементов.
метод
Метод HTTP для отправки формы.
Единственные допустимые методы/значения (без учета регистра):
post : метод POST; данные формы, отправленные в качестве тела запроса.
получить : метод GET; данные формы, добавленные к URL-адресу действия с ? Сепаратор . Используйте этот метод, когда форма не имеет побочных эффектов.
диалоговое окно : Когда форма находится внутри , закрывает диалоговое окно и вызывает событие отправки при отправке без отправки данных или очистки формы.
Это значение переопределяется атрибутами formmethod для , или элементов.
новалидат
Этот логический атрибут указывает, что форма не должна проверяться при отправке. Если этот атрибут не установлен (и поэтому форма проверено ), его можно переопределить атрибутом formnovalidate для принадлежащего элементу , или к форме.
цель
Указывает, где отображать ответ после отправки формы. Это имя/ключевое слово для контекста просмотра (например, вкладка, окно или iframe). Следующие ключевые слова имеют особое значение:
_self (по умолчанию): загрузить в тот же контекст просмотра, что и текущий.
_blank : загрузить в новый безымянный контекст просмотра.
_parent : загрузить в родительский контекст просмотра текущего. Если нет родителя, ведет себя так же, как _self .
_top : загрузить в контекст просмотра верхнего уровня (т. е. контекст просмотра, который является предком текущего и не имеет родителя). Если нет родителя, ведет себя так же, как _себя .
Это значение может быть переопределено атрибутом formtarget в элементе , или .
Примечание: Настройка target="_blank" для элементов
неявно обеспечивает то же поведение rel , что и настройка rel="noopener" , которая не устанавливает window.opener .
Загрузка таблиц в браузере с поддержкой JavaScript. Включите JavaScript для просмотра данных.
Руководство по HTML-формам
Другие элементы, используемые при создании форм: , , , , , , , , , , .
Получение списка элементов в виде: HTMLFormElement.elements
ARIA: роль формы
АРИЯ: роль поиска
Последнее изменение: , авторы MDN
Работа с формами | Документация Django
Об этом документе
Этот документ представляет собой введение в основы веб-форм и как
они обрабатываются в Django. Для более подробного ознакомления с отдельными областями
API форм, см. API форм, поля форм и
Проверка формы и полей.
Если только вы не планируете создавать веб-сайты и приложения, которые ничего не делают, кроме
публиковать контент и не принимать входные данные от ваших посетителей, вы собираетесь
необходимо понимать и использовать формы.
Django предоставляет ряд инструментов и библиотек, которые помогут вам создавать формы для
принять ввод от посетителей сайта, а затем обработать и ответить на ввод.
HTML-формы
В HTML форма — это набор элементов внутри
...
, которые
разрешить посетителю делать такие вещи, как ввод текста, выбор опций, управление
объектов или элементов управления и т. д., а затем отправить эту информацию обратно в
сервер.
Некоторые из этих элементов интерфейса формы — текстовый ввод или флажки — встроены
в сам HTML. Другие намного сложнее; интерфейс, который выводит
выбор даты или позволяет перемещать ползунок или управлять элементами управления.
обычно используют JavaScript и CSS, а также форму HTML элементов в
добиться этих эффектов.
Помимо элементов , в форме должны быть указаны две вещи:
, где : URL-адрес, по которому должны передаваться данные, соответствующие вводу пользователя.
быть возвращен
как : метод HTTP данные должны быть возвращены
Например, форма входа для администратора Django содержит несколько элементов: один из type="text" для имени пользователя, один из type="password" для пароля и один из type="submit" для
Кнопка «Войти». Он также содержит несколько скрытых текстовых полей, которые пользователь
не видит, который Django использует, чтобы определить, что делать дальше.
Он также сообщает браузеру, что данные формы должны быть отправлены на URL
указанный в атрибуте
action — /admin/ — и что он
должны быть отправлены с использованием механизма HTTP, указанного метод атрибут — сообщение .
Когда срабатывает элемент ,
данные возвращаются на /admin/ .
GET и POST
GET и POST — единственные методы HTTP, используемые при работе с формами.
Форма входа Django возвращается с использованием метода POST , в котором браузер
объединяет данные формы, кодирует их для передачи, отправляет на сервер,
а затем получает ответ.
GET , напротив, объединяет отправленные данные в строку и использует это
для составления URL. URL-адрес содержит адрес, на который должны быть отправлены данные, т.к.
а также ключи данных и значения. Вы можете увидеть это в действии, если выполните поиск
в документации Django, которая создаст URL-адрес формы https://docs.djangoproject.com/search/?q=forms&release=1 .
GET и POST обычно используются для разных целей.
Любой запрос, который может быть использован для изменения состояния системы, например,
запрос, который вносит изменения в базу данных, должен использовать POST . ПОЛУЧИТЬ следует использовать только для запросов, не влияющих на состояние системы.
GET также не подходит для формы пароля, потому что пароль
будет отображаться в URL-адресе и, следовательно, также в истории браузера и журналах сервера,
все обычным текстом. Это также не подходит для больших объемов данных,
или для двоичных данных, таких как изображение. Веб-приложение, использующее ПОЛУЧИТЬ запросы на административные формы представляют собой угрозу безопасности: злоумышленник может легко
имитировать запрос формы, чтобы получить доступ к конфиденциальным частям системы. POST в сочетании с другими средствами защиты, такими как защита Django CSRF, обеспечивает больший контроль над доступом.
С другой стороны, GET подходит для таких вещей, как форма веб-поиска,
поскольку URL-адреса, представляющие запрос GET , можно легко добавить в закладки,
поделились или отправили повторно.
Роль Джанго в 9 классах0017
Работа с формами — сложный процесс. Рассмотрим администратора Django, где множество
Элементы данных нескольких различных типов могут быть подготовлены для отображения в
форма, отрендеренная как HTML, отредактированная с помощью удобного интерфейса, возвращенная в
сервер, проверенный и очищенный, а затем сохраненный или переданный для дальнейшего
обработка.
Функциональность формы Django может упростить и автоматизировать большую часть этого
работать, а также может делать это более безопасно, чем большинство программистов
делать в коде, который они написали сами.
Django выполняет три отдельные части работы, связанной с формами:
подготовка и реструктуризация данных для подготовки к рендерингу
создание HTML-форм для данных
получение и обработка представленных форм и данных от клиента
Можно написать код, который делает все это вручную, но Django может
позаботиться обо всем этом для вас.
Формы в Django
Мы кратко описали HTML-формы, но HTML
— это только часть
необходимая техника.
В контексте веб-приложения «форма» может относиться к этому HTML-коду.
, или в Django Form , которая его производит, или в
структурированные данные возвращаются при их отправке или в сквозную рабочую
сбор этих частей.
Класс Django
Form
В основе этой системы компонентов лежит класс Django Form . В
почти так же, как модель Django описывает логическую структуру
объект, его поведение и то, как его части представляются нам, Класс формы описывает форму и определяет, как она работает и выглядит.
Подобно тому, как поля класса модели сопоставляются с полями базы данных, форма
поля класса сопоставляются с HTML-формой элементов. (Модель A Form сопоставляет поля класса модели с HTML-формой элементов через Форма ; это то, на чем основан администратор Django.)
Поля формы сами по себе являются классами; они управляют данными формы и выполняют
проверка при отправке формы. А DateField и FileField обрабатывает очень разные типы данных и должен
разные вещи с ним.
Поле формы представляется пользователю в браузере как виджет HTML —
часть механизма пользовательского интерфейса. Каждый тип поля имеет соответствующее значение по умолчанию.
Класс виджетов, но их можно переопределить как
требуется.
Создание, обработка и рендеринг форм
При рендеринге объекта в Django мы обычно:
получаем его в представлении (например, получаем из базы данных)
передать его в контекст шаблона
расширить его до HTML-разметки, используя переменные шаблона
Отрисовка формы в шаблоне требует почти такой же работы, как и отрисовка любого
другой тип объекта, но есть некоторые ключевые отличия.
В случае экземпляра модели, не содержащего данных, он редко, если вообще когда-либо
будет полезно сделать что-нибудь с ним в шаблоне. С другой стороны, это делает
совершенно разумно отображать незаселенную форму — это то, что мы делаем, когда хотим
пользователь для его заполнения.
Таким образом, когда мы обрабатываем экземпляр модели в представлении, мы обычно извлекаем его из
база данных. Когда мы имеем дело с формой, мы обычно создаем ее экземпляр в
Посмотреть.
Когда мы создаем экземпляр формы, мы можем оставить ее пустой или предварительно заполнить ее, для
пример с:
данные из сохраненного экземпляра модели (как в случае админ форм для редактирования)
данных, которые мы собрали из других источников
данные, полученные от предыдущей отправки HTML-формы
Последний из этих случаев самый интересный, потому что именно он
возможность для пользователей не только читать веб-сайт, но и отправлять информацию обратно
к этому тоже.
Создание формы
Работа, которую необходимо выполнить
Предположим, вы хотите создать простую форму на своем веб-сайте, чтобы получить
имя пользователя. Вам понадобится что-то вроде этого в вашем шаблоне:
Ваше имя:
<тип ввода = "отправить" значение = "ОК">
форма>
Это говорит браузеру вернуть данные формы на URL-адрес /your-name/ , используя
метод POST . Он отобразит текстовое поле с надписью «Ваше имя:» и
кнопку с надписью «ОК». Если контекст шаблона содержит current_name переменная, которая будет использоваться для предварительного заполнения поля your_name .
Вам понадобится представление, отображающее шаблон, содержащий HTML-форму, и
который может предоставить поле current_name по мере необходимости.
При отправке формы запрос POST , который отправляется на сервер
будут содержать данные формы.
Теперь вам также понадобится представление, соответствующее URL-адресу /your-name/ , который будет
найдите в запросе подходящие пары ключ/значение, а затем обработайте их.
Это очень простая форма. На практике форма может содержать десятки или
сотни полей, многие из которых должны быть предварительно заполнены, и мы могли бы
ожидать, что пользователь пройдет через цикл редактирования-отправки несколько раз, прежде чем
заключение операции.
Нам может потребоваться некоторая проверка в браузере, даже перед формой
представлен; мы могли бы захотеть использовать гораздо более сложные поля, которые позволяют
пользователю делать такие вещи, как выбирать даты из календаря и так далее.
На данный момент намного проще заставить Django сделать большую часть этой работы за нас.
Создание формы в Django
Форма класс
Мы уже знаем, как должна выглядеть наша HTML-форма. Наша отправная точка для
это в Джанго это:
forms.py
из форм импорта django
класс NameForm(forms.Form):
your_name = forms.CharField(label='Ваше имя', max_length=100)
Это определяет класс формы с одним полем ( ваше_имя ). У нас есть
применил к полю удобную метку, которая появится в <метка> при рендеринге (хотя в данном случае метка мы указали, на самом деле тот же самый, который был бы сгенерирован автоматически, если бы
мы его пропустили).
Максимально допустимая длина поля определяется максимальная_длина . Это делает две вещи. Это ставит maxlength="100" в HTML (поэтому браузер должен предотвратить
пользователь вводит больше, чем это количество символов в первую очередь). Это
также означает, что когда Django получит форму из браузера, он
проверить длину данных.
Экземпляр формы имеет метод is_valid() , который запускается
подпрограммы проверки для всех его полей. При вызове этого метода, если все
поля содержат действительные данные, это будет:
возврат Правда
поместите данные формы в атрибут clean_data .
Вся форма при первом отображении будет выглядеть так:
Ваше имя:
Обратите внимание, что не включает теги
или кнопку отправки.
Мы должны сами предоставить их в шаблоне.
Представление
Данные формы, отправленные обратно на веб-сайт Django, обрабатываются представлением, обычно
тот же вид, который опубликовал форму. Это позволяет нам повторно использовать одни и те же
логика.
Чтобы обработать форму, нам нужно создать ее экземпляр в представлении для URL-адреса, где мы
хотите, чтобы он был опубликован:
views. py
из django.http import HttpResponseRedirect
из django.shortcuts импортировать рендеринг
из .forms импортировать NameForm
def get_name (запрос):
# если это POST-запрос, нам нужно обработать данные формы
если request.method == 'POST':
# создаем экземпляр формы и заполняем его данными из запроса:
форма = ИмяФорма (запрос.POST)
# проверяем правильность:
если form.is_valid():
# обработать данные в form.cleaned_data по мере необходимости
# ...
# перенаправление на новый URL:
вернуть HttpResponseRedirect('/спасибо/')
# если GET (или любой другой метод) мы создадим пустую форму
еще:
форма = ИмяФорма()
вернуть рендеринг (запрос, 'name.html', {'форма': форма})
Если мы придем к этому представлению с запросом GET , он создаст пустую форму
instance и поместите его в контекст шаблона для отображения. Это то, что мы
можно ожидать при первом посещении URL.
Если форма отправлена с использованием запроса POST , представление снова
создайте экземпляр формы и заполните его данными из запроса: form =
NameForm(request.POST) Это называется «привязка данных к форме» (сейчас граница 9форма 0547).
Вызываем метод формы is_valid() ; если это не True , мы возвращаемся к
шаблон с формой. На этот раз форма больше не пуста ( несвязанных )
поэтому HTML-форма будет заполнена ранее отправленными данными, где они
могут быть отредактированы и исправлены по мере необходимости.
Если is_valid() равно True , теперь мы сможем найти все проверенные формы
data в атрибуте clean_data . Мы можем использовать эти данные для обновления
базу данных или выполнить другую обработку перед отправкой HTTP-перенаправления в браузер
рассказывая ему, куда идти дальше.
Шаблон
Нам не нужно много делать в нашем шаблоне name. html :
{% csrf_token%}
{{ форма }}
форма>
Все поля формы и их атрибуты будут распакованы в HTML-разметку
из этого {{ form }} с помощью языка шаблонов Django.
Формы и межсайтовые запросы Защита от подделки
Django поставляется с простой в использовании защитой от межсайтовых запросов
Подделки. При отправке формы через ПОСТ с
Защита CSRF включена, вы должны использовать тег шаблона csrf_token как в предыдущем примере. Однако, поскольку защита от CSRF не
непосредственно привязан к формам в шаблонах, этот тег отсутствует в
следующие примеры в этом документе.
Типы ввода HTML5 и проверка браузера
Если ваша форма включает URLField , EmailField или любой целочисленный тип поля, Django
используйте адрес , адрес электронной почты и номер Типы ввода HTML5. По умолчанию,
браузеры могут применять собственную проверку этих полей, что может быть
строже, чем проверка Django. Если вы хотите отключить это
поведение, установите атрибут novalidate в теге формы или укажите
другой виджет в поле, например TextInput .
Теперь у нас есть рабочая веб-форма, описанная Django Form , обработанная
представлением и отображается как HTML
.
Это все, что вам нужно для начала работы, но структура форм позволяет гораздо больше.
кончики пальцев. Как только вы поймете основы процесса, описанного выше,
вы должны быть готовы понимать другие особенности системы форм и
готовы узнать немного больше о базовой машине.
Подробнее о Django
Классы Form
Все классы форм создаются как подклассы django.forms.Form или django.forms.ModelForm . Вы можете думать о ModelForm как
подкласс формы . Форма и МодельФорма фактически наследуют общие
функциональность из (частного) класса BaseForm , но эта реализация
детали редко имеют значение.
Модели и формы
На самом деле, если ваша форма будет использоваться для прямого добавления или редактирования Django
модель, ModelForm может сэкономить вам много
много времени, усилий и кода, потому что он создаст форму вместе с
соответствующие поля и их атрибуты, из Модель класс.
Связанные и несвязанные экземпляры форм
Важно различать связанные и несвязанные формы:
Несвязанная форма не имеет связанных с ней данных. При отображении пользователю
он будет пустым или будет содержать значения по умолчанию.
Связанная форма отправила данные и, следовательно, может использоваться, чтобы определить, были ли эти данные
является действительным. Если отображается недопустимая связанная форма, она может содержать встроенную ошибку.
сообщения, сообщающие пользователю, какие данные нужно исправить.
Атрибут формы is_bound сообщит вам, имеет ли форма
данные связаны с ним или нет.
Подробнее о полях
Рассмотрим более полезную форму, чем наш минимальный пример выше, которую мы могли бы использовать
для реализации функции «свяжитесь со мной» на личном веб-сайте:
forms.py
из форм импорта django
класс ContactForm(forms.Form):
предмет = формы.CharField(max_length=100)
сообщение = формы.CharField (виджет = формы.Текстовая область)
отправитель = формы.EmailField()
cc_myself = forms.BooleanField (обязательно = False)
В нашей предыдущей форме использовалось одно поле: your_name , a CharField . В
В этом случае наша форма имеет четыре поля: тема , сообщение , отправитель и cc_myself . CharField , EmailField и BooleanField — это только три из доступных типов полей; полный список
можно найти в полях формы.
Виджеты
Каждое поле формы имеет соответствующий класс виджета,
который, в свою очередь, соответствует виджету HTML-формы, такому как <ввод
тип="текст"> .
В большинстве случаев поле будет иметь разумный виджет по умолчанию. Например, по
по умолчанию CharField будет иметь виджет TextInput , который
создает в HTML. Если вам нужно
вместо этого вы бы указали соответствующий виджет при определении поля формы,
как мы сделали для поля сообщения .
Данные поля
Независимо от данных, представленных с формой, после ее успешного
подтверждено по телефону is_valid() (и is_valid() вернул True ),
проверенные данные формы будут находиться в словаре form.cleaned_data . Этот
данные будут красиво преобразованы в типы Python для вас.
Примечание
Вы по-прежнему можете получить доступ к непроверенным данным непосредственно из запроса . POST в
этот момент, но проверенные данные лучше.
В приведенном выше примере контактной формы cc_myself будет логическим значением.
Аналогично, такие поля, как IntegerField и FloatField преобразовать
значения для Python int и float соответственно.
Вот как данные формы могут быть обработаны в представлении, которое обрабатывает эту форму:
views.py
from django.core.mail import send_mail
если form.is_valid():
тема = form.cleaned_data['тема']
сообщение = form.cleaned_data['сообщение']
отправитель = form.cleaned_data['отправитель']
cc_myself = form.cleaned_data['cc_myself']
получатели = ['info@example.com']
если cc_myself:
получатели.append(отправитель)
send_mail(тема, сообщение, отправитель, получатели)
вернуть HttpResponseRedirect('/спасибо/')
Совет
Дополнительные сведения об отправке электронной почты из Django см. в разделе Отправка электронной почты.
Некоторые типы полей требуют дополнительной обработки. Например, файлы, загруженные
с использованием формы нужно обрабатывать по-разному (их можно получить из
request.FILES , а не request.POST ). Для получения подробной информации о том, как обращаться с
загрузки файлов с помощью формы, см. раздел Привязка загруженных файлов к форме.
Работа с шаблонами форм
Все, что вам нужно сделать, чтобы разместить форму в шаблоне, это поместить форму
экземпляр в контекст шаблона. Итак, если ваша форма называется форма в
context, {{ form }} отобразит свои элементы и
соответственно.
Дополнительная мебель шаблона формы
Не забывайте, что выходные данные формы , а не включают окружающие
тегов или элемент управления формы submit . Вы должны будете предоставить
эти сами.
Повторно используемые шаблоны форм
Вывод HTML при отображении формы сам генерируется с помощью шаблона. Ты
можно управлять этим, создав соответствующий файл шаблона и установив пользовательский
FORM_RENDERER , чтобы использовать это
form_template_name для всего сайта. Ты
также можно настроить производительность формы, переопределив параметры формы.
имя_шаблона атрибут для отображения формы с использованием
пользовательский шаблон или путем передачи имени шаблона непосредственно в
Форма.render() .
В приведенном ниже примере {{ form }} будет отображаться как результат
шаблон form_snippet.html .
В ваших шаблонах:
# В вашем шаблоне:
{{ форма }}
# В form_snippet.html:
{% для поля в форме %}
<дел>
{{поле.ошибки}}
{{ field.label_tag }} {{ поле }}
{% конец для %}
Затем вы можете настроить параметр FORM_RENDERER :
settings. py
из django.forms.renderers import TemplatesSetting
класс CustomFormRenderer (настройка шаблонов):
form_template_name = "form_snippet.html"
FORM_RENDERER = "project.settings.CustomFormRenderer"
… или для одной формы:
class MyForm(forms.Form):
имя_шаблона = "form_snippet.html"
...
… или для одного рендеринга экземпляра формы, передавая имя шаблона в
Форма.render() . Вот пример использования этого в представлении:
def index(request):
форма = МояФорма()
rendered_form = form.render("form_snippet.html")
контекст = {'форма': rendered_form}
вернуть рендеринг (запрос, 'index.html', контекст)
Дополнительные сведения см. в разделе Вывод форм в формате HTML.
Изменено в Django 4.0:
Добавлена шаблонная отрисовка форм.
Изменено в Django 4.1:
Возможность установить по умолчанию form_template_name в средстве визуализации формы
был добавлен.
Параметры рендеринга формы
Существуют и другие параметры вывода для пар / :
{{ form.as_div }} будет отображать их в 0 <2div теги.
{{ form.as_table }} отобразит их как ячейки таблицы, завернутые в
теги.
{{ form.as_p }} сделает их завернутыми в
тегов.
{{ form.as_ul }} отобразит их в тегах
.
Обратите внимание, что вам нужно будет предоставить окружающий
или
элементы сами.
Вот вывод {{ form.as_p }} для нашего экземпляра ContactForm :
Subject:
Сообщение:
Отправитель:
Скопировать себе:
Обратите внимание, что атрибут ID каждого поля формы имеет значение id_ , что
ссылается на сопровождающий тег label. Это важно для обеспечения того, чтобы
формы доступны для вспомогательных технологий, таких как программное обеспечение для чтения с экрана.
Вы также можете настроить способ генерации меток и идентификаторов.
Дополнительные сведения об этом см. в разделе Вывод форм в формате HTML.
Ручной рендеринг полей
Нам не нужно позволять Django распаковывать поля формы; мы можем сделать это вручную, если
нам нравится (например, позволяя нам переупорядочивать поля). Каждое поле
доступен как атрибут формы с использованием {{ form.name_of_field }} и
в шаблоне Django будут отображаться соответствующим образом. Например:
Цена этой гибкости — немного больше работы. До сих пор нам не приходилось
беспокойтесь о том, как отображать ошибки формы, потому что об этом позаботились мы. В
В этом примере мы должны были убедиться, что мы позаботились о любых ошибках для каждого поля.
и любые ошибки для формы в целом. Примечание {{ form.non_field_errors }} в
вверху формы и в шаблоне поиск ошибок в каждом поле.
Использование {{ form. name_of_field.errors }} отображает список ошибок формы,
представлен в виде неупорядоченного списка. Это может выглядеть так:
Требуется отправитель.
Список содержит CSS-класс errorlist , позволяющий изменять его внешний вид.
Если вы хотите дополнительно настроить отображение ошибок, вы можете сделать это, зациклив
над ними:
{% если form.subject.errors %}
<ол>
{% за ошибку в form.subject.errors %}
{{ ошибка|экранирование }}
{% конец для %}
{% конец%}
Ошибки, не относящиеся к полям (и/или ошибки скрытых полей, которые отображаются в верхней части
форма при использовании помощников, таких как form.as_p() ) будет отображаться с
дополнительный класс неполевых , чтобы помочь отличить их от специфичных для поля
ошибки. Например, {{ form.non_field_errors }} будет выглядеть так:
Общая ошибка проверки
Подробнее об ошибках, стилях и работе с формой см. в Forms API.
атрибуты в шаблонах.
Перебор полей формы
Если вы используете один и тот же HTML для каждого поля формы, вы можете уменьшить
дублировать код, просматривая каждое поле по очереди, используя {% for %}
цикл:
{% для поля в форме %}
<дел>
{{поле.ошибки}}
{{ field.label_tag }} {{ поле }}
{% если field.help_text %}
{{ field.help_text|безопасно }}
{% конец%}
{% конец для %}
Полезные атрибуты {{ field }} включают:
{{ field.errors }}
Выводит
, содержащий любые ошибки проверки
соответствующий этому полю. Вы можете настроить представление
ошибки с циклом {% for error in field.errors %} . В этом
случае каждый объект в цикле представляет собой строку, содержащую сообщение об ошибке.
{{ field.field }}
Экземпляр Field из класса формы,
это BoundField оберток. Вы можете использовать его для доступа
Атрибуты поля , например.
{{ char_field.field.max_length }} .
{{ field.help_text }}
Любой текст справки, связанный с полем.
{{ field.html_name }}
Имя поля, которое будет использоваться в имени элемента ввода
поле. При этом учитывается префикс формы, если он был установлен.
{{ field.id_for_label }}
Идентификатор, который будет использоваться для этого поля ( id_email в примере
выше). Если вы создаете этикетку вручную, вы можете использовать
это вместо label_tag . Это также полезно, например, если у вас есть
некоторые встроенные JavaScript и хотят избежать жесткого кодирования идентификатора поля.
{{ field.is_hidden }}
Этот атрибут равен True , если поле формы является скрытым полем и
Ложь в противном случае. Это не особенно полезно в качестве шаблона
переменная, но может быть полезна в условных тестах, таких как:
Метка поля, заключенная в соответствующий тег HTML . Этот
включает форму label_suffix . Например,
по умолчанию label_suffix представляет собой двоеточие:
Адрес электронной почты:
{{ field.legend_tag }}
Новое в Джанго 4.1.
Аналогичен field.label_tag , но использует тег вместо
, для виджетов с несколькими входными данными, заключенными в .
{{ field.use_fieldset }}
Новое в Джанго 4.1.
Этот атрибут равен True , если виджет поля формы содержит несколько
входные данные, которые должны быть семантически сгруппированы в с
<легенда> для улучшения доступности. Пример использования в шаблоне:
{% if field.use_fieldset %}
<набор полей>
{% if field.label %}{{ field.legend_tag }}{% endif %}
{% еще %}
{% if field.label %}{{ field.label_tag }}{% endif %}
{% конец%}
{{ поле }}
{% if field.use_fieldset %}{% endif %}
Если вы вручную размещаете форму в шаблоне, а не полагаетесь на
Макет формы Django по умолчанию, возможно, вы захотите обработать
поля отличаются от не скрытых полей. Например, поскольку скрытые поля
ничего не отображать, размещение сообщений об ошибках «рядом с» полем может привести к
путаница для ваших пользователей - поэтому ошибки для этих полей должны быть обработаны
иначе.
Django предоставляет в форме два метода, которые позволяют перебирать скрытые
и видимые поля независимо: hidden_fields() и
visible_fields() . Вот модификация более раннего примера, в котором используется
эти два метода:
{# Включить скрытые поля #}
{% для скрытых в form.hidden_fields %}
{{ скрытый }}
{% конец для %}
{# Включить видимые поля #}
{% для поля в form.visible_fields %}
<дел>
{{поле.ошибки}}
{{ field.label_tag }} {{ поле }}
{% конец для %}
Этот пример не обрабатывает ошибки в скрытых полях. Обычно
ошибка в скрытом поле является признаком подделки формы, так как обычная форма
взаимодействие не изменит их. Однако вы можете легко вставить какую-то ошибку
отображает для этих ошибок формы, а также.
Дополнительные темы
Здесь рассмотрены основы, но формы могут делать гораздо больше:
Наборы форм
Использование исходных данных с набором форм
Ограничение максимального количества форм
Ограничение максимального количества создаваемых форм
Проверка набора форм
Проверка количества форм в наборе форм
Работа с заказом и удалением форм
Добавление дополнительных полей в набор форм
Передача пользовательских параметров в формы набора форм
Настройка префикса набора форм
Использование набора форм в представлениях и шаблонах
Создание форм из моделей
ModelForm
Наборы форм для моделей
Встраиваемые формы
Активы формы (класс Media )
Активы как статическое определение
Носитель как динамическое свойство
Пути в определениях активов
Медиа объектов
СМИ на формах
См. также
Справочник по формам
Полный справочник по API, включая поля форм, виджеты форм,
и проверка формы и поля.
Регистрационная форма PHP с использованием методов GET, POST с примером
ByPaul Jackson
Hours
Обновлено
Что такое форма?
Когда вы входите на веб-сайт или в свой почтовый ящик, вы взаимодействуете с формой.
Формы используются для получения ввода от пользователя и отправки его на веб-сервер для обработки.
На приведенной ниже диаграмме показан процесс обработки форм.
Форма — это HTML-тег, содержащий элементы графического интерфейса пользователя, такие как поле ввода, флажки, переключатели и т. д.
Форма определяется с помощью тегов
…
, а элементы графического интерфейса определяются с помощью таких элементов формы, как ввод.
В этом уроке вы узнаете-
Когда и почему мы используем формы?
Создать форму
Метод POST
Метод ПОЛУЧИТЬ
Методы GET и POST
Обработка данных регистрационной формы
Еще примеры
Когда и почему мы используем формы?
Формы пригодятся при разработке гибких и динамичных приложений, принимающих пользовательский ввод.
Формы можно использовать для редактирования уже существующих данных из базы данных
Создание формы
Для создания формы мы будем использовать теги HTML. Ниже приведен минимальный список вещей, которые вам понадобятся для создания формы.
Открытие и закрытие тегов формы
…
Тип отправки формы POST или GET
URL-адрес отправки, который будет обрабатывать отправленные данные
Поля ввода, такие как поля ввода, текстовые области, кнопки, флажки и т. д.
Приведенный ниже код создает простую регистрационную форму
<голова>
Регистрационная форма
голова>
<тело>
Регистрационная форма
php" method="POST"> Имя:
Фамилия:
форма>
тело>
При просмотре приведенного выше кода в веб-браузере отображается следующая форма.
ЗДЕСЬ,
…
— открывающий и закрывающий теги формы
.
action="registration_form.php" method="POST"> указывает целевой URL и тип отправки.
Имя/Фамилия: метки для полей ввода
— это теги поля ввода
.
— новый тег строки
— это скрытое значение, которое используется для проверки того, была ли форма отправлена или нет
— это кнопка, при нажатии которой форма отправляется на сервер для обработки
.
Отправка данных формы на сервер
Атрибут действия формы указывает URL-адрес отправки, который обрабатывает данные. Атрибут метода определяет тип отправки.
Метод PHP POST
Это встроенная в PHP сверхглобальная переменная массива, которая используется для получения значений, отправленных с помощью метода HTTP POST.
Доступ к переменной массива можно получить из любого скрипта в программе; он имеет глобальную область действия.
Этот метод идеально подходит, если вы не хотите отображать значения сообщений формы в URL-адресе.
Хорошим примером использования метода post является отправка данных для входа на сервер.
Имеет следующий синтаксис.
ЗДЕСЬ,
«$_POST[…]» — это массив PHP
.
«имя_переменной» — это имя переменной URL.
Метод PHP GET
Это встроенная в PHP сверхглобальная переменная массива, которая используется для получения значений, отправленных с помощью метода HTTP GET.
Доступ к переменной массива можно получить из любого скрипта в программе; он имеет глобальную область действия.
Этот метод отображает значения формы в URL-адресе.
Он идеально подходит для форм поисковых систем, поскольку позволяет пользователям отмечать результаты в закладках.
Имеет следующий синтаксис.
ЗДЕСЬ,
«$_GET[…]» — это массив PHP
.
«имя_переменной» — это имя переменной URL.
Методы GET и POST
POST
ПОЛУЧИТЬ
Значения не видны в URL
Значения, видимые в URL
Не имеет ограничения на длину значений, поскольку они передаются через тело HTTP
.
Имеет ограничение на длину значений обычно 255 символов. Это связано с тем, что значения отображаются в URL-адресе. Обратите внимание, что верхний предел символов зависит от браузера.
Имеет более низкую производительность по сравнению с методом Php_GET из-за времени, затрачиваемого на инкапсуляцию значений Php_POST в тело HTTP
Обладает высокой производительностью по сравнению с методом POST благодаря простому добавлению значений в URL-адрес.
Поддерживает множество различных типов данных, таких как строковые, числовые, двоичные и т. д.
Поддерживает только строковые типы данных, поскольку значения отображаются в URL-адресе
.
Результаты не могут быть занесены в книгу с пометкой
Результаты могут быть помечены книгой из-за видимости значений в URL
.
На приведенной ниже диаграмме показана разница между get и post
Обработка данных регистрационной формы
Регистрационная форма отправляет данные самой себе, как указано в атрибуте действия формы.
Когда форма отправлена, значения заносятся в суперглобальный массив $_POST.
Мы будем использовать функцию PHP isset, чтобы проверить, были ли заполнены значения формы в массиве $_POST, и обработать данные.
Мы изменим регистрационную форму, включив в нее PHP-код, обрабатывающий данные. Ниже приведен модифицированный код
<голова>
Регистрационная форма
голова>
<тело>
// этот код выполняется при отправке формы
Введите GET заглавными буквами и нажмите кнопку отправки.
Будет показано следующее
На приведенной ниже диаграмме показан URL-адрес вышеуказанных результатов
Обратите внимание, что URL-адрес отображает значение search_term и form_submitted. Попробуйте ввести что-нибудь отличное от GET, затем нажмите кнопку отправки и посмотрите, какие результаты вы получите.
Работа с флажками, переключателями
Если пользователь не выбирает флажок или переключатель, значение не передается, если пользователь выбирает флажок или переключатель, передается значение 1 (1) или true .
Мы изменим код регистрационной формы и добавим кнопку проверки, позволяющую пользователю согласиться с условиями обслуживания.
<голова>
Регистрационная форма
голова>
<тело>
Вы не приняли наши условия использования
Спасибо
Вы зарегистрированы как
' ' . $_POST['фамилия']; ?>
Имя:
Фамилия:
Принять Условия использования:
форма>
тело>
Просмотр вышеуказанной формы в браузере
Введите имя и фамилию
Обратите внимание, что флажок «Согласен с условиями обслуживания» не установлен.
Нажмите кнопку отправки
Вы получите следующие результаты
Нажмите на ссылку возврата к форме и установите флажок
Нажмите кнопку отправки
Вы получите следующие результаты
Сводка
Формы используются для получения данных от пользователей
Формы создаются с использованием тегов HTML
Формы можно отправлять на сервер для обработки с помощью метода POST или GET
.
Значения формы, отправленные с помощью метода POST, инкапсулируются в тело HTTP.
Значения формы, отправленные с помощью метода GET, добавляются и отображаются в URL-адресе.
GET против POST - разница и сравнение
Различия в отправке формы
Фундаментальное различие между METHOD="GET" и METHOD="POST" заключается в том, что они соответствуют различным HTTP-запросам , как определено в спецификациях HTTP. Процесс отправки для обоих методов начинается одинаково — набор данных формы создается браузером, а затем кодируется способом, указанным атрибутом enctype . Для METHOD="POST атрибут enctype может иметь значение multipart/form-data или application/x-www-form-urlencoded , тогда как для METHOD="GET" допускается только application/x-www-form-urlencoded . Затем этот набор данных формы передается на сервер.
Для отправки формы с METHOD="GET" браузер создает URL-адрес, беря значение атрибута action и добавляя ? , а затем добавить набор данных формы (закодированный с использованием типа содержимого application/x-www-form-urlencoded). Затем браузер обрабатывает этот URL-адрес, как если бы он перешел по ссылке (или как если бы пользователь ввел URL-адрес напрямую). Браузер делит URL-адрес на части и распознает хост, а затем отправляет этому хосту запрос GET с остальной частью URL-адреса в качестве аргумента. Сервер берет его оттуда. Обратите внимание, что этот процесс означает, что данные формы ограничены кодами ASCII. Особое внимание следует уделить кодированию и декодированию других типов символов при их передаче через URL-адрес в формате ASCII.
Отправка формы с METHOD="POST" приводит к отправке запроса POST с использованием значения атрибута action и сообщения, созданного в соответствии с типом содержимого, указанным атрибутом enctype .
Плюсы и минусы
Поскольку данные формы отправляются как часть URL-адреса при использовании GET --
Данные формы ограничены кодами ASCII. Особое внимание следует уделить кодированию и декодированию других типов символов при их передаче через URL-адрес в формате ASCII. С другой стороны, двоичные данные, изображения и другие файлы могут быть отправлены через МЕТОД="ПОСТ"
Все заполненные данные формы отображаются в URL-адресе. Кроме того, он также хранится в истории/журналах просмотра веб-страниц пользователя для браузера. Эти проблемы делают GET менее безопасным.
Однако одно из преимуществ отправки данных формы как части URL-адреса заключается в том, что можно добавлять URL-адреса в закладки и напрямую использовать их, полностью минуя процесс заполнения формы.
Существует ограничение на объем данных формы, которые можно отправить, поскольку длина URL-адреса ограничена.
Детишки-скрипторы могут легче обнаружить уязвимости в системе, чтобы взломать ее. Например, Citibank был взломан путем изменения номеров счетов в строке URL. [1] Конечно, опытные хакеры или веб-разработчики могут раскрыть такие уязвимости, даже если используется POST; это просто немного сложнее. Как правило, сервер должен с подозрением относиться к любым данным, отправляемым клиентом, и защищаться от небезопасных прямых ссылок на объекты.
Различия в обработке на стороне сервера
В принципе, обработка отправленных данных формы зависит от того, отправляются ли они с помощью METHOD="GET" или METHOD="POST" . Поскольку данные кодируются по-разному, необходимы разные механизмы декодирования. Таким образом, вообще говоря, изменение МЕТОДА может потребовать изменения сценария, обрабатывающего отправку. Например, при использовании интерфейса CGI сценарий получает данные в переменной среды (QUERYSTRING), когда используется GET . Но когда Используется POST , данные формы передаются в стандартном потоке ввода ( stdin ), а количество байтов для чтения задается заголовком Content-length.
Что происходит при конфликте переменных GET и POST?
В некоторых языках, таких как PHP, информация из параметров GET и POST, помимо того, что она доступна отдельно, также объединяется в вспомогательную переменную, например, $_REQUEST в PHP. Если возникает конфликт, т. е. одно и то же имя параметра используется с разными значениями в GET и POST, то конфликт разрешается с помощью определенных правил. В случае PHP приоритет определяется variable_order директива конфигурации. Порядок по умолчанию — EGPCS (среда, GET, POST, Cookie, сервер). Это означает, что переменная в $_GET имеет приоритет над $_POST, которая, в свою очередь, имеет приоритет над $_COOKIE.
Рекомендуемое использование
GET рекомендуется при отправке «идемпотентных» форм — тех, которые «значительно не изменяют состояние мира». Другими словами, формы, которые включают только запросы к базе данных. Другая точка зрения состоит в том, что несколько идемпотентных запросов будут иметь тот же эффект, что и один запрос. Если речь идет об обновлениях базы данных или других действиях, таких как запуск электронных писем, рекомендуется использовать POST.
Из блога разработчиков Dropbox:
браузер не знает точно, что делает конкретная HTML-форма, но если форма отправляется через HTTP GET, браузер знает, что безопасно автоматически повторить попытку отправки в случае сетевой ошибки. Для форм, использующих HTTP POST, повторная попытка может быть небезопасной, поэтому браузер сначала запрашивает у пользователя подтверждение.
Запрос "GET" часто кэшируется, тогда как запрос "POST" вряд ли может быть кэширован. Для систем запросов это может иметь значительное влияние на эффективность, особенно если строки запросов простые, поскольку кэши могут обслуживать наиболее частые запросы.
В некоторых случаях рекомендуется использовать POST даже для идемпотентных запросов:
Если данные формы будут содержать символы, отличные от ASCII (например, символы с диакритическими знаками), то METHOD="GET" в принципе неприменим, хотя на практике он может работать (в основном для символов ISO Latin 1).
Если набор данных формы большой — скажем, сотни символов — тогда METHOD="GET" может вызвать практические проблемы с реализациями, которые не могут обрабатывать такие длинные URL-адреса.
Возможно, вы захотите избежать METHOD="GET" , чтобы пользователи не видели, как работает форма, особенно для того, чтобы сделать "скрытые" поля (INPUT TYPE="HIDDEN") более скрытыми, не отображая в URL. Но даже если вы используете скрытые поля с METHOD="POST" , они все равно будут отображаться в исходном коде HTML.
А как насчет HTTPS?
Обновлено 15 мая 2015 г.: В частности, при использовании HTTPS (HTTP через TLS/SSL) обеспечивает ли POST больше безопасности, чем GET?
Интересный вопрос. Скажем, вы делаете запрос GET на веб-страницу:
ПОЛУЧИТЬ https://www.example.com/login.php?user=mickey&passwd=mini
Если предположить, что ваше интернет-соединение отслеживается, какая информация об этом запросе будет доступна шпиону? Если вместо этого используется POST, а данные пользователя и пароля включены в переменные POST, будет ли это более безопасным в случае соединений HTTPS?
Нет. Если вы сделаете такой GET-запрос, злоумышленнику, отслеживающему ваш веб-трафик, будет известна только следующая информация:
Тот факт, что вы установили HTTPS-соединение
Имя хоста – www.example.com
Общая длина запроса
Длина ответа
Часть пути URL-адреса — т. е. фактическая запрошенная страница, а также параметры строки запроса — защищены (зашифрованы), пока они находятся «по сети», т. е. в пути на пути к целевому серверу. Точно такая же ситуация и с POST-запросами.
9Однако метод 0025 POST по-прежнему сохраняет одно преимущество даже в случае HTTPS. Веб-серверы, как правило, регистрируют весь запрошенный URL-адрес в виде простого текста в своих журналах доступа; поэтому отправка конфиденциальной информации через GET не является хорошей идеей. Это применимо независимо от того, используется ли HTTP или HTTPS.
Ссылки
wikipedia:POST (HTTP)
Методы HTTP-запроса
Сообщение HTTP — W3.org
Получение HTTP — W3.org
Скрывает ли HTTPS доступ к URL-адресам? - Обмен стека
html - Что означает enctype='multipart/form-data'?
когда мы должны его использовать?
Ответ Квентина правильный: используйте multipart/form-data , если форма содержит загрузку файла, и application/x-www-form-urlencoded в противном случае, что является значением по умолчанию, если вы опустите enctype .
Я собираюсь:
добавить еще несколько ссылок HTML5
объяснить почему он прав с формой отправить пример
Ссылки HTML5
Существует три возможности для enctype :
application/x-www-form-urlencoded
multipart/form-data (спецификация указывает на RFC7578)
текст/обычный . Это «ненадежно интерпретируется компьютером», поэтому его никогда не следует использовать в производстве, и мы не будем вдаваться в подробности.
Как генерировать примеры
Как только вы увидите пример каждого метода, станет ясно, как они работают и когда вы должны использовать каждый из них.
POST / HTTP/1.1
[[ Менее интересные заголовки... ]]
Content-Type: multipart/form-data; граница=-------------------------------------------------------735323031399963166993862150
Длина контента: 834
-----------------------------735323031399963166993862150
Content-Disposition: данные формы; имя = "текст1"
текст по умолчанию
-----------------------------735323031399963166993862150
Content-Disposition: данные формы; имя = "текст2"
aωb
-----------------------------735323031399963166993862150
Content-Disposition: данные формы; имя="файл1"; имя файла="a.txt"
Content-Type: текстовый/обычный
Содержимое файла .txt.
-----------------------------735323031399963166993862150
Content-Disposition: данные формы; имя="файл2"; имя файла="a.html"
Тип содержимого: текст/html
Содержимое файла . html.
-----------------------------735323031399963166993862150
Content-Disposition: данные формы; имя="файл3"; имя файла = "двоичный"
Content-Type: приложение/октет-поток
aωb
-----------------------------735323031399963166993862150--
Для двоичного файла и текстового поля байты 61 CF 89 62 ( aωb в UTF-8) отправляются буквально. Вы можете проверить это с помощью nc -l localhost 8000 | hd , что говорит о том, что байты:
61 CF 89 62
были отправлены ( 61 == 'a' и 62 == 'b').
Отсюда ясно, что:
Content-Type: multipart/form-data; граница=-------------------------------------------------------735323031399963166993862150 задает тип содержимого multipart/form-data и говорит, что поля разделены заданной строкой границы .
Это связано с тем, что стандарт требует, чтобы граница начиналась с двух дефисов -- . Другие тире кажутся именно тем, как Firefox решил реализовать произвольную границу. В RFC 7578 четко упоминается, что эти два начальных дефиса -- обязательны:
4.1. "Граница" Параметр multipart/form-data
Как и в других составных типах, части разделяются символом
разделитель границ, построенный с использованием CRLF, "--" и значения
«граничный» параметр.
каждое поле получает несколько подзаголовков перед данными: Content-Disposition: данные формы; , поле имя , имя файла , а затем данные.
Сервер считывает данные до следующей граничной строки. Браузер должен выбрать границу, которая не будет отображаться ни в одном из полей, поэтому граница может различаться между запросами.
Поскольку у нас есть уникальная граница, кодирование данных не требуется: двоичные данные отправляются как есть.
TODO: каков оптимальный размер границы ( log(N) Бьюсь об заклад, и имя/время работы алгоритма, который его находит? Вопрос задан по адресу: https://cs.stackexchange.com/questions/39687/find-the-shortest-sequence-that-is-not-a-sub-sequence-of-a-set-of-sequences
.
Content-Type автоматически определяется браузером.
Как именно определяется был задан вопрос: Как браузер определяет mime-тип загруженного файла?
приложение/x-www-form-urlencoded
Теперь измените enctype на application/x-www-form-urlencoded , перезагрузите браузер и повторите отправку.
Firefox отправлено:
POST / HTTP/1.1
[[ Менее интересные заголовки... ]]
Content-Type: application/x-www-form-urlencoded
Длина контента: 51
text1=text+default&text2=a%CF%89b&file1=a. txt&file2=a.html&file3=binary
Очевидно, данные файла не были отправлены, только базовые имена. Так что это нельзя использовать для файлов.
Что касается текстового поля, мы видим, что обычные печатные символы, такие как a и b отправлялись одним байтом, а непечатаемые, такие как 0xCF и 0x89 , занимали по 3 байта каждый: %CF%89 !
Сравнение
Загруженные файлы часто содержат много непечатаемых символов (например, изображений), в то время как текстовые формы почти никогда этого не делают.
Из примеров мы видели, что:
multipart/form-data : добавляет к сообщению несколько байтов граничных служебных данных и должен потратить некоторое время на их вычисление, но отправляет каждый байт одним байтом.
application/x-www-form-urlencoded : имеет границу одного байта для каждого поля ( и ), но добавляет линейный служебный коэффициент 3x для каждого непечатаемого символа.