Core Basics

Packages

Every Go application needs at least one package, that you can split your code in.

Usually you will have a default package main. Theoretically it could be any package name, as long as all files belong to the same package.

main is a special name for Go that tells it that this package will be the main entrypoint of the application.

• In developing environments when executing the application with go run app.go you specify which file will be the entrypoint.

• But for production environments, where the code is compiled to be runned, everything will be mixed together in the binary file, so the entrypoint from the package name is important.

Compiling a project without a main package produces no executable file.

You may also split your code into multiple packages.

Importing own packages

// Your own packages
import "your-module/package-name"

// Third-party that were downloaded with `go get`
import "https://package-url.com"

Variables, constants, functions, etc, are ONLY available (exported) to other packages if they start in Uppercase.

Ex.:

• GetSomething(): this function will be available in other packages.

• getSomething(): this function is "private" to the package that it is declared.

Add packages locally

This downloads the package and stores globally on your system.

go get https://package-url.com

Install packages

Just like npm install run bellow to install the projects dependencies.

go get

Modules

A module consist of multiple packages, and it is the go.mod file in your project.

Initiate the module in your project, or else, you will not be able to compile your project.

go mod init <path>

The path can be a name or dummy URL, or even a github repository URL.

Functions

Define functions with func.

// If both are same type
func name(param1, param2 string) {}

// If different types
func name(param1 int, param2 string) {}

Return types

func name(param1, param2 string) string {
    return param1
}

Easily return multiple values

func name(param1 int, param2 string) (int, string) {
    return param1, param2
}

var a, b string = name('A', 'B')

Auto declare & return variables

Specify names of returned variables, and Go will auto declare AND return them, when return is called.

// No auto declaring & return
func name(param1 int, param2 string) (int, string) {
    var ra = param1
    var rb = param2
    return ra, rb
}

// Auto declare & return
func name(param1 int, param2 string) (ra int, rb string) {
    ra = param1
    rb = param2
    return
    // Or you can explicitly return them though
    return ra, rb
}

main() function

There is also the need for a main() function to be defined. Which will be the entrypoint function by default to be executed.

There can only be ONE main() function in your package main.

If making a utility package there is no need for a main() function. Because it is not intended to be executed as a program, but to be imported by other packages.

Variables

Create variables with var or with :=.

The convention is to declare variables with := and not var.

BUT, you can't explicitly state the variable type. (Ex: a int := 5)

All Go types come with a "null value" (not nil) which is set in a variable if no other value is explicitly set.

For instance:

• int => 0

• float64 => 0.0

• string => ""

• bool => false

• pointer => nil

var a = 1000 // Inferred "int"
var b float64 = 5.5
var y = float64(a) + b

c := 1000 // Inferred "int"

Variable types can be inferred from values.

In Go you cannot mix types in calculations.

Declare multiple variables in one line

But they will all be of the same type. (You cannot specifiy the type for each one)

var a, b float64 = 1000, 40.1

a, b := 1000, 40.1

Basic types

• int, uint (only positives), int32

• float64

• string

• bool

Custom types

Create new types with type keyword.

// Creates a new type "A" that is "exported" in the package
type A int

var a A = 1

Fetch user input (Stdin)

fmt.Scan

You can't easily fetch multi-word input values.

var a float64

fmt.Print("Enter value: ")
fmt.Scan(&a) // Pass a pointer of the variable

Formatting strings

fmt.Printf (to Stdout)

fmt.Printf("%.2f", a)

fmt.Sprintf

var a string = fmt.Sprintf("%.2f", b)

Multiline strings

var a string = `
    This is multi
    line
`

Variable scopes

Variables or constants can be declared outside of main().

In this case a will be accessable/scoped to the entire file main.go.

But you can't declare these variables with :=.

main.go

var a string = 'AAA'

b := 10 // Can't use this type of declaration

func main() {
    ...
}

Unamed variables

You may use _ as variables to handle values that will not be used.

a, _ := name()

Constants

Declare constants with const.

const a = 1000 // Inferred "int"
const b float64 = 5.5

Control Structures

if, else if, else

// AND, OR, NOT
if (a == 1 && b == 1) || a == 2 || !b {}

if a {}
else {}

if a == 1 {}
else if a == 2
else {}

switch

If using switch inside infinite loops, the break keyword will not be able to be used to end the loop, since it will be used by the switch.

switch choice {
    case 1:
        ...
        break
    case 2:
        ...
    default:
        ...
}

for

// Regular loop
for i := 0; i < 2; i++ {}

// Infinite loop
for {
    break
}

// Infinite loop bounded to variable
for boolVariable {}

Error Handling

In Go, error handling works a bit differently. You should write your functions in a way that errors should not crash the application.

func convert() (float64, error) {
    if a == '' {
        return nil, errors.New("It failed")
    }
    return 10, nil
}

Exit with panic

You can exit the program ungracefully with panic().

a, err = convert()
if err != nil {
    panic(err)
}

Pointers

Pointers are variables that store memory addresses instead of values.

Use them to directly mutate variables or to avoid memory duplication.

By default Go pass variables by value to functions.

// Inferred type
aPointer := &a
// Explicit type
var aPointer *int = &a

fmt.Print(aPointer) // Shows the memory address of "a"
fmt.Print(*aPointer) // Show the value of "a"

Pass parameter by reference

func name(val *string) string {
    return *val
}

a := 'A'

name(&a)