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:

TypeScript
Copy to clipboard
1function countWordFrequencies(text: string): Map<string, number> {
2    let normalizedText: string = text.toLowerCase().replace(/[^\w\s]/g, "");
3    let words: string[] = normalizedText.split(/\s+/);
4    let frequencyMap: Map<string, number> = new Map();
5
6    for (let word of words) {
7        let count: number = frequencyMap.get(word) || 0;
8        frequencyMap.set(word, count + 1);
9    }
10
11    return frequencyMap;
12}

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 lenght 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.

Shifting gears to numbers, let's say we have a map representing a simple ledger with categories as keys and expenses as values. How do we find the total of all categories?

In real life, this could represent a personal finance app displaying your monthly spending. Quickly summing these values gives a clear picture of your financial health — a cornerstone of such an app's utility.

Let's write a function to find the sum of values in a TypeScript Map, which can be useful in scenarios like summing expenses over various categories:

TypeScript
Copy to clipboard
1function sumOfMapValues(numberMap: Map<any, number>): number {
2    let sum: number = 0;
3
4    for (let value of numberMap.values()) {
5        sum += value;
6    }
7    return sum;
8}

We initialize sum to accumulate the total of numeric values. By iterating over the values with .values(), we add each value to sum. This efficiently returns the total sum, demonstrating TypeScript's Map utility in handling numerical data with type safety. The overall time complexity of this function is $O(n)$, where n is the count of entries in the map.

In our foray today, TypeScript maps proved to be an efficient and elegant tool for counting word frequency and summing numeric values. Remember, it's not just about getting the correct answer but also about approaching the problem in a smart, clean way. We've done just that, optimizing both readability and performance, all while leveraging TypeScript's type safety.

Are you ready to practice what you've learned? That's next on the agenda! Upcoming exercises will allow you to put these TypeScript Map operations into practice, solidifying your skills and preparing you for real-world coding challenges. Let's dive in!