Mastering TypeScript Maps

Welcome back! This tutorial focuses on TypeScript maps — powerful data structures ideal for storing key-value pairs with the added advantage of type safety. With two illustrative problems, you'll sharpen your ability to create and operate maps confidently, walking away with crucial skills to solve real-world challenges.

Imagine we have a blog. We want to analyze the posts to see which topics are most discussed. A practical solution involves writing a function to count the frequency of each word in a blog post while ignoring case and punctuation.

This function is essential in text analysis tools used in search engine optimization. It can highlight popular topics and even suggest post tags, increasing visibility in search results.

Let's create a function to count word frequencies by normalizing the input text to lowercase and removing punctuation, then splitting it into words. We employ a TypeScript Map to track word counts efficiently:

function countWordFrequencies(text: string): Map<string, number> {
    let normalizedText: string = text.toLowerCase().replace(/[^\w\s]/g, "");
    let words: string[] = normalizedText.split(/\s+/);
    let frequencyMap: Map<string, number> = new Map();

    for (let word of words) {
        let count: number = frequencyMap.get(word) || 0;
        frequencyMap.set(word, count + 1);
    }

    return frequencyMap;
}

In this function, we first normalize the input text by converting it to lowercase and removing punctuation, ensuring consistency. We then split the cleaned text into individual words. Using a Map, we iterate through each word, updating the word's count by retrieving its current count (defaulting to 0 if it doesn't exist) and incrementing it by one. Finally, the Map is returned, providing a clear mapping of each word to its frequency, all while leveraging TypeScript's type safety to ensure accurate and efficient word counting.

Getting to the complexity of this particular problem isn't as simple as it seems at first glance. Converting to lower case, removing punctuation and splitting into word each take $O(n)$ time, where n is the length of the input string. The main loop takes $O(w)$ time, where w is the count of words in the input string. While it is correct to say that the overall time complexity is $O(n + w)$, since w can never be larger than n, we could simplify and state that this function takes $O(n)$ time.