How can I validate an email address in JavaScript?

Here is a solution to validate an email address in JavaScript:

function validateEmail(email) {
  const emailRegex = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/;
  return emailRegex.test(email);
}

// Example usage:
const userInput = "example@example.com";
if (validateEmail(userInput)) {
  console.log("Email is valid");
} else {
  console.log("Email is not valid");
}

This solution uses a regular expression to match the common patterns of an email address. The regular expression checks for:

• One or more alphanumeric characters, dots, underscores, percent signs, plus signs, or hyphens before the @ symbol
• One or more alphanumeric characters, dots, or hyphens after the @ symbol
• A dot (.) followed by two or more alphabetic characters (the domain extension)

You can use this validateEmail function to check if the user input is a valid email address before sending it to a server or attempting to send an email to it.

Using regular expressions is probably the best way. You can see a bunch of tests here (taken from chromium)

const validateEmail = (email) => {
  return String(email)
    .toLowerCase()
    .match(
      /^(([^<>()[\]\\.,;:\s@"]+(\.[^<>()[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/
    );
};

Here's the example of a regular expression that accepts unicode:

const re =
  /^(([^<>()[\]\.,;:\s@\"]+(\.[^<>()[\]\.,;:\s@\"]+)*)|(\".+\"))@(([^<>()[\]\.,;:\s@\"]+\.)+[^<>()[\]\.,;:\s@\"]{2,})$/i;

But keep in mind that one should not rely only upon JavaScript validation. JavaScript can easily be disabled. This should be validated on the server side as well. Here's an example of the above in action:

const validateEmail = (email) => {
  return email.match(
    /^(([^<>()[\]\\.,;:\s@\"]+(\.[^<>()[\]\\.,;:\s@\"]+)*)|(\".+\"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/
  );
};

const validate = () => {
  const $result = $('#result');
  const email = $('#email').val();
  $result.text('');

  if (validateEmail(email)) {
    $result.text(email + ' is valid :)');
    $result.css('color', 'green');
  } else {
    $result.text(email + ' is not valid :(');
    $result.css('color', 'red');
  }
  return false;
}

$('#email').on('input', validate);

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>

<label for="email">Enter an email address: </label>
<input id="email" />
<h2 id="result"></h2>

function validateEmail(email) {
  const regexPattern = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
  
  return regexPattern.test(email);
}

// Example usage:
const userInput = "example@example.com";
if (validateEmail(userInput)) {
  console.log("Valid email address.");
} else {
  console Writeln("Invalid email address.");
}

Explanation:

• The function validateEmail takes an email string as input and returns a boolean indicating whether the email is valid or not.
• A regular expression (regexPattern) is used to match common patterns of email addresses, ensuring that it contains characters before and after the '@' symbol and at least one period ('.') in the domain part.
• The test method checks if the input matches the regex pattern and returns true or false accordingly.

To validate an email address in JavaScript, you can use regular expressions (regex). Here's how:

1. First, create a regular expression pattern to match email addresses. A common email address regex pattern looks like this:

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

2. Next, create a function that checks whether an email address provided by the user is valid according to the regular expression you created earlier. Here's an example implementation of this email validation function in JavaScript:

const emailRegex = /^[^\s@;:.]+@[^\s@;:.]+\.[^\s@;:.]+$/
function validateEmail(email) {
    return emailRegex.test(email);
}

Finally, to use this email validation function in your JavaScript code, you can call it and pass the user input as an argument like this:

const email = "user@example.com";
const isValid = validateEmail(email);
console.log(`"${email}"" is ${isValid ? 'valid' : 'invalid'}}`);

When you run this example code snippet in your JavaScript environment, it will output the following message to console:

"'user@example.com'" is valid

As you can see from this output message to console, the validateEmail(email) function correctly returns the boolean value true if the user input email address "user@example.com"provided in an argument like aboveemail = "user@example.com";` does indeed match the common regex email address pattern you created earlier in your JavaScript code.

Using regular expressions is probably the best way. You can see a bunch of tests here (taken from chromium)

const validateEmail = (email) => {
  return String(email)
    .toLowerCase()
    .match(
      /^(([^<>()[\]\\.,;:\s@"]+(\.[^<>()[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/
    );
};

Here's the example of a regular expression that accepts unicode:

const re =
  /^(([^<>()[\]\.,;:\s@\"]+(\.[^<>()[\]\.,;:\s@\"]+)*)|(\".+\"))@(([^<>()[\]\.,;:\s@\"]+\.)+[^<>()[\]\.,;:\s@\"]{2,})$/i;

But keep in mind that one should not rely only upon JavaScript validation. JavaScript can easily be disabled. This should be validated on the server side as well. Here's an example of the above in action:

const validateEmail = (email) => {
  return email.match(
    /^(([^<>()[\]\\.,;:\s@\"]+(\.[^<>()[\]\\.,;:\s@\"]+)*)|(\".+\"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/
  );
};

const validate = () => {
  const $result = $('#result');
  const email = $('#email').val();
  $result.text('');

  if (validateEmail(email)) {
    $result.text(email + ' is valid :)');
    $result.css('color', 'green');
  } else {
    $result.text(email + ' is not valid :(');
    $result.css('color', 'red');
  }
  return false;
}

$('#email').on('input', validate);

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>

<label for="email">Enter an email address: </label>
<input id="email" />
<h2 id="result"></h2>

To validate an email address in JavaScript, you can use a regular expression (regex). A regular expression is a sequence of characters that defines a search pattern. Here's an example of how you can validate an email address using a regex in JavaScript:

// Define the regular expression pattern
const emailPattern = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;

// Function to validate the email address
function validateEmail(email) {
  return emailPattern.test(email);
}

// Example usage
const userEmail = "example@example.com";
const isValid = validateEmail(userEmail); // true

const invalidEmail = "invalid@email";
const isInvalid = validateEmail(invalidEmail); // false

Here's a breakdown of the regular expression pattern used in the example:

• ^ and $ are anchors that match the start and end of the string, respectively.
• [^\s@]+ matches one or more characters that are not whitespace or @.
• @ matches the literal @ symbol.
• \. matches a literal period (.).

This regex pattern checks for the following:

1. The email address starts with one or more non-whitespace characters before the @ symbol.
2. There is an @ symbol separating the local part (before @) and the domain part (after @).
3. The domain part contains one or more non-whitespace characters, followed by a period (.), and then one or more non-whitespace characters.

Note that this is a basic email validation pattern and may not cover all edge cases or complex email address formats. If you need more robust email validation, you might want to consider using a third-party library or a more comprehensive regular expression.

Here's an example of how you could use the validateEmail function in an HTML form:

<form id="myForm">
  <label for="email">Email:</label>
  <input type="email" id="email" name="email" required>
  <button type="submit">Submit</button>
</form>

<script>
  const form = document.getElementById('myForm');
  const emailInput = document.getElementById('email');

  form.addEventListener('submit', (event) => {
    event.preventDefault(); // Prevent the form from submitting

    const email = emailInput.value;
    if (validateEmail(email)) {
      // Email is valid, you can proceed with further actions
      console.log('Email is valid:', email);
      // Send the email to the server or perform other actions
    } else {
      // Email is invalid, display an error message or take appropriate action
      console.error('Invalid email address:', email);
    }
  });
</script>

In this example, when the form is submitted, the validateEmail function is called with the value of the email input field. If the email is valid, you can proceed with further actions (e.g., sending the email to the server). If the email is invalid, you can display an error message or take appropriate action.

In JavaScript, you can use the following pattern to validate an email address:

/^[^\s@]+@[^\s@]+\.[^\s@]+$/

This pattern will match any string that contains at least one character before and after the "@" symbol, with at least one dot after the "@". You can then use it to validate user input by passing the email address through a regular expression test like so:

const email = "someone@example.com"
const regex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/
if(email.match(regex)) {
  console.log('Valid email')
} else {
  console.log('Invalid email')
}

This would match an email like someone@example.com, but not an email like someone@@example.com or some@one@example.com. You can also use other regex patterns to check for specific requirements, such as requiring the domain to be at least two characters long, or only allowing certain characters in the address and domain.

To validate an email address in JavaScript, you can use regular expressions or libraries for better results. This approach provides more robust validation compared to only relying on the browser's built-in form validation methods.

Here's a simple way using just vanilla JS:

function ValidateEmail(email) 
{
    var re = /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
    return re.test(String(email).toLowerCase());
}

In the above function ValidateEmail, you can pass an email address to check if it is in the right format or not. The regular expression used here checks for a few basic email pattern violations such as missing '@', and domains having less than two characters. It's simple but effective.

Another recommended way of doing this (especially on big projects) is using a library like validator.js:

1. First, you have to install the validator.js library by running the command npm install validator in your project folder or via yarn with yarn add validator

2. Then include it into your file as below:

var validator = require('validator');
console.log(validator.isEmail('email@gmail.com'));
// Returns true.
console.log(validator.isEmail('email@host.com'));
// Also returns true. 

This is a simple example, it covers more complex cases too such as IP domains and Unicode characters in local-part of emails. It's recommended way for better email validation especially if you plan to do many operations related with validating and normalizing these values.

In JavaScript, you can use regular expressions (regex) to validate an email address. Here's a simple example using a regex to check if the input resembles a valid email address:

function isValidEmail(email) {
  const regex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/; // this regex checks for valid email format
  return regex.test(email);
}

// Usage example:
const inputEmail = "example@example.com";
if (isValidEmail(inputEmail)) {
  console.log("This is a valid email address");
} else {
  console.log("Please enter a valid email address");
}

Keep in mind that while this regex can help you check for some basic issues, it doesn't cover all possible edge cases for email validation. For comprehensive and more complex email validation, consider using libraries like validatorjs or email-validation in your JavaScript project.

To validate an email address in JavaScript, you can use a regular expression (regex) that checks for the general pattern of an email address. Here's a simple way to do it:

1. Define a regex pattern for email validation. A common pattern that conforms to the general rules of email addresses is:

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

This pattern checks for:

• One or more characters that are not whitespace or @ at the beginning ([^\s@]+).
• The @ symbol.
• One or more characters that are not whitespace or @.
• A dot.
• One or more characters that are not whitespace or @.

2. Use the regex to test the email address:

function validateEmail(email) {
  return emailRegex.test(email);
}

3. Call this function with the user input to check if it's a valid email:

const userEmail = "user@example.com";
const isValidEmail = validateEmail(userEmail);

if (isValidEmail) {
  console.log("The email address is valid.");
  // Proceed with sending the email or storing the address.
} else {
  console.log("The email address is invalid.");
  // Inform the user to enter a valid email address.
}

4. Integrate this function into your form submission process:

<form id="emailForm">
  <input type="email" id="emailInput" required>
  <button type="submit">Submit</button>
</form>

<script>
  document.getElementById('emailForm').addEventListener('submit', function(event) {
    const emailInput = document.getElementById('emailInput');
    const email = emailInput.value;
    
    if (!validateEmail(email)) {
      alert('Please enter a valid email address.');
      event.preventDefault(); // Prevent form from submitting.
    }
  });
</script>

Remember that client-side validation is not a substitute for server-side validation. Always validate the email address on the server as well, as client-side validation can be bypassed.

For more robust email validation, you might consider using a library or a more complex regex pattern that adheres to all the rules of the email format specified in RFC 5322. However, the provided solution should suffice for most common use cases.

To validate an email address in JavaScript, you can use a regular expression (regex) to check the format of the input. Here's a step-by-step approach:

1. Define the regular expression: The most common way to validate an email address is to use the following regular expression:

/^[^\s@]+@[^\s@]+\.[^\s@]+$/

This regex checks for the following:

• ^: The start of the string
• [^\s@]+: One or more characters that are not whitespace or the @ symbol
• @: The @ symbol
• [^\s@]+: One or more characters that are not whitespace or the @ symbol
• \.: A literal period (dot)
• [^\s@]+: One or more characters that are not whitespace or the @ symbol
• $: The end of the string

2. Create a function to validate the email: You can create a function that takes the email input and checks it against the regular expression:

function validateEmail(email) {
  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
  return emailRegex.test(email);
}

3. Use the function to validate user input: You can call the validateEmail function whenever you need to check the email address, for example, when the user submits a form:

<form id="myForm">
  <label for="email">Email:</label>
  <input type="email" id="email" name="email" required>
  <button type="submit">Submit</button>
</form>

<script>
  const form = document.getElementById('myForm');
  form.addEventListener('submit', (event) => {
    event.preventDefault(); // Prevent the form from submitting

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

    if (validateEmail(email)) {
      // Email is valid, you can now send it to the server
      console.log('Valid email:', email);
    } else {
      // Email is invalid, display an error message
      console.log('Invalid email:', email);
      alert('Please enter a valid email address.');
    }
  });
</script>

In this example, the validateEmail function is called when the form is submitted. If the email is valid, you can proceed with sending it to the server. If the email is invalid, you can display an error message to the user.

Keep in mind that this is a basic email validation, and there might be more complex cases that this regex might not cover. For example, it doesn't check for top-level domains with more than one period (e.g., john@example.co.uk). If you need more advanced email validation, you might want to consider using a third-party library or a more comprehensive regular expression.

To validate an email address in JavaScript, you can use a regular expression (regex) pattern to check if the input matches the expected format of an email address. Here's how you can achieve this:

function validateEmail(email) {
  // Regular expression pattern for email validation
  const emailPattern = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
  
  // Test the email against the pattern
  return emailPattern.test(email);
}

Explanation:

1. We define a function called validateEmail that takes the email address as a parameter.
2. Inside the function, we define a regular expression pattern emailPattern that represents the basic structure of an email address:
   • ^ asserts the start of the string.
   • [^\s@]+ matches one or more characters that are not whitespace or @.
   • @ matches the @ character.
   • [^\s@]+ matches one or more characters that are not whitespace or @ after the @ character.
   • \. matches the . character (escaped with \ because . has a special meaning in regex).
   • [^\s@]+ matches one or more characters that are not whitespace or @ after the . character.
   • $ asserts the end of the string.
3. We use the test() method of the regex pattern to check if the email matches the pattern. It returns true if the email is valid and false otherwise.
4. Finally, we return the result of the validation.

Here's an example of how you can use this function:

const email1 = "john@example.com";
const email2 = "invalid.email";

console.log(validateEmail(email1)); // Output: true
console.log(validateEmail(email2)); // Output: false

In the above example, email1 is a valid email address, so validateEmail(email1) returns true. On the other hand, email2 is not a valid email address, so validateEmail(email2) returns false.

You can call this function whenever you need to validate an email address, such as before sending it to a server or attempting to send an email.

Note that this is a basic email validation and may not cover all possible email formats. For more comprehensive email validation, you can use more complex regular expressions or libraries specifically designed for email validation.

Here is a simple way to validate an email address in JavaScript:

function validateEmail(email) {
  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
  return emailRegex.test(email);
}

// Example usage:
const userInput = "example@email.com";
if (validateEmail(userInput)) {
  console.log("Valid email address");
} else {
  console.log("Invalid email address");
}

This regular expression checks for the basic structure of an email address: characters before the @ symbol, characters after the @ symbol, and a domain ending with a valid top-level domain.

There are a few ways to validate an email address in JavaScript. One way is to use a regular expression:

function validateEmail(email) {
  const re = /^(([^<>()[\]\\.,;:\s@"]+(\.[^<>()[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
  return re.test(String(email).toLowerCase());
}

This regular expression checks for the following:

• A local part (the part before the @ sign) that can contain letters, numbers, dots, dashes, and underscores.
• An @ sign.
• A domain part (the part after the @ sign) that can contain letters, numbers, dots, and dashes.
• A top-level domain (the part after the last dot) that can be 2 or 3 letters long.

Another way to validate an email address is to use the isEmail function from the validator package:

import { isEmail } from 'validator';

function validateEmail(email) {
  return isEmail(email);
}

The isEmail function checks for the following:

• A local part that can contain letters, numbers, dots, dashes, and underscores.
• An @ sign.
• A domain part that can contain letters, numbers, dots, and dashes.
• A top-level domain that can be 2 or 3 letters long.

Whichever method you choose, it's important to note that email validation is not foolproof. There are some email addresses that will pass validation but are still not valid, and there are some email addresses that will fail validation but are still valid. However, email validation can help to prevent the most basic mistyping errors.

Sure, here's how you can validate an email address in JavaScript:

function validateEmail(email) {
  // Trim the email string to remove any leading or trailing whitespace.
  email = email.trim();

  // Check if the email address is empty.
  if (email === "") {
    return false;
  }

  // Check if the email address contains only whitespace.
  if (/^[ ]*$/.test(email)) {
    return false;
  }

  // Check if the email address contains a non-numeric character.
  const regex = /^\w+@[a-zA-Z0-9]+\.[a-zA-Z]{2,6}$/;
  if (!regex.test(email)) {
    return false;
  }

  // Check if the email address ends with a dot.
  if (email.endsWith(".")) {
    return false;
  }

  // If the email address is valid, return true.
  return true;
}

How to use the function:

const email = prompt("Enter an email address:");
const isValid = validateEmail(email);

if (isValid) {
  // Send the email using XMLHttpRequest or other methods.
} else {
  // Inform the user about the invalid email address.
}

Explanation:

• The validateEmail function takes an email address as a parameter.
• It removes leading and trailing whitespace from the email address.
• It checks if the email address contains only whitespace.
• It checks if the email address contains a non-numeric character.
• It uses a regular expression to check if the email address ends with a dot.
• If the email address is valid, it returns true.
• It returns false if the email address is invalid.

Tips:

• You can use the test method to check if a string ends with a particular character.
• You can use the replace method to remove leading and trailing whitespace from the email address.
• You can use a different regular expression to validate different email formats.

Solution:

To validate an email address in JavaScript, you can use a regular expression (regex) to check if the input text matches the format of an email address. Here's an example:

function validateEmail(email) {
  const emailRegex = /^[a-zA-Z0-9]+@[a-zA-Z0-9]+(\.[a-zA-Z0-9]+)*$/;
  return emailRegex.test(email);
}

// Example usage
const email = "john.doe@example.com";
if (validateEmail(email)) {
  console.log("Email address is valid");
} else {
  console.log("Email address is invalid")
}

Explanation:

• The validateEmail() function takes an email address as input.
• The function uses a regular expression emailRegex to validate the email address format.
• If the input text matches the regex, it returns true, indicating a valid email address. Otherwise, it returns false.

Regular Expression:

^[a-zA-Z0-9]+@[a-zA-Z0-9]+(\.[a-zA-Z0-9]+)*$/

Explanation:

• ^: Matches the beginning of the string.
• [a-zA-Z0-9]+: Matches one or more letters or numbers.
• @: Matches the "@" symbol.
• [a-zA-Z0-9]+: Matches one or more letters or numbers after "@".
• \.: Matches a dot.
• (\.[a-zA-Z0-9]+)*: Matches zero or more dots followed by letters or numbers.
• $: Matches the end of the string.

Additional Tips:

• You can also validate the domain name separately using a separate regular expression.
• Consider adding validation for common errors, such as missing domain name or invalid characters.
• Use a third-party library to handle email validation if you need additional features or want to simplify the code.

You can validate an email address in JavaScript using a regular expression. Here's how you can do it:

1. Create a regular expression pattern for validating an email address:

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

2. Use the regular expression test() method to check if the input matches the email pattern:

   function validateEmail(email) {
       return emailPattern.test(email);
   }
   

3. Call the validateEmail function with the user input to validate the email address:

   const userInput = "example@email.com";
   if (validateEmail(userInput)) {
       console.log("Email address is valid");
   } else {
       console.log("Email address is invalid");
   }
   

4. You can also use HTML input type "email" to validate email addresses on the client-side:

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

5. Additionally, you can use JavaScript to further validate the input before submitting it to the server:

   const emailInput = document.getElementById("emailInput");
   emailInput.addEventListener("change", function() {
       if (!validateEmail(emailInput.value)) {
           alert("Please enter a valid email address");
           emailInput.value = "";
       }
   });
   

To validate an email address in JavaScript using a regular expression (regex), you can follow these steps:

1. Create a Function to Validate Email: Define a function that takes an email address as a parameter and returns true if the email is valid, or false otherwise.

2. Use a Regular Expression: Utilize a regex pattern to check the format of the email. The pattern should ensure the email contains characters like letters, numbers, dots, hyphens, and underscores, followed by an @ symbol, and then a domain part with letters, possibly dots, and a domain extension.

3. Test the Email with the Regex: Use the test() method of the regex object to validate the email string.

Here is a simple implementation:

function validateEmail(email) {
    var regex = /^[a-zA-Z0-9._-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,6}$/;
    return regex.test(email);
}

// Example usage:
var email = "example@domain.com";
console.log(validateEmail(email)); // This will log 'true' if the email is valid, 'false' otherwise.

• Explanation:
  • /^...$/: Anchors the regex to match from the start to the end of the string.
  • [a-zA-Z0-9._-]+: Matches one or more letters, numbers, dots, underscores, or hyphens.
  • @: Must contain an '@' symbol.
  • [a-zA-Z0-9.-]+: Matches one or more letters, numbers, dots, or hyphens in the domain name.
  • \.[a-zA-Z]{2,6}: Ensures the email has a domain suffix (like .com, .org) of 2 to 6 letters.

This function will handle basic validation effectively. However, for more complex validation (like checking top-level domains more accurately), you might consider using more sophisticated regex patterns or external libraries.

function validateEmail(email) {
  const re = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/;
  return re.test(String(email).toLowerCase());
}

To validate an email address in JavaScript, you can use a regular expression (regex) to match the input against the pattern of a valid email address. Here's a simple function that implements this:

function isValidEmail(email) {
  const regex = /^[\w-]+(\.[\w-]+)*@([\w-]+\.)+[a-zA-Z]{2,7}$/;
  return regex.test(email);
}

// Usage
const userEmail = "example@domain.com";
console.log(isValidEmail(userEmail)); // true

Let's break down the regex pattern:

• ^ - Start of the line.
• [\w-]+ - One or more word characters or hyphens.
• (\.[\w-]+)* - Optionally followed by a period and one or more word characters or hyphens (for subdomains).
• @ - The at symbol.
• ([\w-]+\.)+ - One or more occurrences of word characters or hyphens followed by a period (for the domain).
• [a-zA-Z]{2,7}$ - Two to seven letters at the end of the line (for the top-level domain).

This regex pattern covers most common email address formats but might not be 100% accurate due to the complexity of email address specifications. Nevertheless, it's an excellent starting point for basic validation.

For a better user experience, consider performing the validation on the front-end (HTML) as well. Here's an example using the constraint validation API:

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Email Validation</title>
</head>
<body>
  <form id="email-form">
    <label for="email">Email:</label>
    <input type="email" id="email" name="email" required>
    <button type="submit">Submit</button>
  </form>
  <script>
    const emailForm = document.getElementById("email-form");
    emailForm.addEventListener("submit", (event) => {
      const emailInput = document.getElementById("email");
      if (!isValidEmail(emailInput.value)) {
        event.preventDefault();
        emailInput.reportValidity();
      }
    });

    function isValidEmail(email) {
      const regex = /^[\w-]+(\.[\w-]+)*@([\w-]+\.)+[a-zA-Z]{2,7}$/;
      return regex.test(email);
    }
  </script>
</body>
</html>

This code snippet uses the type="email" attribute for the input field, which automatically performs basic validation. The JavaScript code then adds an additional layer of validation using the isValidEmail function we created earlier. The form submission is prevented if the input email address is invalid.

You can use a regular expression to validate an email address in JavaScript. Here's a simple function to check if a given string is a valid email:

function isValidEmail(email) {
    const regex = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/;
    return regex.test(email);
}

You can use this function by calling isValidEmail and passing the user input as an argument, like so:

if (isValidEmail(userInput)) { 
    // proceed with your code here
} else {
    // invalid email address 
}