JavaScript - Find if a Character is a Vowel or Consonant

Here are the different methods to find if a character is a vowel or consonant

1. Using Conditional Statements (If-Else)

The most widely used approach is to check the character against vowels (both uppercase and lowercase) using conditional statements (if-else). This method is simple and effective for small scripts or quick tasks.

let s = 'a';
if (s === 'a' || s === 'e' || s === 'i' || s === 'o' || s === 'u' ||
    s === 'A' || s === 'E' || s === 'I' || s === 'O' || s === 'U') {
    console.log(`${s} is a vowel`);
} else {
    console.log(`${s} is a consonant`);
}

a is a vowel

• The if-else statement checks if the character is one of the vowels (both lowercase and uppercase).
• This method is simple and highly readable, but as the number of conditions increases, it can become less efficient and harder to maintain.

2. Using JavaScript Array and Array.includes() Method

Another efficient approach is using an array of vowels and checking if the character exists within that array. The includes() method provides a clean and readable way to check membership.

let s = 'e';
let vowels = ['a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U'];
if (vowels.includes(s)) {
    console.log(`${s} is a vowel`);
} else {
    console.log(`${s} is a consonant`);
}

e is a vowel

• The includes() method checks if the character s exists in the vowels array.
• This method is more scalable than using multiple if conditions and is cleaner for checking membership in a predefined set of values.

3. Using JavaScript Regular Expression

Regular expressions (regex) are another powerful tool for pattern matching. You can use a regex to check if the character matches any vowel pattern.

let s = 'I';
let regex = /^[aeiouAEIOU]$/;
if (regex.test(s)) {
    console.log(`${s} is a vowel`);
} else {
    console.log(`${s} is a consonant`);
}

I is a vowel

• The regex /^[aeiouAEIOU]$/ checks if the character is a single vowel (either uppercase or lowercase).
• test() method returns true if the character matches the regex, making it a concise and effective approach.

4. Using Set

A Set is a collection of unique values in JavaScript. Using a Set to store vowels allows for quick lookup times with the has() method, which is often faster than arrays for large sets of data.

let s = 'o'; // Input character
let vowels = new Set(['a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U']);
if (vowels.has(s)) {
    console.log(`${s} is a vowel`);
} else {
    console.log(`${s} is a consonant`);
}

o is a vowel

• The Set data structure ensures each vowel is stored only once and can be checked efficiently with has().
• This method is useful when dealing with a larger set of vowels or other repeated characters, as the lookup time is constant, O(1).

5. Using Switch Statement

A switch statement can also be used to determine if a character is a vowel or consonant. It's an alternative to using multiple if-else conditions and can make the code look cleaner when you have a fixed set of values.

let s = 'U';
switch (s.toLowerCase()) {
    case 'a':
    case 'e':
    case 'i':
    case 'o':
    case 'u':
        console.log(`${s} is a vowel`);
        break;
    default:
        console.log(`${s} is a consonant`);
}

U is a vowel

• The switch statement compares the lowercase version of the character with the vowels.
• If it matches any of the vowel cases, it prints that the character is a vowel; otherwise, it defaults to consonant.

6. Using Character Codes

For a more advanced approach, you can use the character codes of the letters to check if the character is a vowel. Vowels have specific character codes, so you can use those ranges to determine the character type.

let s = "i";
let charCode = s.charCodeAt(0);
if (
    (charCode >= 97 && charCode <= 101) ||
    (charCode >= 105 && charCode <= 111) ||
    charCode === 117 ||
    charCode === 65 ||
    charCode === 69 ||
    charCode === 73 ||
    charCode === 79 ||
    charCode === 85
) {
    console.log(`${s} is a vowel`);
} else {
    console.log(`${s} is a consonant`);
}

i is a vowel

• charCodeAt(0) retrieves the Unicode character code of the character.
• The character codes for vowels (a, e, i, o, u) are checked using ranges for lowercase and uppercase letters.

Which Approach to Choose?

For simple use cases, if-else and Array.includes() are quick and readable solutions. If you're dealing with larger data sets or require more optimized performance, consider using Set or character codes. For pattern matching and flexibility, regular expressions offer a powerful approach.