Ads and ad measurement. Disabled until you allow it.
ABOUT SITE
All open site tabs
JavaScript · Syntax · Beginner
Working with files: reading and writing
10 tasks
Hands-on exercises for working with files in JavaScript on Node.js: reading text, writing lines, appending data, counting lines and words, processing file contents, and creating simple reports using the fs module.
Quick topic start and explanations before exercises (exercises below):
In Node.js, file access is provided by the built-in fs module. Import it at the top of your script:
```javascript
const fs = require("fs");
```
Reading a file synchronously — readFileSync returns the entire content as a string:
```javascript
const content = fs.readFileSync("note.txt", "utf-8");
console.log(content);
```
The second argument is the encoding. Without it, readFileSync returns a Buffer object, not a string.
Sync vs async: readFileSync blocks execution until the file is loaded. For scripts and exercises this is fine. In production servers you would use the async version (fs.promises.readFile) to avoid blocking the event loop.
Reading line by line — split on the newline character:
```javascript
const content = fs.readFileSync("tasks.txt", "utf-8");
const lines = content.split("\n");
console.log(lines.length); // number of lines
for (const line of lines) {
console.log(line.trim()); // trim() removes trailing whitespace and \r on Windows
}
```
If the file ends with a newline (which is standard), the last element of lines will be an empty string. Filter it out with lines.filter(l => l.length > 0) if needed.
Checking whether a file exists before reading:
```javascript
if (fs.existsSync("data.txt")) {
const content = fs.readFileSync("data.txt", "utf-8");
}
```
Writing to a file uses writeFileSync. If the file does not exist, Node creates it. If it already exists, writeFileSync overwrites it completely.
```javascript
fs.writeFileSync("message.txt", "Hello, file!");
```
You can optionally pass the encoding as a third argument — it defaults to utf-8 when writing strings, so it is usually not needed.
Writing multiple lines — join an array with newline characters:
```javascript
const products = ["bread", "milk", "cheese"];
fs.writeFileSync("shopping.txt", products.join("\n"));
```
Appending with appendFileSync adds to the end of the file without erasing existing content:
```javascript
fs.appendFileSync("log.txt", "New entry\n");
```
Use appendFileSync for logs, writeFileSync for files you regenerate from scratch each time. The difference matters: using writeFileSync on a log file discards all previous entries.
To read a file, modify the content, and write it back:
```javascript
let content = fs.readFileSync("text.txt", "utf-8");
content = content.toUpperCase();
fs.writeFileSync("text.txt", content);
```
Two separate operations — read, then write. There is no mode that combines both safely.
Creating a file with initial content and reading it back — many exercises follow this two-step shape:
```javascript
fs.writeFileSync("words.txt", "code javascript file student");
const content = fs.readFileSync("words.txt", "utf-8");
const words = content.split(" ");
const longest = words.reduce((a, b) => a.length >= b.length ? a : b);
console.log(longest);
```
reduce() with a comparison callback finds the longest word without writing a separate loop. The accumulator starts as the first element.
Filtering lines and writing them to a new file:
```javascript
const lines = fs.readFileSync("emails.txt", "utf-8").split("\n");
const valid = lines.filter(line => line.includes("@"));
fs.writeFileSync("valid_emails.txt", valid.join("\n"));
```
Chaining readFileSync, split, and filter into one expression keeps things concise when you do not need the intermediate values later.
Writing a computed report:
```javascript
const content = fs.readFileSync("article.txt", "utf-8");
const wordCount = content.split(/\s+/).filter(w => w.length > 0).length;
fs.writeFileSync("report.txt", `Word count: ${wordCount}\n`);
```
Template literals handle the conversion from number to string automatically. Concatenating with + also works, but template literals read more cleanly when mixing text and values.
The file log.txt already contains the line "Start".
The variable newLine stores a new line. Add it to the end of the file on a new line and print the final contents of the file.
There is a shopping array: ["bread", "milk", "cheese"].
Write each array element to the file shopping.txt on a new line. Then read the file and print its contents.
Create a file numbers.txt where numbers are written separated by spaces: 5 10 15 20.
Read the file, calculate the sum of the numbers, and print the result.
Create a file emails.txt with several lines, some of which contain the @ symbol.
Read the file and write only the lines with @ into a new file valid_emails.txt. Then print the contents of the new file.
Create a file text.txt with the line "hello file".
Read the contents, convert them to uppercase, and rewrite the same file with the new text. Then print the final contents.
Create a file article.txt with several words.
Read the file, count the number of words, and write a line like "Word count: N" into the file report.txt. Then print the contents of report.txt.
const fs = require("fs");
const articleFile = "article.txt";
const reportFile = "report.txt";
fs.writeFileSync(articleFile, "JavaScript helps practice file reading and writing", "utf8");
const text = fs.readFileSync(articleFile, "utf8");
const words = text.trim().split(/\s+/);
const count = words.length;
fs.writeFileSync(reportFile, `Word count: ${count}`, "utf8");
const result = fs.readFileSync(reportFile, "utf8");
console.log(result);
No split tab
Cookie preferences
We use necessary cookies to run the site. With your permission, we can also save your site preferences and use analytics and advertising cookies to understand usage and support the project.
Open tools in tabs.Exercises, IDE tools, and trainers stay available as site tabs.
Switch without losing context.Move between explanations, code, and utilities while keeping your place.
Use the sidebar as your map.The left panels hold navigation, settings, files, libraries, and tool controls.
PythonJavaScriptSQLite
One IDE, three practical modes
Python in the browser.Run small scripts, try libraries, and practice API requests without installing anything.
JavaScript for quick experiments.Test browser-friendly code and compare ideas next to your learning materials.
SQLite for data practice.Open the database explorer to inspect tables, write queries, and learn SQL workflows locally.
TopicIDE
Work side by side with split tabs
Keep instructions visible.Open an exercise or reference page beside the IDE instead of jumping back and forth.
Compare tools while you learn.Place regex checks, explanations, and code experiments next to each other when the task needs it.
Close the split when you are done.The workspace returns to a single focused tab, and your open site tabs remain available.
Code Typing Trainer
Or plain text
This trainer is designed for a physical keyboard.Open this section on a laptop or desktop with a wide screen. Touch typing practice will not work correctly on a phone.
Speed: 0 chars/min
0 words/min
Best speed (60s): 0 chars/min
0 words/min
Errors: 0
Total time: 0.0 s
To practice touch typing, avoid looking at your physical keyboard.