Javascript Submit Form: Creating Your Own Forms

Forms are an essential part of web applications, providing a structured way for users to input data and interact with the application. While HTML provides the basic structure for creating forms, JavaScript plays a crucial role in enhancing the functionality and user experience of these forms. In this article, we'll explore how to create and submit forms using JavaScript, covering various techniques and best practices.

The Basics: HTML Form Structure

Before diving into JavaScript, it's essential to understand the basic structure of an HTML form. A form typically consists of the following elements:

<form action="/submit-form" method="POST">

  <label for="name">Name:</label>

  <input type="text" id="name" name="name" required>

  <label for="email">Email:</label>

  <input type="email" id="email" name="email" required>

  <button type="submit">Submit</button>


In this example, we have a form with two input fields (name and email) and a submit button. The action attribute specifies the URL where the form data will be sent, and the method attribute determines the HTTP method used for submission (typically POST for creating new data or GET for retrieving data).

Submitting Forms with JavaScript

While HTML provides the structure for forms, JavaScript allows you to add interactivity and enhance the form submission process. There are several ways to submit a form using JavaScript, each with its own advantages and use cases.

1. Standard Form Submission

The simplest way to submit a form is to rely on the browser's default behavior. When the user clicks the submit button, the form data is automatically sent to the specified action URL using the specified method. In this case, JavaScript is not required for the actual submission process.

// No JavaScript code needed for standard form submission

However, you may want to perform additional actions or validations before submitting the form, which is where JavaScript becomes useful.

2. Programmatic Form Submission

JavaScript provides a way to programmatically submit a form, allowing you to trigger the submission process from your code. This can be achieved using the submit() method on the form element itself or by creating and dispatching a custom event.

// Get the form element

const form = document.querySelector('form');

// Attach an event listener to the submit button

const submitButton = document.querySelector('button[type="submit"]');

submitButton.addEventListener('click', () => {

  // Perform additional validations or actions

  // ...

  // Programmatically submit the form



In this example, we attach an event listener to the submit button. When clicked, we can perform additional validations or actions before programmatically submitting the form using the submit() method.

3. Preventing Default Submission and Using AJAX

While standard form submission and programmatic submission are straightforward, there are cases where you may want to prevent the default submission behavior and handle the form data using JavaScript. This is particularly useful when you want to perform client-side validations, send data asynchronously using AJAX, or update the page content without a full page refresh.

// Get the form element

const form = document.querySelector('form');

// Attach an event listener to the form submission

form.addEventListener('submit', (event) => {

  // Prevent the default form submission


  // Perform client-side validations

  // ...

  // Serialize the form data

  const formData = new FormData(form);

  // Send the form data using AJAX (e.g., fetch or XMLHttpRequest)

  fetch('/submit-form', {

    method: 'POST',

    body: formData


  .then(response => {

    // Handle the server response

    // ...


  .catch(error => {

    // Handle any errors

    // ...



In this example, we attach an event listener to the submit event of the form. We then prevent the default form submission using event.preventDefault(). This allows us to perform client-side validations, serialize the form data using the FormData object, and send the data asynchronously using AJAX (e.g., the fetch API or XMLHttpRequest). This approach enables a more seamless user experience by updating the page content without a full page refresh.

Form Validation

Form validation is a crucial aspect of ensuring data integrity and providing a good user experience. JavaScript offers various methods for validating form input, ranging from built-in HTML5 validation attributes to custom validation logic.

1. Built-in HTML5 Validation

HTML5 introduced several built-in validation attributes that can be applied to form inputs. These include required, pattern, min, max, and more. When used in combination with the validity property of input elements, you can easily check if an input is valid or not.

<input type="text" id="name" name="name" required>

const nameInput = document.getElementById('name');

// Check if the input is valid before submission

if (!nameInput.validity.valid) {

  // Display an error message or highlight the invalid input

  // ...


2. Custom Validation with JavaScript

While built-in HTML5 validation is useful for basic validations, more complex validation scenarios often require custom JavaScript logic. This can include validating input formats, enforcing custom rules, or performing cross-field validations.

// Custom validation function

function validateEmail(email) {

  // Regular expression for email validation

  const emailPattern = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;

  return emailPattern.test(email);


// Get the email input element

const emailInput = document.getElementById('email');


// Attach an event listener for input validation

emailInput.addEventListener('input', () => {

  const email = emailInput.value;

  const isValid = validateEmail(email);

  // Update the input validity and display an error message if needed

  emailInput.setCustomValidity(isValid ? '' : 'Please enter a valid email address.');


In this example, we define a custom validation function validateEmail that uses a regular expression to validate the format of an email address. We then attach an event listener to the email input element and perform the validation on each input event. If the input is invalid, we set a custom validity message using the setCustomValidity method.

Form Styling and UX Enhancements

While JavaScript provides the functionality for form submission and validation, it can also be used to enhance the user experience and styling of forms. Here are a few examples:

1. Dynamic Form Styling

JavaScript can be used to dynamically apply styles to form elements based on their state or user interactions. This can include highlighting invalid inputs, displaying success or error messages, or updating progress indicators.

const inputs = document.querySelectorAll('input');

inputs.forEach(input => {

  input.addEventListener('invalid', () => {



  input.addEventListener('input', () => {

    if (input.validity.valid) {





In this example, we add an invalid class to input elements when they are in an invalid state and remove the class when the input becomes valid again. This allows us to apply custom styles (e.g., red border or error message) to invalid inputs using CSS.

2. Form Progression and Multi-step Forms

JavaScript can be leveraged to create multi-step forms or implement form progression, where users navigate through different sections or steps of a form. This can improve the user experience by breaking down complex forms into smaller, more manageable chunks.

const formSteps = document.querySelectorAll('.form-step');

let currentStep = 0;

function showStep(n) {

  formSteps.forEach((step, index) => {

    if (index === n) { = 'block';

    } else { = 'none';




function nextStep() {




function prevStep() {




Share On