File management and Input/Output (I/O) handling are essential skills for developers, whether you're building web applications, desktop apps, or backend systems. Efficient reading and writing of files ensures your system is stable, secure, and capable of handling large datasets.

In this article, we compare file handling in JavaScript (Node.js) and Go, with practical code examples and best practices, so you can manage files professionally and effectively.

I/O in JavaScript (Node.js)

Node.js provides the built-in fs module for file operations, supporting both synchronous and asynchronous workflows.

Reading a File Synchronously

const fs = require('fs');

try {
  const data = fs.readFileSync('example.txt', 'utf8');
  console.log('File content:', data);
} catch (err) {
  console.error('Error reading file:', err);
}

Reading a File Asynchronously

const fs = require('fs');

fs.readFile('example.txt', 'utf8', (err, data) => {
  if (err) {
    console.error('Error reading file:', err);
    return;
  }
  console.log('File content:', data);
});

Writing a File

fs.writeFile('output.txt', 'Hello, world!', 'utf8', (err) => {
  if (err) {
    console.error('Error writing file:', err);
    return;
  }
  console.log('File has been written.');
});

Advantages of Node.js I/O

• Supports asynchronous operations, avoiding blocking the event loop.
• Large ecosystem with additional modules like fs-extra for extended functionality.
• Easy and flexible to write.

Limitations

• Handling very large files may require careful memory management.
• Asynchronous code can be tricky for beginners.

I/O in Go

Go provides os and io/ioutil / io packages for file and I/O operations.

Reading a File

package main

import (
    "fmt"
    "io/ioutil"
    "log"
)

func main() {
    data, err := ioutil.ReadFile("example.txt")
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("File content:", string(data))
}

Writing a File

package main

import (
    "io/ioutil"
    "log"
)

func main() {
    content := []byte("Hello, Go!")
    err := ioutil.WriteFile("output.txt", content, 0644)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("File has been written.")
}

Advantages of Go I/O

• Type-safe with clear error handling.
• Handles large files and concurrent I/O efficiently.
• Built-in libraries cover most filesystem needs.

Limitations

• Syntax can be verbose for simple tasks.
• Every I/O operation requires error handling; errors cannot be ignored.

Best Practices

• Always handle errors
  • JavaScript: try/catch or callback error checks
  • Go: check err after every I/O operation
• Choose between synchronous or asynchronous operations wisely
  • Node.js: use async/await or callbacks to avoid blocking the server
  • Go: use goroutines or channels for concurrent I/O
• Be cautious with large files
  • Use streaming or buffered reads/writes instead of loading everything into memory
• Set proper file permissions
  • Go: 0644, 0755 when writing files
  • Node.js: specify mode in writeFile if needed

Comparison Summary

Recommendation

• For web servers or event-driven I/O, Node.js is more flexible and easier to use with asynchronous workflows.
• For backend services, performance-critical tasks, or concurrent I/O, Go provides more reliability, speed, and type safety.

Next Episode

In EP.22 of the JS2GO series, we will explore working with JSON in JavaScript vs Go. You’ll learn about JSON parsing, serialization, and best practices to efficiently read, write, and manipulate JSON data.

Read more

• Golang The Series

• JS2GO

• 10 Eps That Will Make You a Pro Tailwind CSS Overnight

🔵 Facebook: Superdev Academy

🔴 YouTube: Superdev Academy

📸 Instagram: Superdev Academy

🎬 TikTok: https://www.tiktok.com/@superdevacademy?lang=th-TH

🌐 Website: https://www.superdevacademy.com/en