Golang File I/O & OS Interactions Quiz

0 Passed

0% acceptance

35 comprehensive questions on Golang's file I/O and OS interaction capabilities, covering file reading/writing, os package usage, streams & buffers, directory operations, and environment variables — with 18 code examples demonstrating practical file and OS operations.

35 Questions

~70 minutes

Question 1

How do you read an entire file in Go?

data, err := os.ReadFile("file.txt")
if err != nil {
    log.Fatal(err)
}
fmt.Println(string(data))

Use os.ReadFile() to read entire file into []byte

Use os.Open() and read line by line

Use bufio.Scanner

Cannot read entire file

Question 2

How do you write to a file in Go?

data := []byte("Hello, World!")
err := os.WriteFile("output.txt", data, 0644)
if err != nil {
    log.Fatal(err)
}

Use os.WriteFile() with data, filename, and permissions

Use fmt.Println to file

Use os.Create and write manually

Cannot write to files

Question 3

What is the difference between os.Open and os.OpenFile?

file, err := os.Open("file.txt")  // Read-only

file, err := os.OpenFile("file.txt", os.O_RDWR|os.O_CREATE, 0644)  // Read/write

os.Open is read-only, os.OpenFile allows specifying flags and permissions

No difference

os.OpenFile is deprecated

os.Open allows writing

Question 4

How do you read a file line by line?

file, err := os.Open("file.txt")
if err != nil {
    log.Fatal(err)
}
defer file.Close()

scanner := bufio.NewScanner(file)
for scanner.Scan() {
    fmt.Println(scanner.Text())
}

if err := scanner.Err(); err != nil {
    log.Fatal(err)
}

Use bufio.Scanner with file reader

Use os.ReadFile and split by \n

Use io.ReadAll

Cannot read line by line

Question 5

How do you create a directory?

err := os.Mkdir("newdir", 0755)
if err != nil {
    log.Fatal(err)
}

// Create nested directories
err = os.MkdirAll("parent/child/grandchild", 0755)

Use os.Mkdir() for single directory, os.MkdirAll() for nested

Use os.Create

Use os.WriteFile

Cannot create directories

Question 6

How do you list directory contents?

files, err := os.ReadDir("mydir")
if err != nil {
    log.Fatal(err)
}

for _, file := range files {
    fmt.Println(file.Name(), file.IsDir())
}

Use os.ReadDir() to get []os.DirEntry

Use os.Open and read

Use filepath.Walk

Cannot list directories

Question 7

How do you get environment variables?

value := os.Getenv("HOME")
fmt.Println("Home:", value)

// Get all environment variables
for _, env := range os.Environ() {
    fmt.Println(env)
}

Use os.Getenv() for single variable, os.Environ() for all

Use os.Args

Use runtime variables

Cannot get environment variables

Question 8

How do you set environment variables?

err := os.Setenv("MY_VAR", "my_value")
if err != nil {
    log.Fatal(err)
}

// Check if set
fmt.Println(os.Getenv("MY_VAR"))

Use os.Setenv() to set environment variables

Use os.Getenv

Use global variables

Cannot set environment variables

Question 9

What is buffered I/O in Go?

file, _ := os.Open("large.txt")
defer file.Close()

bufferedReader := bufio.NewReader(file)
data, err := bufferedReader.ReadString('\n')

// Buffered writer
file, _ = os.Create("output.txt")
bufferedWriter := bufio.NewWriter(file)
bufferedWriter.WriteString("Hello")
bufferedWriter.Flush()

Using bufio.Reader/Writer to buffer reads/writes for efficiency

Reading entire files

Using os.ReadFile

No buffering in Go

Question 10

How do you copy a file in Go?

srcFile, err := os.Open("source.txt")
if err != nil {
    log.Fatal(err)
}
defer srcFile.Close()

dstFile, err := os.Create("dest.txt")
if err != nil {
    log.Fatal(err)
}
defer dstFile.Close()

_, err = io.Copy(dstFile, srcFile)
if err != nil {
    log.Fatal(err)
}

Use io.Copy() to copy between readers and writers

Use os.ReadFile and os.WriteFile

Use bufio.Copy

Cannot copy files

Question 11

How do you check if a file exists?

if _, err := os.Stat("file.txt"); os.IsNotExist(err) {
    fmt.Println("File does not exist")
} else if err != nil {
    log.Fatal(err)
} else {
    fmt.Println("File exists")
}

Use os.Stat() and check os.IsNotExist(err)

Use os.Open

Use os.ReadFile

Cannot check file existence

Question 12

How do you get file permissions?

info, err := os.Stat("file.txt")
if err != nil {
    log.Fatal(err)
}

fmt.Printf("Permissions: %s\n", info.Mode())
fmt.Printf("Is executable: %t\n", info.Mode().Perm()&0111 != 0)

Use os.Stat() to get FileInfo, then info.Mode().Perm()

Use os.Open

Use os.ReadFile

Cannot get permissions

Question 13

How do you change file permissions?

err := os.Chmod("file.txt", 0644)
if err != nil {
    log.Fatal(err)
}

// Change owner
err = os.Chown("file.txt", uid, gid)

Use os.Chmod() to change permissions, os.Chown() for ownership

Use os.WriteFile

Use os.Create

Cannot change permissions

Question 14

How do you work with temporary files?

tmpFile, err := os.CreateTemp("", "prefix-*.txt")
if err != nil {
    log.Fatal(err)
}
defer os.Remove(tmpFile.Name())  // Clean up

defer tmpFile.Close()

tmpFile.WriteString("temporary data")

// Use tmpFile.Name() for the path

Use os.CreateTemp() to create temporary files with auto-generated names

Use os.Create with random names

Use os.WriteFile

Cannot create temporary files

Question 15

How do you read from standard input?

scanner := bufio.NewScanner(os.Stdin)
fmt.Print("Enter text: ")
scanner.Scan()
text := scanner.Text()
fmt.Println("You entered:", text)

Use bufio.Scanner with os.Stdin

Use os.ReadFile

Use fmt.Scan

Cannot read from stdin

Question 16

How do you write to standard output/error?

fmt.Fprintln(os.Stdout, "This goes to stdout")
fmt.Fprintln(os.Stderr, "This goes to stderr")

// Or use os.Stdout/Stderr directly
os.Stdout.WriteString("Direct write\n")

Use os.Stdout and os.Stderr with fmt or direct writes

Use fmt.Print

Use os.WriteFile

Cannot write to stdout/stderr

Question 17

How do you handle file paths cross-platform?

import "path/filepath"

// Join paths
path := filepath.Join("home", "user", "file.txt")

// Get directory and filename
fmt.Println(filepath.Dir(path))   // home/user
fmt.Println(filepath.Base(path))  // file.txt

// Check if absolute
fmt.Println(filepath.IsAbs(path))

Use path/filepath package for cross-platform path operations

Use string concatenation

Use os.PathSeparator manually

No cross-platform paths

Question 18

How do you walk a directory tree?

err := filepath.Walk("rootdir", func(path string, info os.FileInfo, err error) error {
    if err != nil {
        return err
    }
    
    if info.IsDir() {
        fmt.Println("Directory:", path)
    } else {
        fmt.Println("File:", path)
    }
    
    return nil
})

Use filepath.Walk() with a callback function

Use os.ReadDir recursively

Use os.Open

Cannot walk directories

Question 19

How do you handle file locking?

file, err := os.OpenFile("file.txt", os.O_RDWR, 0644)
if err != nil {
    log.Fatal(err)
}
defer file.Close()

// Try to lock (Unix only)
err = syscall.Flock(int(file.Fd()), syscall.LOCK_EX)
if err != nil {
    log.Fatal(err)
}
defer syscall.Flock(int(file.Fd()), syscall.LOCK_UN)

// Now safe to read/write

Use syscall.Flock() for advisory locking (Unix systems)

Use os.Lock

Use sync.Mutex

Cannot lock files

Question 20

How do you read environment variables with defaults?

port := os.Getenv("PORT")
if port == "" {
    port = "8080"  // Default value
}

// Or using a helper function
func getEnv(key, defaultValue string) string {
    if value := os.Getenv(key); value != "" {
        return value
    }
    return defaultValue
}

port = getEnv("PORT", "8080")

Check if os.Getenv() returns empty string, provide default

Use os.Getenv with default parameter

Use global defaults

Cannot provide defaults

Question 21

How do you append to a file?

file, err := os.OpenFile("log.txt", os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
if err != nil {
    log.Fatal(err)
}
defer file.Close()

_, err = file.WriteString("New log entry\n")
if err != nil {
    log.Fatal(err)
}

Use os.OpenFile with O_APPEND flag

Use os.WriteFile

Use os.Create

Cannot append to files

Question 22

How do you get the current working directory?

cwd, err := os.Getwd()
if err != nil {
    log.Fatal(err)
}
fmt.Println("Current directory:", cwd)

Use os.Getwd() to get current working directory

Use os.Args[0]

Use filepath.Abs

Cannot get current directory

Question 23

How do you change the current working directory?

err := os.Chdir("/tmp")
if err != nil {
    log.Fatal(err)
}

// Verify
cwd, _ := os.Getwd()
fmt.Println("New CWD:", cwd)

Use os.Chdir() to change current working directory

Use os.Setwd

Use filepath.Chdir

Cannot change directory

Question 24

How do you handle large files efficiently?

file, err := os.Open("large.txt")
if err != nil {
    log.Fatal(err)
}
defer file.Close()

buffer := make([]byte, 4096)  // 4KB buffer
for {
    n, err := file.Read(buffer)
    if n > 0 {
        // Process buffer[:n]
        processChunk(buffer[:n])
    }
    if err == io.EOF {
        break
    }
    if err != nil {
        log.Fatal(err)
    }
}

Read in chunks using a buffer, don't load entire file into memory

Use os.ReadFile always

Use bufio with small buffer

Cannot handle large files

Question 25

How do you create a pipe for inter-process communication?

r, w, err := os.Pipe()
if err != nil {
    log.Fatal(err)
}

go func() {
    defer w.Close()
    w.WriteString("Hello from child")
}()

buffer := make([]byte, 100)
n, err := r.Read(buffer)
fmt.Println(string(buffer[:n]))
r.Close()

Use os.Pipe() to create connected reader/writer pair

Use io.Pipe

Use channels

Cannot create pipes

Question 26

How do you handle file truncation?

file, err := os.OpenFile("file.txt", os.O_TRUNC|os.O_CREATE|os.O_WRONLY, 0644)
if err != nil {
    log.Fatal(err)
}
defer file.Close()

// File is now empty
file.WriteString("New content")

Use O_TRUNC flag in os.OpenFile to truncate existing files

Use os.Truncate

Use os.Remove and os.Create

Cannot truncate files

Question 27

How do you read environment variables as integers?

timeoutStr := os.Getenv("TIMEOUT")
if timeoutStr == "" {
    timeoutStr = "30"
}

timeout, err := strconv.Atoi(timeoutStr)
if err != nil {
    log.Fatal("Invalid TIMEOUT value:", err)
}

fmt.Println("Timeout:", timeout)

Use os.Getenv then strconv.Atoi to parse as integer

Use os.GetenvInt

Use fmt.Sscanf

Cannot parse env vars

Question 28

How do you safely remove files and directories?

err := os.Remove("file.txt")  // Remove file

err = os.RemoveAll("directory")  // Remove directory and contents

// Check if exists before removing
if _, err := os.Stat("file.txt"); !os.IsNotExist(err) {
    err = os.Remove("file.txt")
}

Use os.Remove() for files, os.RemoveAll() for directories

Use os.Delete

Use os.Rm

Cannot remove files

Question 29

How do you handle symbolic links in Go?

// Read link target
linkTarget, err := os.Readlink("mylink")

// Check if file is a symlink
info, err := os.Lstat("file")
if info.Mode() & os.ModeSymlink != 0 {
    fmt.Println("Is a symlink")
}

// Create symlink
err = os.Symlink("target", "linkname")

Use os.Readlink(), os.Lstat(), os.Symlink() for symlink operations

Use os.Stat

Use filepath.EvalSymlinks

Cannot handle symlinks

Question 30

How do you implement a simple file-based logger?

type FileLogger struct {
    file *os.File
}

func NewFileLogger(filename string) (*FileLogger, error) {
    file, err := os.OpenFile(filename, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
    if err != nil {
        return nil, err
    }
    return &FileLogger{file: file}, nil
}

func (l *FileLogger) Log(message string) {
    timestamp := time.Now().Format(time.RFC3339)
    l.file.WriteString(fmt.Sprintf("[%s] %s\n", timestamp, message))
}

func (l *FileLogger) Close() {
    l.file.Close()
}

Create a struct with *os.File, use os.OpenFile with O_APPEND, implement logging methods

Use fmt.Printf to file

Use log package with file

Cannot implement file logger

Question 31

How do you read configuration from environment variables?

type Config struct {
    Port     int
    Database string
    Debug    bool
}

func loadConfig() Config {
    port, _ := strconv.Atoi(getEnv("PORT", "8080"))
    database := getEnv("DATABASE", "postgres://localhost")
    debug := getEnv("DEBUG", "false") == "true"
    
    return Config{
        Port:     port,
        Database: database,
        Debug:    debug,
    }
}

func getEnv(key, defaultValue string) string {
    if value := os.Getenv(key); value != "" {
        return value
    }
    return defaultValue
}

Create Config struct, read env vars with defaults, parse types as needed

Use global variables

Use JSON files

Cannot read config from env

Question 32

How do you handle file I/O errors properly?

func readFile(filename string) ([]byte, error) {
    data, err := os.ReadFile(filename)
    if err != nil {
        if os.IsNotExist(err) {
            return nil, fmt.Errorf("file %s does not exist", filename)
        }
        if os.IsPermission(err) {
            return nil, fmt.Errorf("permission denied reading %s", filename)
        }
        return nil, fmt.Errorf("error reading %s: %w", filename, err)
    }
    return data, nil
}

Check specific error types with os.IsNotExist, os.IsPermission, etc., wrap errors with context

Ignore errors

Use panic

Cannot handle I/O errors

Question 33

How do you implement a file watcher?

func watchFile(filename string) {
    lastMod := time.Time{}
    
    for {
        info, err := os.Stat(filename)
        if err != nil {
            log.Println("Error stat'ing file:", err)
            time.Sleep(time.Second)
            continue
        }
        
        if info.ModTime().After(lastMod) {
            fmt.Println("File changed!")
            lastMod = info.ModTime()
            // Handle file change
        }
        
        time.Sleep(time.Second)
    }
}

Poll file modification time with os.Stat in a loop

Use os.WatchFile

Use inotify

Cannot watch files

Question 34

How do you work with binary files?

type Header struct {
    Magic   uint32
    Version uint16
    Count   uint32
}

func readBinaryFile(filename string) (*Header, error) {
    file, err := os.Open(filename)
    if err != nil {
        return nil, err
    }
    defer file.Close()
    
    var header Header
    err = binary.Read(file, binary.LittleEndian, &header)
    if err != nil {
        return nil, err
    }
    
    return &header, nil
}

Use encoding/binary package to read/write structured binary data

Use os.ReadFile and cast

Use bufio.Scanner

Cannot work with binary files

Question 35

What is the most important principle for file I/O in Go?

Always close files with defer, handle errors properly, use appropriate buffer sizes, prefer streaming for large files, use cross-platform path handling

Never close files

Use global file handles

Ignore errors

Other Quiz Categories

JavaScript

47 quizzes

Basics

Variables & Data Types

Operators & Expressions

Rust

30 quizzes

Cargo and Project Setup

Variables and Mutability

Data Types

Python

29 quizzes

Introduction & Core Fundamentals

Variables & Data Types

Operators & Expression

Java

22 quizzes

Java Basics & JVM Fundamentals

Variables, Data Types & Type Casting

Operators & Expressions

Matlab

21 quizzes

Basics & Environment

Variables and Data Type

Arrays and Matric

TypeScript

19 quizzes

Introduction and Overview

Installation and Configuration

Basic Types and Type Annotations

SQL Database

15 quizzes

Foundations and Basics

Basic Query Selection

Filter, Sort, and Alias Essentials

PHP

15 quizzes

Syntax Building Blocks

Node Structure and Pointer Fundamentals

Singly Linked List

QUIZZES IN Golang

Basics & Syntax

40 in-depth questions covering Go's fundamentals, packages, imports, syntax rules, variables, constants, comments, and formatting — with 10 code examples to solidify understanding.

Data Types & Zero Values

40 comprehensive questions on Go's built-in types, zero values, type inference, conversions vs casting, and aliased types — with 20 code examples to master type safety and initialization.

Operators & Expressions

40 comprehensive questions on Go's operators and expressions, covering arithmetic, comparison, logical, and bitwise operations — with 12 code examples exploring operator precedence, short-circuit evaluation, and practical usage patterns.

Control Flow

40 comprehensive questions on Golang's control flow statements, covering if-else, switch expressions, for loops, break/continue, and labeled statements — with 20 code examples demonstrating practical usage patterns and edge cases.

Functions

35 comprehensive questions on Golang functions, covering declarations, multiple returns, named returns, variadic functions, and pass-by-value semantics — with 18 code examples exploring function design patterns and parameter passing.

Pointers

50 comprehensive questions on Golang pointers, covering pointer basics, types, nil pointers, receiver semantics, and common pitfalls — with 15 code examples demonstrating pointer operations and memory management.

Structs

40 comprehensive questions on Golang structs, covering struct creation, methods, embedded structs, anonymous structs, and value vs reference behavior — with 20 code examples demonstrating struct operations and composition.

Interfaces

35 comprehensive questions on Golang interfaces, covering interface basics, implicit implementation, empty interface, type assertions, and type switches — with 18 code examples demonstrating interface usage and polymorphism.

Methods & Receivers

35 comprehensive questions on Golang methods and receivers, covering value vs pointer receivers, method sets, interface satisfaction, and practical usage patterns — with 18 code examples demonstrating method behavior and common scenarios.

Arrays & Slices

40 comprehensive questions on Golang arrays and slices, covering fixed-size arrays, slice creation, capacity & length, internals, and copying operations — with 18 code examples demonstrating array and slice behavior.

Maps

35 comprehensive questions on Golang maps, covering map creation, key existence checking, entry deletion, iteration order, and reference behavior — with 18 code examples demonstrating map operations and common patterns.

Strings & Runes

35 comprehensive questions on Golang strings and runes, covering UTF-8 basics, rune vs byte differences, string immutability, manipulation techniques, and conversion operations — with 18 code examples demonstrating string handling patterns.

Error Handling

40 comprehensive questions on Golang error handling, covering error values, custom error types, fmt.Errorf with wrapping, sentinel vs typed errors, and errors.Is & errors.As — with 18 code examples demonstrating error handling patterns.

Packages & Modules

35 comprehensive questions on Golang packages and modules, covering package creation, exported vs unexported identifiers, Go modules usage, dependency management, and versioning rules — with 18 code examples demonstrating package organization and module management.

Concurrency Goroutines

40 comprehensive questions on Golang goroutines, covering goroutine creation, spawning, stack management, leaks, and best practices — with 18 code examples demonstrating concurrent programming patterns and common pitfalls.

Concurrency Channels

35 comprehensive questions on Golang channels, covering unbuffered and buffered channels, directions, closing, and patterns — with 18 code examples demonstrating channel usage in concurrent programming.

Select Statement

35 comprehensive questions on Golang's select statement, covering multiplexing channels, timeouts, non-blocking operations, fan-in/fan-out patterns, and handling closed channels — with 18 code examples demonstrating advanced channel operations.

Synchronization Tools

35 comprehensive questions on Golang's synchronization tools, covering sync.Mutex, sync.RWMutex, sync.WaitGroup, sync.Once, and common race-condition mistakes — with 18 code examples demonstrating thread-safe patterns.

Context Package

35 comprehensive questions on Golang's context package, covering context.Background() & TODO(), context cancellation, deadlines & timeouts, passing values, and best practices — with 18 code examples demonstrating proper context usage.

Memory Model

45 comprehensive questions on Golang's memory model, covering stack vs heap allocation, escape analysis, allocation patterns, garbage collection basics, and avoiding unnecessary allocations — with 25 code examples demonstrating memory management techniques.

Testing & Unit Test

40 comprehensive questions on Golang's testing framework, covering the testing package, writing unit tests, table-driven tests, benchmarks with go test -bench, and test coverage tools — with 20 code examples demonstrating testing best practices.

File I/O & OS Interactions

Networking & HTTP

40 comprehensive questions on Golang's networking and HTTP capabilities, covering basic HTTP servers, HTTP clients, request/response lifecycle, JSON marshalling/unmarshalling, and REST API patterns — with 20 code examples demonstrating practical networking operations.

Goroutine-Safe Patterns

35 comprehensive questions on Golang's goroutine-safe patterns, covering worker pools, producer/consumer patterns, pipeline design, avoiding shared state, and concurrency design pitfalls — with 15 code examples demonstrating safe concurrent programming practices.

Reflection

35 comprehensive questions on Golang's reflection capabilities, covering reflect.Type & reflect.Value usage, value modification, kind checking, performance considerations, and when to avoid reflection — with 15 code examples demonstrating practical reflection techniques.

Generics

35 comprehensive questions on Go's generics system introduced in Go 1.18, covering type parameters, generic functions, generic types, type constraints, and their benefits and limitations — with 15 code examples demonstrating practical generic programming patterns.

Build & Run Tooling

35 comprehensive questions on Go's build and run tooling, covering go build, go run, go test, cross-compiling, and build tags — with 15 code examples demonstrating practical build configurations and testing scenarios.

Modules & Dependency Tools

Test your knowledge of Golang modules and dependency management tools. This quiz covers go mod tidy, go mod vendor, reproducible builds, semantic import versioning, and private modules.

Best Practices & Idioms

Test your knowledge of Golang best practices and idiomatic patterns. This quiz covers idiomatic naming, error-first return style, avoiding global state, composition over inheritance, and profiling & performance tuning.

Golang File I/O & OS Interactions Quiz

Question 1

Question 2

Question 3

Question 4

Question 5

Question 6

Question 7

Question 8

Question 9

Question 10

Question 11

Question 12

Question 13

Question 14

Question 15

Question 16

Question 17

Question 18

Question 19

Question 20

Question 21

Question 22

Question 23

Question 24

Question 25

Question 26

Question 27

Question 28

Question 29

Question 30

Question 31

Question 32

Question 33

Question 34

Question 35

About This Golang File I/O & OS Interactions Quiz

What You Will Practise

Other Quiz Categories

QUIZZES IN Golang

Basics & Syntax

Data Types & Zero Values

Operators & Expressions

Control Flow

Functions

Pointers

Structs

Interfaces

Methods & Receivers

Arrays & Slices

Maps

Strings & Runes

Error Handling

Packages & Modules

Concurrency Goroutines

Concurrency Channels

Select Statement

Synchronization Tools

Context Package

Memory Model

Testing & Unit Test

File I/O & OS Interactions

Networking & HTTP

Goroutine-Safe Patterns

Reflection

Generics

Build & Run Tooling

Modules & Dependency Tools

Best Practices & Idioms