GoLang Tutorial - Workspaces II

Continued from Workspaces.

In this section, we'll download a copy of the Git repo containing the golang.org/x/example/hello module, add it to the workspace, and then add a new function to it that we will use from the hello program.

Also note that there is no real repo for golang.org/x/example/hello because it is an example module. Example modules are typically located in the go/example directory of the Go source tree. The x in golang.org/x/example/hello is a prefix that indicates that the module is experimental. Experimental modules are not considered to be part of the Go standard library, and they may not be as stable or well-supported as core modules.

From the workspace directory, run the git command to clone the repository:

$ git clone https://go.googlesource.com/example

As show in the picture, the Git repo was just checked out into ./example. The source code for the golang.org/x/example/hello module is in ./example/hello. Add it to the workspace:

$ go work use ./example/hello   

The go work use command adds a new module to the go.work file. It will now look like this:

go 1.21.4

use (
	./example/hello
	./hello
)

Benefits of using a go.work file:

There are several benefits to using a go.work file:

1. It allows us to develop multiple Go modules in the same workspace.
2. It allows us to use private modules that are not published to the registry.
3. It can help to improve the performance of Go builds by reducing the number of network requests required.

When to use a go.work file:

We should use a go.work file if we are developing multiple Go modules in the same workspace, or if we need to use private modules that are not published to the registry.

When not to use a go.work file:

If we are only developing a single Go module, and we do not need to use private modules, then we do not need to use a go.work file.

We'll add a new function to reverse a number to the golang.org/x/example/hello/reverse package.

Create a new file named int.go in the workspace/example/hello/reverse directory containing the following contents:

package reverse

import "strconv"

// Int returns the decimal reversal of the integer i.
func Int(i int) int {
    i, _ = strconv.Atoi(String(strconv.Itoa(i)))
    return i
}    

The package imports the strconv package. This package provides functions for converting strings to other types and vice versa, including functions for converting integers to strings (Itoa) and strings to integers (Atoi).

The use of the underscore (_) is an indicator that the error returned by strconv.Atoi is being ignored. This is common when the error is not expected to occur or when it's intentionally being ignored.

Also, we want to modify the workspace/hello/hello.go program to use the function.

package main

import (
    "fmt"

    "golang.org/x/example/hello/reverse"
)

func main() {
    fmt.Println(reverse.String("Hello"), reverse.Int(12345))
}

From the workspace directory, run:

$ go run ./hello
olleH 54321    

The Go command finds the example.com/hello module specified in the command line in the hello directory specified by the go.work file, and similarly resolves the golang.org/x/example/hello/reverse import using the go.work file.

Note that the x in golang.org/x/example/hello is a prefix that indicates that the module is experimental. Experimental modules are not considered to be part of the Go standard library, and they may not be as stable or well-supported as core modules.

Go Tutorial

1. GoLang Tutorial - HelloWorld
2. Calling code in an external package & go.mod / go.sum files
3. Workspaces
4. Workspaces II
5. Visual Studio Code
6. Data Types and Variables
7. byte and rune
8. Packages
9. Functions
10. Arrays and Slices
11. A function taking and returning a slice
12. Conditionals
13. Loops
14. Maps
15. Range
16. Pointers
17. Closures and Anonymous Functions
18. Structs and receiver methods
19. Value or Pointer Receivers
20. Interfaces
21. Web Application Part 0 (Introduction)
22. Web Application Part 1 (Basic)
23. Web Application Part 2 (Using net/http)
24. Web Application Part 3 (Adding "edit" capability)
25. Web Application Part 4 (Handling non-existent pages and saving pages)
26. Web Application Part 5 (Error handling and template caching)
27. Web Application Part 6 (Validating the title with a regular expression)
28. Web Application Part 7 (Function Literals and Closures)
29. Building Docker image and deploying Go application to a Kubernetes cluster (minikube)
30. Serverless Framework (Serverless Application Model-SAM)
31. Serverless Web API with AWS Lambda
32. Arrays vs Slices with an array left rotation sample
33. Variadic Functions
34. Goroutines
35. Channels ("<-")
36. Channels ("<-") with Select
37. Channels ("<-") with worker pools
38. Defer
39. GoLang Panic and Recover
40. String Formatting
41. JSON
42. SQLite
43. Modules 0: Using External Go Modules from GitHub
44. Modules 1 (Creating a new module)
45. Modules 2 (Adding Dependencies)
46. AWS SDK for Go (S3 listing)
47. Linked List
48. Binary Search Tree (BST) Part 1 (Tree/Node structs with insert and print functions)
49. Go Application Authentication I (BasicAuth, Bearer-Token-Based Authentication)
50. Go Application Authentication II (JWT Authentication)