Syntax
Entry Point
You should always have a
main function as your entry point.1
package main
2
3
func main() {
4
}
5
Copied!
Type Declarations
Type declarations always go to the right of variable or function names, e.g.
1
var i int = 1
Copied!
This isn't necessary in this case as it can be inferred from the right hand side
Type Inference
Go has the
:= operator which can infer the type and assign it to a variable at the same time. Using it we can write the same example as above and omit the var and int.1
i := 5
Copied!
Function Declarations
Function declarations are actually quite similar (the return type is to the right of the function name), here's a function that just returns a string when called.
1
func returnHello() string {
2
return "Hello"
3
}
Copied!
Here's the same version but this time it takes in a name as well
1
package main
2
3
import "fmt"
4
5
func main() {
6
fmt.Println(returnHello("Omar"))
7
}
8
9
func returnHello(name string) string {
10
return fmt.Sprintf("Hello %s", name)
11
}
12
Copied!
Conditionals
Conditionals are quire straightforward in Go, they're similar to most languages but without the parentheses
1
package main
2
3
import "fmt"
4
5
func main() {
6
name := "Omar"
7
8
if name == "Omar" {
9
fmt.Println("It's me")
10
} else {
11
fmt.Println("Hey there stranger!")
12
}
13
}
Copied!
Loops
There's only one type of loop in Go, a
for loop.Here's a loop that prints "Hello" five times.
1
package main
2
3
import "fmt"
4
5
func main() {
6
for i := 0; i < 5; i++ {
7
fmt.Println("Hello")
8
}
9
}
Copied!
Here's an infinite loop (useful for servers, game engines, etc.)
Warning: You have to kill the program to end this
1
package main
2
3
import "fmt"
4
5
func main() {
6
for {
7
fmt.Println("Hello")
8
}
9
}
Copied!
This form can also be used to make a finite loop when combined with the
break keyword, this will print 0 to 4.1
package main
2
3
import "fmt"
4
5
func main() {
6
i := 0
7
8
for {
9
if i >= 5 {
10
break
11
}
12
13
fmt.Println(i)
14
i++
15
}
16
}
Copied!
There's also a form of the loop that you only need to provide with the condition, this will print 0 to 5. (This is used to stop it before the next run)
1
package main
2
3
import "fmt"
4
5
func main() {
6
i := 0
7
isLessThanFive := true
8
9
for isLessThanFive {
10
if i >= 5 {
11
isLessThanFive = false
12
}
13
14
fmt.Println(i)
15
i++
16
}
17
}
Copied!
Structs
Structs are a useful way to encapsulate and reuse objects, and they can even have methods. They're similar in some ways to classes in other programming languages.
Here's how to declare a struct (can be done outside of
main)1
package main
2
3
import "fmt"
4
5
// Struct declaration
6
type Person struct {
7
name string
8
age int
9
}
10
11
func main() {
12
// Struct usage
13
omar := Person{name: "Omar", age: 27}
14
fmt.Println(omar)
15
}
Copied!
1
package main
2
3
import "fmt"
4
5
type Person struct {
6
name string
7
age int
8
}
9
10
func (p Person) description() string {
11
return fmt.Sprintf("%s is a Person who is %d years old", p.name, p.age)
12
}
13
14
func main() {
15
omar := Person{name: "Omar", age: 27}
16
fmt.Println(omar.description())
17
}
Copied!
This syntax was the most confusing to me whenever I saw Go code, the
(p Person) part. This basically says that the type that can receive this method call is of type Person and that within that function we want to name that receiver p.Interfaces
Interfaces add a bit of genericness to Go, they're quite similar to other languages except that you don't need to specifically declare that your struct implements an interface, the compiler infers it if the signature of your methods match your interface method's signature.
1
package main
2
3
import "fmt"
4
5
// Interface declaration
6
type Eater interface {
7
eat() string
8
}
9
10
type Cat struct {
11
name string
12
}
13
14
func (c Cat) eat() string {
15
return fmt.Sprintf("%s likes to eat cat food.", c.name)
16
}
17
18
type Dog struct {
19
name string
20
}
21
22
func (d Dog) eat() string {
23
return fmt.Sprintf("%s likes to eat dog food.", d.name)
24
}
25
26
func printEatResult(e Eater) {
27
fmt.Println(e.eat())
28
}
29
30
func main() {
31
cat := Cat{name: "Felix"}
32
dog := Dog{name: "Spark"}
33
34
printEatResult(cat)
35
printEatResult(dog)
36
}
Copied!
This slightly lengthy example allowed us treat both
Cat and Dog as Eaters in the printEatResult function. Notice how we didn't have to do anything to explicitly say that Cats and Dogs implement the Eater interface, the compiler just figured it out because the signature of the eat function on each of those structs matched the Eater 's version of it.It's a convention to name interfaces that have only one method (e.g.
eat) to end with the name of that method plus er, so eater.Arrays and Slices
Arrays
It's quite simple to declare and use an array (the size of the array goes to the left of the type).
1
package main
2
3
func main() {
4
var names [2]string
5
names[0] = "Omar"
6
names[1] = "John"
7
fmt.Println(names)
8
}
Copied!
However with arrays you must always declare the size, if you want to use something with flexible size, that's what slices are for.
Slices
Slices are a type built on top of arrays to provide more convenience and flexibility, most array programming in Go is done using slices.
1
package main
2
3
func main() {
4
var names []string
5
names = append(names, "Omar")
6
names = append(names, "John")
7
}
Copied!
In the example above, the size is omitted (you don't need to know the size of your data when declaring a slice)
Last modified 3yr ago