Count Vowels in String

Program to count vowels in a string

BeginnerTopic: String Programs

JavaScript Count Vowels in String Program

This program helps you to learn the fundamental structure and syntax of JavaScript programming.

// Method 1: Using for loop
function countVowels1(str) {
    let count = 0;
    let vowels = 'aeiouAEIOU';
    
    for (let i = 0; i < str.length; i++) {
        if (vowels.includes(str[i])) {
            count++;
        }
    }
    return count;
}

console.log("Hello World:", countVowels1("Hello World"));

// Method 2: Using for...of loop
function countVowels2(str) {
    let count = 0;
    let vowels = ['a', 'e', 'i', 'o', 'u'];
    
    for (let char of str.toLowerCase()) {
        if (vowels.includes(char)) {
            count++;
        }
    }
    return count;
}

console.log("\nUsing for...of:", countVowels2("JavaScript"));

// Method 3: Using filter
function countVowels3(str) {
    let vowels = ['a', 'e', 'i', 'o', 'u'];
    return str.toLowerCase()
               .split('')
               .filter(char => vowels.includes(char))
               .length;
}

console.log("Using filter:", countVowels3("Programming"));

// Method 4: Using match with regex
function countVowels4(str) {
    let matches = str.match(/[aeiou]/gi);
    return matches ? matches.length : 0;
}

console.log("\nUsing regex:", countVowels4("Hello World"));

// Method 5: Using reduce
function countVowels5(str) {
    let vowels = ['a', 'e', 'i', 'o', 'u'];
    return str.toLowerCase()
               .split('')
               .reduce((count, char) => {
                   return vowels.includes(char) ? count + 1 : count;
               }, 0);
}

console.log("Using reduce:", countVowels5("Education"));

// Method 6: Count each vowel separately
function countEachVowel(str) {
    str = str.toLowerCase();
    return {
        a: (str.match(/a/g) || []).length,
        e: (str.match(/e/g) || []).length,
        i: (str.match(/i/g) || []).length,
        o: (str.match(/o/g) || []).length,
        u: (str.match(/u/g) || []).length
    };
}

console.log("\nEach vowel count:", countEachVowel("Hello World"));

Output

Hello World: 3

Using for...of: 3

Using filter: 3

Using regex: 3

Using reduce: 5

Each vowel count: { a: 0, e: 1, i: 0, o: 2, u: 0 }

Understanding Count Vowels in String

This program demonstrates different methods to count vowels in a string.

Vowels

English vowels: a, e, i, o, u (and sometimes y)

Method 1: For Loop

Traditional approach:

for (let i = 0; i < str.length; i++) {
    if (vowels.includes(str[i])) {
        count++;
    }
}

Method 2: For...Of Loop

Cleaner iteration:

for (let char of str.toLowerCase()) {
    if (vowels.includes(char)) {
        count++;
    }
}

Method 3: Filter

Functional approach:

str.toLowerCase()
   .split('')
   .filter(char => vowels.includes(char))
   .length;

Method 4: Regular Expression

Using match():

str.match(/[aeiou]/gi);

Regex Flags:

•g: Global (all matches)

•i: Case-insensitive

Method 5: Reduce

Accumulate count:

str.split('').reduce((count, char) => {
}, 0);

    return vowels.includes(char) ? count + 1 : count;

Method 6: Count Each Vowel

Individual counts:

{
    a: (str.match(/a/g) || []).length,
    e: (str.match(/e/g) || []).length,
}

    // ...

Null Safety:

•|| []: Default to empty array if no match

•Prevents error on null

When to Use:

Loop

: Simple, learning

Filter

: Functional, readable

Regex

: Concise, powerful

Reduce

: Accumulation pattern

Let us now understand every line and the components of the above program.

Note: To write and run JavaScript programs, you need to set up the local environment on your computer. Refer to the complete article Setting up JavaScript Development Environment. If you do not want to set up the local environment on your computer, you can also use online IDE to write and run your JavaScript programs.

Practical Learning Notes for Count Vowels in String

This JavaScript program is part of the "String Programs" topic and is designed to help you build real problem-solving confidence, not just memorize syntax. Start by understanding the goal of the program in plain language, then trace the logic line by line with a custom input of your own. Once you can predict the output before running the code, your understanding becomes much stronger.

A reliable practice pattern is to run the original version first, then modify only one condition or variable at a time. Observe how that single change affects control flow and output. This deliberate style helps you understand loops, conditions, and data movement much faster than copying full solutions repeatedly.

For interview preparation, explain this solution in three layers: the high-level approach, the step-by-step execution, and the time-space tradeoff. If you can teach these three layers clearly, you are ready to solve close variations of this problem under time pressure.

Anagram Check