Welcome to the first lesson of the course on parsing tables from text files. In our modern world, data is often stored in tabular formats, similar to spreadsheets. Text files can be a convenient way to store this data when dealing with simple, structured datasets. Parsing, or reading, this data efficiently is a key skill in data handling, allowing us to transform unstructured text into usable information.

Consider scenarios like dealing with configuration files, logs, or exported reports from systems where tables are saved as text files. By the end of this lesson, you will learn how to parse such data into a structured format, making it easy to work with in JavaScript.

Before diving into parsing, let's briefly recall some important concepts. You should be familiar with:

• Basic file handling in JavaScript, specifically opening files using Node.js's fs module.
• Using methods like readFileSync to read files synchronously.

Text files often store tables using simple formats, such as space-separated values. Let's analyze the given data.txt file, which looks like this:

Plain text
Copy to clipboard
1Name    Age Occupation
2John    28  Engineer
3Alice   34  Doctor
4Bob     23  Artist

Here, each line represents a row in the table, and each value in a line is separated by spaces, forming columns. The first line contains headers, which describe the content of the subsequent rows.

To parse this table, we'll go through the process one step at a time.

First, we need to open and read the file. Use the fs.readFileSync method from Node.js's fs module to access the file content.

JavaScript
Copy to clipboard
1const fs = require('fs');
2const filePath = 'data.txt';
3
4// Read the entire file content synchronously
5const fileContent = fs.readFileSync(filePath, 'utf-8');

In the above snippet:

• filePath specifies the path to the text file.
• fs.readFileSync(filePath, 'utf-8') reads the file synchronously and returns its content as a string.

Once we have the file content, the next step is to transform each line into a list of values. Each line is formatted like this:

Plain text
Copy to clipboard
1John    28  Engineer

The values are separated by whitespace, and we need to split it.

JavaScript
Copy to clipboard
1const lines = fileContent.split('\n');
2const dataAsList = [];
3
4lines.slice(1).forEach((line) => {
5  const columns = line.trim().split(/\s+/);
6  dataAsList.push(columns);
7});

Explanation:

• lines.slice(1) skips the first line (header) since we're focusing on the actual data rows.
• line.trim().split(/\s+/) splits each line into separate values based on spaces using a regular expression for multiple spaces.
• dataAsList.push(columns) collects these split values (now an array) into a larger array called dataAsList.

Finally, log the parsed data to verify our results.

JavaScript
Copy to clipboard
1console.log("Parsed table from TXT file:");
2console.log(dataAsList);

Here, console.log(dataAsList) displays the table data as an array of arrays:

JavaScript
Copy to clipboard
1Parsed table from TXT file:
2[ [ 'John', '28', 'Engineer' ], [ 'Alice', '34', 'Doctor' ], [ 'Bob', '23', 'Artist' ] ]

Each subarray represents a row from the table, with individual elements corresponding to values in different columns. Now, we can easily extract any needed value from the obtained array. For example, if we need to get the first worker's age, we can call dataAsList[0][1].

In this lesson, we've covered the core elements of parsing a table from a text file using JavaScript. The main takeaways include understanding how to:

• Open and read a text file using the fs module's readFileSync().
• Split lines into columns using split() with regular expressions.
• Organize the data into a manageable format, such as an array of arrays.

These skills empower you to handle simple tabular data formats efficiently. Now, as you move to the practice exercises, experiment with different delimiters and file structures to reinforce these concepts. Use these exercises as an opportunity to experiment and solidify your understanding.