Go tutorial – Chapter 5: Interacting with the outside world

Interacting with the outside world refers to the ability of a program to communicate with other systems, resources, or services outside of its own environment. This can be done through various methods such as file access, network communication, or interacting with other processes.

File access

How to read and write files in Go?

To read and write files in Go, you can use the os package:

package main

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

func main() {
    // read file
    b, err := ioutil.ReadFile("test.txt")
    if err != nil {
        fmt.Print(err)
    }
    str := string(b)
    fmt.Println(str)

    // write file
    file, err := os.Create("test2.txt")
    if err != nil {
        fmt.Print(err)
    }
    defer file.Close()

    file.WriteString("Hello, world!")
}

This program reads the contents of the file test.txt and prints it to the console. It then creates a new file called test2.txt and writes the string “Hello, world!” to it.

Network communication

How to make HTTP requests in Go?

To make HTTP requests in Go, you can use the net/http package:

package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
)

func main() {
    resp, err := http.Get("https://www.example.com/")
    if err != nil {
        fmt.Print(err)
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        fmt.Print(err)
    }
    fmt.Println(string(body))
    fmt.Println(resp.StatusCode)
    fmt.Println(resp.Header.Get("Content-Type"))
}

This program makes an HTTP GET request to https://www.example.com/ and prints the body, status code, and content type of the response.

How to send HTTP requests with headers and data in Go?

To send HTTP requests with headers and data in Go, you can use the Request struct from the net/http package:

package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
    "strings"
)

func main() {
    client := &http.Client{}

    req, err := http.NewRequest("POST", "https://www.example.com/", strings.NewReader("name=John&age=30"))
    if err != nil {
        fmt.Print(err)
    }
    req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
    req.Header.Add("User-Agent", "MyClient/1.0")

    resp, err := client.Do(req)
    if err != nil {
        fmt.Print(err)
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        fmt.Print(err)
    }
    fmt.Println(string(body))
}

This program sends an HTTP POST request to https://www.example.com/ with the headers “Content-Type” and “User-Agent” and the data “name=John&age=30”. It prints the body of the response to the console.

Interacting with processes

How to execute external commands in Go?

To execute external commands in Go, you can use the os/exec package:

package main

import (
    "fmt"
    "os/exec"
)

func main() {
    cmd := exec.Command("ls")
    output, err := cmd.CombinedOutput()
    if err != nil {
        fmt.Print(err)
    }
    fmt.Println(string(output))
}

This program executes the ls command and prints the output to the console.

How to interact with a process in Go?

To interact with a process in Go, you can use the os/exec package and the StdinPipe, StdoutPipe, and StderrPipe methods:

package main

import (
    "fmt"
    "os/exec"
)

func main() {
    cmd := exec.Command("python")
    stdin, err := cmd.StdinPipe()
    if err != nil {
        fmt.Print(err)
    }
    stdout, err := cmd.StdoutPipe()
    if err != nil {
        fmt.Print(err)
    }
    stderr, err := cmd.StderrPipe()
    if err != nil {
        fmt.Print(err)
    }

    if err := cmd.Start(); err != nil {
        fmt.Print(err)
    }

    if _, err := stdin.Write([]byte("print(\"Hello, world!\")\n")); err != nil {
        fmt.Print(err)
    }

    if err := stdin.Close(); err != nil {
        fmt.Print(err)
    }

    if err := cmd.Wait(); err != nil {
        fmt.Print(err)
    }

    out, err := ioutil.ReadAll(stdout)
    if err != nil {
        fmt.Print(err)
    }
    fmt.Println(string(out))

    errOut, err := ioutil.ReadAll(stderr)
    if err != nil {
        fmt.Print(err)
    }
    fmt.Println(string(errOut))
}

This program starts a Python process and writes the string “print(“Hello, world!”)” to its stdin. It then reads the stdout and stderr of the process and prints them to the console.

Conclusion

• Recap of interacting with the outside world in Go In Go, you can interact with the outside world through various methods such as file access, network communication, and interacting with processes. You can use the os package for file access, the net/http package for network communication, and the os/exec package for interacting with processes.
• Tips for interacting with the outside world in Go Here are some tips for interacting with the outside world in Go:
  • Use the os package to read and write files.
  • Use the net/http package to make HTTP