1. Command Line Arguments and File I/O

Setup

$ go get golang.org/x/tools/cmd/goimports
...
$ mkdir engineitops
$ cd engineitops

Hello World

$ touch hello.go

// hello.go
package main

import (
    "fmt"
)

func main() {
    fmt.Println("Hello World!")
}

$ $GOPATH/bin/goimports -w .
# Format and add packages that should be imported

$ go run hello.go
Hello World!

$ go build -o hello .

$ ./hello
Hello World!

flag package

Usage of flag.StringVar

$ touch flag.go

// flag.go
package main

import (
    "flag"
    "fmt"
)

func main() {
    var name string
    flag.StringVar(&name, "opt", "", "Usage")

    flag.Parse()

    fmt.Println(name)
}

$ go run hello.go -opt option
option

If you want to know more about the flag package, please go to the https://golang.org/pkg/flag/

Exercise 1-1

Create a CLI application which outputs Hello World! if no options are specified. And if a string option is specified as -name, it has to output Hello [YOUR_NAME]!

$ go run hello.go
Hello World!

$ go run hello.go -name Gopher
Hello Gopher!

The answer is [hello.go]

package main

import (
    "flag"
    "fmt"
)

func main() {
    // You can get command line options by flag package.
    // 'flag.StringVar' returns a string option as a pointer.
    // If you want to know other flag package's functions, go to https://golang.org/pkg/flag
    var name string
    flag.StringVar(&name, "name", "", "Write your name.")

    flag.Parse()

    if name == "" {
        fmt.Println("Hello World!")
    } else {
        fmt.Printf("Hello %s!\n", name)
    }
}

os package

Usage of os.Args

$ touch args.go

// args.go
package main

import (
    "fmt"
    "os"
)

func main() {
    fmt.Println(os.Args)
    fmt.Println(os.Args[1])
}

$ go build -o args args.go 
$ ./args Gopher
[./args Gopher]
Gopher

File I/O

Reading files

file, err := os.Open(`/path/to/file`)
if err != nil {
    panic(err)
}
defer file.Close()

buf := make([]byte, BUFSIZE)
for {
    n, err := file.Read(buf)
    if n == 0 {
        break
    }
    if err != nil {
        panic(err)
    }

    fmt.Print(string(buf[:n]))
}

Writing files

f, err := os.Create("/path/to/file")
if err != nil {
    panic(err)
}
defer f.Close()

b := []byte("Foo")
n, err := f.Write(b)
if err != nil {
    panic(err)
}
fmt.Println(n)

Exercise 1-2

Create an application file.go which creates a file and write a string Hello Writing to Files! to it. And the file name has to be specified as a command line argument.

$ go run file.go file.txt
The number of bytes written:  23

$ cat file.txt
Hello Writing to Files!

The answer is file.go

package main

import (
    "fmt"
    "os"
)

func main() {
    // You can get command line arguments with 'os.Args', a string slice.
    if len(os.Args) < 2 {
        fmt.Println("Please set a file name.")
        return
    }

    // 'os.Args' contains the executed binary file name and the arguments.
    // If you command './file file.txt', 'os.Args[0]' is './file' and 'os.Args[1] is 'file.txt'.
    filename := os.Args[1]

    f, err := os.Create(filename)
    if err != nil {
        fmt.Println(err)
        return
    }
    defer f.Close()

    b := []byte("Hello Writing to Files!")
    n, err := f.Write(b)
    if err != nil {
        fmt.Println(err)
        return
    }

    fmt.Println("The number of bytes written: ", n)
}