GoLang Tutorial - Interfaces

Interfaces are named collections of methods:

type Shape interface {
    area() float64
}

So, in the above code, the Shape interface has a method called area().

We can add another method called perimeter like this:

type Shape interface {
    area() float64
    perimeter() float64
}

In the following sample, we will see a basic interface for geometric shapes.

The code: interfaces.go

Notice that we're passing an interface (s Shape) but not a specific implementation (neither c Circle nor r Rectangle):

The first time I saw this was the official source code for the linked list (https://golang.org/src/container/list/list.go):

// Element is an element of a linked list.
type Element struct {
	// Next and previous pointers in the doubly-linked list of elements.
	// To simplify the implementation, internally a list l is implemented
	// as a ring, such that &l.root is both the next element of the last
	// list element (l.Back()) and the previous element of the first list
	// element (l.Front()).
	next, prev *Element

	// The list to which this element belongs.
	list *List

	// The value stored with this element.
	Value interface{}
}

The interface{} type is the interface that has no methods. So, if we write a function that takes an interface{} value as a parameter, we can supply that function with any value. Given the following:

func foo(Value interface{}) {
   // ...
}

The function will accept any parameter whatsoever. Again, the type of Value is interface{}. Confusing? Check How to use interfaces in Go.

Here is an example of an empty interface:

The code: empty-interface.go

Another practical example is:

func Marshal(v interface{}) ([]byte, error)

The function returns the JSON encoding form of v.

With a given Go data structure, Message:

type Message struct {
    Name string
    Body string
    Time int64
}

and an instance of Message

m := Message{"Interface", "Empty Interface", 1556747623}

We can marshal a JSON-encoded version of m using json.Marshal:

b, err := json.Marshal(m)

If all is well, err will be nil and b will be a []byte containing this JSON data:

b == []byte(`{"Name":"Interface","Body":"Empty Interface","Time":1556747623}`)

Here is the full code:

The code: json-marshall.go

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)